Yet another shitmed update (DeltaV-Station#1104)

Content.Shared/Body/Organ/OrganComponent.cs

@@ -2,12 +2,13 @@
 using Robust.Shared.Containers;
 using Robust.Shared.GameStates;
 using Robust.Shared.Prototypes; // Shitmed Change
+using Content.Shared._Shitmed.Medical.Surgery; // Shitmed Change
 using Content.Shared._Shitmed.Medical.Surgery.Tools; // Shitmed Change
 
 namespace Content.Shared.Body.Organ;
 
 [RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
-[Access(typeof(SharedBodySystem))]
+[Access(typeof(SharedBodySystem), typeof(SharedSurgerySystem))] // Shitmed Change
 public sealed partial class OrganComponent : Component, ISurgeryToolComponent // Shitmed Change
 {
     /// <summary>
@@ -52,7 +53,7 @@ public sealed partial class OrganComponent : Component, ISurgeryToolComponent //
     public ComponentRegistry? OnAdd;
 
     /// <summary>
-    ///     When removed, the organ will ensure these components on the entity, and add them on removal.
+    ///     When removed, the organ will ensure these components on the entity, and delete them on insertion.
     /// </summary>
     [DataField]
     public ComponentRegistry? OnRemove;

Content.Shared/Body/Systems/SharedBodySystem.Body.cs

@@ -456,7 +456,6 @@ private void OnProfileLoadFinished(EntityUid uid, BodyComponent component, Profi
             || !Initialized(uid)) // We do this last one for urists on test envs.
             return;
 
-        Logger.Debug($"{ToPrettyString(uid)}: ProfileLoadFinished with {HasComp<HumanoidAppearanceComponent>(uid)} and {component}");
         foreach (var part in GetBodyChildren(uid, component))
             EnsureComp<BodyPartAppearanceComponent>(part.Id);
     }

Content.Shared/Stealth/Components/StealthComponent.cs

@@ -79,12 +79,14 @@ public sealed class StealthComponentState : ComponentState
 {
     public readonly float Visibility;
     public readonly TimeSpan? LastUpdated;
+    public readonly float MaxVisibility; // Shitmed Change
     public readonly bool Enabled;
 
-    public StealthComponentState(float stealthLevel, TimeSpan? lastUpdated, bool enabled)
+    public StealthComponentState(float stealthLevel, TimeSpan? lastUpdated, float maxVisibility, bool enabled)
     {
         Visibility = stealthLevel;
         LastUpdated = lastUpdated;
+        MaxVisibility = maxVisibility; // Shitmed Change
         Enabled = enabled;
     }
 }

Content.Shared/Stealth/SharedStealthSystem.cs

@@ -98,7 +98,7 @@ protected virtual void OnInit(EntityUid uid, StealthComponent component, Compone
 
     private void OnStealthGetState(EntityUid uid, StealthComponent component, ref ComponentGetState args)
     {
-        args.State = new StealthComponentState(component.LastVisibility, component.LastUpdated, component.Enabled);
+        args.State = new StealthComponentState(component.LastVisibility, component.LastUpdated, component.MaxVisibility, component.Enabled); // Shitmed Change
     }
 
     private void OnStealthHandleState(EntityUid uid, StealthComponent component, ref ComponentHandleState args)
@@ -109,6 +109,7 @@ private void OnStealthHandleState(EntityUid uid, StealthComponent component, ref
         SetEnabled(uid, cast.Enabled, component);
         component.LastVisibility = cast.Visibility;
         component.LastUpdated = cast.LastUpdated;
+        component.MaxVisibility = cast.MaxVisibility; // Shitmed Change
     }
 
     private void OnMove(EntityUid uid, StealthOnMoveComponent component, ref MoveEvent args)

Content.Shared/Weapons/Ranged/Components/BatteryAmmoProviderComponent.cs

@@ -5,7 +5,7 @@ public abstract partial class BatteryAmmoProviderComponent : AmmoProviderCompone
     /// <summary>
     /// How much battery it costs to fire once.
     /// </summary>
-    [DataField("fireCost"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField("fireCost")] // Shitmed Change
     public float FireCost = 100;
 
     // Batteries aren't predicted which means we need to track the battery and manually count it ourselves woo!
@@ -15,4 +15,4 @@ public abstract partial class BatteryAmmoProviderComponent : AmmoProviderCompone
 
     [ViewVariables(VVAccess.ReadWrite)]
     public int Capacity;
-}
+}

Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Battery.cs

@@ -36,16 +36,24 @@ private void OnBatteryHandleState(EntityUid uid, BatteryAmmoProviderComponent co
         component.Capacity = state.MaxShots;
         component.FireCost = state.FireCost;
         UpdateAmmoCount(uid, prediction: false);
+
+        if (component is HitscanBatteryAmmoProviderComponent hitscan && state.Prototype != null) // Shitmed Change
+            hitscan.Prototype = state.Prototype;
     }
 
     private void OnBatteryGetState(EntityUid uid, BatteryAmmoProviderComponent component, ref ComponentGetState args)
     {
-        args.State = new BatteryAmmoProviderComponentState()
+        var state = new BatteryAmmoProviderComponentState() // Shitmed Change
         {
             Shots = component.Shots,
             MaxShots = component.Capacity,
             FireCost = component.FireCost,
         };
+
+        if (TryComp<HitscanBatteryAmmoProviderComponent>(uid, out var hitscan)) // Shitmed Change
+           state.Prototype = hitscan.Prototype;
+
+        args.State = state; // Shitmed Change
     }
 
     private void OnBatteryExamine(EntityUid uid, BatteryAmmoProviderComponent component, ExaminedEvent args)
@@ -116,5 +124,6 @@ private sealed class BatteryAmmoProviderComponentState : ComponentState
         public int Shots;
         public int MaxShots;
         public float FireCost;
+        public string? Prototype; // Shitmed Change
     }
 }

Content.Shared/_Shitmed/Abilities/Goliath/GoliathTentacleComponent.cs

@@ -0,0 +1,18 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Shared._Shitmed.GoliathTentacle;
+
+/// <summary>
+/// Component that grants the entity the ability to use goliath tentacles.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class GoliathTentacleComponent : Component
+{
+    [DataField(customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
+    public string? Action = "ActionGoliathTentacleCrew";
+
+    [DataField, AutoNetworkedField]
+    public EntityUid? ActionEntity;
+}

Content.Shared/_Shitmed/Abilities/Goliath/GoliathTentacleSystem.cs

@@ -0,0 +1,23 @@
+using Content.Shared.Actions;
+
+namespace Content.Shared._Shitmed.GoliathTentacle;
+
+internal sealed class GoliathTentacleSystem : EntitySystem
+{
+    [Dependency] private readonly SharedActionsSystem _actionsSystem = default!;
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<GoliathTentacleComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<GoliathTentacleComponent, ComponentShutdown>(OnShutdown);
+    }
+
+    private void OnStartup(EntityUid uid, GoliathTentacleComponent component, ComponentStartup args)
+    {
+        _actionsSystem.AddAction(uid, ref component.ActionEntity, component.Action);
+    }
+
+    private void OnShutdown(EntityUid uid, GoliathTentacleComponent component, ComponentShutdown args)
+    {
+        _actionsSystem.RemoveAction(uid, component.ActionEntity);
+    }
+}

Content.Shared/_Shitmed/Surgery/Conditions/SurgeryBodyComponentConditionComponent.cs

@@ -0,0 +1,24 @@
+using Content.Shared.Body.Part;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._Shitmed.Medical.Surgery.Conditions;
+
+// <summary>
+//   What components are necessary in the body for the surgery to be valid.
+// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class SurgeryBodyComponentConditionComponent : Component
+{
+    // <summary>
+    //   The components to check for.
+    // </summary>
+    [DataField(required: true)]
+    public ComponentRegistry Components;
+
+    // <summary>
+    //   If true, the lack of these components will instead make the surgery valid.
+    // </summary>
+    [DataField]
+    public bool Inverse = false;
+}

Content.Shared/_Shitmed/Surgery/Conditions/SurgeryOrganOnAddConditionComponent.cs

@@ -0,0 +1,26 @@
+using Content.Shared.Body.Part;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._Shitmed.Medical.Surgery.Conditions;
+
+// <summary>
+//   What components are necessary in the part's organs' OnAdd fields for the surgery to be valid.
+//
+//   Not all components need to be present (or missing for Inverse = true). At least one component matching (or missing) can make the surgery valid.
+// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class SurgeryOrganOnAddConditionComponent : Component
+{
+    // <summary>
+    //   The components to check for on each organ, with the key being the organ's SlotId.
+    // </summary>
+    [DataField(required: true)]
+    public Dictionary<string, ComponentRegistry> Components;
+
+    // <summary>
+    //   If true, the lack of these components will instead make the surgery valid.
+    // </summary>
+    [DataField]
+    public bool Inverse = false;
+}

Content.Shared/_Shitmed/Surgery/Conditions/SurgeryPartComponentConditionComponent.cs

@@ -0,0 +1,24 @@
+using Content.Shared.Body.Part;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared._Shitmed.Medical.Surgery.Conditions;
+
+// <summary>
+//   What components are necessary in the targeted body part for the surgery to be valid.
+// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class SurgeryPartComponentConditionComponent : Component
+{
+    // <summary>
+    //   The components to check for.
+    // </summary>
+    [DataField(required: true)]
+    public ComponentRegistry Components;
+
+    // <summary>
+    //   If true, the lack of these components will instead make the surgery valid.
+    // </summary>
+    [DataField]
+    public bool Inverse = false;
+}

Content.Shared/_Shitmed/Surgery/SharedSurgerySystem.Steps.cs

@@ -4,6 +4,7 @@
 using Content.Shared.Body.Part;
 using Content.Shared.Body.Organ;
 using Content.Shared.Body.Events;
+using Content.Shared._Shitmed.BodyEffects;
 using Content.Shared._Shitmed.Body.Events;
 using Content.Shared.Buckle.Components;
 using Content.Shared.Containers.ItemSlots;
@@ -123,6 +124,47 @@ private void OnToolStep(Entity<SurgeryStepComponent> ent, ref SurgeryStepEvent a
             }
         }
 
+        // Dude this fucking function is so bloated now what the fuck.
+        if (ent.Comp.AddOrganOnAdd != null)
+        {
+            var organSlotIdToOrgan = _body.GetPartOrgans(args.Part).ToDictionary(o => o.Item2.SlotId, o => o);
+
+            foreach (var (organSlotId, compsToAdd) in ent.Comp.AddOrganOnAdd)
+            {
+                if (!organSlotIdToOrgan.TryGetValue(organSlotId, out var organValue))
+                    continue;
+                var (organId, organ) = organValue;
+
+                organ.OnAdd ??= new();
+
+                foreach (var (key, compToAdd) in compsToAdd)
+                    organ.OnAdd[key] = compToAdd;
+
+                EnsureComp<OrganEffectComponent>(organId);
+                RaiseLocalEvent(organId, new OrganComponentsModifyEvent(args.Body, true));
+            }
+        }
+
+        if (ent.Comp.RemoveOrganOnAdd != null)
+        {
+            var organSlotIdToOrgan = _body.GetPartOrgans(args.Part).ToDictionary(o => o.Item2.SlotId, o => o);
+
+            foreach (var (organSlotId, compsToRemove) in ent.Comp.RemoveOrganOnAdd)
+            {
+                if (!organSlotIdToOrgan.TryGetValue(organSlotId, out var organValue) ||
+                    organValue.Item2.OnAdd == null)
+                    continue;
+                var (organId, organ) = organValue;
+
+                // Need to raise this event first before removing the component entries so
+                // OrganEffectSystem still knows which components on the body to remove
+                RaiseLocalEvent(organId, new OrganComponentsModifyEvent(args.Body, false));
+                foreach (var key in compsToRemove.Keys)
+                    organ.OnAdd.Remove(key);
+            }
+        }
+
+
         //if (!HasComp<ForcedSleepingComponent>(args.Body))
         //    //RaiseLocalEvent(args.Body, new MoodEffectEvent("SurgeryPain"));
         // No mood on Goob :(
@@ -188,6 +230,38 @@ private void OnToolCheck(Entity<SurgeryStepComponent> ent, ref SurgeryStepComple
                 }
             }
         }
+
+        if (ent.Comp.AddOrganOnAdd != null)
+        {
+            var organSlotIdToOrgan = _body.GetPartOrgans(args.Part).ToDictionary(o => o.Item2.SlotId, o => o.Item2);
+            foreach (var (organSlotId, compsToAdd) in ent.Comp.AddOrganOnAdd)
+            {
+                if (!organSlotIdToOrgan.TryGetValue(organSlotId, out var organ))
+                    continue;
+
+                if (organ.OnAdd == null || compsToAdd.Keys.Any(key => !organ.OnAdd.ContainsKey(key)))
+                {
+                    args.Cancelled = true;
+                    return;
+                }
+            }
+        }
+
+        if (ent.Comp.RemoveOrganOnAdd != null)
+        {
+            var organSlotIdToOrgan = _body.GetPartOrgans(args.Part).ToDictionary(o => o.Item2.SlotId, o => o.Item2);
+            foreach (var (organSlotId, compsToRemove) in ent.Comp.RemoveOrganOnAdd)
+            {
+                if (!organSlotIdToOrgan.TryGetValue(organSlotId, out var organ) || organ.OnAdd == null)
+                    continue;
+
+                if (compsToRemove.Keys.Any(key => organ.OnAdd.ContainsKey(key)))
+                {
+                    args.Cancelled = true;
+                    return;
+                }
+            }
+        }
     }
 
     private void OnToolCanPerform(Entity<SurgeryStepComponent> ent, ref SurgeryCanPerformStepEvent args)