[ADD] Самодельный хлам.

Content.Client/ADT/Weapon/WeaponDismantleOnShootSystem.cs

@@ -0,0 +1,24 @@
+using Content.Shared.ADT.Weapon.Systems;
+using System.Numerics;
+using Content.Shared.ADT.Weapon.Components;
+using Content.Shared.Inventory;
+using Content.Shared.Popups;
+using Content.Shared.Tag;
+using Content.Shared.Throwing;
+using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Shared.Physics.Systems;
+
+//linq
+using System.Linq;
+using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.Random;
+using Content.Shared.Damage;
+using Content.Shared.Wieldable;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Player;
+using Robust.Shared.Audio;
+
+namespace Content.Client.ADT.Weapon.Systems;
+public sealed partial class WeaponDismantleOnShootSystem : SharedWeaponDismantleOnShootSystem
+{
+}

Content.Server/ADT/Weapon/WeaponDismantleOnShootSystem.cs

@@ -0,0 +1,103 @@
+using Content.Shared.ADT.Weapon.Systems;
+using System.Numerics;
+using Content.Shared.ADT.Weapon.Components;
+using Content.Shared.Inventory;
+using Content.Shared.Popups;
+using Content.Shared.Tag;
+using Content.Shared.Throwing;
+using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Shared.Physics.Systems;
+
+//linq
+using System.Linq;
+using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.Random;
+using Content.Shared.Damage;
+using Content.Shared.Wieldable;
+using Content.Shared.Weapons.Ranged.Components;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Map;
+
+namespace Content.Server.ADT.Weapon.Systems;
+public sealed partial class WeaponDismantleOnShootSystem : SharedWeaponDismantleOnShootSystem
+{
+    [Dependency] private readonly TagSystem _tagSystem = default!;
+    [Dependency] private readonly SharedGunSystem _gunSystem = default!;
+    [Dependency] private readonly ILogManager _log = default!;
+    [Dependency] protected readonly SharedTransformSystem _transformSystem = default!;
+    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly ThrowingSystem _throwing = default!;
+    [Dependency] private readonly InventorySystem _inventory = default!;
+    [Dependency] protected readonly DamageableSystem Damageable = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<WeaponDismantleOnShootComponent, AmmoShotEvent>(OnGunShot);
+    }
+
+    private void OnGunShot(Entity<WeaponDismantleOnShootComponent> ent, ref AmmoShotEvent args)
+    {
+        if (DismantleCheck(ent, ref args) == false)
+            return;
+
+        //apply the damage to the shooter
+        //get the shooters damageable component
+        Damageable.TryChangeDamage(args.Shooter, ent.Comp.SelfDamage, origin:args.Shooter);
+
+        //we need the user past this point
+        if (!args.Shooter.HasValue)
+            return;
+
+        _audio.PlayPvs(ent.Comp.DismantleSound, args.Shooter.Value);
+
+        //get the users transform
+        var userPosition = Transform(args.Shooter.Value).Coordinates;
+
+        if (!TryComp<GunComponent>(ent, out var gunComponent))
+            return;
+
+        var toCoordinates = gunComponent.ShootCoordinates;
+
+        if (toCoordinates == null)
+            return;
+
+        //loop through all of the items
+        var random = IoCManager.Resolve<IRobustRandom>();
+        foreach (var item in ent.Comp.items)
+        {
+            for (var i = 0; i < item.Amount; i++)
+            {
+                //roll to see if we destroy the item or not
+                if (!random.Prob(item.SpawnProbability))
+                    continue;
+
+                //get the item entity
+                var itemEntity = Spawn(item.PrototypeId, userPosition);
+
+                Vector2 direction = toCoordinates.Value.Position;
+                //normalize it
+                direction = Vector2.Normalize(direction);
+                //multiply it by the distance
+                direction *= ent.Comp.DismantleDistance;
+                //rotate it by the angle
+                direction = item.LaunchAngle.RotateVec(direction);
+
+                //roll for random angle modifier
+                double randomAngle = random.NextDouble(-item.AngleRandomness.Degrees, item.AngleRandomness.Degrees);
+                //rotate it by the random angle
+                direction = Angle.FromDegrees(randomAngle).RotateVec(direction);
+
+                var throwDirection = new EntityCoordinates(args.Shooter.Value, direction);
+
+                _throwing.TryThrow(itemEntity, throwDirection, ent.Comp.DismantleDistance, compensateFriction: true);
+            }
+        }
+
+        //now we need to destroy the gun
+        //get the gun entity
+        _entityManager.QueueDeleteEntity(ent.Owner);
+    }
+}

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

@@ -311,6 +311,7 @@ public override void Shoot(EntityUid gunUid, GunComponent gun, List<(EntityUid?
         RaiseLocalEvent(gunUid, new AmmoShotEvent()
         {
             FiredProjectiles = shotProjectiles,
+            Shooter = user, // ADT-Tweak
         });
 
         void CreateAndFireProjectiles(EntityUid ammoEnt, AmmoComponent ammoComp)

Content.Shared/ADT/Weapons/Components/WeaponDismantleOnShootComponent.cs

@@ -0,0 +1,55 @@
+using Content.Shared.Damage;
+using Content.Shared.Storage;
+using Content.Shared.Tag;
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.ADT.Weapon.Components;
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class WeaponDismantleOnShootComponent : Component
+{
+    [DataField, AutoNetworkedField]
+    public float DismantleChance = 0.0f;
+
+    /// <summary>
+    /// How far to throw things when dismantling.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public float DismantleDistance = 5f;
+
+    [DataField]
+    public SoundCollectionSpecifier? DismantleSound = new SoundCollectionSpecifier("MetalBreak");
+
+    [DataField, AutoNetworkedField]
+    [ViewVariables(VVAccess.ReadWrite)]
+    public DamageSpecifier SelfDamage = new();
+
+    [DataField, AutoNetworkedField]
+    public List<DismantleOnShootItem> items = [];
+}
+
+[DataDefinition]
+[Serializable, NetSerializable]
+public sealed partial class DismantleOnShootItem
+{
+    public DismantleOnShootItem() { }
+    [DataField("id")]
+    public EntProtoId? PrototypeId = null;
+
+    /// <summary>
+    ///     The probability that an item will spawn. Takes decimal form so 0.05 is 5%, 0.50 is 50% etc.
+    /// </summary>
+    [DataField("prob")]
+    public float SpawnProbability = 1;
+
+    [DataField]
+    public int Amount = 1;
+
+    [ViewVariables(VVAccess.ReadWrite), DataField]
+    public Angle LaunchAngle = Angle.FromDegrees(0);
+
+    [ViewVariables(VVAccess.ReadWrite), DataField]
+    public Angle AngleRandomness = Angle.FromDegrees(5);
+}

Content.Shared/ADT/Weapons/SharedWeaponDismantleOnShootSystem.cs

@@ -0,0 +1,38 @@
+using Content.Shared.ADT.Weapon.Components;
+using Content.Shared.Examine;
+using Content.Shared.Weapons.Ranged.Events;
+using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Shared.Random;
+
+namespace Content.Shared.ADT.Weapon.Systems;
+
+public abstract partial class SharedWeaponDismantleOnShootSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<WeaponDismantleOnShootComponent, ExaminedEvent>(OnExamine);
+    }
+
+    public bool DismantleCheck(Entity<WeaponDismantleOnShootComponent> ent, ref AmmoShotEvent args)
+    {
+        //roll to see if we explode or not
+        var random = IoCManager.Resolve<IRobustRandom>();
+        //1.0f means always true, 0.0f means always false
+        if (!random.Prob(ent.Comp.DismantleChance))
+            return false;
+
+        return true;
+    }
+
+    private void OnExamine(Entity<WeaponDismantleOnShootComponent> ent, ref ExaminedEvent args)
+    {
+        if (!args.IsInDetailsRange)
+            return;
+
+        if (ent.Comp.DismantleChance <= 0.0f)
+            return;
+
+        args.PushMarkup(Loc.GetString("examine-weapon-dismantle-on-shoot", ("chance", String.Format("{0:0.#}", ent.Comp.DismantleChance * 100))));
+    }
+}

Content.Shared/Weapons/Ranged/Events/AmmoShotEvent.cs

@@ -6,4 +6,5 @@ namespace Content.Shared.Weapons.Ranged.Events;
 public sealed class AmmoShotEvent : EntityEventArgs
 {
     public List<EntityUid> FiredProjectiles = default!;
+    public EntityUid? Shooter = default!; // ADT-Tweak
 }