diff --git a/EXILED/Exiled.API/Enums/BloodType.cs b/EXILED/Exiled.API/Enums/BloodType.cs
deleted file mode 100644
index 369793e2a..000000000
--- a/EXILED/Exiled.API/Enums/BloodType.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// -----------------------------------------------------------------------
-// <copyright file="BloodType.cs" company="ExMod Team">
-// Copyright (c) ExMod Team. All rights reserved.
-// Licensed under the CC BY-SA 3.0 license.
-// </copyright>
-// -----------------------------------------------------------------------
-
-namespace Exiled.API.Enums
-{
-    using System;
-
-    /// <summary>
-    /// Unique identifier for the different types of blood decals.
-    /// </summary>
-    /// <seealso cref="Features.Map.PlaceBlood(UnityEngine.Vector3, UnityEngine.Vector3)"/>
-    /// <seealso cref="Features.Player.PlaceBlood(UnityEngine.Vector3)"/>
-    [Obsolete("This blood decal are outdated now used DecalPoolType.Blood", true)]
-    public enum BloodType
-    {
-        /// <summary>
-        /// The default blood decal.
-        /// </summary>
-        Default,
-
-        /// <summary>
-        /// The blood decal placed after Scp106 sends someone to the pocket dimension.
-        /// </summary>
-        Scp106,
-
-        /// <summary>
-        /// The spreaded blood decal.
-        /// </summary>
-        Spreaded,
-
-        /// <summary>
-        /// The faded blood decal.
-        /// </summary>
-        Faded,
-    }
-}
\ No newline at end of file
diff --git a/EXILED/Exiled.API/Extensions/MirrorExtensions.cs b/EXILED/Exiled.API/Extensions/MirrorExtensions.cs
index bbd325878..66452d24e 100644
--- a/EXILED/Exiled.API/Extensions/MirrorExtensions.cs
+++ b/EXILED/Exiled.API/Extensions/MirrorExtensions.cs
@@ -22,7 +22,10 @@ namespace Exiled.API.Extensions
 
     using CustomPlayerEffects;
 
+    using Decals;
+
     using Exiled.API.Enums;
+    using Exiled.API.Features.Items;
     using Exiled.API.Features.Items.Keycards;
     using Exiled.API.Features.Pickups.Keycards;
 
@@ -56,6 +59,8 @@ namespace Exiled.API.Extensions
 
     using Utils.Networking;
 
+    using Firearm = Features.Items.Firearm;
+
     /// <summary>
     /// A set of extensions for <see cref="Mirror"/> Networking.
     /// </summary>
@@ -211,58 +216,245 @@ public static ReadOnlyDictionary<string, string> RpcFullNames
         /// </summary>
         /// <param name="player">Target to play.</param>
         /// <param name="position">Position to play on.</param>
-        /// <param name="itemType">Weapon' sound to play.</param>
-        /// <param name="volume">Sound's volume to set.</param>
-        /// <param name="audioClipId">GunAudioMessage's audioClipId to set (default = 0).</param>
-        [Obsolete("This method is not working. Use PlayGunSound(Player, Vector3, FirearmType, float, int, bool) overload instead.")]
-        public static void PlayGunSound(this Player player, Vector3 position, ItemType itemType, byte volume, byte audioClipId = 0)
-            => PlayGunSound(player, position, itemType.GetFirearmType(), volume, audioClipId);
+        /// <param name="firearmType">Weapon's sound to play.</param>
+        /// <param name="pitch">Speed of sound.</param>
+        /// <param name="clipIndex">Index of clip.</param>
+        [Obsolete("This method is deprecated, use PlayGunSound(this Player, FirearmType, int, Vector3, MixerChannel, float, float) instead.")]
+        public static void PlayGunSound(this Player player, Vector3 position, FirearmType firearmType, float pitch = 1, int clipIndex = 0) => player.PlayGunSound(firearmType, clipIndex, position, pitch: pitch);
 
         /// <summary>
         /// Plays a gun sound that only the <paramref name="player"/> can hear.
         /// </summary>
         /// <param name="player">Target to play.</param>
-        /// <param name="position">Position to play on.</param>
         /// <param name="firearmType">Weapon's sound to play.</param>
-        /// <param name="pitch">Speed of sound.</param>
         /// <param name="clipIndex">Index of clip.</param>
-        public static void PlayGunSound(this Player player, Vector3 position, FirearmType firearmType, float pitch = 1, int clipIndex = 0)
+        /// <param name="position">Position to play on.</param>
+        /// <param name="mixerChannel">Audio's mixer channel.</param>
+        /// <param name="range">Max range of sound.</param>
+        /// <param name="pitch">Speed of sound.</param>
+        public static void PlayGunSound(this Player player, FirearmType firearmType, int clipIndex, Vector3 position, MixerChannel mixerChannel = MixerChannel.Weapons, float? range = null, float? pitch = null)
         {
-            if (firearmType is FirearmType.ParticleDisruptor or FirearmType.None)
+            if (firearmType is FirearmType.None)
+            {
+                Log.Error($"Failed to play gun sound for player {player.Nickname} because firearm type was None.");
                 return;
+            }
 
-            Features.Items.Firearm firearm = Features.Items.Firearm.ItemTypeToFirearmInstance[firearmType];
+            if (!InventoryItemLoader.TryGetItem(firearmType.GetItemType(), out ItemBase itemBase))
+            {
+                Log.Error($"Failed to get ItemBase for firearm type {firearmType} when trying to play gun sound for player {player.Nickname}");
+                return;
+            }
 
+            Firearm firearm = Item.Get<Firearm>(itemBase);
             if (firearm == null)
+            {
+                Log.Error($"Failed to get Firearm for firearm type {firearmType} when trying to play gun sound.");
                 return;
+            }
 
             using (NetworkWriterPooled writer = NetworkWriterPool.Get())
             {
                 writer.WriteUShort(NetworkMessageId<RoleSyncInfo>.Id);
-                new RoleSyncInfo(Server.Host.ReferenceHub, RoleTypeId.ClassD, player.ReferenceHub, null).Write(writer);
+                new RoleSyncInfo(Server.Host.ReferenceHub, RoleTypeId.Tutorial, player.ReferenceHub, null).Write(writer);
                 writer.WriteRelativePosition(new RelativePosition(0, 0, 0, 0, false));
                 writer.WriteUShort(0);
                 player.Connection.Send(writer);
             }
 
-            firearm.BarrelAmmo = 1;
-            firearm.BarrelMagazine.IsCocked = true;
             player.SendFakeSyncVar(Server.Host.Inventory.netIdentity, typeof(Inventory), nameof(Inventory.NetworkCurItem), firearm.Identifier);
 
-            if (!firearm.Base.TryGetModule(out AudioModule audioModule))
-                return;
-
-            Timing.CallDelayed(0.1f, () => // due to selecting item we need to delay shot a bit
+            Timing.CallDelayed(0.1f, () =>
             {
-                audioModule.SendRpc(player.ReferenceHub, writer =>
-                    audioModule.ServerSend(writer, clipIndex, pitch, MixerChannel.Weapons, 12f, position, false));
+                if (!player.IsConnected)
+                    return;
 
+                firearm.PlaySound(player, clipIndex, mixerChannel, position, shooterVisible: false, range, pitch);
                 player.SendFakeSyncVar(Server.Host.Inventory.netIdentity, typeof(Inventory), nameof(Inventory.NetworkCurItem), ItemIdentifier.None);
-
                 player.Connection.Send(new RoleSyncInfo(Server.Host.ReferenceHub, Server.Host.Role, player.ReferenceHub, null));
             });
         }
 
+        /// <summary>
+        /// Plays a gun sound to the specified player.
+        /// </summary>
+        /// <param name="firearm">The firearm whose <see cref="AudioModule"/> to use.</param>
+        /// <param name="target">The player to send the sound to.</param>
+        /// <param name="index">The index of the audio clip to play.</param>
+        /// <param name="channel">The <see cref="MixerChannel"/> to play the sound on.</param>
+        /// <param name="position">The world position the sound originates from.</param>
+        /// <param name="shooterVisible">Whether the shooter is visible to the target. If <see langword="false"/>, the sound will be played at <paramref name="position"/> instead of on the firearm's transform.</param>
+        /// <param name="range">The range of the sound.</param>
+        /// <param name="pitch">The pitch of the sound.</param>
+        /// <returns><see langword="true"/> if the sound was played successfully; <see langword="false"/> if <see cref="AudioModule"/> is <see langword="null"/>.</returns>
+        public static bool PlaySound(this Firearm firearm, Player target, int index, MixerChannel channel, Vector3 position, bool shooterVisible, float? range = null, float? pitch = null)
+        {
+            AudioModule audioModule = firearm.AudioModule;
+            if (audioModule == null)
+            {
+                Log.Error($"Firearm {firearm} doesn't have an audio module.");
+                return false;
+            }
+
+            if (target == null)
+            {
+                Log.Error("Target player is null.");
+                return false;
+            }
+
+            if (!range.HasValue)
+                range = audioModule.FinalGunshotRange;
+
+            if (!pitch.HasValue)
+                pitch = audioModule.RandomPitch;
+
+            audioModule.SendRpc(target.ReferenceHub, writer => audioModule.ServerSend(writer, index, pitch.Value, channel, range.Value, position, shooterVisible));
+            return true;
+        }
+
+        /// <summary>
+        /// Plays a gun sound to the specified players.
+        /// </summary>
+        /// <param name="firearm">The firearm whose <see cref="AudioModule"/> to use.</param>
+        /// <param name="targets">The players to send the sound to.</param>
+        /// <param name="index">The index of the audio clip to play.</param>
+        /// <param name="channel">The <see cref="MixerChannel"/> to play the sound on.</param>
+        /// <param name="position">The world position the sound originates from.</param>
+        /// <param name="shooterVisible">Whether the shooter is visible to the target. If <see langword="false"/>, the sound will be played at <paramref name="position"/> instead of on the firearm's transform.</param>
+        /// <param name="range">The range of the sound.</param>
+        /// <param name="pitch">The pitch of the sound.</param>
+        /// <returns><see langword="true"/> if the sound was played successfully; <see langword="false"/> if <see cref="AudioModule"/> is <see langword="null"/>.</returns>
+        public static bool PlaySound(this Firearm firearm, IEnumerable<Player> targets, int index, MixerChannel channel, Vector3 position, bool shooterVisible, float? range = null, float? pitch = null)
+        {
+            AudioModule audioModule = firearm.AudioModule;
+            if (audioModule == null)
+            {
+                Log.Error($"Firearm {firearm} doesn't have an audio module.");
+                return false;
+            }
+
+            if (targets == null)
+            {
+                Log.Error("Failed to play sound, targets is null.");
+                return false;
+            }
+
+            if (!range.HasValue)
+                range = audioModule.FinalGunshotRange;
+
+            if (!pitch.HasValue)
+                pitch = audioModule.RandomPitch;
+
+            HashSet<ReferenceHub> targetHubs = targets.Select(p => p.ReferenceHub).ToHashSet();
+
+            audioModule.SendRpc(targetHubs.Contains, writer => audioModule.ServerSend(writer, index, pitch.Value, channel, range.Value, position, shooterVisible));
+            return true;
+        }
+
+        /// <summary>
+        /// Spawns a blood decal for this player.
+        /// </summary>
+        /// <param name="player">Target to spawn blood decal for.</param>
+        /// <param name="position">The position of the blood decal.</param>
+        /// <param name="sourcePosition">The raycast origin used to determine the decal's orientation.</param>
+        /// <returns><see langword="true"/> if the blood decal was successfully spawned; otherwise, <see langword="false"/>.</returns>
+        public static bool SpawnBlood(this Player player, Vector3 position, Vector3 sourcePosition) => SpawnDecal(player, position, sourcePosition, DecalPoolType.Blood);
+
+        /// <summary>
+        /// Spawns a blood decal for the specified players.
+        /// </summary>
+        /// <param name="players">The players for which to spawn the blood decal.</param>
+        /// <param name="position">The position of the blood decal.</param>
+        /// <param name="sourcePosition">The raycast origin used to determine the decal's orientation.</param>
+        /// <returns><see langword="true"/> if the blood decal was successfully spawned; otherwise, <see langword="false"/>.</returns>
+        public static bool SpawnBlood(this IEnumerable<Player> players, Vector3 position, Vector3 sourcePosition) => SpawnDecal(players, position, sourcePosition, DecalPoolType.Blood, FirearmType.Com15);
+
+        /// <summary>
+        /// Spawns a decal for this player.
+        /// </summary>
+        /// <param name="player">Target to spawn decal for.</param>
+        /// <param name="position">The position of the decal.</param>
+        /// <param name="sourcePosition">The raycast origin used to determine the decal's orientation.</param>
+        /// <param name="decalType">The <see cref="Decals.DecalPoolType"/>.</param>
+        /// <param name="firearmType">The <see cref="Enums.FirearmType"/> to use.</param>
+        /// <returns><see langword="true"/> if the decal was successfully spawned; otherwise, <see langword="false"/>.</returns>
+        public static bool SpawnDecal(this Player player, Vector3 position, Vector3 sourcePosition, DecalPoolType decalType, FirearmType firearmType = FirearmType.Com15)
+        {
+            if (!InventoryItemLoader.TryGetItem(firearmType.GetItemType(), out ItemBase itemBase))
+            {
+                Log.Error($"Failed to spawn decal: Could not find a Firearm for {firearmType}.");
+                return false;
+            }
+
+            Firearm firearm = Item.Get<Firearm>(itemBase);
+            if (firearm == null)
+            {
+                Log.Error($"Failed to spawn decal: Could not find a Firearm for {firearmType}.");
+                return false;
+            }
+
+            ImpactEffectsModule impactEffectsModule = firearm.ImpactEffectsModule;
+            if (impactEffectsModule == null)
+            {
+                Log.Error($"Failed to spawn decal: Could not find an ImpactEffectsModule for {firearmType}.");
+                return false;
+            }
+
+            impactEffectsModule.SendRpc(player.ReferenceHub, writer =>
+            {
+                writer.WriteSubheader(ImpactEffectsModule.RpcType.ImpactDecal);
+                writer.WriteByte((byte)decalType);
+                writer.WriteRelativePosition(new RelativePosition(position));
+                writer.WriteRelativePosition(new RelativePosition(sourcePosition));
+            });
+
+            return true;
+        }
+
+        /// <summary>
+        /// Spawns a decal for the specified targets.
+        /// </summary>
+        /// <param name="targets">The targets for which to spawn the decal.</param>
+        /// <param name="position">The position of the decal.</param>
+        /// <param name="sourcePosition">The raycast origin used to determine the decal's orientation.</param>
+        /// <param name="decalType">The <see cref="Decals.DecalPoolType"/>.</param>
+        /// <param name="firearmType">The <see cref="Enums.FirearmType"/> to use.</param>
+        /// <returns><see langword="true"/> if the decal was successfully spawned; otherwise, <see langword="false"/>.</returns>
+        public static bool SpawnDecal(this IEnumerable<Player> targets, Vector3 position, Vector3 sourcePosition, DecalPoolType decalType, FirearmType firearmType = FirearmType.Com15)
+        {
+            if (!InventoryItemLoader.TryGetItem(firearmType.GetItemType(), out ItemBase itemBase))
+            {
+                Log.Error($"Failed to spawn decal: Could not find a Firearm for {firearmType}.");
+                return false;
+            }
+
+            Firearm firearm = Item.Get<Firearm>(itemBase);
+            if (firearm == null)
+            {
+                Log.Error($"Failed to spawn decal: Could not find a Firearm for {firearmType}.");
+                return false;
+            }
+
+            ImpactEffectsModule impactEffectsModule = firearm.ImpactEffectsModule;
+            if (impactEffectsModule == null)
+            {
+                Log.Error($"Failed to spawn decal: Could not find an ImpactEffectsModule for {firearmType}.");
+                return false;
+            }
+
+            HashSet<ReferenceHub> targetHubs = targets.Select(p => p.ReferenceHub).ToHashSet();
+
+            impactEffectsModule.SendRpc(targetHubs.Contains, writer =>
+            {
+                writer.WriteSubheader(ImpactEffectsModule.RpcType.ImpactDecal);
+                writer.WriteByte((byte)decalType);
+                writer.WriteRelativePosition(new RelativePosition(position));
+                writer.WriteRelativePosition(new RelativePosition(sourcePosition));
+            });
+
+            return true;
+        }
+
         /// <summary>
         /// Place blood that only the <paramref name="player"/> can see.
         /// </summary>
@@ -271,6 +463,7 @@ public static void PlayGunSound(this Player player, Vector3 position, FirearmTyp
         /// <param name="origin">The direction of the blood decal.</param>
         /// <param name="roleTypeId">The RoleTypeId from who blood come from.</param>
         /// <param name="gettingShotSoundIndex">The sound than player get when getting shot.</param>
+        [Obsolete("Use Player::SpawnBlood(Vector3, Vector3) instead.")]
 #pragma warning disable IDE0060 // TODO: Deleted the unused param
         public static void PlaceBlood(this Player player, Vector3 position, Vector3 origin, RoleTypeId roleTypeId, int gettingShotSoundIndex)
 #pragma warning restore IDE0060
diff --git a/EXILED/Exiled.API/Features/Items/Firearm.cs b/EXILED/Exiled.API/Features/Items/Firearm.cs
index 00630fad3..4aea76359 100644
--- a/EXILED/Exiled.API/Features/Items/Firearm.cs
+++ b/EXILED/Exiled.API/Features/Items/Firearm.cs
@@ -10,6 +10,8 @@ namespace Exiled.API.Features.Items
     using System.Collections.Generic;
     using System.Linq;
 
+    using AudioPooling;
+
     using CameraShaking;
 
     using Enums;
@@ -28,7 +30,10 @@ namespace Exiled.API.Features.Items
     using InventorySystem.Items.Firearms.Attachments.Components;
     using InventorySystem.Items.Firearms.Modules;
 
+    using UnityEngine;
+
     using static InventorySystem.Items.Firearms.Modules.AnimatorReloaderModuleBase;
+    using static InventorySystem.Items.Firearms.Modules.AutomaticActionModule;
 
     using BaseFirearm = InventorySystem.Items.Firearms.Firearm;
     using FirearmPickup = Pickups.FirearmPickup;
@@ -67,6 +72,8 @@ public Firearm(BaseFirearm itemBase)
 
                     case IAmmoContainerModule ammoModule:
                         BarrelMagazine ??= (BarrelMagazine)Magazine.Get(ammoModule);
+                        if (module is AutomaticActionModule automaticActionModule)
+                            AutomaticActionModule = automaticActionModule;
                         break;
 
                     case HitscanHitregModuleBase hitregModule:
@@ -77,6 +84,14 @@ public Firearm(BaseFirearm itemBase)
                         AnimatorReloaderModule = animatorReloaderModule;
                         break;
 
+                    case ImpactEffectsModule impactEffectsModule:
+                        ImpactEffectsModule = impactEffectsModule;
+                        break;
+
+                    case AudioModule audioModule:
+                        AudioModule = audioModule;
+                        break;
+
                     default:
                         break;
                 }
@@ -152,6 +167,21 @@ public static IReadOnlyDictionary<Player, Dictionary<FirearmType, AttachmentIden
         /// </summary>
         public AnimatorReloaderModuleBase AnimatorReloaderModule { get; }
 
+        /// <summary>
+        /// Gets an impact effects module for the current firearm.
+        /// </summary>
+        public ImpactEffectsModule ImpactEffectsModule { get; }
+
+        /// <summary>
+        /// Gets an automatic action module for the current firearm.
+        /// </summary>
+        public AutomaticActionModule AutomaticActionModule { get; }
+
+        /// <summary>
+        /// Gets an audio module for the current firearm.
+        /// </summary>
+        public AudioModule AudioModule { get; }
+
         /// <summary>
         /// Gets or sets the amount of ammo in the firearm magazine.
         /// </summary>
@@ -757,6 +787,64 @@ public void Unload()
             AnimatorReloaderModule.SendRpcHeaderWithRandomByte(ReloaderMessageHeader.Unload);
         }
 
+        /// <summary>
+        /// Plays a firearm sound to nearby players.
+        /// </summary>
+        /// <param name="index">The index of the audio clip to play.</param>
+        /// <param name="channel">The <see cref="MixerChannel"/> to play the sound on.</param>
+        /// <param name="range">The range within which nearby players can hear the sound.</param>
+        /// <param name="pitch">The pitch of the sound.</param>
+        /// <returns><see langword="true"/> if the sound was played successfully; <see langword="false"/> if <see cref="AudioModule"/> is <see langword="null"/>.</returns>
+        public bool PlaySound(int index, MixerChannel channel, float? range = null, float? pitch = null)
+        {
+            if (AudioModule == null)
+            {
+                Log.Error($"Failed to play sound, firearm {Type} does not have an AudioModule.");
+                return false;
+            }
+
+            if (!range.HasValue)
+                range = AudioModule.FinalGunshotRange;
+
+            if (!pitch.HasValue)
+                pitch = AudioModule.RandomPitch;
+
+            AudioModule.ServerSendToNearbyPlayers(index, channel, range.Value, pitch.Value);
+            return true;
+        }
+
+        /// <summary>
+        /// Simulates a fire.
+        /// </summary>
+        /// <param name="rpcHeader">Rpc header for fire type like fire or dry fire.</param>
+        /// <param name="chambersFired">The number of chambers fired.</param>
+        /// <param name="soundIndex">The index of the sound to play. 0 is DryFire, 1 is default gunshot.</param>
+        public void FakeFire(MessageHeader rpcHeader = MessageHeader.RpcFire, byte chambersFired = 1, byte soundIndex = 1)
+        {
+            PlaySound(soundIndex, MixerChannel.Weapons, AudioModule.FinalGunshotRange, AudioModule.RandomPitch);
+
+            if (AutomaticActionModule?.gameObject != null)
+            {
+                AutomaticActionModule.SendRpc(
+                writer =>
+                {
+                    writer.WriteSubheader(rpcHeader);
+                    if (rpcHeader == MessageHeader.RpcFire)
+                        writer.WriteByte(chambersFired);
+                },
+                true);
+            }
+
+            if (ImpactEffectsModule != null)
+            {
+                Transform camera = Owner.CameraTransform;
+                float maxDist = HitscanHitregModule.FullDamageDistance + HitscanHitregModule.DamageFalloffDistance;
+
+                if (Physics.Raycast(camera.position, camera.forward, out RaycastHit hit, maxDist, HitscanHitregModuleBase.HitregMask))
+                    ImpactEffectsModule.ServerProcessHit(hit, camera.position, true);
+            }
+        }
+
         /// <summary>
         /// Clones current <see cref="Firearm"/> object.
         /// </summary>
diff --git a/EXILED/Exiled.API/Features/Map.cs b/EXILED/Exiled.API/Features/Map.cs
index 5f3205755..a7c59a1ee 100644
--- a/EXILED/Exiled.API/Features/Map.cs
+++ b/EXILED/Exiled.API/Features/Map.cs
@@ -27,6 +27,9 @@ namespace Exiled.API.Features
     using Interactables.Interobjects;
 
     using InventorySystem;
+    using InventorySystem.Items;
+    using InventorySystem.Items.Autosync;
+    using InventorySystem.Items.Firearms.Modules;
     using InventorySystem.Items.Pickups;
     using InventorySystem.Items.ThrowableProjectiles;
 
@@ -36,8 +39,12 @@ namespace Exiled.API.Features
 
     using MapGeneration;
 
+    using Mirror;
+
     using PlayerRoles.Ragdolls;
 
+    using RelativePositioning;
+
     using RemoteAdmin;
 
     using UnityEngine;
@@ -436,12 +443,64 @@ public static void CleanAllRagdolls(IEnumerable<Ragdoll> ragDolls)
         public static void Clean(DecalPoolType decalType) => Clean(decalType, int.MaxValue);
 
         /// <summary>
-        /// Places a blood decal.
+        /// Places a blood decal using a raycast.
+        /// </summary>
+        /// <param name="position">The origin position of the raycast.</param>
+        /// <param name="direction">The direction in which the raycast is fired to detect a surface.</param>
+        public static void PlaceBlood(Vector3 position, Vector3 direction)
+        {
+            if (Physics.Raycast(position, direction, out RaycastHit hitInfo, ImpactEffectsModule.ReceivingLayers))
+                SpawnBlood(hitInfo.point + (hitInfo.normal * Decal.SurfaceDistance), -hitInfo.normal);
+        }
+
+        /// <summary>
+        /// Spawns a blood decal.
         /// </summary>
         /// <param name="position">The position of the blood decal.</param>
-        /// <param name="direction">The direction of the blood decal.</param>
-        [Obsolete("Use PlaceBlood(this Player, Vector3, Vector3, RoleTypeId, int) instead.")]
-        public static void PlaceBlood(Vector3 position, Vector3 direction) => _ = 0;
+        /// <param name="sourcePosition">The raycast origin used to determine the decal's orientation.</param>
+        /// <returns><see langword="true"/> if the blood decal was successfully spawned; otherwise, <see langword="false"/>.</returns>
+        public static bool SpawnBlood(Vector3 position, Vector3 sourcePosition) => SpawnDecal(position, sourcePosition, DecalPoolType.Blood, FirearmType.Com15);
+
+        /// <summary>
+        /// Spawns a decal.
+        /// </summary>
+        /// <param name="position">The position of the decal.</param>
+        /// <param name="sourcePosition">The raycast origin used to determine the decal's orientation.</param>
+        /// <param name="decalType">The <see cref="Decals.DecalPoolType"/>.</param>
+        /// <param name="firearmType">The <see cref="Enums.FirearmType"/> to use.</param>
+        /// <returns><see langword="true"/> if the decal was successfully spawned; otherwise, <see langword="false"/>.</returns>
+        public static bool SpawnDecal(Vector3 position, Vector3 sourcePosition, DecalPoolType decalType, FirearmType firearmType = FirearmType.Com15)
+        {
+            if (!InventoryItemLoader.TryGetItem(firearmType.GetItemType(), out ItemBase itemBase))
+            {
+                Log.Error($"Failed to spawn decal: Could not find a Firearm for {firearmType}.");
+                return false;
+            }
+
+            Firearm firearm = Item.Get<Firearm>(itemBase);
+            if (firearm == null)
+            {
+                Log.Error($"Failed to spawn decal: Could not find a Firearm for {firearmType}.");
+                return false;
+            }
+
+            ImpactEffectsModule impactEffectsModule = firearm.ImpactEffectsModule;
+            if (impactEffectsModule == null)
+            {
+                Log.Error($"Failed to spawn decal: Could not find an ImpactEffectsModule for {firearmType}.");
+                return false;
+            }
+
+            impactEffectsModule.SendRpc(writer =>
+            {
+                writer.WriteSubheader(ImpactEffectsModule.RpcType.ImpactDecal);
+                writer.WriteByte((byte)decalType);
+                writer.WriteRelativePosition(new RelativePosition(position));
+                writer.WriteRelativePosition(new RelativePosition(sourcePosition));
+            });
+
+            return true;
+        }
 
         /// <summary>
         /// Gets all the near cameras.
diff --git a/EXILED/Exiled.API/Features/Player.cs b/EXILED/Exiled.API/Features/Player.cs
index 936a82c4c..ef43a01eb 100644
--- a/EXILED/Exiled.API/Features/Player.cs
+++ b/EXILED/Exiled.API/Features/Player.cs
@@ -14,6 +14,8 @@ namespace Exiled.API.Features
     using System.Reflection;
     using System.Runtime.CompilerServices;
 
+    using AudioPooling;
+
     using Core;
 
     using CustomPlayerEffects;
@@ -49,6 +51,7 @@ namespace Exiled.API.Features
     using InventorySystem.Items;
     using InventorySystem.Items.Armor;
     using InventorySystem.Items.Firearms.Attachments;
+    using InventorySystem.Items.Firearms.BasicMessages;
     using InventorySystem.Items.Firearms.Modules;
     using InventorySystem.Items.Firearms.ShotEvents;
     using InventorySystem.Items.Usables;
@@ -3855,19 +3858,28 @@ public void Reconnect(ushort newPort = 0, float delay = 5, bool reconnect = true
             Connection.Send(new RoundRestartMessage(roundRestartType, delay, newPort, reconnect, false));
         }
 
-        /// <inheritdoc cref="MirrorExtensions.PlayGunSound(Player, Vector3, ItemType, byte, byte)"/>
-        [Obsolete("Use PlayGunSound(Player, Vector3, FirearmType, byte, byte) instead.")]
-        public void PlayGunSound(ItemType type, byte volume, byte audioClipId = 0)
-            => PlayGunSound(type.GetFirearmType(), volume, audioClipId);
-
-        /// <inheritdoc cref="MirrorExtensions.PlayGunSound(Player, Vector3, FirearmType, float, int)"/>
-        public void PlayGunSound(FirearmType itemType, float pitch = 1, int clipIndex = 0) =>
-            this.PlayGunSound(Position, itemType, pitch, clipIndex);
+        /// <inheritdoc cref="MirrorExtensions.PlayGunSound(Player, FirearmType, int, Vector3, MixerChannel, float?, float?)"/>
+        [Obsolete("Use Player::PlayGunSound(FirearmType, int, Vector3, MixerChannel, float?, float?) instead of this.")]
+        public void PlayGunSound(FirearmType itemType, float pitch = 1, int clipIndex = 0) => this.PlayGunSound(itemType, clipIndex, Position, pitch: pitch);
 
         /// <inheritdoc cref="Map.PlaceBlood(Vector3, Vector3)"/>
-        [Obsolete("Use PlaceBlood(this Player, Vector3, Vector3, RoleTypeId, int) instead.")]
         public void PlaceBlood(Vector3 direction) => Map.PlaceBlood(Position, direction);
 
+        /// <summary>
+        /// Sends a damage indicator to player.
+        /// </summary>
+        /// <param name="dmgDealt">The amount of damage dealt. Controls the size of the damage indicator.</param>
+        /// <param name="position">The world position the damage originated from.</param>
+        /// <param name="sendSpectatorsToo">If true, spectators watching this player will also see the indicator.</param>
+        public void SendHitEffect(float dmgDealt, Vector3 position, bool sendSpectatorsToo = true)
+        {
+            DamageIndicatorMessage damageIndicatorMessage = new(dmgDealt, position);
+            if (!sendSpectatorsToo)
+                Connection.Send(damageIndicatorMessage);
+            else
+                damageIndicatorMessage.SendToSpectatorsOf(ReferenceHub, true);
+        }
+
         /// <inheritdoc cref="Map.GetNearCameras(Vector3, float)"/>
         public IEnumerable<Camera> GetNearCameras(float toleration = 15f) => Map.GetNearCameras(Position, toleration);
 
@@ -3881,8 +3893,7 @@ public void PlayGunSound(FirearmType itemType, float pitch = 1, int clipIndex =
         /// Teleports the player to the given object, with no offset.
         /// </summary>
         /// <param name="obj">The object to teleport to.</param>
-        public void Teleport(object obj)
-            => Teleport(obj, Vector3.zero);
+        public void Teleport(object obj) => Teleport(obj, Vector3.zero);
 
         /// <summary>
         /// Teleports the player to the given object, offset by the defined offset value.