The DEMAG

Content.Server/Doors/Systems/DoorBoltSystem.cs

@@ -1,4 +1,4 @@
-using Content.Server.Power.Components;
+using Content.Server.Power.Components;
 using Content.Server.Power.EntitySystems;
 using Content.Shared.Doors;
 using Content.Shared.Doors.Components;

Content.Server/Doors/Systems/DoorSystem.cs

@@ -6,14 +6,15 @@
 using Content.Shared.Database;
 using Content.Shared.Doors.Components;
 using Content.Shared.Doors.Systems;
-using Content.Shared.Emag.Systems;
+using Content.Shared.Emag.Components;
 using Content.Shared.Interaction;
 using Content.Shared.Prying.Components;
 using Content.Shared.Prying.Systems;
 using Content.Shared.Tools.Systems;
 using Robust.Shared.Audio;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Events;
+using Content.Shared.Emag.Systems; // Frontier - Added DEMUG
 
 namespace Content.Server.Doors.Systems;
 
@@ -33,6 +34,7 @@ public override void Initialize()
         SubscribeLocalEvent<DoorComponent, WeldableAttemptEvent>(OnWeldAttempt);
         SubscribeLocalEvent<DoorComponent, WeldableChangedEvent>(OnWeldChanged);
         SubscribeLocalEvent<DoorComponent, GotEmaggedEvent>(OnEmagged);
+        SubscribeLocalEvent<DoorComponent, GotUnEmaggedEvent>(OnUnEmagged); // Frontier - Added DEMUG
         SubscribeLocalEvent<DoorComponent, PriedEvent>(OnAfterPry);
     }
 
@@ -168,6 +170,23 @@ private void OnEmagged(EntityUid uid, DoorComponent door, ref GotEmaggedEvent ar
         }
     }
 
+    private void OnUnEmagged(EntityUid uid, DoorComponent door, ref GotUnEmaggedEvent args) // Frontier - Added DEMUG
+    {
+        if (TryComp<AirlockComponent>(uid, out var airlockComponent))
+        {
+            if (HasComp<EmaggedComponent>(uid))
+            {
+                if (TryComp<DoorBoltComponent>(uid, out var doorBoltComponent))
+                {
+                    _bolts.SetBoltsDown(uid, doorBoltComponent, !doorBoltComponent.BoltsDown);
+                    SetState(uid, DoorState.Closing, door);
+                }
+                PlaySound(uid, door.SparkSound, AudioParams.Default.WithVolume(8), args.UserUid, false);
+                args.Handled = true;
+            }
+        }
+    }
+
     public override void StartOpening(EntityUid uid, DoorComponent? door = null, EntityUid? user = null, bool predicted = false)
     {
         if (!Resolve(uid, ref door))

Content.Server/VendingMachines/VendingMachineSystem.cs

@@ -67,6 +67,7 @@ public override void Initialize()
             SubscribeLocalEvent<VendingMachineComponent, PowerChangedEvent>(OnPowerChanged);
             SubscribeLocalEvent<VendingMachineComponent, BreakageEventArgs>(OnBreak);
             SubscribeLocalEvent<VendingMachineComponent, GotEmaggedEvent>(OnEmagged);
+            SubscribeLocalEvent<VendingMachineComponent, GotUnEmaggedEvent>(OnUnEmagged); // Frontier - Added DEMUG
             SubscribeLocalEvent<VendingMachineComponent, DamageChangedEvent>(OnDamage);
             SubscribeLocalEvent<VendingMachineComponent, PriceCalculationEvent>(OnVendingPrice);
             SubscribeLocalEvent<VendingMachineComponent, EmpPulseEvent>(OnEmpPulse);
@@ -205,6 +206,12 @@ private void OnEmagged(EntityUid uid, VendingMachineComponent component, ref Got
             args.Handled = component.EmaggedInventory.Count > 0;
         }
 
+        private void OnUnEmagged(EntityUid uid, VendingMachineComponent component, ref GotUnEmaggedEvent args) // Frontier - Added DEMUG
+        {
+            // only unemag if there are emag-only items
+            args.Handled = component.EmaggedInventory.Count > 0;
+        }
+
         private void OnDamage(EntityUid uid, VendingMachineComponent component, DamageChangedEvent args)
         {
             if (component.Broken || component.DispenseOnHitCoolingDown ||

Content.Shared/Access/Systems/AccessReaderSystem.cs

@@ -34,6 +34,7 @@ public override void Initialize()
         base.Initialize();
 
         SubscribeLocalEvent<AccessReaderComponent, GotEmaggedEvent>(OnEmagged);
+        SubscribeLocalEvent<AccessReaderComponent, GotUnEmaggedEvent>(OnUnEmagged); // Frontier - DEMAG
         SubscribeLocalEvent<AccessReaderComponent, LinkAttemptEvent>(OnLinkAttempt);
 
         SubscribeLocalEvent<AccessReaderComponent, ComponentGetState>(OnGetState);
@@ -86,6 +87,13 @@ private void OnEmagged(EntityUid uid, AccessReaderComponent reader, ref GotEmagg
         Dirty(uid, reader);
     }
 
+    private void OnUnEmagged(EntityUid uid, AccessReaderComponent reader, ref GotUnEmaggedEvent args) // Frontier - DEMAG
+    {
+        args.Handled = true;
+        reader.Enabled = true;
+        Dirty(uid, reader);
+    }
+
     /// <summary>
     /// Searches the source for access tags
     /// then compares it with the all targets accesses to see if it is allowed.

Content.Shared/Emag/Components/EmagComponent.cs

@@ -17,4 +17,10 @@ public sealed partial class EmagComponent : Component
     [DataField("emagImmuneTag", customTypeSerializer: typeof(PrototypeIdSerializer<TagPrototype>)), ViewVariables(VVAccess.ReadWrite)]
     [AutoNetworkedField]
     public string EmagImmuneTag = "EmagImmune";
+
+    /// <summary>
+    /// Frontier - Reverse emags
+    /// </summary>
+    [DataField("demag")]
+    public bool Demag = false;
 }

Content.Shared/Emag/Systems/EmagSystem.cs

@@ -56,7 +56,13 @@ public bool TryUseEmag(EntityUid uid, EntityUid user, EntityUid target, EmagComp
             return false;
         }
 
-        var handled = DoEmagEffect(user, target);
+        bool handled;
+
+        if (comp.Demag)
+            handled = DoUnEmagEffect(user, target);
+        else
+            handled = DoEmagEffect(user, target);
+
         if (!handled)
             return false;
 
@@ -86,7 +92,27 @@ public bool DoEmagEffect(EntityUid user, EntityUid target)
             EnsureComp<EmaggedComponent>(target);
         return emaggedEvent.Handled;
     }
+
+    /// <summary>
+    /// Frontier - Does the DEMAG effect on a specified entity
+    /// </summary>
+    public bool DoUnEmagEffect(EntityUid user, EntityUid target)
+    {
+        // prevent unemagging twice
+        if (!HasComp<EmaggedComponent>(target))
+            return false;
+
+        var unEmaggedEvent = new GotUnEmaggedEvent(user);
+        RaiseLocalEvent(target, ref unEmaggedEvent);
+
+        if (unEmaggedEvent.Handled)
+            EntityManager.RemoveComponent<EmaggedComponent>(target);
+        return unEmaggedEvent.Handled;
+    }
 }
 
 [ByRefEvent]
 public record struct GotEmaggedEvent(EntityUid UserUid, bool Handled = false, bool Repeatable = false);
+
+[ByRefEvent]
+public record struct GotUnEmaggedEvent(EntityUid UserUid, bool Handled = false, bool Repeatable = false); // Frontier

Content.Shared/Lock/LockSystem.cs

@@ -14,6 +14,8 @@
 using Robust.Shared.Audio.Systems;
 using Robust.Shared.Utility;
 using Content.Shared._NF.Trade.Components;
+using Content.Shared.Emag.Components;
+using System.Text; // Frontier - DEMAG
 
 namespace Content.Shared.Lock;
 
@@ -39,6 +41,7 @@ public override void Initialize()
         SubscribeLocalEvent<LockComponent, ExaminedEvent>(OnExamined);
         SubscribeLocalEvent<LockComponent, GetVerbsEvent<AlternativeVerb>>(AddToggleLockVerb);
         SubscribeLocalEvent<LockComponent, GotEmaggedEvent>(OnEmagged);
+        SubscribeLocalEvent<LockComponent, GotUnEmaggedEvent>(OnUnEmagged); // Frontier - Added DEMUG
     }
 
     private void OnStartup(EntityUid uid, LockComponent lockComp, ComponentStartup args)
@@ -213,15 +216,28 @@ private void AddToggleLockVerb(EntityUid uid, LockComponent component, GetVerbsE
 
     private void OnEmagged(EntityUid uid, LockComponent component, ref GotEmaggedEvent args)
     {
-        if (component.ImmuneToEmag)
+        if (component.ImmuneToEmag) // Frontier
             return;
 
         if (!component.Locked || !component.BreakOnEmag)
             return;
         _audio.PlayPredicted(component.UnlockSound, uid, null);
         _appearanceSystem.SetData(uid, StorageVisuals.Locked, false);
-        RemComp<LockComponent>(uid); //Literally destroys the lock as a tell it was emagged
+        //RemComp<LockComponent>(uid); //Literally destroys the lock as a tell it was emagged // Frontier - Has to remove this to allow fixing locks
+        component.Locked = false; // Disable lock
         args.Handled = true;
     }
+
+    private void OnUnEmagged(EntityUid uid, LockComponent component, ref GotUnEmaggedEvent args) // Frontier - DEMAG
+    {
+        if (HasComp<EmaggedComponent>(uid))
+        {
+            _audio.PlayPredicted(component.UnlockSound, uid, null, AudioParams.Default.WithVolume(-5));
+            _appearanceSystem.SetData(uid, StorageVisuals.Locked, true);
+            //EnsureComp<LockComponent>(uid); //Literally addes the lock as a tell it was emagged
+            component.Locked = true;
+            args.Handled = true;
+        }
+    }
 }
 

Resources/Prototypes/Catalog/Fills/Lockers/heads.yml

@@ -142,6 +142,7 @@
 #      - id: ClothingHandsGlovesCaptain #TODO replace with new item!
 #      - id: ClothingOuterHardsuitCap #TODO replace with new item!
 #      - id: ClothingMaskGasCaptain #TODO replace with new item!
+      - id: Demag # Frontier
 
 - type: entity
   id: LockerChiefEngineerFilledHardsuit
@@ -346,6 +347,7 @@
       - id: JetpackSecurityFilled # Frontier
       - id: HandheldGPSBasic # Frontier
       - id: ClothingShoesBootsMagCombatFilled # Frontier
+      - id: Demag # Frontier
 
 - type: entity
   id: LockerHeadOfSecurityFilled
@@ -378,12 +380,14 @@
 #      - id: BookSecretDocuments # Frontier
       - id: ClothingNeckMantleHOS # Frontier
       - id: ClothingOuterWinterHoS # Frontier
+      - id: Demag # Frontier
       - id: ClothingShoesBootsWinterHoS # Frontier
 
 - type: entity
   id: LockerFreezerVaultFilled
   suffix: Vault, Locked
   parent: LockerFreezerBase
+  noSpawn: true
   components:
   - type: AccessReader
     access: [ [ "Command" ] ]

Resources/Prototypes/_NF/Entities/Objects/Tools/emag.yml

@@ -0,0 +1,30 @@
+- type: entity
+  parent: BaseItem
+  id: Demag
+  name: cryptographic resequencer
+  description: The all-in-one unhacking solution. The thinking man's lock. The iconic DEMAG fixer.
+  components:
+  - type: Emag
+    demag: true
+  - type: LimitedCharges
+  - type: AutoRecharge
+  - type: Sprite
+    sprite: _NF/Objects/Tools/demag.rsi
+    state: icon
+  - type: Item
+    sprite: _NF/Objects/Tools/demag.rsi
+
+- type: entity
+  parent: BaseItem
+  id: DemagUnlimited
+  suffix: Unlimited
+  name: cryptographic resequencer
+  description: The all-in-one unhacking solution. The thinking man's lock. The iconic DEMAG fixer.
+  components:
+  - type: Emag
+    demag: true
+  - type: Sprite
+    sprite: _NF/Objects/Tools/demag.rsi
+    state: icon
+  - type: Item
+    sprite: _NF/Objects/Tools/demag.rsi

Resources/Textures/_NF/Objects/Tools/demag.rsi/meta.json

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-3.0",
+  "copyright": "Taken from tgstation wiki at https://tgstation13.org/wiki/File:Emag.png, edited by gentlebutter",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "inhand-left",
+      "directions": 4
+    },
+    {
+      "name": "inhand-right",
+      "directions": 4
+    },
+    {
+      "name": "icon"
+    }
+  ]
+}