using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EmotesAPI;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using LethalEmotesAPI.ImportV2;
using LethalHands;
using LethalHands.NetcodePatcher;
using LethalHands.Patches;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
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("LethalHands")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalHands")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3b5b33b2-35bc-42cf-8244-b7242ac50309")]
[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")]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[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;
}
}
}
[Serializable]
public class SyncedInstance<T>
{
[NonSerialized]
protected static int IntSize = 4;
internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;
internal static bool IsClient => NetworkManager.Singleton.IsClient;
internal static bool IsHost => NetworkManager.Singleton.IsHost;
public static T Default { get; private set; }
public static T Instance { get; private set; }
public static bool Synced { get; internal set; }
protected void InitInstance(T instance)
{
Default = instance;
Instance = instance;
IntSize = 4;
}
internal static void SyncInstance(byte[] data)
{
Instance = DeserializeFromBytes(data);
Synced = true;
}
internal static void RevertSync()
{
Instance = Default;
Synced = false;
}
public static byte[] SerializeToBytes(T val)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using MemoryStream memoryStream = new MemoryStream();
try
{
binaryFormatter.Serialize(memoryStream, val);
return memoryStream.ToArray();
}
catch (Exception arg)
{
LethalHandsPlugin.Instance.manualLogSource.LogError((object)$"Error serializing instance: {arg}");
return null;
}
}
public static T DeserializeFromBytes(byte[] data)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using MemoryStream serializationStream = new MemoryStream(data);
try
{
return (T)binaryFormatter.Deserialize(serializationStream);
}
catch (Exception arg)
{
LethalHandsPlugin.Instance.manualLogSource.LogError((object)$"Error deserializing instance: {arg}");
return default(T);
}
}
}
namespace LethalHands
{
internal class Animation
{
private static HumanBodyBones[] ignoredRootBones = (HumanBodyBones[])(object)new HumanBodyBones[2]
{
(HumanBodyBones)1,
(HumanBodyBones)2
};
private static HumanBodyBones[] ignoredSoloBones;
public static void instantiateAnimations()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Expected O, but got Unknown
//IL_023c: Unknown result type (might be due to invalid IL or missing references)
//IL_0243: Expected O, but got Unknown
CustomEmoteParams val = new CustomEmoteParams();
val.primaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("squareup.anim") };
val.secondaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("squaredupidle.anim") };
val.visible = false;
val.audioLevel = 0f;
val.audioLoops = false;
val.allowJoining = false;
val.thirdPerson = false;
val.forceCameraMode = true;
val.allowThirdPerson = false;
val.displayName = " ";
val.internalName = "squareup";
val.rootBonesToIgnore = ignoredRootBones;
val.soloBonesToIgnore = ignoredSoloBones;
val.useLocalTransforms = true;
val.animateHealthbar = false;
CustomEmoteParams val2 = val;
val = new CustomEmoteParams();
val.primaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("squaredown.anim") };
val.visible = false;
val.audioLevel = 0f;
val.audioLoops = false;
val.allowJoining = false;
val.thirdPerson = false;
val.forceCameraMode = true;
val.allowThirdPerson = false;
val.displayName = " ";
val.internalName = "squaredown";
val.rootBonesToIgnore = ignoredRootBones;
val.soloBonesToIgnore = ignoredSoloBones;
val.useLocalTransforms = true;
val.animateHealthbar = false;
CustomEmoteParams val3 = val;
val = new CustomEmoteParams();
val.primaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("lpunch.anim") };
val.secondaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("squaredupidle.anim") };
val.primaryAudioClips = (AudioClip[])(object)new AudioClip[2]
{
Assets.Load<AudioClip>("swing1.ogg"),
Assets.Load<AudioClip>("swing2.ogg")
};
val.visible = false;
val.audioLevel = 0f;
val.audioLoops = false;
val.allowJoining = false;
val.thirdPerson = false;
val.forceCameraMode = true;
val.allowThirdPerson = false;
val.displayName = " ";
val.internalName = "lpunch";
val.rootBonesToIgnore = ignoredRootBones;
val.soloBonesToIgnore = ignoredSoloBones;
val.useLocalTransforms = true;
val.animateHealthbar = false;
CustomEmoteParams val4 = val;
val = new CustomEmoteParams();
val.primaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("rpunch.anim") };
val.secondaryAnimationClips = (AnimationClip[])(object)new AnimationClip[1] { Assets.Load<AnimationClip>("squaredupidle.anim") };
val.primaryAudioClips = (AudioClip[])(object)new AudioClip[2]
{
Assets.Load<AudioClip>("swing1.ogg"),
Assets.Load<AudioClip>("swing2.ogg")
};
val.visible = false;
val.audioLevel = 0f;
val.audioLoops = false;
val.allowJoining = false;
val.thirdPerson = false;
val.forceCameraMode = true;
val.allowThirdPerson = false;
val.displayName = " ";
val.internalName = "rpunch";
val.rootBonesToIgnore = ignoredRootBones;
val.soloBonesToIgnore = ignoredSoloBones;
val.useLocalTransforms = true;
val.animateHealthbar = false;
CustomEmoteParams val5 = val;
EmoteImporter.ImportEmote(val2);
EmoteImporter.ImportEmote(val3);
EmoteImporter.ImportEmote(val4);
EmoteImporter.ImportEmote(val5);
}
static Animation()
{
HumanBodyBones[] array = new HumanBodyBones[4];
RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
ignoredSoloBones = (HumanBodyBones[])(object)array;
}
}
public static class Assets
{
internal static readonly List<AssetBundle> AssetBundles = new List<AssetBundle>();
private static readonly Dictionary<string, int> AssetIndices = new Dictionary<string, int>();
public static void LoadAssetBundlesFromFolder(string folderName)
{
folderName = Path.Combine(Path.GetDirectoryName(LethalHandsPlugin.PInfo.Location), folderName);
string[] files = Directory.GetFiles(folderName);
foreach (string text in files)
{
AssetBundle val = AssetBundle.LoadFromFile(text);
int count = AssetBundles.Count;
AssetBundles.Add(val);
string[] allAssetNames = val.GetAllAssetNames();
foreach (string text2 in allAssetNames)
{
string text3 = text2.ToLowerInvariant();
if (text3.StartsWith("assets/"))
{
text3 = text3.Remove(0, "assets/".Length);
}
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)$"paring [{text3}] with [{count}]");
AssetIndices[text3] = count;
}
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)("Loaded AssetBundle: " + Path.GetFileName(text)));
}
}
public static T Load<T>(string assetName) where T : Object
{
try
{
assetName = assetName.ToLowerInvariant();
if (assetName.Contains(":"))
{
string[] array = assetName.Split(new char[1] { ':' });
assetName = array[1].ToLowerInvariant();
}
if (assetName.StartsWith("assets/"))
{
assetName = assetName.Remove(0, "assets/".Length);
}
int index = AssetIndices[assetName];
return AssetBundles[index].LoadAsset<T>("assets/" + assetName);
}
catch (Exception arg)
{
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)$"Couldn't load asset [{assetName}] reason: {arg}");
return default(T);
}
}
}
public class EnemyFloatHealth
{
public static EnemyFloatHealth Instance;
private Dictionary<EnemyAI, float> enemyHitCounter;
public EnemyFloatHealth()
{
if (Instance == null)
{
Instance = this;
}
enemyHitCounter = new Dictionary<EnemyAI, float>();
}
public void Reset()
{
enemyHitCounter.Clear();
}
public int DamageEnemy(EnemyAI enemy)
{
if (!enemyHitCounter.ContainsKey(enemy))
{
enemyHitCounter.Add(enemy, 0f);
}
int num = 0;
if (enemy is NutcrackerEnemyAI)
{
NutcrackerEnemyAI val = (NutcrackerEnemyAI)(object)((enemy is NutcrackerEnemyAI) ? enemy : null);
FieldInfo field = typeof(NutcrackerEnemyAI).GetField("isInspecting", BindingFlags.Instance | BindingFlags.NonPublic);
if (!(bool)field.GetValue(val) && ((EnemyAI)val).currentBehaviourStateIndex != 2)
{
return 0;
}
}
enemyHitCounter[enemy] += LethalHands.Instance.enemyPunchDamage;
while (enemyHitCounter[enemy] >= 1f)
{
enemyHitCounter[enemy]--;
num++;
}
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)$"new damage : {num}");
return num;
}
}
[Serializable]
public class NetworkConfig : SyncedInstance<NetworkConfig>
{
public float punchRange;
public float punchCooldown;
public float enemyPunchDamage;
public int playerPunchDamage;
public int punchOffClingersChance;
public bool punchingHaltsStaminaRegen;
public int punchStaminaRequirement;
public int staminaDrain;
public ItemMode itemDropMode;
public bool allowItems;
public NetworkConfig()
{
InitInstance(this);
punchRange = LocalConfig.punchRange.Value;
punchCooldown = LocalConfig.punchCooldown.Value;
enemyPunchDamage = LocalConfig.enemyPunchDamage.Value;
playerPunchDamage = LocalConfig.playerPunchDamage.Value;
punchOffClingersChance = LocalConfig.punchOffClingersChance.Value;
staminaDrain = LocalConfig.staminaDrain.Value;
punchStaminaRequirement = LocalConfig.staminaRequirement.Value;
punchingHaltsStaminaRegen = LocalConfig.punchingHaltsStaminaRegen.Value;
itemDropMode = LocalConfig.itemDropMode.Value;
allowItems = LocalConfig.allowItems.Value;
}
public static void RequestSync()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<NetworkConfig>.IsClient)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(SyncedInstance<NetworkConfig>.IntSize, (Allocator)2, -1);
try
{
SyncedInstance<NetworkConfig>.MessageManager.SendNamedMessage("SlapitNow.LethalHands_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
public static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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)
if (!SyncedInstance<NetworkConfig>.IsHost)
{
return;
}
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)$"Config sync request received from client: {clientId}");
byte[] array = SyncedInstance<NetworkConfig>.SerializeToBytes(SyncedInstance<NetworkConfig>.Instance);
int num = array.Length;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<NetworkConfig>.IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
SyncedInstance<NetworkConfig>.MessageManager.SendNamedMessage("SlapitNow.LethalHands_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
}
catch (Exception arg)
{
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
public static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<NetworkConfig>.IntSize))
{
LethalHandsPlugin.Instance.manualLogSource.LogError((object)"Config sync error: Could not begin reading buffer.");
return;
}
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
{
LethalHandsPlugin.Instance.manualLogSource.LogError((object)"Config sync error: Host could not sync.");
return;
}
byte[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
SyncedInstance<NetworkConfig>.SyncInstance(data);
LethalHands.Instance.LoadConfigValues();
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)"Successfully synced config with host.");
}
}
internal class Input
{
public class SquareUpInput : LcInputActions
{
public static SquareUpInput Instance = new SquareUpInput();
[InputAction("<Keyboard>/j", Name = "Square up")]
public InputAction SquareUpKey { get; set; }
}
}
public class LethalHands : MonoBehaviour
{
public bool isSquaredUp = false;
private static int shovelMask = 11012424;
public PlayerControllerB playerControllerInstance = GameNetworkManager.Instance.localPlayerController;
private static readonly string[] controlTips = new string[2] { "Left Punch : [Left Click]", "Right Punch : [Right Click]" };
private AudioClip[] hitSounds = (AudioClip[])(object)new AudioClip[2]
{
Assets.Load<AudioClip>("hit1.ogg"),
Assets.Load<AudioClip>("hit2.ogg")
};
public float recordedStamina = 1f;
public bool freezeStaminaRegen = false;
private Coroutine punchingCoroutine = null;
private Coroutine unfreezeStaminaRegenCoroutine = null;
private float punchRange = SyncedInstance<NetworkConfig>.Default.punchRange;
private float punchDelay = SyncedInstance<NetworkConfig>.Default.punchCooldown;
public float enemyPunchDamage = SyncedInstance<NetworkConfig>.Default.enemyPunchDamage;
public int playerPunchDamage = SyncedInstance<NetworkConfig>.Default.playerPunchDamage;
private int punchOffClingersChance = SyncedInstance<NetworkConfig>.Default.punchOffClingersChance;
private float staminaDrain = (float)SyncedInstance<NetworkConfig>.Default.staminaDrain * 0.01f;
public bool punchingHaltsStaminaRegen = SyncedInstance<NetworkConfig>.Default.punchingHaltsStaminaRegen;
private float punchStaminaRequirement = (float)SyncedInstance<NetworkConfig>.Default.punchStaminaRequirement * 0.01f;
private ItemMode itemMode = SyncedInstance<NetworkConfig>.Default.itemDropMode;
public bool allowItems = SyncedInstance<NetworkConfig>.Default.allowItems;
private float punchConnectTime = Mathf.Min(0.1f * SyncedInstance<NetworkConfig>.Default.punchCooldown, 0.1f);
private float punchFinishingTime = Mathf.Min(0.9f * SyncedInstance<NetworkConfig>.Default.punchCooldown, 0.9f);
public static LethalHands Instance { get; private set; }
public void Awake()
{
if (!((Object)(object)Instance != (Object)null))
{
Instance = this;
Input.SquareUpInput.Instance.SquareUpKey.performed += SquareUpPerformed;
}
}
public void LoadConfigValues()
{
punchRange = SyncedInstance<NetworkConfig>.Instance.punchRange;
punchDelay = SyncedInstance<NetworkConfig>.Instance.punchCooldown * 4f;
enemyPunchDamage = SyncedInstance<NetworkConfig>.Instance.enemyPunchDamage;
playerPunchDamage = SyncedInstance<NetworkConfig>.Instance.playerPunchDamage;
punchOffClingersChance = SyncedInstance<NetworkConfig>.Instance.punchOffClingersChance;
staminaDrain = (float)SyncedInstance<NetworkConfig>.Instance.staminaDrain * 0.01f;
punchingHaltsStaminaRegen = SyncedInstance<NetworkConfig>.Instance.punchingHaltsStaminaRegen;
punchStaminaRequirement = (float)SyncedInstance<NetworkConfig>.Instance.punchStaminaRequirement * 0.01f;
itemMode = SyncedInstance<NetworkConfig>.Instance.itemDropMode;
allowItems = SyncedInstance<NetworkConfig>.Instance.allowItems;
punchConnectTime = Mathf.Min(0.2f * SyncedInstance<NetworkConfig>.Instance.punchCooldown, 0.1f);
}
public void SquareUpPerformed(CallbackContext context)
{
if (((CallbackContext)(ref context)).performed && !playerControllerInstance.quickMenuManager.isMenuOpen && ((((NetworkBehaviour)playerControllerInstance).IsOwner && playerControllerInstance.isPlayerControlled && (!((NetworkBehaviour)playerControllerInstance).IsServer || playerControllerInstance.isHostPlayerObject)) || playerControllerInstance.isTestingPlayer) && !playerControllerInstance.inSpecialInteractAnimation && !playerControllerInstance.isTypingChat)
{
if (isSquaredUp)
{
SquareDown(animate: true);
}
else
{
SquareUp();
}
}
}
public void LeftPunchPerformed(CallbackContext context)
{
if (((CallbackContext)(ref context)).performed && isSquaredUp && playerControllerInstance.sprintMeter >= punchStaminaRequirement && punchingCoroutine == null)
{
punchingCoroutine = ((MonoBehaviour)this).StartCoroutine(LeftPunch());
}
}
public void RightPunchPerformed(CallbackContext context)
{
if (((CallbackContext)(ref context)).performed && isSquaredUp && playerControllerInstance.sprintMeter >= punchStaminaRequirement && punchingCoroutine == null)
{
punchingCoroutine = ((MonoBehaviour)this).StartCoroutine(RightPunch());
}
}
public void SquareUp()
{
//IL_0066: 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)
if (isSquaredUp || playerControllerInstance.inSpecialInteractAnimation)
{
return;
}
switch (itemMode)
{
case ItemMode.All:
playerControllerInstance.DropAllHeldItemsAndSync();
break;
case ItemMode.Current:
if (playerControllerInstance.isHoldingObject)
{
playerControllerInstance.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
}
break;
}
playerControllerInstance.performingEmote = false;
playerControllerInstance.StopPerformingEmoteServerRpc();
playerControllerInstance.timeSinceStartingEmote = 0f;
isSquaredUp = true;
CustomEmotesAPI.PlayAnimation("SlapitNow.LethalHands__squareup", -2);
IngamePlayerSettings.Instance.playerInput.actions.FindAction("ActivateItem", false).performed += LeftPunchPerformed;
IngamePlayerSettings.Instance.playerInput.actions.FindAction("PingScan", false).performed += RightPunchPerformed;
HUDManager.Instance.ClearControlTips();
HUDManager.Instance.ChangeControlTipMultiple(controlTips, false, (Item)null);
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)("Squaring up " + isSquaredUp));
}
public void SquareDown(bool animate)
{
if (isSquaredUp)
{
IngamePlayerSettings.Instance.playerInput.actions.FindAction("ActivateItem", false).performed -= LeftPunchPerformed;
IngamePlayerSettings.Instance.playerInput.actions.FindAction("PingScan", false).performed -= RightPunchPerformed;
if (animate)
{
CustomEmotesAPI.PlayAnimation("SlapitNow.LethalHands__squaredown", -2);
}
else
{
CustomEmotesAPI.PlayAnimation("none", -2);
}
HUDManager.Instance.ClearControlTips();
isSquaredUp = false;
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)("Squaring down " + isSquaredUp));
}
}
private IEnumerator LeftPunch()
{
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)"Left Punch");
playerControllerInstance.sprintMeter = Mathf.Max(playerControllerInstance.sprintMeter - staminaDrain, 0f);
recordedStamina = playerControllerInstance.sprintMeter;
freezeStaminaRegen = true;
CustomEmotesAPI.PlayAnimation("SlapitNow.LethalHands__lpunch", -2);
yield return (object)new WaitForSeconds(punchConnectTime);
PunchThrow();
yield return (object)new WaitForSeconds(punchFinishingTime);
punchingCoroutine = null;
if (unfreezeStaminaRegenCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(unfreezeStaminaRegenCoroutine);
}
unfreezeStaminaRegenCoroutine = ((MonoBehaviour)this).StartCoroutine(UnfreezeStaminaRegen());
}
private IEnumerator RightPunch()
{
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)"Right Punch");
playerControllerInstance.sprintMeter = Mathf.Max(playerControllerInstance.sprintMeter - staminaDrain, 0f);
recordedStamina = playerControllerInstance.sprintMeter;
freezeStaminaRegen = true;
CustomEmotesAPI.PlayAnimation("SlapitNow.LethalHands__rpunch", -2);
yield return (object)new WaitForSeconds(punchConnectTime);
PunchThrow();
yield return (object)new WaitForSeconds(punchFinishingTime);
punchingCoroutine = null;
if (unfreezeStaminaRegenCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(unfreezeStaminaRegenCoroutine);
}
unfreezeStaminaRegenCoroutine = ((MonoBehaviour)this).StartCoroutine(UnfreezeStaminaRegen());
}
private IEnumerator UnfreezeStaminaRegen()
{
yield return (object)new WaitForSeconds(0.5f);
freezeStaminaRegen = false;
}
public void PunchThrow()
{
//IL_0011: 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_0081: 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_0377: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_02da: Unknown result type (might be due to invalid IL or missing references)
RaycastHit[] source = Physics.SphereCastAll(((Component)playerControllerInstance.gameplayCamera).transform.position, 0.8f, ((Component)playerControllerInstance.gameplayCamera).transform.forward, punchRange, shovelMask, (QueryTriggerInteraction)2);
List<RaycastHit> list = source.OrderBy((RaycastHit raycast) => ((RaycastHit)(ref raycast)).distance).ToList();
bool flag = false;
int terrainIndex = -1;
IHittable val = default(IHittable);
RaycastHit val2 = default(RaycastHit);
foreach (RaycastHit item in list)
{
RaycastHit current = item;
if ((((Component)((RaycastHit)(ref current)).transform).gameObject.layer == 8 || ((Component)((RaycastHit)(ref current)).transform).gameObject.layer == 11) && !((RaycastHit)(ref current)).collider.isTrigger)
{
flag = true;
string tag = ((Component)((RaycastHit)(ref current)).collider).gameObject.tag;
for (int i = 0; i < StartOfRound.Instance.footstepSurfaces.Length; i++)
{
if (StartOfRound.Instance.footstepSurfaces[i].surfaceTag == tag)
{
terrainIndex = i;
break;
}
}
}
else
{
if (!((Component)((RaycastHit)(ref current)).transform).TryGetComponent<IHittable>(ref val) || (!(((RaycastHit)(ref current)).point == Vector3.zero) && Physics.Linecast(((Component)playerControllerInstance.gameplayCamera).transform.position, ((RaycastHit)(ref current)).point, ref val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)) || (Object)(object)((RaycastHit)(ref current)).transform == (Object)(object)((Component)playerControllerInstance).transform)
{
continue;
}
flag = true;
Vector3 forward = ((Component)playerControllerInstance.gameplayCamera).transform.forward;
bool flag2 = punchOffClingersChance > 0 && Random.Range(0, 100) < punchOffClingersChance;
if (!flag2)
{
BushWolfTongueCollider val3 = (BushWolfTongueCollider)(object)((val is BushWolfTongueCollider) ? val : null);
if (val3 != null && (Object)(object)val3.bushWolfScript.draggingPlayer == (Object)(object)playerControllerInstance)
{
continue;
}
}
EnemyAICollisionDetect val4 = (EnemyAICollisionDetect)(object)((val is EnemyAICollisionDetect) ? val : null);
if (val4 != null)
{
EnemyAI mainScript = val4.mainScript;
if (mainScript.isEnemyDead)
{
continue;
}
if (!flag2)
{
CentipedeAI val5 = (CentipedeAI)(object)((mainScript is CentipedeAI) ? mainScript : null);
if (val5 != null && (Object)(object)val5.clingingToPlayer == (Object)(object)playerControllerInstance)
{
continue;
}
}
if (!flag2)
{
FlowerSnakeEnemy val6 = (FlowerSnakeEnemy)(object)((mainScript is FlowerSnakeEnemy) ? mainScript : null);
if (val6 != null && (Object)(object)val6.clingingToPlayer == (Object)(object)playerControllerInstance)
{
continue;
}
}
val4.onlyCollideWhenGrounded = false;
}
try
{
val.Hit(-22, forward, playerControllerInstance, true, -1);
}
catch
{
}
break;
}
}
if (flag)
{
int soundIndex = Random.Range(0, hitSounds.Length);
LethalHandsNetworker.Instance.PunchHitSoundServerRpc((int)playerControllerInstance.playerClientId, soundIndex, terrainIndex);
RoundManager.PlayRandomClip(playerControllerInstance.movementAudio, hitSounds, true, 1f, 0, 1000);
RoundManager.Instance.PlayAudibleNoise(((Component)playerControllerInstance).transform.position, 10f, 0.5f, 0, false, 0);
}
}
public void PunchHitSound(int playerID, int soundIndex, int terrainIndex)
{
AudioSource movementAudio = StartOfRound.Instance.allPlayerScripts[playerID].movementAudio;
movementAudio.PlayOneShot(hitSounds[soundIndex]);
WalkieTalkie.TransmitOneShotAudio(movementAudio, hitSounds[soundIndex], 1f);
if (terrainIndex != -1)
{
movementAudio.PlayOneShot(StartOfRound.Instance.footstepSurfaces[terrainIndex].hitSurfaceSFX);
WalkieTalkie.TransmitOneShotAudio(movementAudio, StartOfRound.Instance.footstepSurfaces[terrainIndex].hitSurfaceSFX, 1f);
}
}
public void Sleep()
{
Input.SquareUpInput.Instance.SquareUpKey.performed -= SquareUpPerformed;
if (isSquaredUp)
{
IngamePlayerSettings.Instance.playerInput.actions.FindAction("ActivateItem", false).performed -= LeftPunchPerformed;
IngamePlayerSettings.Instance.playerInput.actions.FindAction("PingScan", false).performed -= RightPunchPerformed;
}
Instance = null;
}
}
internal class LethalHandsNetworker : NetworkBehaviour
{
public static LethalHandsNetworker Instance { get; private set; }
public override void OnNetworkSpawn()
{
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
LethalHandsNetworker instance = Instance;
if (instance != null)
{
((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ServerRpc(RequireOwnership = false)]
public void PunchHitSoundServerRpc(int playerID, int soundIndex, int terrainIndex)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Invalid comparison between Unknown and I4
//IL_005f: 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_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3916256545u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, playerID);
BytePacker.WriteValueBitPacked(val2, soundIndex);
BytePacker.WriteValueBitPacked(val2, terrainIndex);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3916256545u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
PunchHitSoundClientRpc(playerID, soundIndex, terrainIndex);
}
}
}
[ClientRpc]
public void PunchHitSoundClientRpc(int playerID, int soundIndex, int terrainIndex)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Invalid comparison between Unknown and I4
//IL_005f: 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_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3644235124u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, playerID);
BytePacker.WriteValueBitPacked(val2, soundIndex);
BytePacker.WriteValueBitPacked(val2, terrainIndex);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3644235124u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
LethalHands.Instance.PunchHitSound(playerID, soundIndex, terrainIndex);
}
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_LethalHandsNetworker()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(3916256545u, new RpcReceiveHandler(__rpc_handler_3916256545));
NetworkManager.__rpc_func_table.Add(3644235124u, new RpcReceiveHandler(__rpc_handler_3644235124));
}
private static void __rpc_handler_3916256545(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_003d: 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_0072: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
int playerID = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
int soundIndex = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref soundIndex);
int terrainIndex = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref terrainIndex);
target.__rpc_exec_stage = (__RpcExecStage)1;
((LethalHandsNetworker)(object)target).PunchHitSoundServerRpc(playerID, soundIndex, terrainIndex);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_3644235124(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_003d: 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_0072: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
int playerID = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
int soundIndex = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref soundIndex);
int terrainIndex = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref terrainIndex);
target.__rpc_exec_stage = (__RpcExecStage)2;
((LethalHandsNetworker)(object)target).PunchHitSoundClientRpc(playerID, soundIndex, terrainIndex);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "LethalHandsNetworker";
}
}
public class LocalConfig
{
public static ConfigEntry<float> punchRange;
public static ConfigEntry<float> punchCooldown;
public static ConfigEntry<float> enemyPunchDamage;
public static ConfigEntry<int> playerPunchDamage;
public static ConfigEntry<int> punchOffClingersChance;
public static ConfigEntry<int> staminaDrain;
public static ConfigEntry<int> staminaRequirement;
public static ConfigEntry<bool> punchingHaltsStaminaRegen;
public static ConfigEntry<ItemMode> itemDropMode;
public static ConfigEntry<bool> allowItems;
public static NetworkConfig networkConfig;
public LocalConfig(ConfigFile cfg)
{
punchRange = cfg.Bind<float>("Balancing", "PunchRange", 1.2f, "Range of the punch (for reference, shovels are 1.5 and knives are 0.75)");
punchCooldown = cfg.Bind<float>("Balancing", "PunchCooldown", 1f, "Cooldown (in seconds) between punches");
enemyPunchDamage = cfg.Bind<float>("Balancing", "EnemyPunchDamage", 0.5f, "Damage dealt by a punch to enemies");
playerPunchDamage = cfg.Bind<int>("Balancing", "PlayerPunchDamage", 10, "Damage dealt by a punch to other players");
punchOffClingersChance = cfg.Bind<int>("Balancing", "PunchOffClingersChance", 100, "How likely (%) your own punches are to hit snarefleas/tulip snakes/fox tongues that are attached to yourself");
staminaDrain = cfg.Bind<int>("Stamina Balancing", "StaminaDrain", 0, "Max stamina drained (%) per punch");
staminaRequirement = cfg.Bind<int>("Stamina Balancing", "StaminaRequirement", 0, "Max stamina required (%) to punch");
punchingHaltsStaminaRegen = cfg.Bind<bool>("Stamina Balancing", "PunchingHaltsStaminaRegen", false, "Whether punching should halt stamina regeneration for a brief period");
itemDropMode = cfg.Bind<ItemMode>("Item Interaction", "ItemDropMode", ItemMode.All, "Whether to drop all items, only the current item, or no items upon squaring up");
allowItems = cfg.Bind<bool>("Item Interaction", "AllowItems", false, "Whether to allow items to be held while squared up");
networkConfig = new NetworkConfig();
}
}
public enum ItemMode
{
All,
Current,
None
}
[BepInPlugin("SlapitNow.LethalHands", "Lethal Hands", "22.1.5")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class LethalHandsPlugin : BaseUnityPlugin
{
private const string modGUID = "SlapitNow.LethalHands";
private const string modName = "Lethal Hands";
private const string modVersion = "22.1.5";
public static LethalHandsPlugin Instance;
private readonly Harmony harmony = new Harmony("SlapitNow.LethalHands");
public ManualLogSource manualLogSource;
public static LocalConfig MyConfig { get; internal set; }
public static PluginInfo PInfo { get; private set; }
private static void NetcodePatcher()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
private void Awake()
{
Instance = this;
PInfo = ((BaseUnityPlugin)this).Info;
manualLogSource = Logger.CreateLogSource("SlapitNow.LethalHands");
Assets.LoadAssetBundlesFromFolder("assetbundles");
MyConfig = new LocalConfig(((BaseUnityPlugin)this).Config);
harmony.PatchAll(typeof(LethalHandsPlugin));
harmony.PatchAll(typeof(NetworkingPatches));
harmony.PatchAll(typeof(PlayerControllerBPatch));
harmony.PatchAll(typeof(TerminalPatch));
harmony.PatchAll(typeof(StartMatchLeverPatch));
harmony.PatchAll(typeof(HudManagerPatch));
harmony.PatchAll(typeof(InteractTriggerPatch));
harmony.PatchAll(typeof(EnemyAIPatch));
harmony.PatchAll(typeof(StartOfRoundPatch));
harmony.PatchAll(typeof(VehicleControllerPatch));
Animation.instantiateAnimations();
NetcodePatcher();
manualLogSource.LogInfo((object)"Successfully caught these hands");
}
}
}
namespace LethalHands.Patches
{
[HarmonyPatch(typeof(HUDManager))]
internal class HudManagerPatch
{
[HarmonyPatch("CanPlayerScan")]
[HarmonyPostfix]
private static void CanPlayerScanPostfix(ref bool __result)
{
if ((Object)(object)LethalHands.Instance != (Object)null)
{
__result = __result && !LethalHands.Instance.isSquaredUp;
}
}
}
internal class EnemyAIPatch
{
[HarmonyPatch(typeof(EnemyAI), "HitEnemyOnLocalClient")]
[HarmonyPrefix]
private static bool PreHitEnemyOnLocalClient(EnemyAI __instance, int force, PlayerControllerB playerWhoHit, bool playHitSFX, int hitID)
{
if (force != -22)
{
return true;
}
__instance.HitEnemy(EnemyFloatHealth.Instance.DamageEnemy(__instance), playerWhoHit, playHitSFX, hitID);
__instance.HitEnemyServerRpc(force, (int)playerWhoHit.playerClientId, playHitSFX, hitID);
return false;
}
[HarmonyPatch(typeof(EnemyAI), "HitEnemyClientRpc")]
[HarmonyPrefix]
private static void PreHitEnemyClientRpc(EnemyAI __instance, ref int force, int playerWhoHit)
{
if (force == -22 && playerWhoHit != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
{
force = EnemyFloatHealth.Instance.DamageEnemy(__instance);
}
}
}
[HarmonyPatch(typeof(InteractTrigger))]
internal class InteractTriggerPatch
{
[HarmonyPatch("SetUsingLadderOnLocalClient")]
[HarmonyPrefix]
private static void PreSetUsingLadderOnLocalClient()
{
LethalHands.Instance.SquareDown(animate: false);
}
}
internal class NetworkingPatches
{
[CompilerGenerated]
private static class <>O
{
public static HandleNamedMessageDelegate <0>__OnRequestSync;
public static HandleNamedMessageDelegate <1>__OnReceiveSync;
}
private static GameObject networkPrefab;
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
[HarmonyPostfix]
public static void Init()
{
if (!((Object)(object)networkPrefab != (Object)null))
{
networkPrefab = Assets.Load<GameObject>("lethalhandsnetworker.prefab");
networkPrefab.AddComponent<LethalHandsNetworker>();
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPatch(typeof(StartOfRound), "Awake")]
[HarmonyPostfix]
private static void SpawnLethalHandsNetworker()
{
//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)
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
[HarmonyPostfix]
public static void InitializeLocalPlayer()
{
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Expected O, but got Unknown
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Expected O, but got Unknown
if ((Object)(object)LethalHands.Instance == (Object)null)
{
LethalHands lethalHands = ((Component)GameNetworkManager.Instance.localPlayerController).gameObject.AddComponent<LethalHands>();
}
if (EnemyFloatHealth.Instance == null)
{
new EnemyFloatHealth();
}
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)"Player initialized, setting up config...");
if (SyncedInstance<NetworkConfig>.IsHost)
{
CustomMessagingManager messageManager = SyncedInstance<NetworkConfig>.MessageManager;
object obj = <>O.<0>__OnRequestSync;
if (obj == null)
{
HandleNamedMessageDelegate val = NetworkConfig.OnRequestSync;
<>O.<0>__OnRequestSync = val;
obj = (object)val;
}
messageManager.RegisterNamedMessageHandler("SlapitNow.LethalHands_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
SyncedInstance<NetworkConfig>.Synced = true;
return;
}
SyncedInstance<NetworkConfig>.Synced = false;
CustomMessagingManager messageManager2 = SyncedInstance<NetworkConfig>.MessageManager;
object obj2 = <>O.<1>__OnReceiveSync;
if (obj2 == null)
{
HandleNamedMessageDelegate val2 = NetworkConfig.OnReceiveSync;
<>O.<1>__OnReceiveSync = val2;
obj2 = (object)val2;
}
messageManager2.RegisterNamedMessageHandler("SlapitNow.LethalHands_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
NetworkConfig.RequestSync();
}
[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
[HarmonyPostfix]
public static void PlayerLeave()
{
LethalHandsPlugin.Instance.manualLogSource.LogInfo((object)"Player disconnected, restoring config...");
LethalHands.Instance.Sleep();
SyncedInstance<NetworkConfig>.RevertSync();
EnemyFloatHealth.Instance = null;
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerBPatch
{
[HarmonyPatch("GrabObject")]
[HarmonyPrefix]
private static void PreGrabObject()
{
if (!LethalHands.Instance.allowItems)
{
LethalHands.Instance.SquareDown(animate: false);
}
}
[HarmonyPatch("BeginGrabObject")]
[HarmonyPostfix]
private static void PostBeginGrabObject()
{
if (!LethalHands.Instance.allowItems && LethalHands.Instance.playerControllerInstance.isGrabbingObjectAnimation)
{
LethalHands.Instance.SquareDown(animate: false);
}
}
[HarmonyPatch("SwitchToItemSlot")]
[HarmonyPostfix]
private static void PostSwitchToItemSlot()
{
if (!LethalHands.Instance.allowItems && LethalHands.Instance.playerControllerInstance.isHoldingObject)
{
LethalHands.Instance.SquareDown(animate: false);
}
}
[HarmonyPatch("PerformEmote")]
[HarmonyPrefix]
private static void PrePerformEmote()
{
LethalHands.Instance.SquareDown(animate: false);
}
[HarmonyPatch("KillPlayer")]
[HarmonyPostfix]
private static void PostKillPlayer()
{
if (LethalHands.Instance.playerControllerInstance.isPlayerDead)
{
LethalHands.Instance.SquareDown(animate: false);
}
}
[HarmonyPatch("CancelSpecialTriggerAnimations")]
[HarmonyPrefix]
private static void PreCancelSpecialTriggerAnimations()
{
LethalHands.Instance?.SquareDown(animate: false);
}
[HarmonyPatch("LateUpdate")]
[HarmonyPostfix]
private static void PostLateUpdate()
{
if (!((Object)(object)LethalHands.Instance == (Object)null) && LethalHands.Instance.punchingHaltsStaminaRegen && LethalHands.Instance.freezeStaminaRegen)
{
LethalHands.Instance.playerControllerInstance.sprintMeter = Mathf.Clamp(LethalHands.Instance.playerControllerInstance.sprintMeter, 0f, LethalHands.Instance.recordedStamina);
LethalHands.Instance.playerControllerInstance.sprintMeterUI.fillAmount = LethalHands.Instance.playerControllerInstance.sprintMeter;
}
}
[HarmonyPatch("IHittable.Hit")]
[HarmonyPrefix]
private static bool PreHit(PlayerControllerB __instance, int force, Vector3 hitDirection, PlayerControllerB playerWhoHit)
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
if (force != -22)
{
return true;
}
if (!__instance.AllowPlayerDeath())
{
return false;
}
CentipedeAI[] array = Object.FindObjectsByType<CentipedeAI>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
if ((Object)(object)array[i].clingingToPlayer == (Object)(object)__instance)
{
return false;
}
}
if (Object.op_Implicit((Object)(object)__instance.inAnimationWithEnemy))
{
return false;
}
__instance.DamagePlayerFromOtherClientServerRpc(LethalHands.Instance.playerPunchDamage, hitDirection, (int)playerWhoHit.playerClientId);
return false;
}
}
[HarmonyPatch(typeof(StartMatchLever))]
internal class StartMatchLeverPatch
{
[HarmonyPatch("LeverAnimation")]
[HarmonyPrefix]
private static void PreLeverAnimation()
{
LethalHands.Instance.SquareDown(animate: false);
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class StartOfRoundPatch
{
[HarmonyPatch("StartGame")]
[HarmonyPostfix]
private static void PostStartGame()
{
EnemyFloatHealth.Instance.Reset();
}
}
[HarmonyPatch(typeof(Terminal))]
internal class TerminalPatch
{
[HarmonyPatch("BeginUsingTerminal")]
[HarmonyPrefix]
private static void PreBeginUsingTerminal()
{
LethalHands.Instance.SquareDown(animate: false);
}
}
[HarmonyPatch(typeof(VehicleController))]
internal class VehicleControllerPatch
{
[HarmonyPatch("TakeControlOfVehicle")]
[HarmonyPrefix]
private static void PreTakeControlOfVehicle()
{
LethalHands.Instance.SquareDown(animate: false);
}
[HarmonyPatch("SetPassengerInCar")]
[HarmonyPrefix]
private static void PreSetPassengerInCar(PlayerControllerB player)
{
if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
LethalHands.Instance.SquareDown(animate: false);
}
}
}
}
namespace LethalHands.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
