using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.InputSystem;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Toggle Melee Stance")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Toggle Melee Stance")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a7db406a-f689-4a93-87dd-978986c6f891")]
[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")]
namespace ToggleMeleeStance;
[BepInPlugin("kumo.sulfur.toggle_melee_stance", "Toggle Melee Stance", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
private sealed class ToggleState
{
public bool IsToggled;
public bool AttackInProgress;
public bool SheatheAfterAttack;
public bool SuppressMeleeUntilReleased;
public float NextChargeAttemptTime;
}
private sealed class SafeAnimatorState
{
public bool Valid;
public int FullPathHash;
public int ShortNameHash;
public string ClipName;
}
public const string PluginGuid = "kumo.sulfur.toggle_melee_stance";
public const string PluginName = "Toggle Melee Stance";
public const string PluginVersion = "1.0.0";
public const string MeleeExpansionGuid = "kumo.sulfur.melee_expansion";
internal static ManualLogSource Log;
internal static ConfigEntry<bool> EnableMod;
internal static ConfigEntry<bool> FirePerformsMeleeAttack;
internal static ConfigEntry<bool> ResetMeleeAnimatorBeforeSheathe;
internal static ConfigEntry<bool> DisableWhenMeleeExpansionDetected;
internal static ConfigEntry<float> ReChargeRetryInterval;
internal static ConfigEntry<bool> LogStateChanges;
private Harmony harmony;
private static Type equipmentManagerType;
private static Type weaponType;
private static MethodInfo mHandleAimInput;
private static MethodInfo mHandleMeleeInput;
private static MethodInfo mPullTrigger;
private static MethodInfo mReleaseTrigger;
private static MethodInfo mChargeBasicMelee;
private static MethodInfo mUseBasicMelee;
private static MethodInfo mOnMeleeDone;
private static MethodInfo mReportMeleeDone;
private static MethodInfo mIsMeleeCharging;
private static MethodInfo mChargeMelee;
private static MethodInfo mSetAlternativeState;
private static PropertyInfo pIsMelee;
private static PropertyInfo pAnimator;
private static FieldInfo fAltFireAction;
private static FieldInfo fMeleeFireAction;
private static FieldInfo fMeleeFireActionAlternative;
private static FieldInfo fCurrentHoldable;
private static FieldInfo fEquipmentManager;
private static FieldInfo fIsInMeleeCharge;
private static FieldInfo fMeleePressed;
private static FieldInfo fAlternativeMeleePressed;
private static FieldInfo fAimingInputHeld;
private static FieldInfo fMeleeInputCooldown;
private static FieldInfo fCurrentParries;
private static readonly ConditionalWeakTable<object, ToggleState> States = new ConditionalWeakTable<object, ToggleState>();
private static readonly ConditionalWeakTable<object, SafeAnimatorState> SafeAnimatorStates = new ConditionalWeakTable<object, SafeAnimatorState>();
private void Awake()
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enable Toggle Melee Stance.");
FirePerformsMeleeAttack = ((BaseUnityPlugin)this).Config.Bind<bool>("Melee", "FirePerformsMeleeAttack", true, "When melee stance is toggled on, pressing the normal Fire action performs one melee attack.");
ReChargeRetryInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Melee", "ReChargeRetryInterval", 0.08f, new ConfigDescription("Seconds between retry attempts when the mod tries to re-enter melee charge after an attack.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 0.5f), Array.Empty<object>()));
ResetMeleeAnimatorBeforeSheathe = ((BaseUnityPlugin)this).Config.Bind<bool>("Visual", "ResetMeleeAnimatorBeforeSheathe", true, "Before sheathing a toggled melee weapon, reset its Animator to the cached safe equip state. This prevents stale idle states from causing a slash-frame flash on the next draw.");
DisableWhenMeleeExpansionDetected = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "DisableWhenMeleeExpansionDetected", true, "Disable this standalone mod when kumo.sulfur.melee_expansion is installed.");
LogStateChanges = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "LogStateChanges", false, "Log toggle melee state changes. Keep false for normal gameplay.");
if (DisableWhenMeleeExpansionDetected.Value && Chainloader.PluginInfos.ContainsKey("kumo.sulfur.melee_expansion"))
{
((BaseUnityPlugin)this).Logger.LogInfo((object)"Melee Expansion detected. Toggle Melee Stance will stay disabled.");
return;
}
if (!InitializeReflection())
{
((BaseUnityPlugin)this).Logger.LogError((object)"Reflection initialization failed. Mod will not patch.");
return;
}
harmony = new Harmony("kumo.sulfur.toggle_melee_stance");
Patch(mHandleAimInput, "HandleAimInputPrefix");
Patch(mHandleMeleeInput, "HandleMeleeInputPrefix");
Patch(mPullTrigger, "PullTriggerPrefix");
Patch(mReleaseTrigger, "ReleaseTriggerPrefix");
Patch(mReportMeleeDone, "ReportMeleeDonePrefix", "ReportMeleeDonePostfix");
Patch(mChargeMelee, null, "ChargeMeleePostfix");
((BaseUnityPlugin)this).Logger.LogInfo((object)"Toggle Melee Stance loaded.");
}
private void OnDestroy()
{
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
}
private static bool InitializeReflection()
{
equipmentManagerType = AccessTools.TypeByName("PerfectRandom.Sulfur.Core.Items.EquipmentManager");
weaponType = AccessTools.TypeByName("PerfectRandom.Sulfur.Core.Weapons.Weapon");
if (equipmentManagerType == null)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)"Could not find EquipmentManager type.");
}
return false;
}
if (weaponType == null)
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogError((object)"Could not find Weapon type.");
}
return false;
}
mHandleAimInput = AccessTools.Method(equipmentManagerType, "HandleAimInput", new Type[1] { typeof(bool) }, (Type[])null);
mHandleMeleeInput = AccessTools.Method(equipmentManagerType, "HandleMeleeInput", new Type[1] { typeof(bool) }, (Type[])null);
mPullTrigger = AccessTools.Method(equipmentManagerType, "PullTrigger", (Type[])null, (Type[])null);
mReleaseTrigger = AccessTools.Method(equipmentManagerType, "ReleaseTrigger", (Type[])null, (Type[])null);
mChargeBasicMelee = AccessTools.Method(equipmentManagerType, "ChargeBasicMelee", (Type[])null, (Type[])null);
mUseBasicMelee = AccessTools.Method(equipmentManagerType, "UseBasicMelee", (Type[])null, (Type[])null);
mOnMeleeDone = AccessTools.Method(equipmentManagerType, "OnMeleeDone", (Type[])null, (Type[])null);
mReportMeleeDone = AccessTools.Method(weaponType, "ReportMeleeDone", (Type[])null, (Type[])null);
mIsMeleeCharging = AccessTools.Method(weaponType, "IsMeleeCharging", (Type[])null, (Type[])null);
mChargeMelee = AccessTools.Method(weaponType, "ChargeMelee", new Type[1] { typeof(bool) }, (Type[])null);
mSetAlternativeState = AccessTools.Method(weaponType, "SetAlternativeState", new Type[1] { typeof(int) }, (Type[])null);
pIsMelee = AccessTools.Property(weaponType, "IsMelee");
pAnimator = FindPropertyRecursive(weaponType, "Animator");
fAltFireAction = FindFieldRecursive(equipmentManagerType, "altFireAction");
fMeleeFireAction = FindFieldRecursive(equipmentManagerType, "meleeFireAction");
fMeleeFireActionAlternative = FindFieldRecursive(equipmentManagerType, "meleeFireActionAlternative");
fCurrentHoldable = FindFieldRecursive(equipmentManagerType, "currentHoldable");
fEquipmentManager = FindFieldRecursive(weaponType, "equipmentManager");
fIsInMeleeCharge = FindFieldRecursive(equipmentManagerType, "<isInMeleeCharge>k__BackingField", "isInMeleeCharge");
fMeleePressed = FindFieldRecursive(equipmentManagerType, "<meleePressed>k__BackingField", "meleePressed");
fAlternativeMeleePressed = FindFieldRecursive(equipmentManagerType, "<alternativeMeleePressed>k__BackingField", "alternativeMeleePressed");
fAimingInputHeld = FindFieldRecursive(equipmentManagerType, "<AimingInputHeld>k__BackingField", "AimingInputHeld");
fMeleeInputCooldown = FindFieldRecursive(equipmentManagerType, "meleeInputCooldown");
fCurrentParries = FindFieldRecursive(weaponType, "currentParries");
return Require(mHandleAimInput, "EquipmentManager.HandleAimInput(bool)") && Require(mHandleMeleeInput, "EquipmentManager.HandleMeleeInput(bool)") && Require(mPullTrigger, "EquipmentManager.PullTrigger()") && Require(mReleaseTrigger, "EquipmentManager.ReleaseTrigger()") && Require(mChargeBasicMelee, "EquipmentManager.ChargeBasicMelee()") && Require(mUseBasicMelee, "EquipmentManager.UseBasicMelee()") && Require(mOnMeleeDone, "EquipmentManager.OnMeleeDone()") && Require(mReportMeleeDone, "Weapon.ReportMeleeDone()") && Require(mIsMeleeCharging, "Weapon.IsMeleeCharging()") && Require(mChargeMelee, "Weapon.ChargeMelee(bool)") && Require(mSetAlternativeState, "Weapon.SetAlternativeState(int)") && Require(pIsMelee, "Weapon.IsMelee") && Require(pAnimator, "Holdable.Animator") && Require(fAltFireAction, "EquipmentManager.altFireAction") && Require(fMeleeFireAction, "EquipmentManager.meleeFireAction") && Require(fMeleeFireActionAlternative, "EquipmentManager.meleeFireActionAlternative") && Require(fCurrentHoldable, "EquipmentManager.currentHoldable") && Require(fEquipmentManager, "Weapon.equipmentManager") && Require(fIsInMeleeCharge, "EquipmentManager.isInMeleeCharge") && Require(fMeleePressed, "EquipmentManager.meleePressed") && Require(fAlternativeMeleePressed, "EquipmentManager.alternativeMeleePressed") && Require(fAimingInputHeld, "EquipmentManager.AimingInputHeld") && Require(fMeleeInputCooldown, "EquipmentManager.meleeInputCooldown");
}
private static bool Require(MemberInfo member, string name)
{
if (member != null)
{
return true;
}
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Missing required member: " + name));
}
return false;
}
private void Patch(MethodInfo original, string prefix = null, string postfix = null)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
HarmonyMethod val = null;
HarmonyMethod val2 = null;
if (!string.IsNullOrEmpty(prefix))
{
val = new HarmonyMethod(AccessTools.Method(typeof(Plugin), prefix, (Type[])null, (Type[])null));
}
if (!string.IsNullOrEmpty(postfix))
{
val2 = new HarmonyMethod(AccessTools.Method(typeof(Plugin), postfix, (Type[])null, (Type[])null));
}
harmony.Patch((MethodBase)original, val, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
private static FieldInfo FindFieldRecursive(Type type, params string[] names)
{
Type type2 = type;
while (type2 != null)
{
foreach (string text in names)
{
FieldInfo fieldInfo = AccessTools.Field(type2, text);
if (fieldInfo != null)
{
return fieldInfo;
}
}
type2 = type2.BaseType;
}
return null;
}
private static PropertyInfo FindPropertyRecursive(Type type, string name)
{
Type type2 = type;
while (type2 != null)
{
PropertyInfo propertyInfo = AccessTools.Property(type2, name);
if (propertyInfo != null)
{
return propertyInfo;
}
type2 = type2.BaseType;
}
return null;
}
private static ToggleState GetState(object equipmentManager)
{
return States.GetValue(equipmentManager, (object _) => new ToggleState());
}
private static bool IsModActive()
{
return EnableMod != null && EnableMod.Value;
}
private static void HandleAimInputPrefix(object __instance, ref bool holdingMeleeAction)
{
if (IsModActive())
{
ToggleState state = GetState(__instance);
if (state.IsToggled)
{
holdingMeleeAction = true;
}
}
}
private static bool HandleMeleeInputPrefix(object __instance, bool holdingMeleeAction)
{
if (!IsModActive())
{
return true;
}
ToggleState state = GetState(__instance);
if (state.SuppressMeleeUntilReleased)
{
if (IsMeleeHeld(__instance))
{
return false;
}
state.SuppressMeleeUntilReleased = false;
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)"Melee input released after manual sheathe. Input suppression cleared.");
}
}
return false;
}
bool flag = WasMeleePressedThisFrame(__instance);
if (!state.IsToggled && IsAimingInputHeld(__instance) && holdingMeleeAction)
{
return true;
}
if (!state.IsToggled && IsMeleeInputCoolingDown(__instance))
{
return true;
}
if (flag)
{
if (!state.IsToggled)
{
ToggleOn(__instance, state);
return false;
}
ToggleOff(__instance, state);
return false;
}
if (state.IsToggled)
{
MaintainToggledMelee(__instance, state);
return false;
}
return true;
}
private static bool PullTriggerPrefix(object __instance)
{
if (!IsModActive())
{
return true;
}
ToggleState state = GetState(__instance);
if (!state.IsToggled)
{
return true;
}
if (!FirePerformsMeleeAttack.Value)
{
return false;
}
object currentHoldable = GetCurrentHoldable(__instance);
if (!IsMeleeWeapon(currentHoldable))
{
MaintainToggledMelee(__instance, state);
return false;
}
if (!IsMeleeCharging(currentHoldable))
{
MaintainToggledMelee(__instance, state);
return false;
}
if (state.AttackInProgress)
{
return false;
}
state.AttackInProgress = true;
state.SheatheAfterAttack = false;
state.SuppressMeleeUntilReleased = false;
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)"Fire action converted to melee attack.");
}
}
InvokeUseBasicMelee(__instance);
return false;
}
private static bool ReleaseTriggerPrefix(object __instance)
{
if (!IsModActive())
{
return true;
}
ToggleState state = GetState(__instance);
if (!state.IsToggled && !state.AttackInProgress && !state.SheatheAfterAttack)
{
return true;
}
return false;
}
private static void ReportMeleeDonePrefix(object __instance)
{
if (!IsModActive())
{
return;
}
object equipmentManagerFromWeapon = GetEquipmentManagerFromWeapon(__instance);
if (equipmentManagerFromWeapon != null)
{
ToggleState state = GetState(equipmentManagerFromWeapon);
if (state.IsToggled || state.AttackInProgress || state.SheatheAfterAttack)
{
PrepareMeleeAnimatorForFutureDraw(__instance);
}
}
}
private static void ReportMeleeDonePostfix(object __instance)
{
if (!IsModActive())
{
return;
}
object equipmentManagerFromWeapon = GetEquipmentManagerFromWeapon(__instance);
if (equipmentManagerFromWeapon == null)
{
return;
}
ToggleState state = GetState(equipmentManagerFromWeapon);
if (state.SheatheAfterAttack)
{
state.AttackInProgress = false;
state.SheatheAfterAttack = false;
state.IsToggled = false;
state.SuppressMeleeUntilReleased = true;
state.NextChargeAttemptTime = 0f;
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)"Melee attack finished. Staying sheathed.");
}
}
return;
}
if (!state.IsToggled)
{
state.AttackInProgress = false;
state.NextChargeAttemptTime = 0f;
return;
}
state.AttackInProgress = false;
state.NextChargeAttemptTime = Time.time + ClampRetryInterval();
if (LogStateChanges.Value)
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogInfo((object)"Melee attack finished. Re-entering toggled melee stance.");
}
}
InvokeChargeBasicMelee(equipmentManagerFromWeapon);
}
private static void ChargeMeleePostfix(object __instance, bool state)
{
if (IsModActive() && state)
{
CacheSafeMeleeAnimatorStateIfUseful(__instance, "ChargeMelee(true)");
}
}
private static void ToggleOn(object equipmentManager, ToggleState state)
{
state.IsToggled = true;
state.AttackInProgress = false;
state.SheatheAfterAttack = false;
state.SuppressMeleeUntilReleased = false;
state.NextChargeAttemptTime = Time.time + ClampRetryInterval();
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)"Toggle melee ON.");
}
}
InvokeChargeBasicMelee(equipmentManager);
SetMeleePressed(equipmentManager, value: true);
}
private static void ToggleOff(object equipmentManager, ToggleState state)
{
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)"Toggle melee OFF.");
}
}
state.IsToggled = false;
state.NextChargeAttemptTime = 0f;
state.SuppressMeleeUntilReleased = true;
SetAlternativeMeleePressed(equipmentManager, value: false);
SetMeleePressed(equipmentManager, value: false);
object currentHoldable = GetCurrentHoldable(equipmentManager);
if (state.AttackInProgress)
{
state.SheatheAfterAttack = true;
if (LogStateChanges.Value)
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogInfo((object)"Melee attack is in progress. Will sheathe after current attack finishes.");
}
}
}
else
{
state.AttackInProgress = false;
state.SheatheAfterAttack = false;
CleanCurrentMeleeWeaponState(currentHoldable);
InvokeOnMeleeDone(equipmentManager);
}
}
private static void MaintainToggledMelee(object equipmentManager, ToggleState state)
{
if (!state.AttackInProgress && !state.SheatheAfterAttack)
{
bool flag = IsAltFirePressed(equipmentManager);
SetAlternativeMeleePressed(equipmentManager, flag);
UpdateCurrentMeleeAlternativeAnimator(equipmentManager, flag);
if (!IsInMeleeCharge(equipmentManager) && !(Time.time < state.NextChargeAttemptTime))
{
state.NextChargeAttemptTime = Time.time + ClampRetryInterval();
InvokeChargeBasicMelee(equipmentManager);
SetMeleePressed(equipmentManager, value: true);
}
}
}
private static void CacheSafeMeleeAnimatorStateIfUseful(object weapon, string source)
{
//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)
if (!IsMeleeWeapon(weapon))
{
return;
}
Animator animator = GetAnimator(weapon);
if ((Object)(object)animator == (Object)null)
{
return;
}
AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(0);
string currentClipName = GetCurrentClipName(animator);
if (!IsSafeMeleeDrawClip(currentClipName))
{
return;
}
SafeAnimatorState value = SafeAnimatorStates.GetValue(weapon, (object _) => new SafeAnimatorState());
value.FullPathHash = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash;
value.ShortNameHash = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).shortNameHash;
value.ClipName = currentClipName;
value.Valid = true;
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)("Cached safe melee animator state from " + source + ": clip=" + currentClipName + " fullPathHash=" + ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash));
}
}
}
private static bool IsSafeMeleeDrawClip(string clipName)
{
if (string.IsNullOrEmpty(clipName))
{
return false;
}
if (ContainsIgnoreCase(clipName, "Slash"))
{
return false;
}
if (ContainsIgnoreCase(clipName, "Attack"))
{
return false;
}
if (ContainsIgnoreCase(clipName, "Fire"))
{
return false;
}
if (ContainsIgnoreCase(clipName, "ADS"))
{
return false;
}
if (ContainsIgnoreCase(clipName, "ToADS"))
{
return false;
}
if (ContainsIgnoreCase(clipName, "Charge") || ContainsIgnoreCase(clipName, "Charged"))
{
return false;
}
return ContainsIgnoreCase(clipName, "Equip");
}
private static bool ContainsIgnoreCase(string value, string part)
{
return value != null && part != null && value.IndexOf(part, StringComparison.OrdinalIgnoreCase) >= 0;
}
private static void PrepareMeleeAnimatorForFutureDraw(object weapon)
{
if (!ResetMeleeAnimatorBeforeSheathe.Value || !IsMeleeWeapon(weapon))
{
return;
}
try
{
InvokeSetAlternativeState(weapon, 0);
if (fCurrentParries != null)
{
fCurrentParries.SetValue(weapon, 0);
}
Animator animator = GetAnimator(weapon);
if ((Object)(object)animator == (Object)null)
{
return;
}
animator.SetBool("Charge", false);
animator.SetBool("Sprinting", false);
animator.SetBool("AlternativePressed", false);
animator.ResetTrigger("Parry");
if (!SafeAnimatorStates.TryGetValue(weapon, out var value) || value == null || !value.Valid)
{
CacheSafeMeleeAnimatorStateIfUseful(weapon, "PrepareMeleeAnimatorForFutureDraw fallback");
if (!SafeAnimatorStates.TryGetValue(weapon, out value) || value == null || !value.Valid)
{
if (LogStateChanges.Value)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)("No cached safe melee animator state available for " + weapon));
}
}
return;
}
}
animator.Play(value.FullPathHash, 0, 0f);
animator.Update(0f);
if (LogStateChanges.Value)
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogInfo((object)("Reset melee animator to safe draw state before sheathe: " + value.ClipName + " hash=" + value.FullPathHash));
}
}
}
catch (Exception ex)
{
ManualLogSource log3 = Log;
if (log3 != null)
{
log3.LogError((object)("Failed to prepare melee animator for future draw: " + ex));
}
}
}
private static void CleanCurrentMeleeWeaponState(object currentHoldable)
{
if (!IsMeleeWeapon(currentHoldable))
{
return;
}
try
{
PrepareMeleeAnimatorForFutureDraw(currentHoldable);
}
catch (Exception ex)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Failed to clean melee weapon state: " + ex));
}
}
}
private static string GetCurrentClipName(Animator animator)
{
if ((Object)(object)animator == (Object)null)
{
return string.Empty;
}
try
{
AnimatorClipInfo[] currentAnimatorClipInfo = animator.GetCurrentAnimatorClipInfo(0);
if (currentAnimatorClipInfo != null && currentAnimatorClipInfo.Length != 0 && (Object)(object)((AnimatorClipInfo)(ref currentAnimatorClipInfo[0])).clip != (Object)null)
{
return ((Object)((AnimatorClipInfo)(ref currentAnimatorClipInfo[0])).clip).name;
}
}
catch
{
return string.Empty;
}
return string.Empty;
}
private static float ClampRetryInterval()
{
if (ReChargeRetryInterval == null)
{
return 0.08f;
}
float value = ReChargeRetryInterval.Value;
if (float.IsNaN(value) || float.IsInfinity(value))
{
return 0.08f;
}
return Mathf.Clamp(value, 0.01f, 0.5f);
}
private static bool WasMeleePressedThisFrame(object equipmentManager)
{
InputAction inputAction = GetInputAction(fMeleeFireAction, equipmentManager);
InputAction inputAction2 = GetInputAction(fMeleeFireActionAlternative, equipmentManager);
return WasPerformedThisFrame(inputAction) || WasPerformedThisFrame(inputAction2);
}
private static bool IsMeleeHeld(object equipmentManager)
{
InputAction inputAction = GetInputAction(fMeleeFireAction, equipmentManager);
InputAction inputAction2 = GetInputAction(fMeleeFireActionAlternative, equipmentManager);
bool flag = inputAction != null && inputAction.IsPressed();
bool flag2 = inputAction2 != null && inputAction2.IsPressed();
return flag || flag2;
}
private static bool IsAltFirePressed(object equipmentManager)
{
InputAction inputAction = GetInputAction(fAltFireAction, equipmentManager);
return inputAction != null && inputAction.IsPressed();
}
private static bool WasPerformedThisFrame(InputAction action)
{
return action != null && action.WasPerformedThisFrame();
}
private static InputAction GetInputAction(FieldInfo field, object instance)
{
if (field == null || instance == null)
{
return null;
}
object? value = field.GetValue(instance);
return (InputAction)((value is InputAction) ? value : null);
}
private static object GetCurrentHoldable(object equipmentManager)
{
if (fCurrentHoldable == null || equipmentManager == null)
{
return null;
}
return fCurrentHoldable.GetValue(equipmentManager);
}
private static object GetEquipmentManagerFromWeapon(object weapon)
{
if (fEquipmentManager == null || weapon == null)
{
return null;
}
return fEquipmentManager.GetValue(weapon);
}
private static bool IsMeleeWeapon(object holdable)
{
if (holdable == null)
{
return false;
}
if (!weaponType.IsInstanceOfType(holdable))
{
return false;
}
object value = pIsMelee.GetValue(holdable, null);
return value is bool && (bool)value;
}
private static bool IsMeleeCharging(object weapon)
{
if (weapon == null || mIsMeleeCharging == null)
{
return false;
}
object obj = mIsMeleeCharging.Invoke(weapon, null);
return obj is bool && (bool)obj;
}
private static bool IsInMeleeCharge(object equipmentManager)
{
return GetBoolField(fIsInMeleeCharge, equipmentManager);
}
private static bool IsAimingInputHeld(object equipmentManager)
{
return GetBoolField(fAimingInputHeld, equipmentManager);
}
private static bool IsMeleeInputCoolingDown(object equipmentManager)
{
if (fMeleeInputCooldown == null || equipmentManager == null)
{
return false;
}
object value = fMeleeInputCooldown.GetValue(equipmentManager);
if (!(value is float))
{
return false;
}
return Time.time < (float)value;
}
private static bool GetBoolField(FieldInfo field, object instance)
{
if (field == null || instance == null)
{
return false;
}
object value = field.GetValue(instance);
return value is bool && (bool)value;
}
private static void SetMeleePressed(object equipmentManager, bool value)
{
SetBoolField(fMeleePressed, equipmentManager, value);
}
private static void SetAlternativeMeleePressed(object equipmentManager, bool value)
{
SetBoolField(fAlternativeMeleePressed, equipmentManager, value);
}
private static void SetBoolField(FieldInfo field, object instance, bool value)
{
if (!(field == null) && instance != null)
{
field.SetValue(instance, value);
}
}
private static void UpdateCurrentMeleeAlternativeAnimator(object equipmentManager, bool altHeld)
{
object currentHoldable = GetCurrentHoldable(equipmentManager);
if (IsMeleeWeapon(currentHoldable))
{
Animator animator = GetAnimator(currentHoldable);
if (!((Object)(object)animator == (Object)null))
{
animator.SetBool("AlternativePressed", altHeld);
}
}
}
private static Animator GetAnimator(object holdable)
{
if (holdable == null || pAnimator == null)
{
return null;
}
object? value = pAnimator.GetValue(holdable, null);
return (Animator)((value is Animator) ? value : null);
}
private static void InvokeChargeBasicMelee(object equipmentManager)
{
try
{
mChargeBasicMelee.Invoke(equipmentManager, null);
}
catch (Exception ex)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Failed to invoke ChargeBasicMelee: " + ex));
}
}
}
private static void InvokeUseBasicMelee(object equipmentManager)
{
try
{
mUseBasicMelee.Invoke(equipmentManager, null);
}
catch (Exception ex)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Failed to invoke UseBasicMelee: " + ex));
}
}
}
private static void InvokeOnMeleeDone(object equipmentManager)
{
try
{
mOnMeleeDone.Invoke(equipmentManager, null);
}
catch (Exception ex)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Failed to invoke OnMeleeDone: " + ex));
}
}
}
private static void InvokeSetAlternativeState(object weapon, int value)
{
if (weapon == null || mSetAlternativeState == null)
{
return;
}
try
{
mSetAlternativeState.Invoke(weapon, new object[1] { value });
}
catch (Exception ex)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogError((object)("Failed to invoke SetAlternativeState: " + ex));
}
}
}
}
