Station AI ability to electricute doors

Content.Client/Silicons/StationAi/StationAiSystem.Airlock.cs

@@ -1,4 +1,5 @@
 using Content.Shared.Doors.Components;
+using Content.Shared.Electrocution;
 using Content.Shared.Silicons.StationAi;
 using Robust.Shared.Utility;
 
@@ -9,6 +10,8 @@ public sealed partial class StationAiSystem
     private void InitializeAirlock()
     {
         SubscribeLocalEvent<DoorBoltComponent, GetStationAiRadialEvent>(OnDoorBoltGetRadial);
+        SubscribeLocalEvent<AirlockComponent, GetStationAiRadialEvent>(OnEmergencyAccessGetRadial);
+        SubscribeLocalEvent<ElectrifiedComponent, GetStationAiRadialEvent>(OnDoorElectrifiedGetRadial);
     }
 
     private void OnDoorBoltGetRadial(Entity<DoorBoltComponent> ent, ref GetStationAiRadialEvent args)
@@ -17,14 +20,48 @@ private void OnDoorBoltGetRadial(Entity<DoorBoltComponent> ent, ref GetStationAi
         {
             Sprite = ent.Comp.BoltsDown ?
                 new SpriteSpecifier.Rsi(
-                new ResPath("/Textures/Structures/Doors/Airlocks/Standard/basic.rsi"), "open") :
+                new ResPath("/Textures/Interface/Actions/actions_ai.rsi"), "unbolt_door") :
                 new SpriteSpecifier.Rsi(
-                new ResPath("/Textures/Structures/Doors/Airlocks/Standard/basic.rsi"), "closed"),
+                new ResPath("/Textures/Interface/Actions/actions_ai.rsi"), "bolt_door"),
             Tooltip = ent.Comp.BoltsDown ? Loc.GetString("bolt-open") : Loc.GetString("bolt-close"),
             Event = new StationAiBoltEvent()
             {
                 Bolted = !ent.Comp.BoltsDown,
             }
         });
     }
+
+	private void OnEmergencyAccessGetRadial(Entity<AirlockComponent> ent, ref GetStationAiRadialEvent args)
+    {
+        args.Actions.Add(new StationAiRadial()
+        {
+            Sprite = ent.Comp.EmergencyAccess ?
+                new SpriteSpecifier.Rsi(
+                new ResPath("/Textures/Interface/Actions/actions_ai.rsi"), "emergency_off") :
+                new SpriteSpecifier.Rsi(
+                new ResPath("/Textures/Interface/Actions/actions_ai.rsi"), "emergency_on"),
+            Tooltip = ent.Comp.EmergencyAccess ? Loc.GetString("emergency-access-off") : Loc.GetString("emergency-access-on"),
+            Event = new StationAiEmergencyAccessEvent()
+            {
+                EmergencyAccess = !ent.Comp.EmergencyAccess,
+            }
+        });
+    }
+
+	private void OnDoorElectrifiedGetRadial(Entity<ElectrifiedComponent> ent, ref GetStationAiRadialEvent args)
+    {
+        args.Actions.Add(new StationAiRadial
+        {
+            Sprite = ent.Comp.Enabled ?
+                new SpriteSpecifier.Rsi(
+                    new ResPath("/Textures/Interface/Actions/actions_ai.rsi"), "door_overcharge_off") :
+                new SpriteSpecifier.Rsi(
+                    new ResPath("/Textures/Interface/Actions/actions_ai.rsi"), "door_overcharge_on"),
+            Tooltip = ent.Comp.Enabled ? Loc.GetString("bolt-open") : Loc.GetString("bolt-close"),
+            Event = new StationAiElectrifiedEvent
+            {
+                Electrified = !ent.Comp.Enabled,
+            }
+        });
+    }
 }

Content.Server/Administration/Systems/AdminVerbSystem.Tools.cs

@@ -90,22 +90,22 @@ private void AddTricksVerbs(GetVerbsEvent<Verb> args)
                 args.Verbs.Add(bolt);
             }
 
-            if (TryComp<AirlockComponent>(args.Target, out var airlock))
+            if (TryComp<AirlockComponent>(args.Target, out var airlockComp))
             {
                 Verb emergencyAccess = new()
                 {
-                    Text = airlock.EmergencyAccess ? "Emergency Access Off" : "Emergency Access On",
+                    Text = airlockComp.EmergencyAccess ? "Emergency Access Off" : "Emergency Access On",
                     Category = VerbCategory.Tricks,
                     Icon = new SpriteSpecifier.Texture(new("/Textures/Interface/AdminActions/emergency_access.png")),
                     Act = () =>
                     {
-                        _airlockSystem.ToggleEmergencyAccess(args.Target, airlock);
+                        _airlockSystem.ToggleEmergencyAccess((args.Target, airlockComp));
                     },
                     Impact = LogImpact.Medium,
-                    Message = Loc.GetString(airlock.EmergencyAccess
+                    Message = Loc.GetString(airlockComp.EmergencyAccess
                         ? "admin-trick-emergency-access-off-description"
                         : "admin-trick-emergency-access-on-description"),
-                    Priority = (int) (airlock.EmergencyAccess ? TricksVerbPriorities.EmergencyAccessOff : TricksVerbPriorities.EmergencyAccessOn),
+                    Priority = (int) (airlockComp.EmergencyAccess ? TricksVerbPriorities.EmergencyAccessOff : TricksVerbPriorities.EmergencyAccessOn),
                 };
                 args.Verbs.Add(emergencyAccess);
             }

Content.Server/Construction/Completions/AttemptElectrocute.cs

@@ -1,4 +1,5 @@
 using Content.Server.Electrocution;
+using Content.Shared.Electrocution;
 using Content.Shared.Construction;
 
 namespace Content.Server.Construction.Completions;

Content.Server/Doors/WireActions/DoorBoltWireAction.cs

@@ -2,7 +2,6 @@
 using Content.Server.Wires;
 using Content.Shared.Doors;
 using Content.Shared.Doors.Components;
-using Content.Shared.Doors.Systems;
 using Content.Shared.Wires;
 
 namespace Content.Server.Doors;

Content.Server/Electrocution/ElectrocutionSystem.cs

@@ -488,4 +488,10 @@ private void PlayElectrocutionSound(EntityUid targetUid, EntityUid sourceUid, El
         }
         _audio.PlayPvs(electrified.ShockNoises, targetUid, AudioParams.Default.WithVolume(electrified.ShockVolume));
     }
+
+    public void SetElectrifiedWireCut(Entity<ElectrifiedComponent> ent, bool value)
+    {
+        ent.Comp.IsWireCut = value;
+        Dirty(ent);
+    }
 }

Content.Server/Power/PowerWireAction.cs

@@ -1,4 +1,5 @@
 using Content.Server.Electrocution;
+using Content.Shared.Electrocution;
 using Content.Server.Power.Components;
 using Content.Server.Wires;
 using Content.Shared.Power;
@@ -104,6 +105,7 @@ private void SetElectrified(EntityUid used, bool setting, ElectrifiedComponent?
             && !EntityManager.TryGetComponent(used, out electrified))
             return;
 
+        _electrocutionSystem.SetElectrifiedWireCut((used, electrified), setting);
         electrified.Enabled = setting;
     }
 

Content.Server/Remotes/DoorRemoteSystem.cs

@@ -74,7 +74,7 @@ private void OnBeforeInteract(Entity<DoorRemoteComponent> entity, ref BeforeRang
                 case OperatingMode.ToggleEmergencyAccess:
                     if (airlockComp != null)
                     {
-                        _airlock.ToggleEmergencyAccess(args.Target.Value, airlockComp);
+                        _airlock.ToggleEmergencyAccess((args.Target.Value, airlockComp));
                         _adminLogger.Add(LogType.Action, LogImpact.Medium,
                             $"{ToPrettyString(args.User):player} used {ToPrettyString(args.Used)} on {ToPrettyString(args.Target.Value)} to set emergency access {(airlockComp.EmergencyAccess ? "on" : "off")}");
                     }

Content.Shared/Doors/Components/AirlockComponent.cs

@@ -1,5 +1,6 @@
 using Content.Shared.DeviceLinking;
 using Content.Shared.Doors.Systems;
+using Robust.Shared.Audio;
 using Robust.Shared.GameStates;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
@@ -23,6 +24,18 @@ public sealed partial class AirlockComponent : Component
     [ViewVariables(VVAccess.ReadWrite)]
     [DataField, AutoNetworkedField]
     public bool EmergencyAccess = false;
+
+    /// <summary>
+    /// Sound to play when the airlock emergency access is turned on.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public SoundSpecifier EmergencyOnSound = new SoundPathSpecifier("/Audio/Machines/airlock_emergencyon.ogg");
+
+    /// <summary>
+    /// Sound to play when the airlock emergency access is turned off.
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
+    public SoundSpecifier EmergencyOffSound = new SoundPathSpecifier("/Audio/Machines/airlock_emergencyoff.ogg");
 
     /// <summary>
     /// Pry modifier for a powered airlock.

Content.Shared/Doors/Systems/SharedAirlockSystem.cs

@@ -1,4 +1,5 @@
 using Content.Shared.Doors.Components;
+using Robust.Shared.Audio.Systems;
 using Content.Shared.Popups;
 using Content.Shared.Prying.Components;
 using Content.Shared.Wires;
@@ -11,6 +12,7 @@ public abstract class SharedAirlockSystem : EntitySystem
     [Dependency] protected readonly SharedDoorSystem DoorSystem = default!;
     [Dependency] protected readonly SharedPopupSystem Popup = default!;
     [Dependency] private readonly SharedWiresSystem _wiresSystem = default!;
+    [Dependency] protected readonly SharedAudioSystem Audio = default!;
 
     public override void Initialize()
     {
@@ -123,11 +125,20 @@ public void UpdateEmergencyLightStatus(EntityUid uid, AirlockComponent component
         Appearance.SetData(uid, DoorVisuals.EmergencyLights, component.EmergencyAccess);
     }
 
-    public void ToggleEmergencyAccess(EntityUid uid, AirlockComponent component)
+    public void ToggleEmergencyAccess(Entity<AirlockComponent> ent, EntityUid? user = null, bool predicted = false)
     {
-        component.EmergencyAccess = !component.EmergencyAccess;
-        Dirty(uid, component); // This only runs on the server apparently so we need this.
-        UpdateEmergencyLightStatus(uid, component);
+        if(!ent.Comp.Powered)
+            return;
+
+        ent.Comp.EmergencyAccess = !ent.Comp.EmergencyAccess;
+        Dirty(ent, ent.Comp); // This only runs on the server apparently so we need this.
+        UpdateEmergencyLightStatus(ent, ent.Comp);
+
+        var sound = ent.Comp.EmergencyAccess ? ent.Comp.EmergencyOnSound : ent.Comp.EmergencyOffSound;
+        if (predicted)
+            Audio.PlayPredicted(sound, ent, user: user);
+        else
+            Audio.PlayPvs(sound, ent);
     }
 
     public void SetAutoCloseDelayModifier(AirlockComponent component, float value)

Content.Server/Electrocution/Components/ElectrifiedComponent.cs → Content.Shared/Electrocution/Components/ElectrifiedComponent.cs

@@ -1,121 +1,128 @@
+using Robust.Shared.GameStates;
 using Robust.Shared.Audio;
 
-namespace Content.Server.Electrocution;
+namespace Content.Shared.Electrocution;
 
 /// <summary>
 ///     Component for things that shock users on touch.
 /// </summary>
-[RegisterComponent]
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
 public sealed partial class ElectrifiedComponent : Component
 {
-    [DataField("enabled")]
+    [DataField, AutoNetworkedField]
     public bool Enabled = true;
 
     /// <summary>
     /// Should player get damage on collide
     /// </summary>
-    [DataField("onBump")]
+    [DataField, AutoNetworkedField]
     public bool OnBump = true;
 
     /// <summary>
     /// Should player get damage on attack
     /// </summary>
-    [DataField("onAttacked")]
+    [DataField, AutoNetworkedField]
     public bool OnAttacked = true;
 
     /// <summary>
     /// When true - disables power if a window is present in the same tile
     /// </summary>
-    [DataField("noWindowInTile")]
+    [DataField, AutoNetworkedField]
     public bool NoWindowInTile = false;
 
     /// <summary>
     /// Should player get damage on interact with empty hand
     /// </summary>
-    [DataField("onHandInteract")]
+    [DataField, AutoNetworkedField]
     public bool OnHandInteract = true;
 
     /// <summary>
     /// Should player get damage on interact while holding an object in their hand
     /// </summary>
-    [DataField("onInteractUsing")]
+    [DataField, AutoNetworkedField]
     public bool OnInteractUsing = true;
 
     /// <summary>
     /// Indicates if the entity requires power to function
     /// </summary>
-    [DataField("requirePower")]
+    [DataField, AutoNetworkedField]
     public bool RequirePower = true;
 
     /// <summary>
     /// Indicates if the entity uses APC power
     /// </summary>
-    [DataField("usesApcPower")]
+    [DataField, AutoNetworkedField]
     public bool UsesApcPower = false;
 
     /// <summary>
     /// Identifier for the high voltage node.
     /// </summary>
-    [DataField("highVoltageNode")]
+    [DataField, AutoNetworkedField]
     public string? HighVoltageNode;
 
     /// <summary>
     /// Identifier for the medium voltage node.
     /// </summary>
-    [DataField("mediumVoltageNode")]
+    [DataField, AutoNetworkedField]
     public string? MediumVoltageNode;
 
     /// <summary>
     /// Identifier for the low voltage node.
     /// </summary>
-    [DataField("lowVoltageNode")]
+    [DataField, AutoNetworkedField]
     public string? LowVoltageNode;
 
     /// <summary>
     /// Damage multiplier for HV electrocution
     /// </summary>
-    [DataField]
+    [DataField, AutoNetworkedField]
     public float HighVoltageDamageMultiplier = 3f;
 
     /// <summary>
     /// Shock time multiplier for HV electrocution
     /// </summary>
-    [DataField]
+    [DataField, AutoNetworkedField]
     public float HighVoltageTimeMultiplier = 1.5f;
 
     /// <summary>
     /// Damage multiplier for MV electrocution
     /// </summary>
-    [DataField]
+    [DataField, AutoNetworkedField]
     public float MediumVoltageDamageMultiplier = 2f;
 
     /// <summary>
     /// Shock time multiplier for MV electrocution
     /// </summary>
-    [DataField]
+    [DataField, AutoNetworkedField]
     public float MediumVoltageTimeMultiplier = 1.25f;
 
-    [DataField("shockDamage")]
+    [DataField, AutoNetworkedField]
     public float ShockDamage = 7.5f;
 
     /// <summary>
     /// Shock time, in seconds.
     /// </summary>
-    [DataField("shockTime")]
+    [DataField, AutoNetworkedField]
     public float ShockTime = 8f;
 
-    [DataField("siemensCoefficient")]
+    [DataField, AutoNetworkedField]
     public float SiemensCoefficient = 1f;
 
-    [DataField("shockNoises")]
+    [DataField, AutoNetworkedField]
     public SoundSpecifier ShockNoises = new SoundCollectionSpecifier("sparks");
 
-    [DataField("playSoundOnShock")]
+    [DataField, AutoNetworkedField]
+    public SoundSpecifier DoorElectrified = new SoundCollectionSpecifier("sparks");
+
+    [DataField, AutoNetworkedField]
     public bool PlaySoundOnShock = true;
 
-    [DataField("shockVolume")]
+    [DataField, AutoNetworkedField]
     public float ShockVolume = 20;
 
-    [DataField]
+    [DataField, AutoNetworkedField]
     public float Probability = 1f;
+
+    [DataField, AutoNetworkedField]
+    public bool IsWireCut = false;
 }

Content.Shared/Electrocution/SharedElectrocutionSystem.cs

@@ -43,6 +43,12 @@ public virtual bool TryDoElectrocution(
         private void OnInsulatedElectrocutionAttempt(EntityUid uid, InsulatedComponent insulated, ElectrocutionAttemptEvent args)
         {
             args.SiemensCoefficient *= insulated.Coefficient;
+        }
+
+		public void ToggleElectrified(Entity<ElectrifiedComponent> ent, EntityUid? user = null, bool predicted = false)
+        {
+            ent.Comp.Enabled = !ent.Comp.Enabled;
+            Dirty(ent, ent.Comp);
         }
     }
 }