Проникновение со взломом

Content.Client/Weapons/Ranged/Systems/GunSystem.cs

@@ -185,6 +185,28 @@ public override void Shoot(EntityUid gunUid, GunComponent gun, List<(EntityUid?
     {
         userImpulse = true;
 
+        // Получение и модификация свойств снаряда на основе параметров оружия
+        foreach (var (ammoEntity, shootable) in ammo)
+        {
+            if (shootable is ProjectileComponent projectile && EntityManager.TryGetComponent<GunComponent>(gunUid, out var gunComp))
+            {
+                // Применение модификаторов проникающей способности
+                if (EntityManager.TryGetComponent<CanPenetrateComponent>(ammoEntity, out var penetration) &&
+                    gunComp.PenetrationModifier != null)
+                {
+                    penetration.PenetrationPower += gunComp.PenetrationModifier.Value;
+                }
+
+                // Применение модификатора урона
+                if (gunComp.DamageMultiplier != null)
+                {
+                    projectile.Damage *= gunComp.DamageMultiplier.Value;
+            }
+
+                projectile.GunModifiersApplied = true;
+            }
+        }
+
         // Rather than splitting client / server for every ammo provider it's easier
         // to just delete the spawned entities. This is for programmer sanity despite the wasted perf.
         // This also means any ammo specific stuff can be grabbed as necessary.

Content.Shared/Projectiles/SharedProjectileSystem.cs

@@ -159,8 +159,69 @@
     {
         args.Cancel("pacified-cannot-throw-embed");
     }
-}
+
+    /// <summary>
+    /// Checks if the projectile is allowed to penetrate the target it hit.
+    /// </summary>
+    private void AfterProjectileHit(EntityUid uid, ProjectileComponent component, ref AfterProjectileHitEvent args)
+    {
+        if (!TryComp<CanPenetrateComponent>(uid, out var canPenetrate))
+            return;
+
+        //Delete the projectile if it has no penetration power left.
+        if (canPenetrate.PenetrationPower <= 0)
+        {
+            QueueDel(uid);
+            return;
+        }
+
+        //Delete the projectile if it hits an entity with a CollisionLayer that has a higher value than it's PenetrationLayer.
+        //This allows a projectile to only penetrate a specific set of entities.
+        if (canPenetrate.PenetrationLayer != null)
+        {
+            if (args.Fixture.CollisionLayer > (int) canPenetrate.PenetrationLayer)
+            {
+                QueueDel(uid);
+                return;
+            }
+        }
+
+        //Allow the projectile to deal damage again.
+        if(canPenetrate.DamageAfterCollide)
+            component.DamagedEntity = false;
+
+        //If the projectile has a limit on the amount of penetrations, reduce it.
+        if (canPenetrate.PenetrationPower != null)
+        {
+            //If it's CollisonLayer is higher than the MachineLayer it's a "hard" target and
+            //deducts more penetration power.
+            if (args.Fixture.CollisionLayer > (int) CollisionGroup.MachineLayer)
+                canPenetrate.PenetrationPower -= 1;
+
+            //If the target's CollisonLayer is equal to or lower than the MachineLayer,
+            //it's a "soft" target and deducts less penetration power.
+            else
+                canPenetrate.PenetrationPower -= 0.5f;
+
+            // Delete the projectile if it collides with an entity that it doesn't have enough penetration power for.
+            if (canPenetrate.PenetrationPower < 0)
+            {
+                QueueDel(uid);
+                return;
+            }
+        }
 
+        //Apply the penetration damage modifier if the projectile has one.
+        if (canPenetrate.DamageModifier != null)
+            component.Damage *= canPenetrate.DamageModifier.Value;
+
+        //Overrides the original DeleteOnCollide if the projectile passes all penetration checks.
+        //This is to prevent having to set DeleteOnCollide to false on every prototype
+        //you want to give the ability to penetrate entities.
+        if(component.DeleteOnCollide)
+            component.DeleteOnCollide = false;
+    }
+}
 [Serializable, NetSerializable]
 public sealed class ImpactEffectEvent : EntityEventArgs
 {
@@ -174,6 +235,22 @@
     }
 }
 
+[Serializable, NetSerializable]
+public class AfterProjectileHitEvent : EntityEventArgs
+{
+    public EntityUid ProjectileId { get; set; }
+    public EntityUid TargetId { get; set; }
+    public bool ShouldPenetrate { get; set; }
+
+    public AfterProjectileHitEvent(EntityUid projectileId, EntityUid targetId, bool shouldPenetrate)
+    {
+        ProjectileId = projectileId;
+        TargetId = targetId;
+        ShouldPenetrate = shouldPenetrate;
+    }
+}
+
+
 /// <summary>
 /// Raised when an entity is just about to be hit with a projectile but can reflect it
 /// </summary>

Content.Shared/Weapons/Ranged/Components/GunComponent.cs

@@ -228,6 +228,18 @@ public sealed partial class GunComponent : Component
     /// </summary>
     [DataField]
     public bool ClumsyProof = false;
+
+    /// <summary>
+    /// The amount of penetrations the gun adds to projectiles shot by the gun.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public float? PenetrationModifier;
+
+    /// <summary>
+    /// The damage multiplier added to projectiles shot by the gun.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public float? DamageMultiplier;
 }
 
 [Flags]

Resources/Prototypes/Entities/Objects/Weapons/Guns/Ammunition/Projectiles/antimateriel.yml

@@ -9,5 +9,7 @@
       types:
         Piercing: 40
         Structural: 30
+  - type: CanPenetrate
+    penetrationPower: 0
   - type: StaminaDamageOnCollide
     damage: 35

Resources/Prototypes/Entities/Objects/Weapons/Guns/Snipers/snipers.yml

@@ -19,6 +19,7 @@
     - suitStorage
   - type: AmmoCounter
   - type: Gun
+    penetrationModifier: 1.5 #3 mobs or 1 wall and 1 mob.
     fireRate: 0.75
     selectedMode: SemiAuto
     availableModes: