Shitmed Update 2 - [Insert Snarky Remark]

Content.Client/Options/UI/Tabs/KeyRebindTab.xaml.cs

@@ -256,9 +256,13 @@ void AddCheckBox(string checkBoxName, bool currentState, Action<BaseButton.Butto
             AddButton(ContentKeyFunctions.TargetHead);
             AddButton(ContentKeyFunctions.TargetTorso);
             AddButton(ContentKeyFunctions.TargetLeftArm);
+            AddButton(ContentKeyFunctions.TargetLeftHand);
             AddButton(ContentKeyFunctions.TargetRightArm);
+            AddButton(ContentKeyFunctions.TargetRightHand);
             AddButton(ContentKeyFunctions.TargetLeftLeg);
+            AddButton(ContentKeyFunctions.TargetLeftFoot);
             AddButton(ContentKeyFunctions.TargetRightLeg);
+            AddButton(ContentKeyFunctions.TargetRightFoot);
 
             AddHeader("ui-options-header-misc");
             AddButton(ContentKeyFunctions.TakeScreenshot);

Content.Client/Smoking/MatchstickSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Smoking.Systems;
+
+namespace Content.Client.Smoking;
+
+public sealed class MatchstickSystem : SharedMatchstickSystem;

Content.Client/Speech/Components/OhioAccentComponent.cs

@@ -0,0 +1,6 @@
+namespace Content.Client.Speech.Components;
+
+// We keep this here because of surgery checks being client-side.
+[RegisterComponent]
+public sealed partial class OhioAccentComponent : Component
+{ }

Content.Client/Targeting/TargetingSystem.cs

@@ -32,20 +32,20 @@ public override void Initialize()
             InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.Torso)))
         .Bind(ContentKeyFunctions.TargetLeftArm,
             InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.LeftArm)))
-/*        .Bind(ContentKeyFunctions.TargetLeftHand,
-            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.LeftHand))) SOON :TM: */
+        .Bind(ContentKeyFunctions.TargetLeftHand,
+            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.LeftHand)))
         .Bind(ContentKeyFunctions.TargetRightArm,
             InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.RightArm)))
-/*        .Bind(ContentKeyFunctions.TargetRightHand,
-            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.RightHand)))*/
+        .Bind(ContentKeyFunctions.TargetRightHand,
+            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.RightHand)))
         .Bind(ContentKeyFunctions.TargetLeftLeg,
             InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.LeftLeg)))
-/*        .Bind(ContentKeyFunctions.TargetLeftFoot,
-            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.LeftFoot)))*/
+        .Bind(ContentKeyFunctions.TargetLeftFoot,
+            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.LeftFoot)))
         .Bind(ContentKeyFunctions.TargetRightLeg,
             InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.RightLeg)))
-/*        .Bind(ContentKeyFunctions.TargetRightFoot,
-            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.RightFoot)))*/
+        .Bind(ContentKeyFunctions.TargetRightFoot,
+            InputCmdHandler.FromDelegate((session) => HandleTargetChange(session, TargetBodyPart.RightFoot)))
         .Register<SharedTargetingSystem>();
     }
 

Content.Server/Body/Components/BrainComponent.cs

@@ -5,5 +5,10 @@ namespace Content.Server.Body.Components
     [RegisterComponent, Access(typeof(BrainSystem))]
     public sealed partial class BrainComponent : Component
     {
+        /// <summary>
+        ///     Is this brain currently controlling the entity?
+        /// </summary>
+        [DataField]
+        public bool Active = true;
     }
 }

Content.Server/Body/Systems/BodySystem.cs

@@ -168,6 +168,16 @@ public override HashSet<EntityUid> GibPart(
         return gibs;
     }
 
+    public override bool BurnPart(EntityUid partId, BodyPartComponent? part = null)
+    {
+        if (!Resolve(partId, ref part, logMissing: false)
+            || TerminatingOrDeleted(partId)
+            || EntityManager.IsQueuedForDeletion(partId))
+            return false;
+
+        return base.BurnPart(partId, part);
+    }
+
     protected override void ApplyPartMarkings(EntityUid target, BodyPartAppearanceComponent component)
     {
         return;

Content.Server/Body/Systems/BrainSystem.cs

@@ -2,9 +2,11 @@
 using Content.Server.Ghost.Components;
 using Content.Shared.Body.Components;
 using Content.Shared.Body.Systems;
+using Content.Shared.Body.Systems;
 using Content.Shared.Body.Events;
 using Content.Shared.Body.Organ;
 using Content.Server.DelayedDeath;
+using Content.Server.DelayedDeath;
 using Content.Shared.Mind;
 using Content.Shared.Mind.Components;
 using Content.Shared.Pointing;
@@ -25,29 +27,33 @@ public override void Initialize()
             SubscribeLocalEvent<BrainComponent, PointAttemptEvent>(OnPointAttempt);
         }
 
-        private void HandleRemoval(EntityUid uid, BrainComponent _, ref OrganRemovedFromBodyEvent args)
+        private void HandleRemoval(EntityUid uid, BrainComponent brain, ref OrganRemovedFromBodyEvent args)
         {
             if (TerminatingOrDeleted(uid) || TerminatingOrDeleted(args.OldBody))
                 return;
 
+            brain.Active = false;
             // Prevents revival, should kill the user within a given timespan too.
-            EnsureComp<DebrainedComponent>(args.OldBody);
-            EnsureComp<DelayedDeathComponent>(args.OldBody);
-            HandleMind(uid, args.OldBody);
+            if (!CheckOtherBrains(args.OldBody))
+            {
+                EnsureComp<DebrainedComponent>(args.OldBody);
+                HandleMind(uid, args.OldBody);
+            }
         }
 
-        private void HandleAddition(EntityUid uid, BrainComponent _, ref OrganAddedToBodyEvent args)
+        private void HandleAddition(EntityUid uid, BrainComponent brain, ref OrganAddedToBodyEvent args)
         {
             if (TerminatingOrDeleted(uid) || TerminatingOrDeleted(args.Body))
                 return;
 
-            RemComp<DebrainedComponent>(args.Body);
-            if (_bodySystem.TryGetBodyOrganComponents<HeartComponent>(args.Body, out var _))
-                RemComp<DelayedDeathComponent>(args.Body);
-            HandleMind(args.Body, uid);
+            if (!CheckOtherBrains(args.Body))
+            {
+                RemComp<DebrainedComponent>(args.Body);
+                HandleMind(args.Body, uid, brain);
+            }
         }
 
-        private void HandleMind(EntityUid newEntity, EntityUid oldEntity)
+        private void HandleMind(EntityUid newEntity, EntityUid oldEntity, BrainComponent? brain = null)
         {
             if (TerminatingOrDeleted(newEntity) || TerminatingOrDeleted(oldEntity))
                 return;
@@ -63,11 +69,36 @@ private void HandleMind(EntityUid newEntity, EntityUid oldEntity)
                 return;
 
             _mindSystem.TransferTo(mindId, newEntity, mind: mind);
+            if (brain != null)
+                brain.Active = true;
         }
 
         private void OnPointAttempt(Entity<BrainComponent> ent, ref PointAttemptEvent args)
         {
             args.Cancel();
         }
+
+        private bool CheckOtherBrains(EntityUid entity)
+        {
+            var hasOtherBrains = false;
+            if (TryComp<BodyComponent>(entity, out var body))
+            {
+                if (TryComp<BrainComponent>(entity, out var bodyBrain))
+                    hasOtherBrains = true;
+                else
+                {
+                    foreach (var (organ, _) in _bodySystem.GetBodyOrgans(entity, body))
+                    {
+                        if (TryComp<BrainComponent>(organ, out var brain) && brain.Active)
+                        {
+                            hasOtherBrains = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return hasOtherBrains;
+        }
     }
 }

Content.Server/Body/Systems/DebrainedSystem.cs

@@ -0,0 +1,62 @@
+using Content.Shared.Body.Systems;
+using Content.Shared.Body.Organ;
+using Content.Server.DelayedDeath;
+using Content.Shared.Mind;
+using Content.Server.Popups;
+using Content.Shared.Speech;
+using Content.Shared.Standing;
+using Content.Shared.Stunnable;
+
+namespace Content.Server.Body.Systems;
+
+/// <summary>
+///     This system handles behavior on entities when they lose their head or their brains are removed.
+///     MindComponent fuckery should still be mainly handled on BrainSystem as usual.
+/// </summary>
+public sealed class DebrainedSystem : EntitySystem
+{
+    [Dependency] private readonly SharedBodySystem _bodySystem = default!;
+    [Dependency] private readonly PopupSystem _popupSystem = default!;
+    [Dependency] private readonly StandingStateSystem _standingSystem = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<DebrainedComponent, ComponentInit>(OnComponentInit);
+        SubscribeLocalEvent<DebrainedComponent, ComponentRemove>(OnComponentRemove);
+        SubscribeLocalEvent<DebrainedComponent, SpeakAttemptEvent>(OnSpeakAttempt);
+        SubscribeLocalEvent<DebrainedComponent, StandAttemptEvent>(OnStandAttempt);
+    }
+
+    private void OnComponentInit(EntityUid uid, DebrainedComponent _, ComponentInit args)
+    {
+        if (TerminatingOrDeleted(uid))
+            return;
+
+        EnsureComp<DelayedDeathComponent>(uid);
+        EnsureComp<StunnedComponent>(uid);
+        _standingSystem.Down(uid);
+    }
+
+    private void OnComponentRemove(EntityUid uid, DebrainedComponent _, ComponentRemove args)
+    {
+        if (TerminatingOrDeleted(uid))
+            return;
+
+        RemComp<DelayedDeathComponent>(uid);
+        RemComp<StunnedComponent>(uid);
+        if (_bodySystem.TryGetBodyOrganComponents<HeartComponent>(uid, out var _))
+            RemComp<DelayedDeathComponent>(uid);
+    }
+
+    private void OnSpeakAttempt(EntityUid uid, DebrainedComponent _, SpeakAttemptEvent args)
+    {
+        _popupSystem.PopupEntity(Loc.GetString("speech-muted"), uid, uid);
+        args.Cancel();
+    }
+
+    private void OnStandAttempt(EntityUid uid, DebrainedComponent _, StandAttemptEvent args)
+    {
+        args.Cancel();
+    }
+}

Content.Server/Body/Systems/EyesSystem.cs

@@ -0,0 +1,87 @@
+using Content.Server.Body.Components;
+using Content.Shared.Body.Components;
+using Content.Shared.Body.Events;
+using Content.Shared.Body.Organ;
+using Content.Shared.Eye.Blinding.Components;
+using Content.Shared.Eye.Blinding.Systems;
+
+namespace Content.Server.Body.Systems
+{
+    public sealed class EyesSystem : EntitySystem
+    {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly BlindableSystem _blindableSystem = default!;
+        [Dependency] private readonly BodySystem _bodySystem = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<EyesComponent, OrganEnabledEvent>(OnOrganEnabled);
+            SubscribeLocalEvent<EyesComponent, OrganDisabledEvent>(OnOrganDisabled);
+        }
+
+        private void HandleSight(EntityUid newEntity, EntityUid oldEntity)
+        {
+            if (TerminatingOrDeleted(newEntity) || TerminatingOrDeleted(oldEntity))
+                return;
+
+            BlindableComponent? newSight;
+            BlindableComponent? oldSight;
+            //transfer existing component to organ
+            if (!TryComp(newEntity, out newSight))
+                newSight = EnsureComp<BlindableComponent>(newEntity);
+
+            if (!TryComp(oldEntity, out oldSight))
+                oldSight = EnsureComp<BlindableComponent>(oldEntity);
+
+            //give new sight all values of old sight
+            _blindableSystem.TransferBlindness(newSight, oldSight, newEntity);
+
+            var hasOtherEyes = false;
+            //check for other eye components on owning body and owning body organs (if old entity has a body)
+            if (TryComp<BodyComponent>(oldEntity, out var body))
+            {
+                if (TryComp<EyesComponent>(oldEntity, out var bodyEyes)) //some bodies see through their skin!!! (slimes)
+                    hasOtherEyes = true;
+                else
+                {
+                    foreach (var (organ, _) in _bodySystem.GetBodyOrgans(oldEntity, body))
+                    {
+                        if (TryComp<EyesComponent>(organ, out var eyes))
+                        {
+                            hasOtherEyes = true;
+                            break;
+                        }
+                    }
+                    //TODO (MS14): Should we do this for body parts too? might be a little overpowered but could be funny/interesting
+                }
+            }
+
+            //if there are no existing eye components for the old entity - set old sight to be blind otherwise leave it as is
+            if (!hasOtherEyes && !TryComp<EyesComponent>(oldEntity, out var self))
+                _blindableSystem.AdjustEyeDamage((oldEntity, oldSight), oldSight.MaxDamage);
+
+        }
+
+        private void OnOrganEnabled(EntityUid uid, EyesComponent component, OrganEnabledEvent args)
+        {
+            if (TerminatingOrDeleted(uid)
+            || args.Organ.Comp.Body is not { Valid: true } body)
+                return;
+
+            RemComp<TemporaryBlindnessComponent>(body);
+            HandleSight(uid, body);
+        }
+
+        private void OnOrganDisabled(EntityUid uid, EyesComponent component, OrganDisabledEvent args)
+        {
+            if (TerminatingOrDeleted(uid)
+            || args.Organ.Comp.Body is not { Valid: true } body)
+                return;
+
+            EnsureComp<TemporaryBlindnessComponent>(body);
+            HandleSight(body, uid);
+        }
+    }
+}

Content.Server/Cybernetics/CyberneticsSystem.cs

@@ -0,0 +1,54 @@
+using Content.Server.Emp;
+using Content.Server.Body.Systems;
+using Content.Shared.Body.Part;
+using Content.Shared.Body.Organ;
+using Content.Shared.Cybernetics;
+
+namespace Content.Server.Cybernetics;
+
+internal sealed class CyberneticsSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<CyberneticsComponent, EmpPulseEvent>(OnEmpPulse);
+        SubscribeLocalEvent<CyberneticsComponent, EmpDisabledRemoved>(OnEmpDisabledRemoved);
+    }
+    private void OnEmpPulse(Entity<CyberneticsComponent> cyberEnt, ref EmpPulseEvent ev)
+    {
+        if (!cyberEnt.Comp.Disabled)
+        {
+            ev.Affected = true;
+            ev.Disabled = true;
+            cyberEnt.Comp.Disabled = true;
+
+            if (HasComp<OrganComponent>(cyberEnt))
+            {
+                var disableEvent = new OrganEnableChangedEvent(false);
+                RaiseLocalEvent(cyberEnt, ref disableEvent);
+            }
+            else if (HasComp<BodyPartComponent>(cyberEnt))
+            {
+                var disableEvent = new BodyPartEnableChangedEvent(false);
+                RaiseLocalEvent(cyberEnt, ref disableEvent);
+            }
+        }
+    }
+
+    private void OnEmpDisabledRemoved(Entity<CyberneticsComponent> cyberEnt, ref EmpDisabledRemoved ev)
+    {
+        if (cyberEnt.Comp.Disabled)
+        {
+            cyberEnt.Comp.Disabled = false;
+            if (HasComp<OrganComponent>(cyberEnt))
+            {
+                var enableEvent = new OrganEnableChangedEvent(true);
+                RaiseLocalEvent(cyberEnt, ref enableEvent);
+            }
+            else if (HasComp<BodyPartComponent>(cyberEnt))
+            {
+                var enableEvent = new BodyPartEnableChangedEvent(true);
+                RaiseLocalEvent(cyberEnt, ref enableEvent);
+            }
+        }
+    }
+}