IPC

Content.Server/ADT/Damage/Components/DamageOnTriggerComponent.cs

@@ -0,0 +1,12 @@
+using Content.Shared.Damage;
+
+namespace Content.Server.Damage.Components;
+
+[RegisterComponent]
+public sealed partial class DamageOnTriggerComponent : Component
+{
+    [DataField("ignoreResistances")] public bool IgnoreResistances;
+
+    [DataField("damage", required: true)]
+    public DamageSpecifier Damage = default!;
+}

Content.Server/ADT/Damage/Systems/DamageOnTriggerSystem.cs

@@ -0,0 +1,26 @@
+// Simple  Station
+
+using Content.Server.Damage.Components;
+using Content.Server.Explosion.EntitySystems;
+using Content.Shared.Damage;
+using Content.Shared.StepTrigger.Systems;
+
+namespace Content.Server.Damage.Systems
+{
+    // System for damage that occurs on specific trigger, towards the entity..
+    public sealed class DamageOnTriggerSystem : EntitySystem
+    {
+        [Dependency] private readonly DamageableSystem _damageableSystem = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<DamageOnTriggerComponent, TriggerEvent>(DamageOnTrigger);
+        }
+
+        private void DamageOnTrigger(EntityUid uid, DamageOnTriggerComponent component, TriggerEvent args)
+        {
+            _damageableSystem.TryChangeDamage(uid, component.Damage, component.IgnoreResistances);
+        }
+    }
+}

Content.Server/ADT/Power/Components/BatteryDrinkerComponent.cs

@@ -0,0 +1,33 @@
+// Simple Station
+
+namespace Content.Server.ADT.Power;
+
+[RegisterComponent]
+public sealed partial class BatteryDrinkerComponent : Component
+{
+    /// <summary>
+    ///     Is this drinker allowed to drink batteries not tagged as <see cref="BatteryDrinkSource"/>?
+    /// </summary>
+    [DataField("drinkAll"), ViewVariables(VVAccess.ReadWrite)]
+    public bool DrinkAll = false;
+
+    /// <summary>
+    ///     How long it takes to drink from a battery, in seconds.
+    ///     Is multiplied by the source.
+    /// </summary>
+    [DataField("drinkSpeed"), ViewVariables(VVAccess.ReadWrite)]
+    public float DrinkSpeed = 1.5f;
+
+    /// <summary>
+    ///     The multiplier for the amount of power to attempt to drink.
+    ///     Default amount is 1000
+    /// </summary>
+    [DataField("drinkMultiplier"), ViewVariables(VVAccess.ReadWrite)]
+    public float DrinkMultiplier = 5f;
+
+    /// <summary>
+    ///     The multiplier for how long it takes to drink a non-source battery, if <see cref="DrinkAll"/> is true.
+    /// </summary>
+    [DataField("drinkAllMultiplier"), ViewVariables(VVAccess.ReadWrite)]
+    public float DrinkAllMultiplier = 2.5f;
+}

Content.Server/ADT/Power/Components/SiliconEmitSoundOnDrainedComponent.cs

@@ -0,0 +1,26 @@
+// Simple Station
+
+using System.ComponentModel.DataAnnotations;
+using Robust.Shared.Audio;
+using Content.Server.Sound.Components;
+
+namespace Content.Server.ADT.Silicon;
+
+/// <summary>
+///     Applies a <see cref="SpamEmitSoundComponent"/> to a Silicon when its battery is drained, and removes it when it's not.
+/// </summary>
+[RegisterComponent]
+public sealed partial class SiliconEmitSoundOnDrainedComponent : Component
+{
+    [DataField("sound"), Required]
+    public SoundSpecifier Sound = default!;
+
+    [DataField("interval")]
+    public float Interval = 8f;
+
+    [DataField("playChance")]
+    public float PlayChance = 1f;
+
+    [DataField("popUp")]
+    public string? PopUp;
+}

Content.Server/ADT/Power/Systems/BatteryDrinkerSystem.cs

@@ -0,0 +1,149 @@
+// Simple Station
+
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.Power.Components;
+using Content.Shared.Containers.ItemSlots;
+using Content.Shared.DoAfter;
+using Content.Shared.PowerCell.Components;
+using Content.Shared.ADT.Silicon;
+using Content.Shared.Verbs;
+using Robust.Shared.Utility;
+using Content.Server.ADT.Silicon.Charge;
+using Content.Server.Power.EntitySystems;
+using Content.Server.Popups;
+
+namespace Content.Server.ADT.Power;
+
+public sealed class BatteryDrinkerSystem : EntitySystem
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly ItemSlotsSystem _slots = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
+    //[Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly BatterySystem _battery = default!;
+    [Dependency] private readonly SiliconChargeSystem _silicon = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<BatteryComponent, GetVerbsEvent<AlternativeVerb>>(AddAltVerb);
+
+        SubscribeLocalEvent<BatteryDrinkerComponent, BatteryDrinkerDoAfterEvent>(OnDoAfter);
+    }
+
+    private void AddAltVerb(EntityUid uid, BatteryComponent batteryComponent, GetVerbsEvent<AlternativeVerb> args)
+    {
+        if (!args.CanAccess || !args.CanInteract)
+            return;
+
+        if (!TryComp<BatteryDrinkerComponent>(args.User, out var drinkerComp) ||
+            !TestDrinkableBattery(uid, drinkerComp) ||
+            !TryGetFillableBattery(args.User, out var drinkerBattery, out _))
+            return;
+
+        AlternativeVerb verb = new()
+        {
+            Act = () => DrinkBattery(uid, args.User, drinkerComp),
+            Text = Loc.GetString("battery-drinker-verb-drink"),
+            Icon = new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/VerbIcons/smite.svg.192dpi.png")),
+        };
+
+        args.Verbs.Add(verb);
+    }
+
+    private bool TestDrinkableBattery(EntityUid target, BatteryDrinkerComponent drinkerComp)
+    {
+        if (!drinkerComp.DrinkAll && !HasComp<BatteryDrinkerSourceComponent>(target))
+            return false;
+
+        return true;
+    }
+
+    private bool TryGetFillableBattery(EntityUid uid, [NotNullWhen(true)] out BatteryComponent? battery, [NotNullWhen(true)] out EntityUid batteryUid)
+    {
+        if (_silicon.TryGetSiliconBattery(uid, out battery, out batteryUid))
+            return true;
+
+        if (TryComp(uid, out battery))
+            return true;
+
+        if (TryComp<PowerCellSlotComponent>(uid, out var powerCellSlot) &&
+            _slots.TryGetSlot(uid, powerCellSlot.CellSlotId, out var slot) &&
+            slot.Item != null &&
+            TryComp(slot.Item.Value, out battery))
+        {
+            batteryUid = slot.Item.Value;
+            return true;
+        }
+
+        return false;
+    }
+
+    private void DrinkBattery(EntityUid target, EntityUid user, BatteryDrinkerComponent drinkerComp)
+    {
+        var doAfterTime = drinkerComp.DrinkSpeed;
+
+        if (TryComp<BatteryDrinkerSourceComponent>(target, out var sourceComp))
+            doAfterTime *= sourceComp.DrinkSpeedMulti;
+        else
+            doAfterTime *= drinkerComp.DrinkAllMultiplier;
+        var args = new DoAfterArgs(_entityManager, user, doAfterTime, new BatteryDrinkerDoAfterEvent(), user, target) //modern.df
+        //var args = new DoAfterArgs(user, doAfterTime, new BatteryDrinkerDoAfterEvent(), user, target) // TODO: Make this doafter loop, once we merge Upstream.
+        {
+            BreakOnDamage = true,
+            BreakOnMove = true,
+            Broadcast = false,
+            DistanceThreshold = 1.35f,
+            RequireCanInteract = true,
+            CancelDuplicate = false
+        };
+
+        _doAfter.TryStartDoAfter(args);
+    }
+
+    private void OnDoAfter(EntityUid uid, BatteryDrinkerComponent drinkerComp, DoAfterEvent args)
+    {
+        if (args.Cancelled || args.Target == null)
+            return;
+
+        var source = args.Target.Value;
+        var drinker = uid;
+        var sourceBattery = Comp<BatteryComponent>(source);
+
+        TryGetFillableBattery(drinker, out var drinkerBattery, out var drinkerBatteryUid);
+
+        TryComp<BatteryDrinkerSourceComponent>(source, out var sourceComp);
+
+        DebugTools.AssertNotNull(drinkerBattery);
+
+        if (drinkerBattery == null)
+            return;
+
+        var amountToDrink = drinkerComp.DrinkMultiplier * 1000;
+
+        amountToDrink = MathF.Min(amountToDrink, sourceBattery.CurrentCharge);
+        amountToDrink = MathF.Min(amountToDrink, drinkerBattery.MaxCharge - drinkerBattery.CurrentCharge);
+
+        if (sourceComp != null && sourceComp.MaxAmount > 0)
+            amountToDrink = MathF.Min(amountToDrink, (float) sourceComp.MaxAmount);
+
+        if (amountToDrink <= 0)
+        {
+            _popup.PopupEntity(Loc.GetString("battery-drinker-empty", ("target", source)), drinker, drinker);
+            return;
+        }
+
+        if (_battery.TryUseCharge(source, amountToDrink, sourceBattery))
+            _battery.SetCharge(drinkerBatteryUid, drinkerBattery.CurrentCharge + amountToDrink, drinkerBattery);
+        else
+        {
+            _battery.SetCharge(drinker, sourceBattery.CurrentCharge + drinkerBattery.CurrentCharge, drinkerBattery);
+            _battery.SetCharge(source, 0, sourceBattery);
+        }
+
+        //if (sourceComp != null && sourceComp.DrinkSound != null)
+        //    _audio.PlayPvs(sourceComp.DrinkSound, source);
+    }
+}

Content.Server/ADT/Power/Systems/BatteryElectrocuteChargeSystem.cs

@@ -0,0 +1,40 @@
+// Simple Station
+
+using Content.Server.Electrocution;
+using Content.Server.Popups;
+using Content.Server.Power.Components;
+using Content.Server.Power.EntitySystems;
+using Content.Shared.Electrocution;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.ADT.Power.Systems;
+
+public sealed class BatteryElectrocuteChargeSystem : EntitySystem
+{
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly BatterySystem _battery = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<BatteryComponent, ElectrocutedEvent>(OnElectrocuted);
+    }
+
+    private void OnElectrocuted(EntityUid uid, BatteryComponent battery, ElectrocutedEvent args)
+    {
+        if (args.ShockDamage == null || args.ShockDamage <= 0)
+            return;
+
+        var damagePerWatt = ElectrocutionSystem.ElectrifiedDamagePerWatt * 2;
+
+        var damage = args.ShockDamage.Value * args.SiemensCoefficient;
+        var charge = Math.Min(damage / damagePerWatt, battery.MaxCharge * 0.25f) * _random.NextFloat(0.75f, 1.25f);
+
+        _battery.SetCharge(uid, battery.CurrentCharge + charge);
+
+        _popup.PopupEntity(Loc.GetString("battery-electrocute-charge"), uid, uid);
+    }
+}

Content.Server/ADT/Power/Systems/SiliconEmitSoundOnDrainedSystem.cs

@@ -0,0 +1,44 @@
+// Simple Station
+
+using Content.Server.ADT.Silicon.Death;
+using Content.Shared.Sound.Components;
+using Content.Shared.Mobs;
+using Robust.Shared.Timing;
+//using Content.Shared.SimpleStation14.Silicon.Systems;
+
+namespace Content.Server.ADT.Silicon;
+
+public sealed class EmitSoundOnCritSystem : EntitySystem
+{
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<SiliconEmitSoundOnDrainedComponent, SiliconChargeDeathEvent>(OnDeath);
+        SubscribeLocalEvent<SiliconEmitSoundOnDrainedComponent, SiliconChargeAliveEvent>(OnAlive);
+        SubscribeLocalEvent<SiliconEmitSoundOnDrainedComponent, MobStateChangedEvent>(OnStateChange);
+    }
+
+    private void OnDeath(EntityUid uid, SiliconEmitSoundOnDrainedComponent component, SiliconChargeDeathEvent args)
+    {
+        var spamComp = EnsureComp<SpamEmitSoundComponent>(uid);
+
+        // spamComp.Accumulator = 0f;
+        spamComp.MinInterval = TimeSpan.FromSeconds(component.Interval);
+        spamComp.MaxInterval = TimeSpan.FromSeconds(component.Interval);
+        spamComp.PopUp = component.PopUp;
+        spamComp.Enabled = true;
+        spamComp.Sound = component.Sound;
+    }
+
+    private void OnAlive(EntityUid uid, SiliconEmitSoundOnDrainedComponent component, SiliconChargeAliveEvent args)
+    {
+        RemComp<SpamEmitSoundComponent>(uid); // This component is bad and I don't feel like making a janky work around because of it.
+        // If you give something the SiliconEmitSoundOnDrainedComponent, know that it can't have the SpamEmitSoundComponent, and any other systems that play with it will just be broken.
+    }
+
+    public void OnStateChange(EntityUid uid, SiliconEmitSoundOnDrainedComponent component, MobStateChangedEvent args)
+    {
+        if (args.NewMobState == MobState.Dead)
+            RemComp<SpamEmitSoundComponent>(uid);
+    }
+}

Content.Server/ADT/Radio/IntrinsicRadioKeySystem.cs

@@ -0,0 +1,34 @@
+// Simple Station
+
+using Content.Server.Radio.Components;
+using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
+
+namespace Content.Server.ADT.Radio;
+
+public sealed class IntrinsicRadioKeySystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<IntrinsicRadioTransmitterComponent, EncryptionChannelsChangedEvent>(OnTransmitterChannelsChanged);
+        SubscribeLocalEvent<ActiveRadioComponent, EncryptionChannelsChangedEvent>(OnReceiverChannelsChanged);
+    }
+
+    private void OnTransmitterChannelsChanged(EntityUid uid, IntrinsicRadioTransmitterComponent component, EncryptionChannelsChangedEvent args)
+    {
+        UpdateChannels(uid, args.Component, ref component.Channels);
+    }
+
+    private void OnReceiverChannelsChanged(EntityUid uid, ActiveRadioComponent component, EncryptionChannelsChangedEvent args)
+    {
+        UpdateChannels(uid, args.Component, ref component.Channels);
+    }
+
+    private void UpdateChannels(EntityUid _, EncryptionKeyHolderComponent keyHolderComp, ref HashSet<string> channels)
+    {
+        channels.Clear();
+        channels.UnionWith(keyHolderComp.Channels);
+    }
+}