surgery refucktoring

Content.Server/_Starlight/Medical/Surgery/ImplantSystem.cs

@@ -11,12 +11,12 @@ public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<OrganImplantComponent, SurgeryOrganInsertCompleted>(OnOrganInsertComplete);
+        SubscribeLocalEvent<OrganImplantComponent, SurgeryOrganImplantationCompleted>(OnOrganInsertComplete);
 
         SubscribeLocalEvent<OrganImplantComponent, SurgeryOrganExtractCompleted>(OnOrganExtractComplete);
     }
 
-    private void OnOrganInsertComplete(Entity<OrganImplantComponent> ent, ref SurgeryOrganInsertCompleted args)
+    private void OnOrganInsertComplete(Entity<OrganImplantComponent> ent, ref SurgeryOrganImplantationCompleted args)
     {
         foreach (var comp in (ent.Comp.AddComp ?? []).Values)
         {

Content.Server/_Starlight/Medical/Surgery/SurgeryOrganSystem.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Content.Shared.Damage;
+using Content.Shared.Eye.Blinding.Components;
+using Content.Shared.Eye.Blinding.Systems;
+using Content.Shared.Interaction;
+using Content.Shared.Speech.Muting;
+using Content.Shared.Starlight.Antags.Abductor;
+using Content.Shared.Starlight.Medical.Surgery.Effects.Step;
+using Content.Shared.Starlight.Medical.Surgery.Events;
+using Content.Shared.Starlight.Medical.Surgery.Steps.Parts;
+using Content.Shared.VentCraw;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server._Starlight.Medical.Surgery;
+public sealed partial class SurgeryOrganSystem : EntitySystem
+{
+
+    [Dependency] private readonly BlindableSystem _blindable = default!;
+    [Dependency] private readonly DamageableSystem _damageableSystem = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<OrganEyesComponent, SurgeryOrganImplantationCompleted>(OnEyeImplanted);
+        SubscribeLocalEvent<OrganTongueComponent, SurgeryOrganImplantationCompleted>(OnTongueImplanted);
+        SubscribeLocalEvent<AbductorOrganComponent, SurgeryOrganImplantationCompleted>(OnAbductorOrganImplanted);
+        SubscribeLocalEvent<DamageableComponent, SurgeryOrganImplantationCompleted>(OnOrganImplanted);
+
+        SubscribeLocalEvent<OrganEyesComponent, SurgeryOrganExtractCompleted>(OnOrganExtracted);
+        SubscribeLocalEvent<OrganTongueComponent, SurgeryOrganExtractCompleted>(OnTongueExtracted);
+        SubscribeLocalEvent<AbductorOrganComponent, SurgeryOrganExtractCompleted>(OnAbductorOrganExtracted);
+        SubscribeLocalEvent<DamageableComponent, SurgeryOrganExtractCompleted>(OnOrganExtracted);
+    }
+
+    private void OnOrganExtracted(Entity<DamageableComponent> ent, ref SurgeryOrganExtractCompleted args)
+    {
+        if (!TryComp<OrganDamageComponent>(ent.Owner, out var damageRule)
+         || damageRule.Damage is null
+         || !TryComp<DamageableComponent>(args.Body, out var bodyDamageable)) return;
+
+        var change = _damageableSystem.TryChangeDamage(args.Body, damageRule.Damage.Invert(), true, false, bodyDamageable);
+        if (change is not null)
+            _damageableSystem.TryChangeDamage(ent.Owner, change.Invert(), true, false, ent.Comp);
+    }
+
+    private void OnAbductorOrganExtracted(Entity<AbductorOrganComponent> ent, ref SurgeryOrganExtractCompleted args)
+    {
+        if (TryComp<AbductorVictimComponent>(args.Body, out var victim))
+            if (victim.Organ == ent.Comp.Organ)
+                victim.Organ = AbductorOrganType.None;
+
+        if (ent.Comp.Organ == AbductorOrganType.Vent)
+            RemComp<VentCrawlerComponent>(args.Body);
+    }
+
+    private void OnTongueExtracted(Entity<OrganTongueComponent> ent, ref SurgeryOrganExtractCompleted args)
+    {
+        ent.Comp.IsMuted = HasComp<MutedComponent>(args.Body);
+        AddComp<MutedComponent>(args.Body);
+    }
+
+    private void OnOrganExtracted(Entity<OrganEyesComponent> ent, ref SurgeryOrganExtractCompleted args)
+    {
+        if (!TryComp<BlindableComponent>(args.Body, out var blindable)) return;
+
+        ent.Comp.EyeDamage = blindable.EyeDamage;
+        ent.Comp.MinDamage = blindable.MinDamage;
+        _blindable.UpdateIsBlind((args.Body, blindable));
+    }
+
+    private void OnOrganImplanted(Entity<DamageableComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    {
+        if (!TryComp<DamageableComponent>(args.Body, out var bodyDamageable)) return;
+
+        var change = _damageableSystem.TryChangeDamage(args.Body, ent.Comp.Damage, true, false, bodyDamageable);
+        if (change is not null)
+            _damageableSystem.TryChangeDamage(ent.Owner, change.Invert(), true, false, ent.Comp);
+    }
+    private void OnAbductorOrganImplanted(Entity<AbductorOrganComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    {
+        if (TryComp<AbductorVictimComponent>(args.Body, out var victim))
+            victim.Organ = ent.Comp.Organ;
+        if (ent.Comp.Organ == AbductorOrganType.Vent)
+            AddComp<VentCrawlerComponent>(args.Body);
+    }
+
+    private void OnTongueImplanted(Entity<OrganTongueComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    {
+        if (HasComp<AbductorComponent>(args.Body) || !ent.Comp.IsMuted) return;
+        RemComp<MutedComponent>(args.Body);
+    }
+
+    private void OnEyeImplanted(Entity<OrganEyesComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    {
+        if (!TryComp<BlindableComponent>(args.Body, out var blindable)) return;
+
+        _blindable.SetMinDamage((args.Body, blindable), ent.Comp.MinDamage ?? 0);
+        _blindable.AdjustEyeDamage((args.Body, blindable), (ent.Comp.EyeDamage ?? 0) - blindable.MaxDamage);
+    }
+}

Content.Server/_Starlight/Medical/Surgery/SurgerySystem.Steps.cs

@@ -79,16 +79,16 @@ private void OnStepOrganInsertComplete(Entity<SurgeryStepOrganInsertComponent> e
         if (args.Tools.Count == 0
             || !(args.Tools.FirstOrDefault() is var organId)
             || !TryComp<BodyPartComponent>(args.Part, out var bodyPart))
-                return;
-                
+            return;
+
         var containerId = SharedBodySystem.GetOrganContainerId(ent.Comp.Slot);
-            
+
         if (ent.Comp.Slot == "cavity" && _containers.TryGetContainer(args.Part, containerId, out var container))
         {
             _containers.Insert(organId, container);
             return;
         }
-        
+
         if (!TryComp<OrganComponent>(organId, out var organComp))
             return;
 
@@ -97,94 +97,36 @@ private void OnStepOrganInsertComplete(Entity<SurgeryStepOrganInsertComponent> e
         _delayAccumulator = 0;
         _delayQueue.Enqueue(() =>
         {
-            if (_body.InsertOrgan(part, organId, ent.Comp.Slot, bodyPart, organComp) // todo move to system
-            && TryComp<DamageableComponent>(organId, out var organDamageable)
-            && TryComp<DamageableComponent>(body, out var bodyDamageable))
-            {
-                var ev = new SurgeryOrganInsertCompleted(body, part, organId);
-                RaiseLocalEvent(organId, ref ev);
-
-                if (TryComp<OrganEyesComponent>(organId, out var organEyes)
-                    && TryComp<BlindableComponent>(body, out var blindable))
-                {
-                    _blindable.SetMinDamage((body, blindable), organEyes.MinDamage ?? 0);
-                    _blindable.AdjustEyeDamage((body, blindable), (organEyes.EyeDamage ?? 0) - blindable.MaxDamage);
-                }
-                if (TryComp<AbductorOrganComponent>(organId, out var abductorOrgan))
-                {
-                    if (TryComp<AbductorVictimComponent>(body, out var victim))
-                        victim.Organ = abductorOrgan.Organ;
-                    if (abductorOrgan.Organ == AbductorOrganType.Vent)
-                        AddComp<VentCrawlerComponent>(body);
-                }
-                if (TryComp<OrganTongueComponent>(organId, out var organTongue)
-                    && !organTongue.IsMuted)
-                    RemComp<MutedComponent>(body);
+            if (!_body.InsertOrgan(part, organId, ent.Comp.Slot, bodyPart, organComp)) return;
 
-                var change = _damageableSystem.TryChangeDamage(body, organDamageable.Damage, true, false, bodyDamageable);
-                if (change is not null)
-                    _damageableSystem.TryChangeDamage(organId, change.Invert(), true, false, organDamageable);
-            }
+            var ev = new SurgeryOrganImplantationCompleted(body, part, organId);
+            RaiseLocalEvent(organId, ref ev);
         });
     }
     private void OnStepOrganExtractComplete(Entity<SurgeryStepOrganExtractComponent> ent, ref SurgeryStepEvent args)
     {
         if (ent.Comp.Organ?.Count != 1) return;
-        
+
         var type = ent.Comp.Organ.Values.First().Component.GetType();
-        
+
         if (ent.Comp.Slot != null && _containers.TryGetContainer(args.Part, SharedBodySystem.GetOrganContainerId(ent.Comp.Slot), out var container))
         {
-
             foreach (var containedEnt in container.ContainedEntities)
-            {
                 if (HasComp(containedEnt, type))
                     _containers.Remove(containedEnt, container);
-            }
-
+
             return;
         }
-        
+
         var organs = _body.GetPartOrgans(args.Part, Comp<BodyPartComponent>(args.Part));
-        foreach (var organ in organs) // todo move to system
+        foreach (var organ in organs) 
         {
-            if (HasComp(organ.Id, type))
-            {
-                var ev = new SurgeryOrganExtractCompleted(args.Body, args.Part, organ.Id);
-                RaiseLocalEvent(organ.Id, ref ev);
-
-                if (_body.RemoveOrgan(organ.Id, organ.Component)
-                    && TryComp<OrganDamageComponent>(organ.Id, out var damageRule)
-                    && damageRule.Damage is not null
-                    && TryComp<DamageableComponent>(organ.Id, out var organDamageable)
-                    && TryComp<DamageableComponent>(args.Body, out var bodyDamageable))
-                {
-                    if (TryComp<OrganEyesComponent>(organ.Id, out var organEyes)
-                        && TryComp<BlindableComponent>(args.Body, out var blindable))
-                    {
-                        organEyes.EyeDamage = blindable.EyeDamage;
-                        organEyes.MinDamage = blindable.MinDamage;
-                        _blindable.UpdateIsBlind((args.Body, blindable));
-                    }
-                    if (TryComp<OrganTongueComponent>(organ.Id, out var organTongue))
-                    {
-                        organTongue.IsMuted = HasComp<MutedComponent>(args.Body);
-                        AddComp<MutedComponent>(args.Body);
-                    }
-                    if (TryComp<AbductorOrganComponent>(organ.Id, out var abductorOrgan))
-                    {
-                        if (TryComp<AbductorVictimComponent>(args.Body, out var victim))
-                            if (victim.Organ == abductorOrgan.Organ)
-                                victim.Organ = AbductorOrganType.None;
-                        if (abductorOrgan.Organ == AbductorOrganType.Vent)
-                            RemComp<VentCrawlerComponent>(args.Body);
-                    }
-                    var change = _damageableSystem.TryChangeDamage(args.Body, damageRule.Damage.Invert(), true, false, bodyDamageable);
-                    if (change is not null)
-                        _damageableSystem.TryChangeDamage(organ.Id, change.Invert(), true, false, organDamageable);
-                }
-                return;
-            }
+            if (!HasComp(organ.Id, type) || !_body.RemoveOrgan(organ.Id, organ.Component)) continue;
+
+            var ev = new SurgeryOrganExtractCompleted(args.Body, args.Part, organ.Id);
+            RaiseLocalEvent(organ.Id, ref ev);
+
+            return;
         }
     }
 

Content.Shared/_Starlight/Medical/Surgery/Components/_Organs.cs

@@ -11,14 +11,14 @@ namespace Content.Shared.Starlight.Medical.Surgery.Steps.Parts;
 [RegisterComponent, NetworkedComponent, Access(typeof(SharedSurgerySystem))] public sealed partial class OrganStomachComponent : Component;
 [RegisterComponent, NetworkedComponent, Access(typeof(SharedSurgerySystem))] public sealed partial class OrganLiverComponent : Component;
 [RegisterComponent, NetworkedComponent, Access(typeof(SharedSurgerySystem))] public sealed partial class OrganKidneysComponent : Component;
-[RegisterComponent, NetworkedComponent, Access(typeof(SharedSurgerySystem))] 
+[RegisterComponent, NetworkedComponent] 
 public sealed partial class OrganTongueComponent : Component
 {
     [DataField]
     public bool IsMuted;
 }
 
-[RegisterComponent, NetworkedComponent, Access(typeof(SharedSurgerySystem))] 
+[RegisterComponent, NetworkedComponent] 
 public sealed partial class OrganEyesComponent : Component
 {
     [DataField]
@@ -34,7 +34,7 @@ public sealed partial class OrganImplantComponent : Component
     public ComponentRegistry? AddComp;
 }
 
-[RegisterComponent, NetworkedComponent, Access(typeof(SharedSurgerySystem))]
+[RegisterComponent, NetworkedComponent]
 public sealed partial class OrganDamageComponent : Component
 {
     [DataField]

Content.Shared/_Starlight/Medical/Surgery/Events/SurgeryOrganInsertCompleted.cs → Content.Shared/_Starlight/Medical/Surgery/Events/SurgeryOrganImplantationCompleted.cs

@@ -4,6 +4,6 @@ namespace Content.Shared.Starlight.Medical.Surgery.Events;
 // Based on the RMC14.
 // https://github.com/RMC-14/RMC-14
 [ByRefEvent]
-public record struct SurgeryOrganInsertCompleted(EntityUid Body, EntityUid Part, EntityUid Organ);
+public record struct SurgeryOrganImplantationCompleted(EntityUid Body, EntityUid Part, EntityUid Organ);
 [ByRefEvent]
 public record struct SurgeryOrganExtractCompleted(EntityUid Body, EntityUid Part, EntityUid Organ);

Resources/Textures/_Starlight/Mobs/Species/Cyberlimbs/parts.rsi/meta.json

@@ -155,6 +155,10 @@
           2.0
         ]
       ]
+    },
+    {
+      "name": "eyes",
+      "directions": 4
     }
   ]
 }