Decompiled source of AntiGrab v1.1.3

Mods/AntiGrab.dll

Decompiled 4 hours ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using AntiGrab;
using BoneLib.BoneMenu;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Interaction;
using LabFusion.Entities;
using LabFusion.Extensions;
using LabFusion.Marrow.Extenders;
using LabFusion.Network;
using LabFusion.Player;
using LabFusion.SDK.Metadata;
using LabFusion.Utilities;
using MelonLoader;
using MelonLoader.Preferences;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(AntiGrabMod), "Anti-Grab", "1.1.3", "Anti-Grab", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AntiGrab")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: AssemblyInformationalVersion("1.1.3+6418f3759670c4362c618b360c4ece48b0c93a05")]
[assembly: AssemblyProduct("AntiGrab")]
[assembly: AssemblyTitle("AntiGrab")]
[assembly: AssemblyVersion("1.1.3.0")]
namespace AntiGrab;

public sealed class AntiGrabMod : MelonMod
{
	private static readonly Dictionary<byte, PlayerID> exceptions = new Dictionary<byte, PlayerID>();

	private Page page;

	private bool rosterChanged = true;

	private bool permissionsDirty = true;

	private static readonly HashSet<ulong> damageAllowedPlayers = new HashSet<ulong>();

	private static MelonPreferences_Entry<string> savedDamagePermissions;

	internal static bool CanDamageWhileGrabbing(PlayerID player)
	{
		if (player != null)
		{
			return damageAllowedPlayers.Contains(player.PlatformID);
		}
		return false;
	}

	internal static bool IsAllowed(PlayerID player)
	{
		if (player != null && exceptions.TryGetValue(player.SmallID, out var value))
		{
			return value == player;
		}
		return false;
	}

	public override void OnInitializeMelon()
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Expected O, but got Unknown
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Expected O, but got Unknown
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Expected O, but got Unknown
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Expected O, but got Unknown
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Expected O, but got Unknown
		savedDamagePermissions = MelonPreferences.CreateCategory("AntiGrab").CreateEntry<string>("DamageAllowedPlayers", "", (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		damageAllowedPlayers.Clear();
		string[] array = savedDamagePermissions.Value.Split(',');
		for (int i = 0; i < array.Length; i++)
		{
			if (ulong.TryParse(array[i], out var result) && result != 0L)
			{
				damageAllowedPlayers.Add(result);
			}
		}
		string text = typeof(AntiGrabMod).Assembly.GetName().Version.ToString(3);
		page = Page.Root.CreatePage("Anti-Grab v" + text, Color.cyan, 0, true);
		Menu.OnPageOpened += OnPageOpened;
		MultiplayerHooking.OnPlayerJoined += new PlayerUpdate(OnRosterChanged);
		MultiplayerHooking.OnPlayerLeft += new PlayerUpdate(OnPlayerLeft);
		MultiplayerHooking.OnDisconnected += new ServerEvent(ResetLobby);
		MultiplayerHooking.OnJoinedServer += new ServerEvent(ResetLobby);
		MultiplayerHooking.OnStartedServer += new ServerEvent(ResetLobby);
		LocalPlayer.OnApplyInitialMetadata += MarkPermissionsDirty;
	}

	private void MarkPermissionsDirty()
	{
		permissionsDirty = true;
	}

	private void OnPageOpened(Page opened)
	{
		if (opened == page)
		{
			rosterChanged = true;
		}
	}

	private void OnRosterChanged(PlayerID _)
	{
		rosterChanged = true;
	}

	private void OnPlayerLeft(PlayerID player)
	{
		if (IsAllowed(player))
		{
			exceptions.Remove(player.SmallID);
			permissionsDirty = true;
		}
		GrabProtection.Forget(player.SmallID);
		rosterChanged = true;
	}

	private void ResetLobby()
	{
		exceptions.Clear();
		GrabProtection.Clear();
		permissionsDirty = true;
		rosterChanged = true;
	}

	public override void OnLateUpdate()
	{
		//IL_021e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		if (!rosterChanged || page == null || Menu.CurrentPage != page)
		{
			return;
		}
		rosterChanged = false;
		page.RemoveAll();
		if (NetworkInfo.HasServer)
		{
			string text = default(string);
			foreach (PlayerID player in from p in PlayerIDManager.PlayerIDs
				where !p.IsMe
				orderby p.SmallID
				select p)
			{
				if (!MetadataHelper.TryGetDisplayName(player, ref text) || string.IsNullOrWhiteSpace(text))
				{
					text = "Player";
				}
				text = text.Replace('<', '‹').Replace('>', '›').Replace('\n', ' ')
					.Replace('\r', ' ');
				page.CreateBool($"Allow {text} [#{player.SmallID}]", Color.white, IsAllowed(player), (Action<bool>)delegate(bool allow)
				{
					SetPermission(player, allow);
				});
				page.CreateBool($"Take grab damage from {text} [#{player.SmallID}]", Color.white, CanDamageWhileGrabbing(player), (Action<bool>)delegate(bool allow)
				{
					SetDamagePermission(player, allow);
				});
			}
		}
		if (page.ElementCount == 0)
		{
			page.CreateFunction(NetworkInfo.HasServer ? "No other players in this lobby" : "Join a Fusion lobby", Color.gray, (Action)delegate
			{
			});
		}
	}

	public override void OnFixedUpdate()
	{
		if (!NetworkInfo.HasServer)
		{
			return;
		}
		if (permissionsDirty && PlayerIDManager.LocalID != null && LocalPlayer.Metadata != null && LocalPlayer.Metadata.IsValid)
		{
			string text = string.Join(",", exceptions.Values.Select((PlayerID p) => p.PlatformID.ToString()));
			permissionsDirty = !LocalPlayer.Metadata.Metadata.TrySetMetadata("AntiGrab.permissions.v1", "1:" + text);
		}
		GrabProtection.ReleaseForbiddenLocalHands();
	}

	private void SetPermission(PlayerID player, bool allow)
	{
		if (!NetworkInfo.HasServer || PlayerIDManager.GetPlayerID(player.SmallID) != player)
		{
			return;
		}
		if (allow)
		{
			exceptions[player.SmallID] = player;
		}
		else
		{
			exceptions.Remove(player.SmallID);
			NetworkPlayer val = default(NetworkPlayer);
			if (NetworkPlayerManager.TryGetPlayer(player.SmallID, ref val) && val.HasRig)
			{
				GrabFilter.ReleaseLocalGrips(val);
			}
		}
		permissionsDirty = true;
	}

	private void SetDamagePermission(PlayerID player, bool allow)
	{
		if (NetworkInfo.HasServer && player.PlatformID != 0L && PlayerIDManager.GetPlayerID(player.SmallID) == player)
		{
			if (allow)
			{
				damageAllowedPlayers.Add(player.PlatformID);
			}
			else
			{
				damageAllowedPlayers.Remove(player.PlatformID);
			}
			savedDamagePermissions.Value = string.Join(",", damageAllowedPlayers.OrderBy((ulong id) => id));
			MelonPreferences.Save();
		}
	}

	public override void OnDeinitializeMelon()
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Expected O, but got Unknown
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Expected O, but got Unknown
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Expected O, but got Unknown
		if (LocalPlayer.Metadata != null && LocalPlayer.Metadata.IsValid)
		{
			LocalPlayer.Metadata.Metadata.TryRemoveMetadata("AntiGrab.permissions.v1");
		}
		Menu.OnPageOpened -= OnPageOpened;
		MultiplayerHooking.OnPlayerJoined -= new PlayerUpdate(OnRosterChanged);
		MultiplayerHooking.OnPlayerLeft -= new PlayerUpdate(OnPlayerLeft);
		MultiplayerHooking.OnDisconnected -= new ServerEvent(ResetLobby);
		MultiplayerHooking.OnJoinedServer -= new ServerEvent(ResetLobby);
		MultiplayerHooking.OnStartedServer -= new ServerEvent(ResetLobby);
		LocalPlayer.OnApplyInitialMetadata -= MarkPermissionsDirty;
		ResetLobby();
		if (page != null)
		{
			Page.Root.RemovePage(page);
		}
	}
}
[HarmonyPatch(typeof(RigGrabber), "Attach")]
internal static class GrabFilter
{
	private static bool Prefix(RigGrabber __instance, RigRefs ____references, Handedness handedness, Grip grip)
	{
		//IL_0031: 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)
		NetworkPlayer networkPlayer = LocalPlayer.GetNetworkPlayer();
		if (networkPlayer == null || __instance == networkPlayer.Grabber)
		{
			return true;
		}
		bool flag = IsLocalGrip(grip, networkPlayer);
		NetworkPlayer val = default(NetworkPlayer);
		if (NetworkPlayerManager.TryGetPlayer(____references.RigManager, ref val))
		{
			GrabProtection.MarkGrab(val.PlayerID, handedness, flag);
			if (!flag || AntiGrabMod.IsAllowed(val.PlayerID))
			{
				return true;
			}
		}
		else if (!flag)
		{
			return true;
		}
		__instance.Detach(handedness);
		return false;
	}

	private static bool IsLocalGrip(Grip grip, NetworkPlayer local)
	{
		NetworkEntity val = default(NetworkEntity);
		if ((Object)(object)grip != (Object)null && GripExtender.Cache.TryGet(grip, ref val))
		{
			return val == local.NetworkEntity;
		}
		return false;
	}

	internal static void ReleaseLocalGrips(NetworkPlayer remote)
	{
		NetworkPlayer local = LocalPlayer.GetNetworkPlayer();
		if (local != null)
		{
			ReleaseHand(remote.RigRefs.LeftHand);
			ReleaseHand(remote.RigRefs.RightHand);
		}
		void ReleaseHand(Hand hand)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)hand == (Object)null) && !((Object)(object)hand.AttachedReceiver == (Object)null) && IsLocalGrip(((Il2CppObjectBase)hand.AttachedReceiver).TryCast<Grip>(), local))
			{
				remote.Grabber.Detach(hand.handedness);
			}
		}
	}
}
internal static class GrabProtection
{
	internal const string MetadataKey = "AntiGrab.permissions.v1";

	private static readonly Dictionary<byte, HashSet<Handedness>> grabbingHands = new Dictionary<byte, HashSet<Handedness>>();

	internal static void MarkGrab(PlayerID player, Handedness hand, bool active)
	{
		//IL_0069: 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)
		if (player == null)
		{
			return;
		}
		if (!active)
		{
			if (grabbingHands.TryGetValue(player.SmallID, out var value))
			{
				value.Remove(hand);
				if (value.Count == 0)
				{
					grabbingHands.Remove(player.SmallID);
				}
			}
		}
		else
		{
			if (!grabbingHands.TryGetValue(player.SmallID, out var value2))
			{
				value2 = new HashSet<Handedness>();
				grabbingHands[player.SmallID] = value2;
			}
			value2.Add(hand);
		}
	}

	internal static void Forget(byte id)
	{
		grabbingHands.Remove(id);
	}

	internal static void Clear()
	{
		grabbingHands.Clear();
	}

	internal static bool BlockDamage(byte sender)
	{
		PlayerID playerID = PlayerIDManager.GetPlayerID(sender);
		if (playerID != null && grabbingHands.ContainsKey(sender))
		{
			return !AntiGrabMod.CanDamageWhileGrabbing(playerID);
		}
		return false;
	}

	internal static void ReleaseForbiddenLocalHands()
	{
		NetworkPlayer networkPlayer = LocalPlayer.GetNetworkPlayer();
		if (networkPlayer != null && networkPlayer.HasRig && PlayerIDManager.LocalID != null)
		{
			Release(networkPlayer.RigRefs.LeftHand);
			Release(networkPlayer.RigRefs.RightHand);
		}
	}

	private static void Release(Hand hand)
	{
		if ((Object)(object)hand == (Object)null || (Object)(object)hand.AttachedReceiver == (Object)null)
		{
			return;
		}
		Grip val = ((Il2CppObjectBase)hand.AttachedReceiver).TryCast<Grip>();
		NetworkEntity val2 = default(NetworkEntity);
		if ((Object)(object)val == (Object)null || !GripExtender.Cache.TryGet(val, ref val2))
		{
			return;
		}
		NetworkPlayer extender = val2.GetExtender<NetworkPlayer>();
		object obj;
		if (extender == null)
		{
			obj = null;
		}
		else
		{
			PlayerID playerID = extender.PlayerID;
			if (playerID == null)
			{
				obj = null;
			}
			else
			{
				PlayerMetadata metadata = playerID.Metadata;
				obj = ((metadata != null) ? metadata.Metadata : null);
			}
		}
		NetworkMetadata val3 = (NetworkMetadata)obj;
		string text = default(string);
		if (extender != null && !extender.PlayerID.IsMe && val3 != null && val3.TryGetMetadata("AntiGrab.permissions.v1", ref text) && text != null && text.StartsWith("1:", StringComparison.Ordinal))
		{
			string value = PlayerIDManager.LocalID.PlatformID.ToString();
			if (!text.Substring(2).Split(',').Contains(value))
			{
				HandExtensions.TryDetach(hand);
			}
		}
	}
}
[HarmonyPatch(typeof(PlayerRepReleaseMessage), "OnHandleMessage")]
internal static class GrabReleasePatch
{
	private static void Prefix(ReceivedMessage received)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		if (((ReceivedMessage)(ref received)).Sender.HasValue)
		{
			GrabProtection.MarkGrab(PlayerIDManager.GetPlayerID(((ReceivedMessage)(ref received)).Sender.Value), ((ReceivedMessage)(ref received)).ReadData<PlayerRepReleaseData>().Handedness, active: false);
		}
	}
}
[HarmonyPatch(typeof(PlayerRepDamageMessage), "OnHandleMessage")]
internal static class GrabDamagePatch
{
	private static bool Prefix(ReceivedMessage received)
	{
		if (((ReceivedMessage)(ref received)).Sender.HasValue)
		{
			return !GrabProtection.BlockDamage(((ReceivedMessage)(ref received)).Sender.Value);
		}
		return true;
	}
}