[Resonance] New SCP Events & Disguise Prefix To Transpiler

Exiled.Events/EventArgs/Scp0492/AttackingEventArgs.cs

@@ -0,0 +1,47 @@
+// -----------------------------------------------------------------------
+// <copyright file="AttackingEventArgs.cs" company="Exiled Team">
+// Copyright (c) Exiled Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.Events.EventArgs.Scp0492
+{
+    using API.Features;
+    using Exiled.API.Features.Roles;
+    using Exiled.Events.EventArgs.Interfaces;
+
+    /// <summary>
+    /// Contains all information before a Scp-0492 attacks a player.
+    /// </summary>
+    public class AttackingEventArgs : IScp0492Event, IDeniableEvent
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AttackingEventArgs" /> class.
+        /// </summary>
+        /// <param name="player"><see cref="Player"/>.</param>
+        /// <param name="target"><see cref="Target"/>.</param>
+        /// <param name="isAllowed"><see cref="IsAllowed"/>.</param>
+        public AttackingEventArgs(Player player, Player target, bool isAllowed = true)
+        {
+            Player = player;
+            Scp0492 = Player.Role.As<Scp0492Role>();
+            Target = target;
+            IsAllowed = isAllowed;
+        }
+
+        /// <inheritdoc/>
+        public Player Player { get; }
+
+        /// <inheritdoc/>
+        public Scp0492Role Scp0492 { get; }
+
+        /// <summary>
+        /// Gets the player that is going to damaged by a SCP-0492.
+        /// </summary>
+        public Player Target { get; }
+
+        /// <inheritdoc/>
+        public bool IsAllowed { get; set; }
+    }
+}

Exiled.Events/EventArgs/Scp096/AttackingEventArgs.cs

@@ -0,0 +1,61 @@
+// -----------------------------------------------------------------------
+// <copyright file="AttackingEventArgs.cs" company="Exiled Team">
+// Copyright (c) Exiled Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.Events.EventArgs.Scp096
+{
+    using Exiled.API.Features;
+    using Exiled.API.Features.Roles;
+    using Exiled.Events.EventArgs.Interfaces;
+
+    /// <summary>
+    /// Contains all information before SCP-096 attacks someone.
+    /// </summary>
+    public class AttackingEventArgs : IScp096Event, IDeniableEvent
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AttackingEventArgs" /> class.
+        /// </summary>
+        /// <param name="player"><see cref="Player"/>.</param>
+        /// <param name="target"><see cref="Target"/>.</param>
+        /// <param name="humanDamage"><see cref="HumanDamage"/>.</param>
+        /// <param name="nonTargetDamage"><see cref="NonTargetDamage"/>.</param>
+        /// <param name="isAllowed"><see cref="IsAllowed"/>.</param>
+        public AttackingEventArgs(Player player, Player target, float humanDamage, float nonTargetDamage, bool isAllowed = true)
+        {
+            Player = player;
+            Scp096 = Player.Role.As<Scp096Role>();
+            Target = target;
+            HumanDamage = humanDamage;
+            NonTargetDamage = nonTargetDamage;
+            IsAllowed = isAllowed;
+        }
+
+        /// <inheritdoc/>
+        public Player Player { get; }
+
+        /// <inheritdoc/>
+        public Scp096Role Scp096 { get; }
+
+        /// <summary>
+        /// Gets the player that is going to be damaged by the SCP-096.
+        /// </summary>
+        public Player Target { get; }
+
+        /// <summary>
+        /// Gets or sets the amount of damage of the SCP-096 hit.
+        /// </summary>
+        public float HumanDamage { get; set; }
+
+        /// <summary>
+        /// Gets or sets the amount of damage of the SCP-096 if the target is not a target of the SCP-096.
+        /// </summary>
+        public float NonTargetDamage { get; set; }
+
+        /// <inheritdoc/>
+        public bool IsAllowed { get; set; }
+    }
+}

Exiled.Events/EventArgs/Scp173/AttackingEventArgs.cs

@@ -0,0 +1,47 @@
+// -----------------------------------------------------------------------
+// <copyright file="AttackingEventArgs.cs" company="Exiled Team">
+// Copyright (c) Exiled Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.Events.EventArgs.Scp173
+{
+    using API.Features;
+    using Exiled.API.Features.Roles;
+    using Exiled.Events.EventArgs.Interfaces;
+
+    /// <summary>
+    /// Contains all information before a Scp-173 snaps a player neck.
+    /// </summary>
+    public class AttackingEventArgs : IScp173Event, IDeniableEvent
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AttackingEventArgs" /> class.
+        /// </summary>
+        /// <param name="player"><see cref="Player"/>.</param>
+        /// <param name="target"><see cref="Target"/>.</param>
+        /// <param name="isAllowed"><see cref="IsAllowed"/>.</param>
+        public AttackingEventArgs(Player player, Player target, bool isAllowed = true)
+        {
+            Player = player;
+            Scp173 = Player.Role.As<Scp173Role>();
+            Target = target;
+            IsAllowed = isAllowed;
+        }
+
+        /// <inheritdoc/>
+        public Player Player { get; }
+
+        /// <inheritdoc/>
+        public Scp173Role Scp173 { get; }
+
+        /// <summary>
+        /// Gets the player that is going to be snapped.
+        /// </summary>
+        public Player Target { get; }
+
+        /// <inheritdoc/>
+        public bool IsAllowed { get; set; }
+    }
+}

Exiled.Events/EventArgs/Scp3114/StranglingEventArgs.cs

@@ -10,65 +10,36 @@ namespace Exiled.Events.EventArgs.Scp3114
     using Exiled.API.Features;
     using Exiled.Events.EventArgs.Interfaces;
 
-    using PlayerRoles.PlayableScps.Scp3114;
-
-    using HumanRole = PlayerRoles.HumanRole;
     using Scp3114Role = API.Features.Roles.Scp3114Role;
 
     /// <summary>
     /// Contains all information before strangling a player.
     /// </summary>
     public class StranglingEventArgs : IScp3114Event, IDeniableEvent
     {
-        private readonly Scp3114Strangle strangle;
-        private Player target = null;
-
         /// <summary>
         /// Initializes a new instance of the <see cref="StranglingEventArgs"/> class.
         /// </summary>
-        /// <param name="strangle">The <see cref="Scp3114Strangle"/> instance.</param>
         /// <param name="player">The <see cref="API.Features.Player"/> triggering the event.</param>
         /// <param name="target">The <see cref="API.Features.Player"/> being targeted.</param>
-        public StranglingEventArgs(Scp3114Strangle strangle, Player player, Scp3114Strangle.StrangleTarget target)
+        public StranglingEventArgs(Player player, Player target)
         {
-            this.strangle = strangle;
             Scp3114 = player.Role.As<Scp3114Role>();
             Player = player;
-            Target = Player.Get(target.Target);
-            StrangleTarget = target;
+            Target = target;
         }
 
         /// <inheritdoc />
         public Scp3114Role Scp3114 { get; }
 
         /// <inheritdoc />
-        public Player Player
-        {
-            get => target;
-            set
-            {
-                target = value;
-
-                if (!target)
-                {
-                    StrangleTarget = default(Scp3114Strangle.StrangleTarget);
-                    return;
-                }
-
-                StrangleTarget = new(target.ReferenceHub, strangle.GetStranglePosition(target.ReferenceHub.roleManager.CurrentRole as HumanRole), Player.Position);
-            }
-        }
+        public Player Player { get; }
 
         /// <summary>
-        /// Gets the target player.
+        /// Gets the target that the skeleton is strangling.
         /// </summary>
         public Player Target { get; }
 
-        /// <summary>
-        /// Gets the <see cref="Scp3114Strangle.StrangleTarget"/>. This value is updated when <see cref="Target"/> is changed.
-        /// </summary>
-        public Scp3114Strangle.StrangleTarget? StrangleTarget { get; private set; }
-
         /// <inheritdoc />
         public bool IsAllowed { get; set; } = true;
     }

Exiled.Events/Handlers/Scp0492.cs

@@ -32,6 +32,11 @@ public class Scp0492
         /// </summary>
         public static Event<ConsumingCorpseEventArgs> ConsumingCorpse { get; set; } = new();
 
+        /// <summary>
+        /// Called before 049-2 damages someone.
+        /// </summary>
+        public static Event<AttackingEventArgs> Attacking { get; set; } = new();
+
         /// <summary>
         /// Called before a player triggers the bloodlust effect for 049-2.
         /// </summary>
@@ -49,5 +54,11 @@ public class Scp0492
         /// </summary>
         /// <param name="ev"><inheritdoc cref="ConsumingCorpseEventArgs"/> instance.</param>
         public static void OnConsumingCorpse(ConsumingCorpseEventArgs ev) => ConsumingCorpse.InvokeSafely(ev);
+
+        /// <summary>
+        /// Invokes before 049-2 hits someone.
+        /// </summary>
+        /// <param name="ev"><inheritdoc cref="AttackingEventArgs"/> instance.</param>
+        public static void OnAttacking(AttackingEventArgs ev) => Attacking.InvokeSafely(ev);
     }
 }

Exiled.Events/Handlers/Scp096.cs

@@ -47,6 +47,11 @@ public static class Scp096
         /// </summary>
         public static Event<TryingNotToCryEventArgs> TryingNotToCry { get; set; } = new();
 
+        /// <summary>
+        /// Invoked before SCP-096 damages someone.
+        /// </summary>
+        public static Event<AttackingEventArgs> Attacking { get; set; } = new();
+
         /// <summary>
         /// Called before SCP-096 is enraged.
         /// </summary>
@@ -82,5 +87,11 @@ public static class Scp096
         /// </summary>
         /// <param name="ev">The <see cref="TryingNotToCryEventArgs" /> instance.</param>
         public static void OnTryingNotToCry(TryingNotToCryEventArgs ev) => TryingNotToCry.InvokeSafely(ev);
+
+        /// <summary>
+        /// Called before SCP-096 damages someone.
+        /// </summary>
+        /// <param name="ev">The <see cref="AttackingEventArgs"/> instance.</param>
+        public static void OnAttacking(AttackingEventArgs ev) => Attacking.InvokeSafely(ev);
     }
 }

Exiled.Events/Handlers/Scp173.cs

@@ -47,6 +47,11 @@ public static class Scp173
         /// </summary>
         public static Event<RemoveObserverEventArgs> RemoveObserver { get; set; } = new();
 
+        /// <summary>
+        /// Invoked before SCP-173 snaps a player neck.
+        /// </summary>
+        public static Event<AttackingEventArgs> Attacking { get; set; } = new();
+
         /// <summary>
         /// Called before players near SCP-173 blink.
         /// </summary>
@@ -82,5 +87,11 @@ public static class Scp173
         /// </summary>
         /// <param name="ev">The <see cref="AddingObserverEventArgs" /> instance.</param>
         public static void OnRemoveObserver(RemoveObserverEventArgs ev) => RemoveObserver.InvokeSafely(ev);
+
+        /// <summary>
+        /// Called before SCP-173 snaps a player neck.
+        /// </summary>
+        /// <param name="ev">The <see cref="AttackingEventArgs"/> instance.</param>
+        public static void OnAttacking(AttackingEventArgs ev) => Attacking.InvokeSafely(ev);
     }
 }

Exiled.Events/Patches/Events/Scp0492/Attacking.cs

@@ -0,0 +1,76 @@
+// -----------------------------------------------------------------------
+// <copyright file="Attacking.cs" company="Exiled Team">
+// Copyright (c) Exiled Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.Events.Patches.Events.Scp0492
+{
+    using System.Collections.Generic;
+    using System.Reflection.Emit;
+
+    using Exiled.API.Features.Core.Generic.Pools;
+    using Exiled.Events.Attributes;
+    using Exiled.Events.EventArgs.Scp0492;
+    using HarmonyLib;
+    using PlayerRoles.PlayableScps.Scp049.Zombies;
+    using PlayerRoles.PlayableScps.Subroutines;
+
+    using static HarmonyLib.AccessTools;
+
+    using Player = Exiled.API.Features.Player;
+
+    /// <summary>
+    /// Patches <see cref="ScpAttackAbilityBase{T}.ServerPerformAttack" />.
+    /// Adds the <see cref="Handlers.Scp0492.Attacking" /> event.
+    /// </summary>
+    [EventPatch(typeof(Handlers.Scp0492), nameof(Handlers.Scp0492.Attacking))]
+    [HarmonyPatch(typeof(ScpAttackAbilityBase<ZombieRole>), nameof(ScpAttackAbilityBase<ZombieRole>.ServerPerformAttack))]
+    internal static class Attacking
+    {
+        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        {
+            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
+
+            Label retLabel = generator.DefineLabel();
+
+            const int offset = -4;
+            int index = newInstructions.FindIndex(instruction => instruction.Calls(Method(typeof(HashSet<ReferenceHub>), nameof(HashSet<ReferenceHub>.Add)))) + offset;
+
+            newInstructions.InsertRange(index, new CodeInstruction[]
+            {
+                // Player::Get(ScpAttackAbilityBase<ZombieRole>::Owner)
+                new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(newInstructions[index]),
+                new(OpCodes.Callvirt, PropertyGetter(typeof(ScpAttackAbilityBase<ZombieRole>), nameof(ScpAttackAbilityBase<ZombieRole>.Owner))),
+                new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
+
+                // Player::Get(hitboxIdentity)
+                new(OpCodes.Ldloc_3),
+                new(OpCodes.Callvirt, PropertyGetter(typeof(HitboxIdentity), nameof(HitboxIdentity.TargetHub))),
+                new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
+
+                // true
+                new(OpCodes.Ldc_I4_1),
+
+                // AttackingEventArgs args = new(player, target, true)
+                new(OpCodes.Newobj, GetDeclaredConstructors(typeof(AttackingEventArgs))[0]),
+                new(OpCodes.Dup),
+
+                // Scp0492::OnAttacking(args)
+                new(OpCodes.Call, Method(typeof(Handlers.Scp0492), nameof(Handlers.Scp0492.OnAttacking))),
+
+                // if (!args.IsAllowed) return
+                new(OpCodes.Callvirt, PropertyGetter(typeof(AttackingEventArgs), nameof(AttackingEventArgs.IsAllowed))),
+                new(OpCodes.Brfalse_S, retLabel),
+            });
+
+            newInstructions[newInstructions.Count - 1].labels.Add(retLabel);
+
+            foreach (CodeInstruction instruction in newInstructions)
+                yield return instruction;
+
+            ListPool<CodeInstruction>.Pool.Return(newInstructions);
+        }
+    }
+}