using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RealControl")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RealControl")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("486de57c-6d4c-406a-adf7-a4433b917004")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("Sapphire009.RealControl", "RealControl", "1.0.2")]
public sealed class RealControlPlugin : BaseUnityPlugin
{
private enum ExpectedHand
{
Left,
Right
}
private enum StepDirection
{
Up,
Down,
Left,
Right
}
private sealed class InputState
{
public bool WasControlledWallClimbing;
public float LastPrimaryPressedTime = float.NegativeInfinity;
public ExpectedHand NextHand = ExpectedHand.Left;
}
[HarmonyPatch(typeof(CharacterInput), "Sample", new Type[] { typeof(bool) })]
private static class CharacterInputSamplePatch
{
[HarmonyPostfix]
[HarmonyPriority(0)]
[HarmonyAfter(new string[] { "Sapphire009.WASDX", "Sapphire009.JumpingPEAK" })]
private static void Postfix(CharacterInput __instance)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null)
{
return;
}
Character component = ((Component)__instance).GetComponent<Character>();
if ((Object)(object)component == (Object)null || !component.IsLocal)
{
return;
}
InputState orCreateState = GetOrCreateState(__instance);
Vector2 movementInput = __instance.movementInput;
bool upHeld = ReadUpHeld(movementInput);
bool leftHeld = ReadLeftHeld(movementInput);
bool rightHeld = ReadRightHeld(movementInput);
bool downHeld = ReadDownHeld(movementInput);
if (!IsControlledWallClimbing(component))
{
if (__instance.usePrimaryWasPressed)
{
orCreateState.LastPrimaryPressedTime = Time.unscaledTime;
}
orCreateState.WasControlledWallClimbing = false;
}
else
{
if (!orCreateState.WasControlledWallClimbing)
{
BeginControlledClimb(component, orCreateState);
}
ProcessControlledClimbInput(__instance, component, orCreateState, upHeld, leftHeld, rightHeld, downHeld);
}
}
}
public const string PluginGUID = "Sapphire009.RealControl";
public const string PluginName = "RealControl";
public const string PluginVersion = "1.0.2";
private const string BuildMarker = "DirectionalAlternatingInput-Stamina-R3";
private const float NormalGrabDetectionWindow = 0.75f;
private const float MinimumDirectionSqrMagnitude = 0.0001f;
private const float StepStaminaCost = 0.05f;
internal static ManualLogSource ModLogger;
private static ConfigEntry<float> upStepDistance;
private static ConfigEntry<float> sideStepDistance;
private static ConfigEntry<float> downStepDistance;
private static ConfigEntry<bool> logSuccessfulSteps;
private static readonly Dictionary<int, InputState> InputStates = new Dictionary<int, InputState>();
private Harmony harmony;
private void Awake()
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Expected O, but got Unknown
ModLogger = ((BaseUnityPlugin)this).Logger;
upStepDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Climb Step", "UpStepDistance", 1.5f, "W를 누른 상태에서 올바른 좌클릭/우클릭 교대 입력 1회당 위로 이동할 거리입니다.");
sideStepDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Climb Step", "SideStepDistance", 1.5f, "A 또는 D를 누른 상태에서 올바른 좌클릭/우클릭 교대 입력 1회당 좌우로 이동할 거리입니다.");
downStepDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Climb Step", "DownStepDistance", 1.5f, "S를 누른 상태에서 올바른 좌클릭/우클릭 교대 입력 1회당 아래로 이동할 거리입니다.");
logSuccessfulSteps = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "LogSuccessfulSteps", false, "true이면 적용된 등반 스텝을 로그에 기록합니다.");
harmony = new Harmony("Sapphire009.RealControl");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"RealControl 1.0.2 loaded. Developer=Sapphire009. Build=DirectionalAlternatingInput-Stamina-R3.");
}
private void OnDestroy()
{
InputStates.Clear();
if (harmony != null)
{
harmony.UnpatchSelf();
harmony = null;
}
ModLogger = null;
}
private static InputState GetOrCreateState(CharacterInput characterInput)
{
int instanceID = ((Object)characterInput).GetInstanceID();
if (!InputStates.TryGetValue(instanceID, out var value))
{
value = new InputState();
InputStates.Add(instanceID, value);
}
return value;
}
private static bool IsControlledWallClimbing(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null || character.refs == null || (Object)(object)character.refs.climbing == (Object)null)
{
return false;
}
return character.data.isClimbing && !character.data.isRopeClimbing && !character.data.isVineClimbing && (Object)(object)character.data.currentClimbHandle == (Object)null;
}
private static bool ReadUpHeld(Vector2 sampledMovement)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (CharacterInput.action_moveForward != null)
{
return CharacterInput.action_moveForward.IsPressed();
}
return sampledMovement.y > 0.5f;
}
private static bool ReadLeftHeld(Vector2 sampledMovement)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (CharacterInput.action_moveLeft != null)
{
return CharacterInput.action_moveLeft.IsPressed();
}
return sampledMovement.x < -0.5f;
}
private static bool ReadRightHeld(Vector2 sampledMovement)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (CharacterInput.action_moveRight != null)
{
return CharacterInput.action_moveRight.IsPressed();
}
return sampledMovement.x > 0.5f;
}
private static bool ReadDownHeld(Vector2 sampledMovement)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (CharacterInput.action_moveBackward != null)
{
return CharacterInput.action_moveBackward.IsPressed();
}
return sampledMovement.y < -0.5f;
}
private static bool TryGetHeldDirection(bool upHeld, bool leftHeld, bool rightHeld, bool downHeld, out StepDirection stepDirection)
{
stepDirection = StepDirection.Up;
int num = 0;
if (upHeld)
{
stepDirection = StepDirection.Up;
num++;
}
if (downHeld)
{
stepDirection = StepDirection.Down;
num++;
}
if (leftHeld)
{
stepDirection = StepDirection.Left;
num++;
}
if (rightHeld)
{
stepDirection = StepDirection.Right;
num++;
}
return num == 1;
}
private static void BeginControlledClimb(Character character, InputState state)
{
//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)
bool flag = Time.unscaledTime - state.LastPrimaryPressedTime <= 0.75f;
state.NextHand = (flag ? ExpectedHand.Right : ExpectedHand.Left);
character.refs.climbing.playerSlide = Vector2.zero;
state.WasControlledWallClimbing = true;
}
private static bool HasEnoughStepStamina(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
{
return false;
}
float num = Mathf.Max(0f, character.data.currentStamina) + Mathf.Max(0f, character.data.extraStamina);
return num + 0.0001f >= 0.05f;
}
private static bool ConsumeStepStamina(Character character)
{
if (!HasEnoughStepStamina(character))
{
return false;
}
float num = 0.05f;
float num2 = Mathf.Min(Mathf.Max(0f, character.data.currentStamina), num);
CharacterData data = character.data;
data.currentStamina -= num2;
num -= num2;
if (num > 0f)
{
float num3 = Mathf.Min(Mathf.Max(0f, character.data.extraStamina), num);
CharacterData data2 = character.data;
data2.extraStamina -= num3;
num -= num3;
}
character.ClampStamina();
character.data.extraStamina = Mathf.Max(0f, character.data.extraStamina);
character.data.sinceUseStamina = 0f;
if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
{
GUIManager.instance.bar.ChangeBar();
}
return num <= 0.0001f;
}
private static bool TryApplyStep(Character character, StepDirection stepDirection)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: 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_010d: 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_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_026f: Unknown result type (might be due to invalid IL or missing references)
if (!IsControlledWallClimbing(character))
{
return false;
}
Vector3 climbNormal = character.data.climbNormal;
if (((Vector3)(ref climbNormal)).sqrMagnitude < 0.0001f)
{
return false;
}
((Vector3)(ref climbNormal)).Normalize();
Vector3 val = Vector3.ProjectOnPlane(Vector3.up, climbNormal);
if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
{
return false;
}
((Vector3)(ref val)).Normalize();
Vector3 val2 = Vector3.Cross(climbNormal, val);
if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
{
return false;
}
((Vector3)(ref val2)).Normalize();
Vector3 val3 = Vector3.zero;
switch (stepDirection)
{
case StepDirection.Up:
val3 = val * Mathf.Max(0.01f, upStepDistance.Value);
break;
case StepDirection.Down:
val3 = -val * Mathf.Max(0.01f, downStepDistance.Value);
break;
case StepDirection.Left:
val3 = -val2 * Mathf.Max(0.01f, sideStepDistance.Value);
break;
case StepDirection.Right:
val3 = val2 * Mathf.Max(0.01f, sideStepDistance.Value);
break;
}
if (((Vector3)(ref val3)).sqrMagnitude < 0.0001f)
{
return false;
}
if (!ConsumeStepStamina(character))
{
return false;
}
character.refs.climbing.playerSlide = Vector2.zero;
CharacterData data = character.data;
data.climbPos += val3;
character.data.sinceGrounded = 0f;
if (logSuccessfulSteps.Value)
{
ManualLogSource modLogger = ModLogger;
if (modLogger != null)
{
modLogger.LogInfo((object)($"[RealControl] Step={stepDirection}, " + $"Distance={((Vector3)(ref val3)).magnitude:0.000}, " + $"StaminaCost={0.05f:0.00}, " + $"CurrentStamina={character.data.currentStamina:0.000}, " + $"ExtraStamina={character.data.extraStamina:0.000}, " + $"ClimbPos={character.data.climbPos}"));
}
}
return true;
}
private static void ProcessControlledClimbInput(CharacterInput characterInput, Character character, InputState state, bool upHeld, bool leftHeld, bool rightHeld, bool downHeld)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
bool usePrimaryWasPressed = characterInput.usePrimaryWasPressed;
bool useSecondaryWasPressed = characterInput.useSecondaryWasPressed;
characterInput.movementInput = Vector2.zero;
characterInput.usePrimaryWasReleased = false;
if (((state.NextHand == ExpectedHand.Left) ? usePrimaryWasPressed : useSecondaryWasPressed) && TryGetHeldDirection(upHeld, leftHeld, rightHeld, downHeld, out var stepDirection) && TryApplyStep(character, stepDirection))
{
state.NextHand = ((state.NextHand == ExpectedHand.Left) ? ExpectedHand.Right : ExpectedHand.Left);
}
characterInput.usePrimaryWasPressed = false;
characterInput.usePrimaryIsPressed = false;
characterInput.useSecondaryWasPressed = false;
characterInput.useSecondaryIsPressed = false;
characterInput.useSecondaryWasReleased = false;
}
}
namespace Sapphire009.RealControlMod;
internal static class AnimationFlow
{
private sealed class AnimationFlowState
{
public bool HasPositionSample;
public bool HasDirectionalPose;
public bool StepActive;
public bool IsFrozen;
public bool HasInputSampleSnapshot;
public float StepStartedTime;
public float TimeWithoutMovement;
public Vector2 LastDirection = Vector2.zero;
public Vector3 InputSampleStartClimbPosition = Vector3.zero;
public Vector3 LastCharacterCenter = Vector3.zero;
}
[HarmonyPatch(typeof(CharacterInput), "Sample", new Type[] { typeof(bool) })]
private static class CharacterInputStepDetectionPatch
{
[HarmonyPrefix]
[HarmonyPriority(800)]
private static void Prefix(CharacterInput __instance)
{
//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)
Character val = ResolveCharacter((Component)(object)__instance);
if (IsLocalNormalWallClimbing(val))
{
AnimationFlowState orCreateState = GetOrCreateState(val);
orCreateState.InputSampleStartClimbPosition = val.data.climbPos;
orCreateState.HasInputSampleSnapshot = true;
}
}
[HarmonyPostfix]
[HarmonyPriority(-200)]
private static void Postfix(CharacterInput __instance)
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
Character val = ResolveCharacter((Component)(object)__instance);
if (!IsLocalNormalWallClimbing(val))
{
return;
}
AnimationFlowState orCreateState = GetOrCreateState(val);
if (orCreateState.HasInputSampleSnapshot)
{
orCreateState.HasInputSampleSnapshot = false;
Vector3 worldMovement = val.data.climbPos - orCreateState.InputSampleStartClimbPosition;
if (!(((Vector3)(ref worldMovement)).sqrMagnitude <= 1E-06f) && TryConvertWorldMovementToInput(val, worldMovement, out var inputDirection))
{
BeginStepAnimation(val, orCreateState, inputDirection);
}
}
}
}
[HarmonyPatch(typeof(CharacterAnimations), "Update")]
private static class CharacterAnimationsFlowPatch
{
[HarmonyPostfix]
[HarmonyPriority(-200)]
private static void Postfix(CharacterAnimations __instance)
{
Character val = ResolveCharacter((Component)(object)__instance);
if (!((Object)(object)val == (Object)null) && val.IsLocal)
{
if (!IsLocalNormalWallClimbing(val))
{
RestoreAndRemoveState(val);
}
else
{
UpdateAnimationFlow(val);
}
}
}
}
[HarmonyPatch(typeof(CharacterClimbing), "StartClimbRpc", new Type[]
{
typeof(Vector3),
typeof(Vector3)
})]
private static class StartClimbAnimationFlowPatch
{
[HarmonyPostfix]
[HarmonyPriority(-200)]
private static void Postfix(CharacterClimbing __instance)
{
Character val = ResolveCharacter((Component)(object)__instance);
if (!((Object)(object)val == (Object)null) && val.IsLocal)
{
RestoreAndRemoveState(val);
}
}
}
[HarmonyPatch(typeof(CharacterClimbing), "StopClimbingRpc", new Type[] { typeof(float) })]
private static class StopClimbAnimationFlowPatch
{
[HarmonyPostfix]
[HarmonyPriority(-200)]
private static void Postfix(CharacterClimbing __instance)
{
Character val = ResolveCharacter((Component)(object)__instance);
if (!((Object)(object)val == (Object)null) && val.IsLocal)
{
RestoreAndRemoveState(val);
}
}
}
private const float AppliedStepSqrMagnitude = 1E-06f;
private const float MinimumDirectionalMovement = 0.0005f;
private const float MinimumStepAnimationTime = 0.12f;
private const float MovementStopGraceTime = 0.08f;
private const float MinimumDirectionSqrMagnitude = 0.0001f;
private const float MinimumAnimationSpeed = 0.01f;
private static readonly int ClimbJumpAnimationHash = Animator.StringToHash("Climb Jump");
private static readonly int InputXAnimationHash = Animator.StringToHash("Input X");
private static readonly int InputYAnimationHash = Animator.StringToHash("Input Y");
private static readonly Dictionary<int, AnimationFlowState> FlowStates = new Dictionary<int, AnimationFlowState>();
private static Character ResolveCharacter(Component component)
{
if ((Object)(object)component == (Object)null)
{
return null;
}
Character val = component.GetComponent<Character>();
if ((Object)(object)val == (Object)null)
{
val = component.GetComponentInParent<Character>();
}
return val;
}
private static bool IsLocalNormalWallClimbing(Character character)
{
if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null || character.refs == null || (Object)(object)character.refs.climbing == (Object)null || (Object)(object)character.refs.animator == (Object)null)
{
return false;
}
return character.data.isClimbing && !character.data.isRopeClimbing && !character.data.isVineClimbing && (Object)(object)character.data.currentClimbHandle == (Object)null;
}
private static AnimationFlowState GetOrCreateState(Character character)
{
//IL_002c: 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)
int instanceID = ((Object)character).GetInstanceID();
if (!FlowStates.TryGetValue(instanceID, out var value))
{
value = new AnimationFlowState();
value.HasPositionSample = true;
value.LastCharacterCenter = character.Center;
FlowStates.Add(instanceID, value);
}
return value;
}
private static float GetClimbAnimationSpeed(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
{
return 1f;
}
return Mathf.Max(0.01f, character.data.staminaMod);
}
private static bool TryGetWallAxes(Character character, out Vector3 wallUp, out Vector3 wallRight)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: 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_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
wallUp = Vector3.zero;
wallRight = Vector3.zero;
if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
{
return false;
}
Vector3 climbNormal = character.data.climbNormal;
if (((Vector3)(ref climbNormal)).sqrMagnitude <= 0.0001f)
{
return false;
}
((Vector3)(ref climbNormal)).Normalize();
wallUp = Vector3.ProjectOnPlane(Vector3.up, climbNormal);
if (((Vector3)(ref wallUp)).sqrMagnitude <= 0.0001f)
{
return false;
}
((Vector3)(ref wallUp)).Normalize();
wallRight = Vector3.Cross(climbNormal, wallUp);
if (((Vector3)(ref wallRight)).sqrMagnitude <= 0.0001f)
{
return false;
}
((Vector3)(ref wallRight)).Normalize();
return true;
}
private static bool TryConvertWorldMovementToInput(Character character, Vector3 worldMovement, out Vector2 inputDirection)
{
//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_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
inputDirection = Vector2.zero;
if (!TryGetWallAxes(character, out var wallUp, out var wallRight))
{
return false;
}
inputDirection = new Vector2(Vector3.Dot(worldMovement, wallRight), Vector3.Dot(worldMovement, wallUp));
if (((Vector2)(ref inputDirection)).sqrMagnitude <= 0.0001f)
{
inputDirection = Vector2.zero;
return false;
}
((Vector2)(ref inputDirection)).Normalize();
return true;
}
private static bool TryConvertInputToWorldDirection(Character character, Vector2 inputDirection, out Vector3 worldDirection)
{
//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_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
worldDirection = Vector3.zero;
if (((Vector2)(ref inputDirection)).sqrMagnitude <= 0.0001f)
{
return false;
}
if (!TryGetWallAxes(character, out var wallUp, out var wallRight))
{
return false;
}
worldDirection = wallRight * inputDirection.x + wallUp * inputDirection.y;
if (((Vector3)(ref worldDirection)).sqrMagnitude <= 0.0001f)
{
worldDirection = Vector3.zero;
return false;
}
((Vector3)(ref worldDirection)).Normalize();
return true;
}
private static Vector3 GetWallSurfaceMovement(Character character, Vector3 worldMovement)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: 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)
if (!TryGetWallAxes(character, out var wallUp, out var wallRight))
{
return Vector3.zero;
}
return wallRight * Vector3.Dot(worldMovement, wallRight) + wallUp * Vector3.Dot(worldMovement, wallUp);
}
private static void BeginStepAnimation(Character character, AnimationFlowState state, Vector2 direction)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)character == (Object)null) && state != null && !(((Vector2)(ref direction)).sqrMagnitude <= 0.0001f))
{
((Vector2)(ref direction)).Normalize();
state.LastDirection = direction;
state.HasDirectionalPose = true;
state.StepActive = true;
state.IsFrozen = false;
state.StepStartedTime = Time.unscaledTime;
state.TimeWithoutMovement = 0f;
ResumeAnimation(character, state);
}
}
private static void ApplyDirectionalAnimation(Animator animator, Vector2 direction)
{
//IL_0007: 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)
animator.SetFloat(InputXAnimationHash, direction.x);
animator.SetFloat(InputYAnimationHash, direction.y);
}
private static void ResumeAnimation(Character character, AnimationFlowState state)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
Animator animator = character.refs.animator;
animator.SetBool(ClimbJumpAnimationHash, false);
ApplyDirectionalAnimation(animator, state.LastDirection);
animator.speed = GetClimbAnimationSpeed(character);
state.IsFrozen = false;
}
private static void FreezeAnimation(Character character, AnimationFlowState state)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
Animator animator = character.refs.animator;
animator.SetBool(ClimbJumpAnimationHash, false);
ApplyDirectionalAnimation(animator, state.LastDirection);
animator.speed = 0f;
state.IsFrozen = true;
state.StepActive = false;
}
private static void RestoreAndRemoveState(Character character)
{
if ((Object)(object)character == (Object)null)
{
return;
}
int instanceID = ((Object)character).GetInstanceID();
if (FlowStates.TryGetValue(instanceID, out var _))
{
if (character.refs != null && (Object)(object)character.refs.animator != (Object)null)
{
character.refs.animator.speed = 1f;
}
FlowStates.Remove(instanceID);
}
}
private static void UpdateAnimationFlow(Character character)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
Animator animator = character.refs.animator;
AnimationFlowState orCreateState = GetOrCreateState(character);
Vector3 center = character.Center;
if (!orCreateState.HasPositionSample)
{
orCreateState.HasPositionSample = true;
orCreateState.LastCharacterCenter = center;
return;
}
Vector3 worldMovement = center - orCreateState.LastCharacterCenter;
Vector3 wallSurfaceMovement = GetWallSurfaceMovement(character, worldMovement);
bool flag = false;
if (orCreateState.StepActive && orCreateState.HasDirectionalPose && TryConvertInputToWorldDirection(character, orCreateState.LastDirection, out var worldDirection))
{
float num = Vector3.Dot(wallSurfaceMovement, worldDirection);
flag = num > 0.0005f;
}
if (orCreateState.StepActive && orCreateState.HasDirectionalPose)
{
float num2 = Time.unscaledTime - orCreateState.StepStartedTime;
if (flag || num2 < 0.12f)
{
orCreateState.TimeWithoutMovement = 0f;
ResumeAnimation(character, orCreateState);
}
else
{
orCreateState.TimeWithoutMovement += Time.unscaledDeltaTime;
if (orCreateState.TimeWithoutMovement >= 0.08f)
{
FreezeAnimation(character, orCreateState);
}
else
{
ResumeAnimation(character, orCreateState);
}
}
}
else if (orCreateState.HasDirectionalPose)
{
FreezeAnimation(character, orCreateState);
}
else
{
animator.SetBool(ClimbJumpAnimationHash, false);
}
orCreateState.LastCharacterCenter = center;
}
}
internal static class NoDelay
{
private enum MouseHand
{
None,
Left,
Right
}
private sealed class MouseDelayState
{
public bool WasNormalWallClimbing;
public MouseHand LastAcceptedHand = MouseHand.None;
public float LastAcceptedClickTime = float.NegativeInfinity;
public float LastPrimaryPressedTime = float.NegativeInfinity;
}
[HarmonyPatch(typeof(CharacterInput), "Sample", new Type[] { typeof(bool) })]
private static class CharacterInputSampleShortDelayPatch
{
[HarmonyPrefix]
[HarmonyPriority(800)]
private static void Prefix(CharacterInput __instance)
{
Character character = ResolveCharacter((Component)(object)__instance);
UpdateShortDelay(character);
}
[HarmonyPostfix]
[HarmonyPriority(800)]
private static void Postfix(CharacterInput __instance)
{
if (!((Object)(object)__instance == (Object)null))
{
Character character = ResolveCharacter((Component)(object)__instance);
ApplyMouseAlternationDelay(__instance, character);
}
}
}
[HarmonyPatch(typeof(CharacterClimbing), "RPCA_ClimbJump")]
private static class ClimbJumpShortDelayPatch
{
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void Postfix(CharacterClimbing __instance)
{
Character val = ResolveCharacter((Component)(object)__instance);
if (IsLocalNormalWallClimbing(val))
{
val.data.sinceClimbJump = 0f;
}
}
}
[HarmonyPatch(typeof(CharacterClimbing), "StartClimbRpc", new Type[]
{
typeof(Vector3),
typeof(Vector3)
})]
private static class StartClimbShortDelayPatch
{
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void Postfix(CharacterClimbing __instance)
{
Character val = ResolveCharacter((Component)(object)__instance);
if (IsLocalNormalWallClimbing(val))
{
val.data.sinceClimbJump = 0f;
MouseDelayState orCreateMouseDelayState = GetOrCreateMouseDelayState(val);
BeginMouseAlternationForClimb(orCreateMouseDelayState);
}
}
}
private const float ShortClimbDelay = 0.5f;
private const float ReadyClimbJumpTime = 2f;
private const float MouseAlternationDelay = 0.5f;
private const float NormalGrabDetectionWindow = 0.75f;
private static readonly Dictionary<int, MouseDelayState> MouseDelayStates = new Dictionary<int, MouseDelayState>();
private static Character ResolveCharacter(Component component)
{
if ((Object)(object)component == (Object)null)
{
return null;
}
Character val = component.GetComponent<Character>();
if ((Object)(object)val == (Object)null)
{
val = component.GetComponentInParent<Character>();
}
return val;
}
private static MouseDelayState GetOrCreateMouseDelayState(Character character)
{
int instanceID = ((Object)character).GetInstanceID();
if (!MouseDelayStates.TryGetValue(instanceID, out var value))
{
value = new MouseDelayState();
MouseDelayStates.Add(instanceID, value);
}
return value;
}
private static bool IsLocalCharacter(Character character)
{
return (Object)(object)character != (Object)null && character.IsLocal && (Object)(object)character.data != (Object)null;
}
private static bool IsLocalNormalWallClimbing(Character character)
{
if (!IsLocalCharacter(character))
{
return false;
}
return character.data.isClimbing && !character.data.isRopeClimbing && !character.data.isVineClimbing && (Object)(object)character.data.currentClimbHandle == (Object)null;
}
private static void UpdateShortDelay(Character character)
{
if (IsLocalNormalWallClimbing(character) && character.data.sinceClimbJump >= 0.5f && character.data.sinceClimbJump < 2f)
{
character.data.sinceClimbJump = 2f;
}
}
private static void ResetMouseAlternation(MouseDelayState state)
{
state.LastAcceptedHand = MouseHand.None;
state.LastAcceptedClickTime = float.NegativeInfinity;
}
private static void BeginMouseAlternationForClimb(MouseDelayState state)
{
if (Time.unscaledTime - state.LastPrimaryPressedTime <= 0.75f)
{
state.LastAcceptedHand = MouseHand.Left;
state.LastAcceptedClickTime = state.LastPrimaryPressedTime;
}
else
{
ResetMouseAlternation(state);
}
state.WasNormalWallClimbing = true;
}
private static bool CanAcceptOppositeClick(MouseDelayState state, MouseHand pressedHand)
{
if (state.LastAcceptedHand == MouseHand.None)
{
return true;
}
if (state.LastAcceptedHand == pressedHand)
{
return false;
}
float num = Time.unscaledTime - state.LastAcceptedClickTime;
return num >= 0.5f;
}
private static void AcceptClick(MouseDelayState state, MouseHand pressedHand)
{
state.LastAcceptedHand = pressedHand;
state.LastAcceptedClickTime = Time.unscaledTime;
}
private static void SuppressPrimaryClick(CharacterInput characterInput)
{
characterInput.usePrimaryWasPressed = false;
characterInput.usePrimaryIsPressed = false;
}
private static void SuppressSecondaryClick(CharacterInput characterInput)
{
characterInput.useSecondaryWasPressed = false;
characterInput.useSecondaryIsPressed = false;
}
private static void ProcessPrimaryClick(CharacterInput characterInput, MouseDelayState state)
{
if (characterInput.usePrimaryWasPressed)
{
if (!CanAcceptOppositeClick(state, MouseHand.Left))
{
SuppressPrimaryClick(characterInput);
}
else
{
AcceptClick(state, MouseHand.Left);
}
}
}
private static void ProcessSecondaryClick(CharacterInput characterInput, MouseDelayState state)
{
if (characterInput.useSecondaryWasPressed)
{
if (!CanAcceptOppositeClick(state, MouseHand.Right))
{
SuppressSecondaryClick(characterInput);
}
else
{
AcceptClick(state, MouseHand.Right);
}
}
}
private static void ApplyMouseAlternationDelay(CharacterInput characterInput, Character character)
{
if (!IsLocalCharacter(character))
{
return;
}
MouseDelayState orCreateMouseDelayState = GetOrCreateMouseDelayState(character);
if (!IsLocalNormalWallClimbing(character))
{
if (characterInput.usePrimaryWasPressed)
{
orCreateMouseDelayState.LastPrimaryPressedTime = Time.unscaledTime;
}
orCreateMouseDelayState.WasNormalWallClimbing = false;
ResetMouseAlternation(orCreateMouseDelayState);
return;
}
if (!orCreateMouseDelayState.WasNormalWallClimbing)
{
if (characterInput.usePrimaryWasPressed)
{
orCreateMouseDelayState.LastPrimaryPressedTime = Time.unscaledTime;
}
BeginMouseAlternationForClimb(orCreateMouseDelayState);
}
bool usePrimaryWasPressed = characterInput.usePrimaryWasPressed;
bool useSecondaryWasPressed = characterInput.useSecondaryWasPressed;
if (usePrimaryWasPressed && useSecondaryWasPressed)
{
if (orCreateMouseDelayState.LastAcceptedHand == MouseHand.Left)
{
SuppressPrimaryClick(characterInput);
ProcessSecondaryClick(characterInput, orCreateMouseDelayState);
}
else if (orCreateMouseDelayState.LastAcceptedHand == MouseHand.Right)
{
SuppressSecondaryClick(characterInput);
ProcessPrimaryClick(characterInput, orCreateMouseDelayState);
}
else
{
SuppressSecondaryClick(characterInput);
ProcessPrimaryClick(characterInput, orCreateMouseDelayState);
}
}
else
{
ProcessPrimaryClick(characterInput, orCreateMouseDelayState);
ProcessSecondaryClick(characterInput, orCreateMouseDelayState);
}
}
}
internal static class NoWall
{
[HarmonyPatch(typeof(CharacterClimbing), "Update")]
private static class CharacterClimbingUpdatePatch
{
[HarmonyPrefix]
[HarmonyPriority(800)]
private static bool Prefix(CharacterClimbing __instance)
{
Character val = ResolveCharacter((Component)(object)__instance);
if (!IsLocalCharacter(val))
{
return true;
}
KeepOrClearReleaseLock(val);
if (!IsLocalNormalWallClimbing(val))
{
return true;
}
if ((Object)(object)val.input != (Object)null)
{
val.input.jumpWasPressed = false;
}
if (!IsAtReleaseThreshold(val))
{
return true;
}
StopClimbingImmediately(__instance, val);
return false;
}
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void Postfix(CharacterClimbing __instance)
{
Character character = ResolveCharacter((Component)(object)__instance);
if (IsLocalNormalWallClimbing(character) && IsAtReleaseThreshold(character))
{
StopClimbingImmediately(__instance, character);
}
}
}
[HarmonyPatch(typeof(CharacterClimbing), "TryToStartWallClimb")]
private static class TryToStartWallClimbPatch
{
[HarmonyPrefix]
[HarmonyPriority(800)]
private static bool Prefix(CharacterClimbing __instance)
{
Character character = ResolveCharacter((Component)(object)__instance);
if (!IsLocalCharacter(character))
{
return true;
}
return !KeepOrClearReleaseLock(character);
}
}
[HarmonyPatch(typeof(CharacterClimbing), "StartClimbRpc", new Type[]
{
typeof(Vector3),
typeof(Vector3)
})]
private static class StartClimbRpcPatch
{
[HarmonyPrefix]
[HarmonyPriority(800)]
private static bool Prefix(CharacterClimbing __instance)
{
Character character = ResolveCharacter((Component)(object)__instance);
if (!IsLocalCharacter(character))
{
return true;
}
return !KeepOrClearReleaseLock(character);
}
}
[HarmonyPatch(typeof(Character), "OnDestroy")]
private static class CharacterOnDestroyPatch
{
[HarmonyPostfix]
private static void Postfix(Character __instance)
{
RemoveReleaseLock(__instance);
}
}
private const float ReleaseStaminaThreshold = 0.049f;
private const float ComparisonEpsilon = 0.0005f;
private static readonly HashSet<int> ForcedReleaseLocks = new HashSet<int>();
private static Character ResolveCharacter(Component component)
{
if ((Object)(object)component == (Object)null)
{
return null;
}
Character val = component.GetComponent<Character>();
if ((Object)(object)val == (Object)null)
{
val = component.GetComponentInParent<Character>();
}
return val;
}
private static bool IsLocalCharacter(Character character)
{
return (Object)(object)character != (Object)null && character.refs != null && (Object)(object)character.refs.view != (Object)null && character.refs.view.IsMine;
}
private static bool IsNormalWallClimbing(Character character)
{
return (Object)(object)character != (Object)null && (Object)(object)character.data != (Object)null && character.refs != null && (Object)(object)character.refs.climbing != (Object)null && character.data.isClimbing && !character.data.isRopeClimbing && !character.data.isVineClimbing && (Object)(object)character.data.currentClimbHandle == (Object)null;
}
private static bool IsLocalNormalWallClimbing(Character character)
{
return IsLocalCharacter(character) && IsNormalWallClimbing(character);
}
private static float GetRemainingStamina(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
{
return float.MaxValue;
}
return Mathf.Max(0f, character.data.currentStamina) + Mathf.Max(0f, character.data.extraStamina);
}
private static bool IsAtReleaseThreshold(Character character)
{
return GetRemainingStamina(character) <= 0.0495f;
}
private static bool IsPrimaryActuallyHeld(Character character)
{
if (CharacterInput.action_usePrimary != null)
{
return CharacterInput.action_usePrimary.IsPressed();
}
return (Object)(object)character != (Object)null && (Object)(object)character.input != (Object)null && character.input.usePrimaryIsPressed;
}
private static bool HasReleaseLock(Character character)
{
return (Object)(object)character != (Object)null && ForcedReleaseLocks.Contains(((Object)character).GetInstanceID());
}
private static void AddReleaseLock(Character character)
{
if (!((Object)(object)character == (Object)null))
{
ForcedReleaseLocks.Add(((Object)character).GetInstanceID());
}
}
private static void RemoveReleaseLock(Character character)
{
if (!((Object)(object)character == (Object)null))
{
ForcedReleaseLocks.Remove(((Object)character).GetInstanceID());
}
}
private static bool KeepOrClearReleaseLock(Character character)
{
if (!HasReleaseLock(character))
{
return false;
}
bool flag = !IsAtReleaseThreshold(character);
bool flag2 = !IsPrimaryActuallyHeld(character);
if (flag && flag2)
{
RemoveReleaseLock(character);
return false;
}
if ((Object)(object)character.data != (Object)null)
{
character.data.sincePressClimb = 10f;
}
return true;
}
private static void StopClimbingImmediately(CharacterClimbing climbing, Character character)
{
//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 (!((Object)(object)climbing == (Object)null) && !((Object)(object)character == (Object)null) && !((Object)(object)character.data == (Object)null))
{
AddReleaseLock(character);
if ((Object)(object)character.input != (Object)null)
{
character.input.jumpWasPressed = false;
}
character.data.sincePressClimb = 10f;
climbing.playerSlide = Vector2.zero;
if (character.data.isClimbing)
{
climbing.StopClimbingRpc(0f);
}
if (PhotonNetwork.InRoom && character.refs != null && (Object)(object)character.refs.view != (Object)null)
{
character.refs.view.RPC("StopClimbingRpc", (RpcTarget)1, new object[1] { 0f });
}
}
}
}
internal static class StopStamina
{
[HarmonyPatch(typeof(Character), "UseStamina", new Type[]
{
typeof(float),
typeof(bool)
})]
private static class CharacterUseStaminaPatch
{
[HarmonyPrefix]
[HarmonyPriority(800)]
private static bool Prefix(Character __instance, float __0, ref bool __result)
{
if (!IsNormalWallClimbing(__instance))
{
return true;
}
if (__0 <= 0f)
{
return true;
}
if (__0 >= 0.099f)
{
return true;
}
__instance.data.sinceUseStamina = 0f;
__result = true;
return false;
}
}
private const float DashStaminaCost = 0.1f;
private const float ComparisonEpsilon = 0.001f;
private static bool IsNormalWallClimbing(Character character)
{
if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null)
{
return false;
}
return character.data.isClimbing && !character.data.isRopeClimbing && !character.data.isVineClimbing && (Object)(object)character.data.currentClimbHandle == (Object)null;
}
}
