перенос файлов сервера из папки White в _White

Content.Server/_White/Crossbow/ModifyDamageOnShootComponent.cs

@@ -0,0 +1,19 @@
+using System.Numerics;
+using Content.Shared.Damage;
+
+namespace Content.Server._White.Crossbow;
+
+[RegisterComponent]
+public sealed partial class ModifyDamageOnShootComponent : Component
+{
+    [DataField("damage", required: true)]
+    [ViewVariables(VVAccess.ReadWrite)]
+    public DamageSpecifier Damage = new();
+
+    [DataField("addEmbedding")]
+    [ViewVariables(VVAccess.ReadWrite)]
+    public bool AddEmbedding;
+
+    [DataField("offset")]
+    public Vector2 Offset = Vector2.Zero;
+}

Content.Server/_White/Crossbow/ModifyDamageOnShootSystem.cs

@@ -0,0 +1,33 @@
+using Content.Shared.Projectiles;
+using Content.Shared.Throwing;
+using Content.Shared.Weapons.Ranged.Events;
+
+namespace Content.Server._White.Crossbow;
+
+public sealed class ModifyDamageOnShootSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ModifyDamageOnShootComponent, AmmoShotEvent>(OnShoot);
+    }
+
+    private void OnShoot(EntityUid uid, ModifyDamageOnShootComponent component, AmmoShotEvent args)
+    {
+        foreach (var proj in args.FiredProjectiles)
+        {
+            var comp = EnsureComp<ThrowDamageModifierComponent>(proj);
+            comp.Damage += component.Damage;
+
+            if (!component.AddEmbedding)
+                continue;
+
+            comp.AddEmbedding = true;
+            var embed = EnsureComp<EmbeddableProjectileComponent>(proj);
+            embed.Offset = component.Offset;
+            embed.PreventEmbedding = false;
+            Dirty(proj, embed);
+        }
+    }
+}

Content.Server/_White/Crossbow/PoweredComponent.cs

@@ -0,0 +1,15 @@
+using Content.Shared.Damage;
+
+namespace Content.Server._White.Crossbow;
+
+[RegisterComponent]
+public sealed partial class PoweredComponent : Component
+{
+    [DataField("charge", required: true)]
+    [ViewVariables(VVAccess.ReadWrite)]
+    public float Charge;
+
+    [DataField("damage", required: true)]
+    [ViewVariables(VVAccess.ReadWrite)]
+    public DamageSpecifier Damage = new();
+}

Content.Server/_White/Crossbow/PoweredSystem.cs

@@ -0,0 +1,99 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.Power.Components;
+using Content.Server.Power.EntitySystems;
+using Content.Shared.Projectiles;
+using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.Containers;
+using Robust.Shared.Utility;
+
+namespace Content.Server._White.Crossbow;
+
+public sealed class PoweredSystem : EntitySystem
+{
+    [Dependency] private readonly SharedContainerSystem _containers = default!;
+    [Dependency] private readonly BatterySystem _battery = default!;
+
+    private const string CellSlot = "cell_slot";
+    private const string CrystalSlot = "crystal_slot";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PoweredComponent, AmmoShotEvent>(OnShoot);
+    }
+
+    private void OnShoot(EntityUid uid, PoweredComponent component, AmmoShotEvent args)
+    {
+        if (!TryGetBatteryComponent(uid, out var battery, out var batteryUid))
+            return;
+
+        var (factor, charge) = GetFactor(uid, component, battery, batteryUid.Value);
+
+         // Чтобы затриггерить взрыв на полную мощь, если есть плазма в батарейке
+        _battery.SetCharge(batteryUid.Value, battery.CurrentCharge, battery);
+
+        _battery.SetCharge(batteryUid.Value, battery.CurrentCharge - charge, battery);
+        var damage = component.Damage * factor;
+
+        foreach (var proj in args.FiredProjectiles)
+        {
+            EnsureComp<ThrowDamageModifierComponent>(proj).Damage += damage;
+
+            if (factor == 0)
+                continue;
+
+            var embed = EnsureComp<EmbeddableProjectileComponent>(proj);
+            embed.Penetrate = true;
+            Dirty(proj, embed);
+        }
+    }
+
+    public float GetPowerCoefficient(EntityUid uid)
+    {
+        if (!TryComp(uid, out PoweredComponent? component) ||
+            !TryGetBatteryComponent(uid, out var battery, out var batteryUid))
+            return 1f;
+
+        return 1f + GetFactor(uid, component, battery, batteryUid.Value).Item1;
+    }
+
+    private (float, float) GetFactor(EntityUid uid, PoweredComponent component, BatteryComponent battery, EntityUid batteryUid)
+    {
+        DebugTools.Assert(component.Charge != 0f);
+        var charge = MathF.Min(battery.CurrentCharge, component.Charge);
+        var factor = charge / component.Charge;
+        var multiplier = 1f;
+
+        if (TryComp(batteryUid, out RiggableComponent? rig) && rig.IsRigged)
+            multiplier += 1f;
+
+        if (_containers.TryGetContainer(uid, CrystalSlot, out var container) && container is ContainerSlot slot &&
+            slot.ContainedEntity.HasValue)
+            multiplier += 1f;
+
+        factor *= multiplier;
+
+        return (factor, charge);
+    }
+
+    private bool TryGetBatteryComponent(EntityUid uid, [NotNullWhen(true)] out BatteryComponent? battery,
+        [NotNullWhen(true)] out EntityUid? batteryUid)
+    {
+        if (!_containers.TryGetContainer(uid, CellSlot, out var container) ||
+            container is not ContainerSlot slot)
+        {
+            battery = null;
+            batteryUid = null;
+            return false;
+        }
+
+        batteryUid = slot.ContainedEntity;
+
+        if (batteryUid != null)
+            return TryComp(batteryUid, out battery);
+
+        battery = null;
+        return false;
+    }
+}

Content.Server/_White/Crossbow/ThrowDamageModifierComponent.cs

@@ -0,0 +1,13 @@
+using Content.Shared.Damage;
+
+namespace Content.Server._White.Crossbow;
+
+[RegisterComponent]
+public sealed partial class ThrowDamageModifierComponent : Component
+{
+    public DamageSpecifier Damage = new();
+
+    public bool AddEmbedding;
+
+    public bool ClearDamageOnRemove;
+}

Content.Server/_White/Crossbow/ThrowDamageModifierSystem.cs

@@ -0,0 +1,43 @@
+using Content.Shared.Projectiles;
+using Content.Shared.Throwing;
+using Content.Shared.White.Crossbow;
+
+namespace Content.Server._White.Crossbow;
+
+public sealed class ThrowDamageModifierSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ThrowDamageModifierComponent, StopThrowEvent>(OnStopped);
+        SubscribeLocalEvent<ThrowDamageModifierComponent, EmbedStartEvent>(OnEmbedStart);
+        SubscribeLocalEvent<ThrowDamageModifierComponent, EmbedRemovedEvent>(OnEmbedRemoved);
+    }
+
+    private void OnEmbedStart(EntityUid uid, ThrowDamageModifierComponent component, ref EmbedStartEvent args)
+    {
+        component.ClearDamageOnRemove = true;
+
+        if (component.AddEmbedding)
+            args.Embed.PreventEmbedding = true;
+    }
+
+    private void OnEmbedRemoved(EntityUid uid, ThrowDamageModifierComponent component, EmbedRemovedEvent args)
+    {
+        if (!component.ClearDamageOnRemove)
+            return;
+
+        component.ClearDamageOnRemove = false;
+        component.Damage.DamageDict.Clear();
+
+        if (component.AddEmbedding)
+            RemComp<EmbeddableProjectileComponent>(uid);
+    }
+
+    private void OnStopped(EntityUid uid, ThrowDamageModifierComponent component, StopThrowEvent args)
+    {
+        if (!component.ClearDamageOnRemove)
+            component.Damage.DamageDict.Clear();
+    }
+}