using System;
using System.Collections.Generic;
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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("REPOJP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("REPOJP")]
[assembly: AssemblyTitle("REPOJP")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace REPOJP.GambitEnhancements
{
[BepInPlugin("REPOJP.GambitEnhancements", "GambitEnhancements", "1.0.0")]
public sealed class GambitEnhancementsPlugin : BaseUnityPlugin
{
public const string PluginGuid = "REPOJP.GambitEnhancements";
public const string PluginName = "GambitEnhancements";
public const string PluginVersion = "1.0.0";
internal static GambitEnhancementsPlugin Instance;
internal static ManualLogSource Log;
private Harmony _harmony;
internal static ConfigEntry<bool> EnableMod;
internal static ConfigEntry<bool> EnableVerboseLog;
internal static ConfigEntry<int> RouletteDurationSeconds;
internal static ConfigEntry<bool> ForceCarryToGoalAfterRoulette;
internal static ConfigEntry<float> ReleaseGrabDistance;
internal static ConfigEntry<bool> RunAwayDuringRoulette;
internal static ConfigEntry<float> RouletteRunSpeed;
internal static ConfigEntry<float> RouletteRunAcceleration;
internal static ConfigEntry<float> GoalReachedDistance;
internal static ConfigEntry<float> EscapeDestinationRefreshInterval;
internal static ConfigEntry<bool> StrengthenPlayerLockDuringRoulette;
internal static ConfigEntry<float> RouletteFollowForceMultiplier;
internal static ConfigEntry<float> RouletteFollowForceGrabbedMultiplier;
internal static ConfigEntry<float> RouletteLockLerpSpeed;
internal static ConfigEntry<bool> ImmuneToStunDuringRoulette;
internal static ConfigEntry<bool> BlockStunSetCallDuringRoulette;
internal static ConfigEntry<bool> EnableJumpAssistDuringRoulette;
internal static ConfigEntry<float> JumpAssistInterval;
internal static ConfigEntry<float> StuckVelocityThreshold;
internal static ConfigEntry<float> StuckDistanceThreshold;
internal static ConfigEntry<float> StuckRepathDelay;
internal static ConfigEntry<bool> InstantRepathWhenStuck;
internal static ConfigEntry<float> SameGoalReapplyInterval;
private void Awake()
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Expected O, but got Unknown
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Expected O, but got Unknown
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Expected O, but got Unknown
//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
//IL_01db: Expected O, but got Unknown
//IL_020e: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Expected O, but got Unknown
//IL_026b: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Expected O, but got Unknown
//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
//IL_02b2: Expected O, but got Unknown
//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
//IL_02ef: Expected O, but got Unknown
//IL_0382: Unknown result type (might be due to invalid IL or missing references)
//IL_038c: Expected O, but got Unknown
//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
//IL_03c9: Expected O, but got Unknown
//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0406: Expected O, but got Unknown
//IL_0439: Unknown result type (might be due to invalid IL or missing references)
//IL_0443: Expected O, but got Unknown
//IL_0496: Unknown result type (might be due to invalid IL or missing references)
//IL_04a0: Expected O, but got Unknown
//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
//IL_04b5: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
((Component)this).transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enable or disable this mod");
EnableVerboseLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Logging", "EnableVerboseLog", true, "Enable verbose logs");
RouletteDurationSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("Roulette", "RouletteDurationSeconds", 10, new ConfigDescription("Roulette duration in whole seconds", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), Array.Empty<object>()));
ForceCarryToGoalAfterRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Roulette", "ForceCarryToGoalAfterRoulette", true, "Keep dragging the grabbed player to the selected farthest destination even after roulette has ended");
ReleaseGrabDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Roulette", "ReleaseGrabDistance", 4.999999f, new ConfigDescription("Release the grabbed player if Gambit and the target become farther apart than this distance", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
RunAwayDuringRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Movement", "RunAwayDuringRoulette", true, "Run away during roulette");
RouletteRunSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "RouletteRunSpeed", 6f, new ConfigDescription("Run speed during roulette or forced carry", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
RouletteRunAcceleration = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "RouletteRunAcceleration", 12f, new ConfigDescription("Run acceleration during roulette or forced carry", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
GoalReachedDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "GoalReachedDistance", 5f, new ConfigDescription("Distance at which the farthest destination is considered reached", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 10f), Array.Empty<object>()));
EscapeDestinationRefreshInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "EscapeDestinationRefreshInterval", 3f, new ConfigDescription("Reserved compatibility setting for destination refresh interval", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 30f), Array.Empty<object>()));
StrengthenPlayerLockDuringRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Grab", "StrengthenPlayerLockDuringRoulette", true, "Strengthen player lock during roulette and forced carry");
RouletteFollowForceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Grab", "RouletteFollowForceMultiplier", 1f, new ConfigDescription("Follow force multiplier while target is not grabbed by another player", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
RouletteFollowForceGrabbedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Grab", "RouletteFollowForceGrabbedMultiplier", 3f, new ConfigDescription("Follow force multiplier while target is grabbed by another player", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
RouletteLockLerpSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Grab", "RouletteLockLerpSpeed", 6f, new ConfigDescription("Lock lerp speed during roulette and forced carry", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
ImmuneToStunDuringRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Stun", "ImmuneToStunDuringRoulette", true, "Prevent stun during roulette only");
BlockStunSetCallDuringRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Stun", "BlockStunSetCallDuringRoulette", true, "Block EnemyStateStunned.Set during roulette only");
EnableJumpAssistDuringRoulette = ((BaseUnityPlugin)this).Config.Bind<bool>("Assist", "EnableJumpAssistDuringRoulette", true, "Enable jump assist during roulette and forced carry");
JumpAssistInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Assist", "JumpAssistInterval", 0.5f, new ConfigDescription("Jump assist call interval", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.02f, 5f), Array.Empty<object>()));
StuckVelocityThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Assist", "StuckVelocityThreshold", 0.15f, new ConfigDescription("Velocity threshold for stuck detection", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 3f), Array.Empty<object>()));
StuckDistanceThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Assist", "StuckDistanceThreshold", 2f, new ConfigDescription("Distance threshold for stuck detection", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
StuckRepathDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Assist", "StuckRepathDelay", 0.2f, new ConfigDescription("Delay before stronger stuck recovery starts", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), Array.Empty<object>()));
InstantRepathWhenStuck = ((BaseUnityPlugin)this).Config.Bind<bool>("Assist", "InstantRepathWhenStuck", true, "When stuck, reapply the same goal and trigger stronger recovery");
SameGoalReapplyInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Assist", "SameGoalReapplyInterval", 5f, new ConfigDescription("Minimum interval between same-goal reapply operations while stuck", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 30f), Array.Empty<object>()));
_harmony = new Harmony("REPOJP.GambitEnhancements");
_harmony.PatchAll();
Log.LogInfo((object)"GambitEnhancements 1.0.0 loaded");
}
private void OnDestroy()
{
if (_harmony != null)
{
_harmony.UnpatchSelf();
}
}
internal static bool ModEnabled()
{
return EnableMod.Value;
}
internal static void Verbose(string message)
{
if (EnableVerboseLog.Value && Log != null)
{
Log.LogInfo((object)message);
}
}
}
internal static class GambitEnhancementsCore
{
private sealed class SpinnyRuntimeState
{
public bool GrabValuesStored;
public float OriginalFollowForceMultiplier;
public float OriginalFollowForceGrabbedMultiplier;
public float OriginalLockLerpSpeed;
public bool WasRouletteGoingOn;
public bool GoalCaptured;
public bool GoalActive;
public bool PersistCarryActive;
public Vector3 StartPosition;
public Vector3 GoalDestination;
public float StuckTimer;
public float JumpAssistTimer;
public float SameGoalReapplyTimer;
}
private static readonly FieldInfo SpinnyFieldFollowForceGrabbedMultiplier = AccessTools.Field(typeof(EnemySpinny), "_followForceGrabbedMultiplier");
private static readonly FieldInfo SpinnyFieldLockLerpSpeed = AccessTools.Field(typeof(EnemySpinny), "lockLerpSpeed");
private static readonly FieldInfo EnemyRigidbodyFieldRb = AccessTools.Field(typeof(EnemyRigidbody), "rb");
private static readonly FieldInfo EnemyJumpFieldJumping = AccessTools.Field(typeof(EnemyJump), "jumping");
private static readonly MethodInfo SpinnyMethodJumpIfStuck = AccessTools.Method(typeof(EnemySpinny), "JumpIfStuck", new Type[1] { typeof(bool) }, (Type[])null);
private static readonly MethodInfo SpinnyMethodLockInPlayer = AccessTools.Method(typeof(EnemySpinny), "LockInPlayer", new Type[2]
{
typeof(bool),
typeof(bool)
}, (Type[])null);
private static readonly MethodInfo SpinnyMethodUpdateState = AccessTools.Method(typeof(EnemySpinny), "UpdateState", new Type[1] { typeof(State) }, (Type[])null);
private static readonly Dictionary<int, SpinnyRuntimeState> RuntimeStates = new Dictionary<int, SpinnyRuntimeState>();
internal static void PostUpdate(EnemySpinny spinny)
{
if (!CanControl(spinny))
{
RestoreAndDisable(spinny);
return;
}
SpinnyRuntimeState runtime = GetRuntime(spinny);
UpdateGoalState(spinny, runtime);
if (spinny.RouletteGoingOn())
{
spinny.spinDurationSeconds = Mathf.Clamp(GambitEnhancementsPlugin.RouletteDurationSeconds.Value, 0, 10);
}
if (ShouldMaintainGrab(spinny, runtime) && IsTargetTooFar(spinny))
{
ReleaseGrab(spinny, runtime);
}
if (ShouldMaintainGrab(spinny, runtime))
{
if (GambitEnhancementsPlugin.StrengthenPlayerLockDuringRoulette.Value)
{
ApplyGrabSettings(spinny, runtime);
}
}
else
{
RestoreGrabSettings(spinny, runtime);
}
if (spinny.RouletteGoingOn() && GambitEnhancementsPlugin.ImmuneToStunDuringRoulette.Value)
{
ClearStun(spinny);
}
if (ShouldMaintainMovement(spinny, runtime))
{
ApplyMovement(spinny, runtime);
}
}
internal static void PostFixedUpdate(EnemySpinny spinny)
{
if (!CanControl(spinny))
{
RestoreAndDisable(spinny);
return;
}
SpinnyRuntimeState runtime = GetRuntime(spinny);
UpdateGoalState(spinny, runtime);
if (ShouldMaintainGrab(spinny, runtime) && !IsTargetTooFar(spinny))
{
InvokeLockInPlayer(spinny, horizontalPull: false, fixedUpdate: true);
}
}
internal static bool ShouldBlockStun(EnemyStateStunned stunnedComponent)
{
if (!GambitEnhancementsPlugin.ModEnabled())
{
return false;
}
if (!GambitEnhancementsPlugin.BlockStunSetCallDuringRoulette.Value)
{
return false;
}
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return false;
}
EnemySpinny component = ((Component)stunnedComponent).GetComponent<EnemySpinny>();
if ((Object)(object)component == (Object)null)
{
return false;
}
return component.RouletteGoingOn();
}
private static void UpdateGoalState(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
//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_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_019f: 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)
if ((Object)(object)spinny.playerTarget == (Object)null || spinny.playerTarget.isDisabled)
{
runtime.GoalActive = false;
runtime.GoalCaptured = false;
runtime.PersistCarryActive = false;
return;
}
if (spinny.RouletteGoingOn() && !runtime.WasRouletteGoingOn)
{
runtime.StartPosition = GetCurrentPosition(spinny);
runtime.GoalDestination = GetFarthestPointFromPosition(runtime.StartPosition);
runtime.GoalActive = true;
runtime.GoalCaptured = true;
runtime.PersistCarryActive = false;
runtime.StuckTimer = 0f;
runtime.JumpAssistTimer = 0f;
runtime.SameGoalReapplyTimer = 0f;
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] Goal locked -> {runtime.GoalDestination}");
}
if (!spinny.RouletteGoingOn() && runtime.WasRouletteGoingOn)
{
if (runtime.GoalCaptured && GambitEnhancementsPlugin.ForceCarryToGoalAfterRoulette.Value && (Object)(object)spinny.playerTarget != (Object)null && !spinny.playerTarget.isDisabled && !IsGoalReached(spinny, runtime))
{
runtime.PersistCarryActive = true;
runtime.GoalActive = true;
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] Persist carry enabled -> {runtime.GoalDestination}");
}
else
{
runtime.PersistCarryActive = false;
}
}
if (runtime.GoalActive && IsGoalReached(spinny, runtime))
{
runtime.GoalActive = false;
runtime.PersistCarryActive = false;
runtime.StuckTimer = 0f;
runtime.JumpAssistTimer = 0f;
runtime.SameGoalReapplyTimer = 0f;
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] Goal reached -> {runtime.GoalDestination}");
}
runtime.WasRouletteGoingOn = spinny.RouletteGoingOn();
}
private static bool ShouldMaintainMovement(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
if (!GambitEnhancementsPlugin.RunAwayDuringRoulette.Value)
{
return false;
}
if (spinny.RouletteGoingOn() && runtime.GoalActive)
{
return true;
}
if (runtime.PersistCarryActive && runtime.GoalActive)
{
return true;
}
return false;
}
private static bool ShouldMaintainGrab(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
if (spinny.RouletteGoingOn())
{
return true;
}
if (runtime.PersistCarryActive && runtime.GoalActive)
{
return true;
}
return false;
}
private static void ApplyMovement(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
//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_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
Enemy component = ((Component)spinny).GetComponent<Enemy>();
EnemyNavMeshAgent component2 = ((Component)spinny).GetComponent<EnemyNavMeshAgent>();
EnemyRigidbody component3 = ((Component)spinny).GetComponent<EnemyRigidbody>();
EnemyJump component4 = ((Component)spinny).GetComponent<EnemyJump>();
if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || !runtime.GoalActive)
{
return;
}
float num = Time.deltaTime;
if (num <= 0f)
{
num = 0.0166667f;
}
Vector3 currentPosition = GetCurrentPosition(spinny);
Rigidbody enemyRigidBody = GetEnemyRigidBody(component3);
component2.SetDestination(runtime.GoalDestination);
component2.OverrideAgent(GambitEnhancementsPlugin.RouletteRunSpeed.Value, GambitEnhancementsPlugin.RouletteRunAcceleration.Value, 0.25f);
if (runtime.SameGoalReapplyTimer > 0f)
{
runtime.SameGoalReapplyTimer -= num;
}
bool flag = IsLikelyStuck(currentPosition, enemyRigidBody, runtime);
if (flag)
{
runtime.StuckTimer += num;
}
else
{
runtime.StuckTimer = 0f;
}
if (GambitEnhancementsPlugin.InstantRepathWhenStuck.Value && flag && runtime.StuckTimer >= GambitEnhancementsPlugin.StuckRepathDelay.Value && runtime.SameGoalReapplyTimer <= 0f)
{
runtime.SameGoalReapplyTimer = GambitEnhancementsPlugin.SameGoalReapplyInterval.Value;
component2.SetDestination(runtime.GoalDestination);
component2.OverrideAgent(GambitEnhancementsPlugin.RouletteRunSpeed.Value, GambitEnhancementsPlugin.RouletteRunAcceleration.Value, 0.25f);
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] Reapply same goal -> {runtime.GoalDestination}");
}
if (!GambitEnhancementsPlugin.EnableJumpAssistDuringRoulette.Value)
{
return;
}
runtime.JumpAssistTimer -= num;
if (runtime.JumpAssistTimer <= 0f)
{
runtime.JumpAssistTimer = GambitEnhancementsPlugin.JumpAssistInterval.Value;
InvokeJumpIfStuck(spinny);
if (flag)
{
ForceStuckJump(component4, currentPosition, runtime.GoalDestination);
}
}
}
private static void ClearStun(EnemySpinny spinny)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
Enemy component = ((Component)spinny).GetComponent<Enemy>();
EnemyStateStunned component2 = ((Component)spinny).GetComponent<EnemyStateStunned>();
if (!((Object)(object)component2 == (Object)null))
{
component2.OverrideDisable(0.3f);
component2.stunTimer = 0f;
if ((Object)(object)component != (Object)null && (int)component.CurrentState == 9)
{
component.CurrentState = (EnemyState)2;
}
}
}
private static void ReleaseGrab(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
RestoreGrabSettings(spinny, runtime);
runtime.GoalActive = false;
runtime.PersistCarryActive = false;
runtime.StuckTimer = 0f;
runtime.JumpAssistTimer = 0f;
runtime.SameGoalReapplyTimer = 0f;
spinny.playerTarget = null;
if (SpinnyMethodUpdateState != null)
{
try
{
SpinnyMethodUpdateState.Invoke(spinny, new object[1] { (object)(State)12 });
}
catch (Exception arg)
{
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] UpdateState invoke failed: {arg}");
}
}
GambitEnhancementsPlugin.Verbose("[GambitEnhancements] Grab released because target distance exceeded threshold");
}
private static bool IsTargetTooFar(EnemySpinny spinny)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: 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_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: 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_0043: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)spinny.playerTarget == (Object)null)
{
return false;
}
Vector3 currentPosition = GetCurrentPosition(spinny);
Vector3 position = ((Component)spinny.playerTarget).transform.position;
float value = GambitEnhancementsPlugin.ReleaseGrabDistance.Value;
Vector3 val = currentPosition - position;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
return sqrMagnitude > value * value;
}
private static Vector3 GetFarthestPointFromPosition(Vector3 startPosition)
{
//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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
List<LevelPoint> list = SemiFunc.LevelPointsGetAll();
if (list == null || list.Count == 0)
{
return startPosition + Vector3.forward * 5f;
}
float num = -1f;
LevelPoint val = null;
foreach (LevelPoint item in list)
{
if (!((Object)(object)item == (Object)null) && (!((Object)(object)item.Room != (Object)null) || !item.Room.Truck))
{
Vector3 val2 = startPosition - ((Component)item).transform.position;
float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
if (sqrMagnitude > num)
{
num = sqrMagnitude;
val = item;
}
}
}
if ((Object)(object)val != (Object)null)
{
return ((Component)val).transform.position;
}
return startPosition + Vector3.forward * 5f;
}
private static bool IsGoalReached(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
//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_0013: 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)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
Vector3 currentPosition = GetCurrentPosition(spinny);
float value = GambitEnhancementsPlugin.GoalReachedDistance.Value;
Vector3 val = currentPosition - runtime.GoalDestination;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
return sqrMagnitude <= value * value;
}
private static Vector3 GetCurrentPosition(EnemySpinny spinny)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
Enemy component = ((Component)spinny).GetComponent<Enemy>();
if ((Object)(object)component != (Object)null && (Object)(object)component.Rigidbody != (Object)null && (Object)(object)((Component)component.Rigidbody).transform != (Object)null)
{
return ((Component)component.Rigidbody).transform.position;
}
return ((Component)spinny).transform.position;
}
private static void ApplyGrabSettings(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
if (!runtime.GrabValuesStored)
{
runtime.OriginalFollowForceMultiplier = spinny._followForceMultiplier;
runtime.OriginalFollowForceGrabbedMultiplier = GetPrivateFloat(spinny, SpinnyFieldFollowForceGrabbedMultiplier, 0.025f);
runtime.OriginalLockLerpSpeed = GetPrivateFloat(spinny, SpinnyFieldLockLerpSpeed, 1f);
runtime.GrabValuesStored = true;
}
spinny._followForceMultiplier = GambitEnhancementsPlugin.RouletteFollowForceMultiplier.Value;
SetPrivateFloat(spinny, SpinnyFieldFollowForceGrabbedMultiplier, GambitEnhancementsPlugin.RouletteFollowForceGrabbedMultiplier.Value);
SetPrivateFloat(spinny, SpinnyFieldLockLerpSpeed, GambitEnhancementsPlugin.RouletteLockLerpSpeed.Value);
}
private static void RestoreGrabSettings(EnemySpinny spinny, SpinnyRuntimeState runtime)
{
if (runtime.GrabValuesStored)
{
spinny._followForceMultiplier = runtime.OriginalFollowForceMultiplier;
SetPrivateFloat(spinny, SpinnyFieldFollowForceGrabbedMultiplier, runtime.OriginalFollowForceGrabbedMultiplier);
SetPrivateFloat(spinny, SpinnyFieldLockLerpSpeed, runtime.OriginalLockLerpSpeed);
runtime.GrabValuesStored = false;
}
}
private static void InvokeJumpIfStuck(EnemySpinny spinny)
{
if (SpinnyMethodJumpIfStuck == null)
{
return;
}
try
{
SpinnyMethodJumpIfStuck.Invoke(spinny, new object[1] { true });
}
catch (Exception arg)
{
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] JumpIfStuck invoke failed: {arg}");
}
}
private static void InvokeLockInPlayer(EnemySpinny spinny, bool horizontalPull, bool fixedUpdate)
{
if (SpinnyMethodLockInPlayer == null)
{
return;
}
try
{
SpinnyMethodLockInPlayer.Invoke(spinny, new object[2] { horizontalPull, fixedUpdate });
}
catch (Exception arg)
{
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] LockInPlayer invoke failed: {arg}");
}
}
private static void ForceStuckJump(EnemyJump enemyJump, Vector3 currentPosition, Vector3 destination)
{
//IL_0022: 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_0029: 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_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)
if (!((Object)(object)enemyJump == (Object)null) && !GetPrivateBool(enemyJump, EnemyJumpFieldJumping, fallback: false))
{
Vector3 val = destination - currentPosition;
if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
{
val = Vector3.forward;
}
enemyJump.StuckTrigger(((Vector3)(ref val)).normalized);
}
}
private static bool IsLikelyStuck(Vector3 currentPosition, Rigidbody rb, SpinnyRuntimeState runtime)
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
float value = GambitEnhancementsPlugin.StuckVelocityThreshold.Value;
float num = value * value;
float velocitySqrMagnitude = GetVelocitySqrMagnitude(rb);
if (velocitySqrMagnitude >= num)
{
return false;
}
float value2 = GambitEnhancementsPlugin.StuckDistanceThreshold.Value;
float num2 = value2 * value2;
Vector3 val = currentPosition - runtime.GoalDestination;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
return sqrMagnitude > num2;
}
private static Rigidbody GetEnemyRigidBody(EnemyRigidbody enemyRigidbody)
{
if ((Object)(object)enemyRigidbody == (Object)null || EnemyRigidbodyFieldRb == null)
{
return null;
}
try
{
object? value = EnemyRigidbodyFieldRb.GetValue(enemyRigidbody);
return (Rigidbody)((value is Rigidbody) ? value : null);
}
catch
{
return null;
}
}
private static float GetVelocitySqrMagnitude(Rigidbody rb)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)rb == (Object)null)
{
return 0f;
}
Vector3 velocity = rb.velocity;
return ((Vector3)(ref velocity)).sqrMagnitude;
}
private static bool CanControl(EnemySpinny spinny)
{
if (!GambitEnhancementsPlugin.ModEnabled())
{
return false;
}
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return false;
}
if ((Object)(object)spinny == (Object)null)
{
return false;
}
return true;
}
private static void RestoreAndDisable(EnemySpinny spinny)
{
if (RuntimeStates.TryGetValue(((Object)spinny).GetInstanceID(), out SpinnyRuntimeState value))
{
RestoreGrabSettings(spinny, value);
value.GoalActive = false;
value.GoalCaptured = false;
value.PersistCarryActive = false;
value.WasRouletteGoingOn = false;
value.StuckTimer = 0f;
value.JumpAssistTimer = 0f;
value.SameGoalReapplyTimer = 0f;
}
}
private static SpinnyRuntimeState GetRuntime(EnemySpinny spinny)
{
int instanceID = ((Object)spinny).GetInstanceID();
if (!RuntimeStates.TryGetValue(instanceID, out SpinnyRuntimeState value))
{
value = new SpinnyRuntimeState();
RuntimeStates[instanceID] = value;
}
return value;
}
private static float GetPrivateFloat(object instance, FieldInfo fieldInfo, float fallback)
{
if (instance == null || fieldInfo == null)
{
return fallback;
}
try
{
object value = fieldInfo.GetValue(instance);
if (value is float)
{
return (float)value;
}
}
catch
{
}
return fallback;
}
private static void SetPrivateFloat(object instance, FieldInfo fieldInfo, float value)
{
if (instance == null || fieldInfo == null)
{
return;
}
try
{
fieldInfo.SetValue(instance, value);
}
catch (Exception arg)
{
GambitEnhancementsPlugin.Verbose($"[GambitEnhancements] Failed to set private float: {arg}");
}
}
private static bool GetPrivateBool(object instance, FieldInfo fieldInfo, bool fallback)
{
if (instance == null || fieldInfo == null)
{
return fallback;
}
try
{
object value = fieldInfo.GetValue(instance);
if (value is bool)
{
return (bool)value;
}
}
catch
{
}
return fallback;
}
}
[HarmonyPatch(typeof(EnemySpinny), "Update")]
internal static class EnemySpinnyUpdatePatch
{
private static void Postfix(EnemySpinny __instance)
{
GambitEnhancementsCore.PostUpdate(__instance);
}
}
[HarmonyPatch(typeof(EnemySpinny), "FixedUpdate")]
internal static class EnemySpinnyFixedUpdatePatch
{
private static void Postfix(EnemySpinny __instance)
{
GambitEnhancementsCore.PostFixedUpdate(__instance);
}
}
[HarmonyPatch(typeof(EnemyStateStunned), "Set")]
internal static class EnemyStateStunnedSetPatch
{
private static bool Prefix(EnemyStateStunned __instance, float time)
{
if (!GambitEnhancementsCore.ShouldBlockStun(__instance))
{
return true;
}
__instance.OverrideDisable(Mathf.Max(0.3f, time));
__instance.stunTimer = 0f;
GambitEnhancementsPlugin.Verbose("[GambitEnhancements] Blocked stun Set() during roulette");
return false;
}
}
[HarmonyPatch(typeof(EnemyStateStunned), "Update")]
internal static class EnemyStateStunnedUpdatePatch
{
private static void Prefix(EnemyStateStunned __instance)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Invalid comparison between Unknown and I4
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
if (GambitEnhancementsCore.ShouldBlockStun(__instance))
{
__instance.OverrideDisable(0.3f);
__instance.stunTimer = 0f;
Enemy component = ((Component)__instance).GetComponent<Enemy>();
if ((Object)(object)component != (Object)null && (int)component.CurrentState == 9)
{
component.CurrentState = (EnemyState)2;
}
}
}
}
}
