From 6a9c9b6ab96db59cb144355b24be4af14d65393f Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Thu, 28 Nov 2024 14:57:12 +0200
Subject: [PATCH 1/8] New Shooting patch (not tested)

---
 .../EventArgs/Player/ShootingEventArgs.cs     | 89 +++++--------------
 .../Patches/Events/Player/Shooting.cs         | 89 +++++++++----------
 2 files changed, 67 insertions(+), 111 deletions(-)

diff --git a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
index c348e649b..e58f0b9d9 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
@@ -5,20 +5,16 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
+using InventorySystem.Items.Firearms.Modules.Misc;
+
 namespace Exiled.Events.EventArgs.Player
 {
     using API.Features;
-
+    
     using Exiled.API.Features.Items;
-
+    
     using Interfaces;
-
-    using InventorySystem.Items.Firearms.BasicMessages;
-
-    using RelativePositioning;
-
-    using UnityEngine;
-
+    
     using BaseFirearm = InventorySystem.Items.Firearms.Firearm;
 
     /// <summary>
@@ -29,85 +25,46 @@ public class ShootingEventArgs : IPlayerEvent, IDeniableEvent, IFirearmEvent
         /// <summary>
         /// Initializes a new instance of the <see cref="ShootingEventArgs" /> class.
         /// </summary>
-        /// <param name="shooter">
-        /// <inheritdoc cref="Player" />
-        /// </param>
         /// <param name="firearm">
-        /// <inheritdoc cref="Firearm" />
+        /// The <see cref="BaseFirearm"/> that is being fired.
+        /// </param>
+        /// <param name="shotBacktrackData">
+        /// <see cref="ShotBacktrackData"/> sent by the client.
         /// </param>
-        public ShootingEventArgs(Player shooter, BaseFirearm firearm)
+        public ShootingEventArgs(BaseFirearm firearm, ShotBacktrackData shotBacktrackData)
         {
-            Player = shooter;
-            Firearm = Item.Get(firearm).As<Firearm>();
-
+            Firearm = (Firearm)Item.Get(firearm);
+            Player = Firearm.Owner;
+            ShotBacktrackData = shotBacktrackData;
             // ShotMessage = msg;
         }
 
         /// <summary>
-        /// Gets the player who's shooting.
+        /// Gets the player who is shooting.
         /// </summary>
         public Player Player { get; }
 
         /// <summary>
-        /// Gets the target <see cref="API.Features.Items.Firearm" />.
+        /// Gets the target that client claims it hit. This value is controlled by the client and should not be trusted. Can be null.
         /// </summary>
-        public Firearm Firearm { get; }
+        public Player ClaimedTarget => ShotBacktrackData.HasPrimaryTarget ? Player.Get(ShotBacktrackData.PrimaryTargetHub) : null;
 
-        /// <inheritdoc/>
-        public Item Item => Firearm;
-
-        /*
         /// <summary>
-        /// Gets or sets the <see cref="ShotMessage" /> for the event.
+        /// Gets the <see cref="ShotBacktrackData" />. This object contains the data sent by the client to the server. Values should not be trusted.
         /// </summary>
-        public ShotMessage ShotMessage { get; set; }
+        public ShotBacktrackData ShotBacktrackData { get; }
 
         /// <summary>
-        /// Gets or sets the position of the shot.
+        /// Gets the target <see cref="API.Features.Items.Firearm" />.
         /// </summary>
-        public Vector3 ShotPosition
-        {
-            get => ShotMessage.TargetPosition.Position;
-            set
-            {
-                ShotMessage msg = ShotMessage;
-                ShotMessage = new ShotMessage
-                {
-                    ShooterPosition = msg.ShooterPosition,
-                    ShooterCameraRotation = msg.ShooterCameraRotation,
-                    ShooterWeaponSerial = msg.ShooterWeaponSerial,
-                    TargetPosition = new RelativePosition(value),
-                    TargetRotation = msg.TargetRotation,
-                    TargetNetId = msg.TargetNetId,
-                };
-            }
-        }
+        public Firearm Firearm { get; }
 
-        /// <summary>
-        /// Gets or sets the netId of the target of the shot.
-        /// </summary>
-        public uint TargetNetId
-        {
-            get => ShotMessage.TargetNetId;
-            set
-            {
-                ShotMessage msg = ShotMessage;
-                ShotMessage = new ShotMessage
-                {
-                    ShooterPosition = msg.ShooterPosition,
-                    ShooterCameraRotation = msg.ShooterCameraRotation,
-                    ShooterWeaponSerial = msg.ShooterWeaponSerial,
-                    TargetPosition = msg.TargetPosition,
-                    TargetRotation = msg.TargetRotation,
-                    TargetNetId = value,
-                };
-            }
-        }
-        */
+        /// <inheritdoc />
+        public Item Item => Firearm;
 
         /// <summary>
         /// Gets or sets a value indicating whether the shot can be fired.
         /// </summary>
         public bool IsAllowed { get; set; } = true;
     }
-}
+}
\ No newline at end of file
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index 3c779e704..bbc60faea 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -18,8 +18,7 @@ namespace Exiled.Events.Patches.Events.Player
 
     using HarmonyLib;
 
-    using InventorySystem.Items.Firearms.BasicMessages;
-    using InventorySystem.Items.Firearms.Modules;
+    using InventorySystem.Items.Firearms.Modules.Misc;
 
     using static HarmonyLib.AccessTools;
 
@@ -28,58 +27,59 @@ namespace Exiled.Events.Patches.Events.Player
     /// Adds the <see cref="Handlers.Player.Shooting" /> events.
     /// </summary>
     [EventPatch(typeof(Handlers.Player), nameof(Handlers.Player.Shooting))]
-
-    // [HarmonyPatch(typeof(FirearmBasicMessagesHandler), nameof(FirearmBasicMessagesHandler.ServerShotReceived))]
+    
+    [HarmonyPatch(typeof(ShotBacktrackData), nameof(ShotBacktrackData.ProcessShot))]
     internal static class Shooting
     {
-        /*
         private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
 
-            Label isAllowedLabel = generator.DefineLabel();
             Label returnLabel = generator.DefineLabel();
 
-            LocalBuilder ev = generator.DeclareLocal(typeof(ShootingEventArgs));
-
-            int offset = -2;
-            int index = newInstructions.FindIndex(instruction => instruction.Calls(Method(typeof(IActionModule), nameof(IActionModule.ServerAuthorizeShot)))) + offset;
+            /*
+            [] <= Here
+            IL_0078: ldarg.2      // processingMethod (FindIndex here)
+            IL_0079: ldarg.0      // this
+            IL_007a: ldfld        class ReferenceHub InventorySystem.Items.Firearms.Modules.Misc.ShotBacktrackData::PrimaryTargetHub
+            IL_007f: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
+             */
+            int hasTargetIndex = newInstructions.FindIndex(instruction => instruction.IsLdarg(2)) - 1;
+            List<Label> hasTargetLabels = newInstructions[hasTargetIndex].ExtractLabels();
+
+            /*
+            [] <= Here
+            IL_0092: ldarg.2      // processingMethod (FindIndex here)
+            IL_0093: ldnull
+            IL_0094: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
+             */
+            int noTargetIndex = newInstructions.FindIndex(hasTargetIndex, instruction => instruction.IsLdarg(2)) - 1;
+            List<Label> noTargetLabels = newInstructions[noTargetIndex].ExtractLabels();
+
+            CodeInstruction[] patchInstructions = {
+                // ShootingEventArgs ev = new(firearm, this)
+                new(OpCodes.Ldarg_0),
+                new(OpCodes.Ldarg_1),
+                new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ShootingEventArgs))[0]),
+                
+                // Handlers.Player.OnShooting(ev)
+                new(OpCodes.Dup), // Dup to keep ev on the stack
+                new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnShooting))),
+
+                // if (!ev.IsAllowed) return
+                new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
+                new(OpCodes.Brfalse_S, returnLabel), 
+            };
+
+            newInstructions.InsertRange( // noTargetIndex goes first because it's higher then hasTargetIndex so it won't mess it up
+                noTargetIndex,
+                patchInstructions);
+            newInstructions[noTargetIndex].WithLabels(noTargetLabels);
 
             newInstructions.InsertRange(
-                index,
-                new[]
-                {
-                    // Player.Get(referenceHub)
-                    new CodeInstruction(OpCodes.Ldloc_0).MoveLabelsFrom(newInstructions[index]),
-                    new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
-
-                    // firearm
-                    new(OpCodes.Ldloc_1),
-
-                    // msg
-                    new(OpCodes.Ldarg_1),
-
-                    // ShootingEventArgs ev = new(Player, firearm, ShotMessage)
-                    new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ShootingEventArgs))[0]),
-                    new(OpCodes.Dup),
-                    new(OpCodes.Dup),
-                    new(OpCodes.Stloc, ev.LocalIndex),
-
-                    // Handlers.Player.OnShooting(ev)
-                    new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnShooting))),
-
-                    // if (ev.IsAllowed)
-                    //    return;
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
-                    new(OpCodes.Brfalse_S, returnLabel),
-
-                    // isAllowedLabel:
-                    // msg = ev.ShotMessage
-                    new CodeInstruction(OpCodes.Ldloc_S, ev.LocalIndex).WithLabels(isAllowedLabel),
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.ShotMessage))),
-                    new(OpCodes.Starg_S, 1),
-                });
-
+                hasTargetIndex,
+                patchInstructions);
+            newInstructions[hasTargetIndex].WithLabels(hasTargetLabels);
             newInstructions[newInstructions.Count - 1].WithLabels(returnLabel);
 
             for (int z = 0; z < newInstructions.Count; z++)
@@ -87,6 +87,5 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             ListPool<CodeInstruction>.Pool.Return(newInstructions);
         }
-        */
     }
 }
\ No newline at end of file

From 407ee992e3d29e847cd20b34dd74ac34217e8c84 Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Thu, 28 Nov 2024 15:18:14 +0200
Subject: [PATCH 2/8] formatting stuff

---
 .../Exiled.Events/EventArgs/Player/ShootingEventArgs.cs  | 8 ++------
 EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs   | 9 +++++----
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
index e58f0b9d9..5305ba3e4 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
@@ -5,16 +5,13 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
-using InventorySystem.Items.Firearms.Modules.Misc;
-
 namespace Exiled.Events.EventArgs.Player
 {
     using API.Features;
-    
     using Exiled.API.Features.Items;
-    
     using Interfaces;
-    
+    using InventorySystem.Items.Firearms.Modules.Misc;
+
     using BaseFirearm = InventorySystem.Items.Firearms.Firearm;
 
     /// <summary>
@@ -36,7 +33,6 @@ public ShootingEventArgs(BaseFirearm firearm, ShotBacktrackData shotBacktrackDat
             Firearm = (Firearm)Item.Get(firearm);
             Player = Firearm.Owner;
             ShotBacktrackData = shotBacktrackData;
-            // ShotMessage = msg;
         }
 
         /// <summary>
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index bbc60faea..8aabab9ce 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -27,7 +27,7 @@ namespace Exiled.Events.Patches.Events.Player
     /// Adds the <see cref="Handlers.Player.Shooting" /> events.
     /// </summary>
     [EventPatch(typeof(Handlers.Player), nameof(Handlers.Player.Shooting))]
-    
+
     [HarmonyPatch(typeof(ShotBacktrackData), nameof(ShotBacktrackData.ProcessShot))]
     internal static class Shooting
     {
@@ -56,19 +56,20 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             int noTargetIndex = newInstructions.FindIndex(hasTargetIndex, instruction => instruction.IsLdarg(2)) - 1;
             List<Label> noTargetLabels = newInstructions[noTargetIndex].ExtractLabels();
 
-            CodeInstruction[] patchInstructions = {
+            CodeInstruction[] patchInstructions =
+            {
                 // ShootingEventArgs ev = new(firearm, this)
                 new(OpCodes.Ldarg_0),
                 new(OpCodes.Ldarg_1),
                 new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ShootingEventArgs))[0]),
-                
+
                 // Handlers.Player.OnShooting(ev)
                 new(OpCodes.Dup), // Dup to keep ev on the stack
                 new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnShooting))),
 
                 // if (!ev.IsAllowed) return
                 new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
-                new(OpCodes.Brfalse_S, returnLabel), 
+                new(OpCodes.Brfalse_S, returnLabel),
             };
 
             newInstructions.InsertRange( // noTargetIndex goes first because it's higher then hasTargetIndex so it won't mess it up

From 72ea335bc5df4dee38acf7db82705afcef4fcd9a Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Sun, 1 Dec 2024 18:12:59 +0200
Subject: [PATCH 3/8] Tested & working

---
 .../EventArgs/Player/ShootingEventArgs.cs     |  2 +-
 .../Patches/Events/Player/Shooting.cs         | 23 ++++++++++++-------
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
index 5305ba3e4..5fb2be294 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
@@ -28,7 +28,7 @@ public class ShootingEventArgs : IPlayerEvent, IDeniableEvent, IFirearmEvent
         /// <param name="shotBacktrackData">
         /// <see cref="ShotBacktrackData"/> sent by the client.
         /// </param>
-        public ShootingEventArgs(BaseFirearm firearm, ShotBacktrackData shotBacktrackData)
+        public ShootingEventArgs(BaseFirearm firearm, ref ShotBacktrackData shotBacktrackData)
         {
             Firearm = (Firearm)Item.Get(firearm);
             Player = Firearm.Owner;
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index 8aabab9ce..b317628ba 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -8,16 +8,14 @@
 namespace Exiled.Events.Patches.Events.Player
 {
     using System.Collections.Generic;
+    using System.Reflection;
     using System.Reflection.Emit;
 
     using API.Features;
     using API.Features.Pools;
-
     using Exiled.Events.Attributes;
     using Exiled.Events.EventArgs.Player;
-
     using HarmonyLib;
-
     using InventorySystem.Items.Firearms.Modules.Misc;
 
     using static HarmonyLib.AccessTools;
@@ -36,6 +34,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
 
             Label returnLabel = generator.DefineLabel();
+            Label continueLabel = generator.DefineLabel();
 
             /*
             [] <= Here
@@ -44,7 +43,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             IL_007a: ldfld        class ReferenceHub InventorySystem.Items.Firearms.Modules.Misc.ShotBacktrackData::PrimaryTargetHub
             IL_007f: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
              */
-            int hasTargetIndex = newInstructions.FindIndex(instruction => instruction.IsLdarg(2)) - 1;
+            int hasTargetIndex = newInstructions.FindIndex(instruction => instruction.IsLdarg(2));
             List<Label> hasTargetLabels = newInstructions[hasTargetIndex].ExtractLabels();
 
             /*
@@ -53,15 +52,19 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             IL_0093: ldnull
             IL_0094: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
              */
-            int noTargetIndex = newInstructions.FindIndex(hasTargetIndex, instruction => instruction.IsLdarg(2)) - 1;
+            int noTargetIndex = newInstructions.FindIndex(hasTargetIndex + 1, instruction => instruction.IsLdarg(2));
             List<Label> noTargetLabels = newInstructions[noTargetIndex].ExtractLabels();
 
+            ConstructorInfo constructorInfo = Constructor(
+                typeof(ShootingEventArgs),
+                new[] { typeof(InventorySystem.Items.Firearms.Firearm), typeof(ShotBacktrackData).MakeByRefType() });
+
             CodeInstruction[] patchInstructions =
             {
                 // ShootingEventArgs ev = new(firearm, this)
-                new(OpCodes.Ldarg_0),
                 new(OpCodes.Ldarg_1),
-                new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ShootingEventArgs))[0]),
+                new(OpCodes.Ldarg_0),
+                new(OpCodes.Newobj, constructorInfo),
 
                 // Handlers.Player.OnShooting(ev)
                 new(OpCodes.Dup), // Dup to keep ev on the stack
@@ -69,7 +72,10 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
                 // if (!ev.IsAllowed) return
                 new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
-                new(OpCodes.Brfalse_S, returnLabel),
+                new(OpCodes.Brtrue_S, continueLabel),
+                new(OpCodes.Leave_S, returnLabel),
+
+                new CodeInstruction(OpCodes.Nop).WithLabels(continueLabel),
             };
 
             newInstructions.InsertRange( // noTargetIndex goes first because it's higher then hasTargetIndex so it won't mess it up
@@ -81,6 +87,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 hasTargetIndex,
                 patchInstructions);
             newInstructions[hasTargetIndex].WithLabels(hasTargetLabels);
+
             newInstructions[newInstructions.Count - 1].WithLabels(returnLabel);
 
             for (int z = 0; z < newInstructions.Count; z++)

From 4034fbec8c30bf7116f260baf7dd2cad03854306 Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Sun, 1 Dec 2024 19:02:15 +0200
Subject: [PATCH 4/8] Added shootingEventArgs.Direction

---
 .../EventArgs/Player/ShootingEventArgs.cs              | 10 ++++++++++
 EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs |  6 +++---
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
index 5fb2be294..8f6508d76 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
@@ -11,6 +11,7 @@ namespace Exiled.Events.EventArgs.Player
     using Exiled.API.Features.Items;
     using Interfaces;
     using InventorySystem.Items.Firearms.Modules.Misc;
+    using UnityEngine;
 
     using BaseFirearm = InventorySystem.Items.Firearms.Firearm;
 
@@ -50,6 +51,15 @@ public ShootingEventArgs(BaseFirearm firearm, ref ShotBacktrackData shotBacktrac
         /// </summary>
         public ShotBacktrackData ShotBacktrackData { get; }
 
+        /// <summary>
+        /// Gets or sets the exact direction of the shot.
+        /// </summary>
+        public Vector3 Direction
+        {
+            get => Player.CameraTransform.forward;
+            set => Player.CameraTransform.forward = value; // It is going to be reset by FpcBacktracker the same frame, so why we can set it freely.
+        }
+
         /// <summary>
         /// Gets the target <see cref="API.Features.Items.Firearm" />.
         /// </summary>
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index b317628ba..0d99be4cc 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -38,7 +38,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             /*
             [] <= Here
-            IL_0078: ldarg.2      // processingMethod (FindIndex here)
+            IL_0078: ldarg.2      // processingMethod
             IL_0079: ldarg.0      // this
             IL_007a: ldfld        class ReferenceHub InventorySystem.Items.Firearms.Modules.Misc.ShotBacktrackData::PrimaryTargetHub
             IL_007f: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
@@ -48,8 +48,8 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             /*
             [] <= Here
-            IL_0092: ldarg.2      // processingMethod (FindIndex here)
-            IL_0093: ldnull
+            IL_0092: ldarg.2      // processingMethod
+            IL_0093: ldnull       // null
             IL_0094: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
              */
             int noTargetIndex = newInstructions.FindIndex(hasTargetIndex + 1, instruction => instruction.IsLdarg(2));

From a669c1eaf64e9382ac18df36e72b93cbc7f4e716 Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Sun, 1 Dec 2024 19:24:50 +0200
Subject: [PATCH 5/8] Minor documentation improvements

---
 EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
index 8f6508d76..a5d49f952 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
@@ -17,6 +17,7 @@ namespace Exiled.Events.EventArgs.Player
 
     /// <summary>
     /// Contains all information before a player fires a weapon.
+    /// ClaimedTarget and Player transform values are modified by <see cref="PlayerRoles.FirstPersonControl.FpcBacktracker"/> according to <see cref="ShotBacktrackData"/> sent by the Player and do not match the actual values.
     /// </summary>
     public class ShootingEventArgs : IPlayerEvent, IDeniableEvent, IFirearmEvent
     {
@@ -42,7 +43,7 @@ public ShootingEventArgs(BaseFirearm firearm, ref ShotBacktrackData shotBacktrac
         public Player Player { get; }
 
         /// <summary>
-        /// Gets the target that client claims it hit. This value is controlled by the client and should not be trusted. Can be null.
+        /// Gets the target that client claims it hit. This value is controlled by the shooting player and should not be trusted. Can be null.
         /// </summary>
         public Player ClaimedTarget => ShotBacktrackData.HasPrimaryTarget ? Player.Get(ShotBacktrackData.PrimaryTargetHub) : null;
 
@@ -52,7 +53,7 @@ public ShootingEventArgs(BaseFirearm firearm, ref ShotBacktrackData shotBacktrac
         public ShotBacktrackData ShotBacktrackData { get; }
 
         /// <summary>
-        /// Gets or sets the exact direction of the shot.
+        /// Gets or sets the exact direction of the shot. This value doesn't account for bullet spread.
         /// </summary>
         public Vector3 Direction
         {
@@ -61,7 +62,7 @@ public Vector3 Direction
         }
 
         /// <summary>
-        /// Gets the target <see cref="API.Features.Items.Firearm" />.
+        /// Gets the firearm that is being fired.
         /// </summary>
         public Firearm Firearm { get; }
 

From 5ec6abe81de8b67536d7abb014d1ede6418809fd Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Sun, 1 Dec 2024 19:50:41 +0200
Subject: [PATCH 6/8] remarks

---
 .../Exiled.Events/EventArgs/Player/ShootingEventArgs.cs   | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
index a5d49f952..3c2f9d12b 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/ShootingEventArgs.cs
@@ -43,17 +43,19 @@ public ShootingEventArgs(BaseFirearm firearm, ref ShotBacktrackData shotBacktrac
         public Player Player { get; }
 
         /// <summary>
-        /// Gets the target that client claims it hit. This value is controlled by the shooting player and should not be trusted. Can be null.
+        /// Gets the target that client claims it hit.
         /// </summary>
+        /// <remarks>This value is controlled by the shooting player and should not be trusted. Can be null.</remarks>
         public Player ClaimedTarget => ShotBacktrackData.HasPrimaryTarget ? Player.Get(ShotBacktrackData.PrimaryTargetHub) : null;
 
         /// <summary>
-        /// Gets the <see cref="ShotBacktrackData" />. This object contains the data sent by the client to the server. Values should not be trusted.
+        /// Gets the <see cref="ShotBacktrackData" />. This object contains the data sent by the client to the server.
         /// </summary>
+        /// <remarks>Values are controlled by the shooting player and should not be trusted.</remarks>
         public ShotBacktrackData ShotBacktrackData { get; }
 
         /// <summary>
-        /// Gets or sets the exact direction of the shot. This value doesn't account for bullet spread.
+        /// Gets or sets the exact direction of the shot before the bullet spread is applied.
         /// </summary>
         public Vector3 Direction
         {

From b9140bff02e669b1060cf97392e6b09183c2b694 Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Sun, 1 Dec 2024 23:32:31 +0200
Subject: [PATCH 7/8] Requested changes

---
 .../Patches/Events/Player/Shooting.cs         | 41 +++++++++++--------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index 0d99be4cc..c683ebd28 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -34,7 +34,8 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
 
             Label returnLabel = generator.DefineLabel();
-            Label continueLabel = generator.DefineLabel();
+            Label continueLabel1 = generator.DefineLabel();
+            Label continueLabel2 = generator.DefineLabel();
 
             /*
             [] <= Here
@@ -59,33 +60,37 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 typeof(ShootingEventArgs),
                 new[] { typeof(InventorySystem.Items.Firearms.Firearm), typeof(ShotBacktrackData).MakeByRefType() });
 
-            CodeInstruction[] patchInstructions =
-            {
-                // ShootingEventArgs ev = new(firearm, this)
-                new(OpCodes.Ldarg_1),
-                new(OpCodes.Ldarg_0),
-                new(OpCodes.Newobj, constructorInfo),
+            CodeInstruction[] patchInstructions1 = GetInstructions(continueLabel1);
+            CodeInstruction[] patchInstructions2 = GetInstructions(continueLabel2);
 
-                // Handlers.Player.OnShooting(ev)
-                new(OpCodes.Dup), // Dup to keep ev on the stack
-                new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnShooting))),
+            CodeInstruction[] GetInstructions(Label continueLabel) =>
+                new[]
+                {
+                    // ShootingEventArgs ev = new(firearm, this)
+                    new(OpCodes.Ldarg_1),
+                    new(OpCodes.Ldarg_0),
+                    new(OpCodes.Newobj, constructorInfo),
 
-                // if (!ev.IsAllowed) return
-                new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
-                new(OpCodes.Brtrue_S, continueLabel),
-                new(OpCodes.Leave_S, returnLabel),
+                    // Handlers.Player.OnShooting(ev)
+                    new(OpCodes.Dup), // Dup to keep ev on the stack
+                    new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnShooting))),
 
-                new CodeInstruction(OpCodes.Nop).WithLabels(continueLabel),
-            };
+                    // if (!ev.IsAllowed) return
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
+                    new(OpCodes.Brtrue_S, continueLabel),
+                    new(OpCodes.Leave_S, returnLabel),
+
+                    new CodeInstruction(OpCodes.Nop).WithLabels(continueLabel),
+                };
 
             newInstructions.InsertRange( // noTargetIndex goes first because it's higher then hasTargetIndex so it won't mess it up
                 noTargetIndex,
-                patchInstructions);
+                patchInstructions1);
             newInstructions[noTargetIndex].WithLabels(noTargetLabels);
 
             newInstructions.InsertRange(
                 hasTargetIndex,
-                patchInstructions);
+                patchInstructions2);
             newInstructions[hasTargetIndex].WithLabels(hasTargetLabels);
 
             newInstructions[newInstructions.Count - 1].WithLabels(returnLabel);

From 4d0061ea3c334bdbed487eb08d966317999b5c1e Mon Sep 17 00:00:00 2001
From: Banalny-Banan <elisey1324@gmail.com>
Date: Mon, 2 Dec 2024 10:07:20 +0200
Subject: [PATCH 8/8] Requested changes

---
 EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index c683ebd28..501c1f812 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -45,7 +45,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             IL_007f: callvirt     instance void class [mscorlib]System.Action`1<class ReferenceHub>::Invoke(!0/*class ReferenceHub* /)
              */
             int hasTargetIndex = newInstructions.FindIndex(instruction => instruction.IsLdarg(2));
-            List<Label> hasTargetLabels = newInstructions[hasTargetIndex].ExtractLabels();
 
             /*
             [] <= Here
@@ -91,7 +90,6 @@ CodeInstruction[] GetInstructions(Label continueLabel) =>
             newInstructions.InsertRange(
                 hasTargetIndex,
                 patchInstructions2);
-            newInstructions[hasTargetIndex].WithLabels(hasTargetLabels);
 
             newInstructions[newInstructions.Count - 1].WithLabels(returnLabel);