Doll species

Content.Server/Mobs/CritMobActionsSystem.cs

@@ -49,7 +49,7 @@ private void OnSuccumb(EntityUid uid, MobStateActionsComponent component, CritSu
 
     private void OnFakeDeath(EntityUid uid, MobStateActionsComponent component, CritFakeDeathEvent args)
     {
-        if (!_mobState.IsCritical(uid))
+        if (_mobState.IsDead(uid)) //Starlight - changed to checking if the creature is *dead*, rather than not critical, now we can use the same action to fake death on anyone still alive.
             return;
 
         //Starlight Start

Content.Server/_Starlight/Actions/EntitySystems/ShellSystem.cs

@@ -0,0 +1,27 @@
+using Content.Shared.Actions;
+using Content.Shared._Starlight.Actions.Components;
+
+namespace Content.Server._Starlight.Actions.EntitySystems;
+
+public sealed class ShellSystem : EntitySystem
+{
+    [Dependency] private SharedActionsSystem _actionsSystem = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ShellComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ShellComponent, ComponentShutdown>(OnCompRemove);
+    }
+
+    private void OnMapInit(EntityUid uid, ShellComponent comp, MapInitEvent args)
+    {
+        _actionsSystem.AddAction(uid, ref comp.GenerateShellPieceActionEntity, comp.GenerateShellPieceAction);
+    }
+
+    private void OnCompRemove(EntityUid uid, ShellComponent comp, ComponentShutdown args)
+    {
+        _actionsSystem.RemoveAction(uid, comp.GenerateShellPieceActionEntity);
+    }
+}

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

@@ -1,13 +1,18 @@
 using System.Linq;
 using Content.Server._Starlight.Language;
 using Content.Server.Humanoid;
+using Content.Shared._Starlight.Actions.Components;
 using Content.Shared.Actions;
+using Content.Shared.Body.Part;
+using Content.Shared.Body.Systems;
+using Content.Shared._Starlight.Medical.Body.Part;
 using Content.Shared.Damage;
 using Content.Shared.Damage.Components;
 using Content.Shared.Damage.Systems;
 using Content.Shared.Eye.Blinding.Components;
 using Content.Shared.Eye.Blinding.Systems;
 using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Markings;
 using Content.Shared.Radio.Components;
 using Content.Shared.Speech.Muting;
 using Content.Shared._Starlight.Cybernetics;
@@ -22,6 +27,7 @@
 using Content.Shared._Starlight.VentCrawl.Components;
 using Content.Shared._Starlight.Medical.Surgery.Components;
 using Content.Shared._Starlight.Antags.Abductor.Components;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.Manager;
 
 namespace Content.Server._Starlight.Medical.Surgery;
@@ -36,7 +42,9 @@ public sealed partial class OrganSystem : EntitySystem
     [Dependency] private LanguageSystem _language = default!;
     [Dependency] private SharedContainerSystem _container = default!;
     [Dependency] private IGameTiming _timing = default!;
-    [Dependency] private SharedActionsSystem _actions = default!;
+    [Dependency] private MarkingManager _markingManager = default!;
+    [Dependency] private SharedBodySystem _body = default!;
+    [Dependency] private SharedActionsSystem _actionsSystem = default!;
     [Dependency] private ISerializationManager _serialization = default!;
     [Dependency] private SharedSurgerySystem _surgery = default!;
 
@@ -49,8 +57,14 @@ public override void Initialize()
         SubscribeLocalEvent<TaggedOrganComponent, SurgeryOrganImplantationCompleted>(OnTaggedOrganImplanted);
         SubscribeLocalEvent<TaggedOrganComponent, SurgeryOrganExtracted>(OnTaggedOrganExtracted);
 
-        SubscribeLocalEvent<StorageOrganComponent, SurgeryOrganImplantationCompleted>(OnStorageOrganImplanted);
-        SubscribeLocalEvent<StorageOrganComponent, SurgeryOrganExtracted>(OnStorageOrganExtracted);
+        SubscribeLocalEvent<MarkingOrganComponent, SurgeryOrganImplantationCompleted>(OnMarkingOrganImplanted);
+        SubscribeLocalEvent<MarkingOrganComponent, SurgeryOrganExtracted>(OnMarkingOrganExtracted);
+
+        SubscribeLocalEvent<DamageModifierOrganComponent, SurgeryOrganImplantationCompleted>(OnDamageModifierOrganImplanted);
+        SubscribeLocalEvent<DamageModifierOrganComponent, SurgeryOrganExtracted>(OnDamageModifierOrganExtracted);
+
+        SubscribeLocalEvent<OrganShellComponent, SurgeryOrganImplantationCompleted>(OnShellImplanted);
+        SubscribeLocalEvent<OrganShellComponent, SurgeryOrganExtracted>(OnShellExtracted);
 
         SubscribeLocalEvent<OrganEyesComponent, SurgeryOrganImplantationCompleted>(OnEyeImplanted);
         SubscribeLocalEvent<OrganEyesComponent, SurgeryOrganExtracted>(OnEyeExtracted);
@@ -106,7 +120,7 @@ private void OnFunctionalOrganExtracted(Entity<FunctionalOrganComponent> ent, re
 
     private void UpdateEntity(EntityUid ent, IComponent comp, EntityUid? implant = null)
     {
-        //For all those components where the enity needs to be updated in their own way after adding or removing a component
+        //For all those components where the entity needs to be updated in their own way after adding or removing a component
         switch (comp)
         {
             case IntrinsicTranslatorComponent _:
@@ -147,27 +161,131 @@ private void OnTaggedOrganExtracted(Entity<TaggedOrganComponent> ent, ref Surger
 
     //
 
-    private void OnStorageOrganImplanted(Entity<StorageOrganComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    private void OnMarkingOrganImplanted(Entity<MarkingOrganComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    {
+        if(ent.Comp.Markings.Count > 0)
+        {
+            var addedMarkings = new List<ProtoId<MarkingPrototype>>();
+            foreach(var marking in ent.Comp.Markings)
+            {
+                _humanoidAppearanceSystem.AddMarking(args.Body, marking.Key, marking.Value.markingColors, marking.Value.isGlowing, forced: true);
+                addedMarkings.Add(marking.Key);
+            }
+            foreach(var key in addedMarkings)
+                ent.Comp.Markings.Remove(key);
+        }
+        else
+            foreach(var markingProto in ent.Comp.AppliedMarkings)
+                UpdateMarking(ent, args.Body, args.Part, markingProto, true);
+
+        UpdateEntity(args.Body, ent.Comp);
+    }
+
+    private void OnMarkingOrganExtracted(Entity<MarkingOrganComponent> ent, ref SurgeryOrganExtracted args)
+    {
+        if(ent.Comp.StoreMarkings)
+        {
+            if (!TryComp(args.Body, out HumanoidAppearanceComponent? appearance))
+                return;
+
+            if (!TryComp(args.Part, out BodyPartComponent? part))
+                return;
+
+            var resolvedLayers = ResolveBodyPartLayers(part.PartType, part.Symmetry);
+            if (!resolvedLayers.Any())
+                return;
+
+            var removedMarkings = new List<string>();
+            foreach (var markingSet in appearance.MarkingSet.Markings)
+                foreach (var marking in markingSet.Value)
+                {
+                    if (!_markingManager.Markings.TryGetValue(marking.MarkingId, out var prototype))
+                        continue;
+                    if (!resolvedLayers.Contains(prototype.BodyPart))
+                        continue;
+                    ent.Comp.Markings.TryAdd(prototype, (marking.IsGlowing, marking.MarkingColors));
+                    removedMarkings.Add(prototype.ID);
+                }
+            foreach(var key in removedMarkings)
+                _humanoidAppearanceSystem.RemoveMarking(args.Body, key);
+        }
+        else
+            foreach(var markingProto in ent.Comp.AppliedMarkings)
+                UpdateMarking(ent, args.Body, args.Part, markingProto, false);
+
+        UpdateEntity(args.Body, ent.Comp);
+    }
+
+    private static IEnumerable<HumanoidVisualLayers> ResolveBodyPartLayers(BodyPartType partType, BodyPartSymmetry symmetry = BodyPartSymmetry.Right)
     {
-        // The results of the container change are already networked on their own
-        if (_timing.ApplyingState)
+        switch(partType)
+        {
+            case BodyPartType.Torso:
+                yield return HumanoidVisualLayers.Chest;
+                break;
+            case BodyPartType.Head:
+                yield return  HumanoidVisualLayers.Head;
+                yield return  HumanoidVisualLayers.HeadSide;
+                yield return  HumanoidVisualLayers.HeadTop;
+                break;
+            case BodyPartType.Arm:
+                yield return symmetry == BodyPartSymmetry.Left ? HumanoidVisualLayers.LArm : HumanoidVisualLayers.RArm;
+                break;
+            case BodyPartType.Hand:
+                yield return symmetry == BodyPartSymmetry.Left ? HumanoidVisualLayers.LHand : HumanoidVisualLayers.RHand;
+                break;
+            case BodyPartType.Leg:
+                yield return symmetry == BodyPartSymmetry.Left ? HumanoidVisualLayers.LLeg : HumanoidVisualLayers.RLeg;
+                break;
+            case BodyPartType.Foot:
+                yield return symmetry == BodyPartSymmetry.Left ? HumanoidVisualLayers.LFoot : HumanoidVisualLayers.RFoot;
+                break;
+            case BodyPartType.Tail:
+                yield return HumanoidVisualLayers.Tail;
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void UpdateMarking(Entity<MarkingOrganComponent> ent, EntityUid targetBody, EntityUid targetPart, string marking, bool add = true)
+    {
+        if (!_markingManager.Markings.TryGetValue(marking, out var prototype))
             return;
 
-        Dirty(ent);
+        if(!TryComp(targetPart, out BodyPartComponent? part))
+            return;
 
-        if (ent.Comp.OrganAction != null)
-            _actions.AddAction(args.Body, ref ent.Comp.ActionEntity, ent.Comp.OrganAction, ent.Owner);
+        if(!ResolveBodyPartLayers(part.PartType, part.Symmetry).Contains(prototype.BodyPart))
+            return;
+
+        if(add)
+            _humanoidAppearanceSystem.AddMarking(targetBody, marking, ent.Comp.IsGlowing, forced: true);
+        else
+            _humanoidAppearanceSystem.RemoveMarking(targetBody, marking);
 
     }
 
-    private void OnStorageOrganExtracted(Entity<StorageOrganComponent> ent, ref SurgeryOrganExtracted args)
+    //
+
+    private void OnDamageModifierOrganImplanted(Entity<DamageModifierOrganComponent> ent, ref SurgeryOrganImplantationCompleted args)
     {
-        // The results of the container change are already networked on their own
-        if (_timing.ApplyingState)
+        if (!TryComp(args.Body, out DamageableComponent? damage))
             return;
 
-        _actions.RemoveAction(args.Body, ent.Comp.ActionEntity);
-        ent.Comp.ActionEntity = null;
+        _damageableSystem.AddAdditiveModifierSet((args.Body, damage), ent, ent.Comp.Modifiers);
+
+        UpdateEntity(args.Body, ent.Comp);
+    }
+
+    private void OnDamageModifierOrganExtracted(Entity<DamageModifierOrganComponent> ent, ref SurgeryOrganExtracted args)
+    {
+        if (!TryComp(args.Body, out DamageableComponent? damage))
+            return;
+
+        _damageableSystem.RemoveAdditiveModifierSet((args.Body, damage), ent, ent.Comp.Modifiers);
+
+        UpdateEntity(args.Body, ent.Comp);
     }
 
     //
@@ -200,6 +318,36 @@ private void OnOrganExtracted(Entity<DamageableComponent> ent, ref SurgeryOrganE
 
     //
 
+    private void OnShellImplanted(Entity<OrganShellComponent> ent, ref SurgeryOrganImplantationCompleted args)
+    {
+        if(!TryComp(args.Body, out ShellComponent? shell))
+            return;
+
+        if(!_body.GetBodyOrgans(args.Body).Where(o => TryComp(o.Id, out OrganShellComponent? _)).Any())
+            return;
+
+        if(shell.NoShellComponents != null)
+            EntityManager.RemoveComponents(args.Body, shell.NoShellComponents);
+
+        _actionsSystem.AddAction(args.Body, ref shell.GenerateShellPieceActionEntity, shell.GenerateShellPieceAction);
+    }
+
+    private void OnShellExtracted(Entity<OrganShellComponent> ent, ref SurgeryOrganExtracted args)
+    {
+        if(!TryComp(args.Body, out ShellComponent? shell))
+            return;
+
+        if(_body.GetBodyOrgans(args.Body).Where(o => TryComp(o.Id, out OrganShellComponent? _)).Any())
+            return;
+
+        if(shell.NoShellComponents != null)
+            EntityManager.AddComponents(args.Body, shell.NoShellComponents, removeExisting: false);
+
+        _actionsSystem.RemoveAction(args.Body, shell.GenerateShellPieceActionEntity);
+    }
+
+    //
+
     private void OnAbductorOrganImplanted(Entity<AbductorOrganComponent> ent, ref SurgeryOrganImplantationCompleted args)
     {
         if (TryComp<AbductorVictimComponent>(args.Body, out var victim))

Content.Shared/Damage/Components/DamageableComponent.cs

@@ -89,6 +89,22 @@
 
     [DataField]
     public FixedPoint2? HealthBarThreshold;
+
+    #region Starlight
+
+    /// <summary>
+    ///     Additive changes to damage coefficients. See also: <see cref="DamageModifierSet"/>
+    /// </summary>
+    [DataField]
+    public Dictionary<(EntityUid Source, string ModifierKey), float> AdditiveCoefficients = [];
+
+
+    /// <summary>
+    ///     Additive changes to damage modifiers. See also: <see cref="DamageModifierSet"/>
+    /// </summary>
+    [DataField]
+    public Dictionary<(EntityUid Source, string ModifierKey), float> AdditiveModifiers = [];
+    #endregion Starlight
 }
 
 [Serializable, NetSerializable]

Content.Shared/Damage/Systems/DamageableSystem.API.cs

@@ -148,11 +148,34 @@ public DamageSpecifier ChangeDamage(
         // Apply resistances
         if (!ignoreResistances)
         {
+            //Starlight Start
+            var computedModifiers = new DamageModifierSet();
             if (
                 ent.Comp.DamageModifierSetId != null &&
                 _prototypeManager.Resolve(ent.Comp.DamageModifierSetId, out var modifierSet)
             )
-                damage = DamageSpecifier.ApplyModifierSet(damage, modifierSet, armorPenetration, canHeal); // starlight
+            {
+                foreach (var coefficient in modifierSet.Coefficients)
+                    computedModifiers.Coefficients.Add(coefficient.Key, modifierSet.Coefficients[coefficient.Key]);
+
+                foreach (var modifier in modifierSet.FlatReductions)
+                    computedModifiers.FlatReductions.Add(modifier.Key, modifierSet.FlatReductions[modifier.Key]);
+            }
+
+            foreach(var additiveCoefficient in ent.Comp.AdditiveCoefficients)
+                if(computedModifiers.Coefficients.ContainsKey(additiveCoefficient.Key.ModifierKey))
+                    computedModifiers.Coefficients[additiveCoefficient.Key.ModifierKey] += additiveCoefficient.Value;
+                else
+                    computedModifiers.Coefficients.Add( additiveCoefficient.Key.ModifierKey, 1.0f + additiveCoefficient.Value);
+
+            foreach(var additiveModifier in ent.Comp.AdditiveModifiers)
+                if(computedModifiers.FlatReductions.ContainsKey(additiveModifier.Key.ModifierKey))
+                    computedModifiers.FlatReductions[additiveModifier.Key.ModifierKey] += additiveModifier.Value;
+                else
+                    computedModifiers.FlatReductions.Add( additiveModifier.Key.ModifierKey, 0.0f + additiveModifier.Value);
+
+            damage = DamageSpecifier.ApplyModifierSet(damage, computedModifiers, armorPenetration, canHeal);
+            //Starlight End
 
             // TODO DAMAGE
             // byref struct event.
@@ -471,4 +494,38 @@ public void SetDamageContainerID(Entity<DamageableComponent?> ent, ProtoId<Damag
         Dirty(ent);
     }
     // End Stellar
+
+    #region Starlight
+
+    /// <summary>
+    ///     Adds to the additive damage modifiers of the DamageableComponent
+    /// </summary>
+    public void AddAdditiveModifierSet(Entity<DamageableComponent?> ent, EntityUid source, DamageModifierSet mods)
+    {
+        if(!Resolve(ent, ref ent.Comp))
+            return;
+
+        foreach (var coefficient in mods.Coefficients)
+            ent.Comp.AdditiveCoefficients.TryAdd((source, coefficient.Key), coefficient.Value);
+
+        foreach (var modifier in mods.FlatReductions)
+            ent.Comp.AdditiveModifiers.TryAdd((source, modifier.Key), modifier.Value);
+    }
+
+    /// <summary>
+    ///     Subtracts from the additive damage modifiers of the DamageableComponent
+    /// </summary>
+    public void RemoveAdditiveModifierSet(Entity<DamageableComponent?> ent, EntityUid source, DamageModifierSet mods)
+    {
+        if(!Resolve(ent, ref ent.Comp))
+            return;
+
+        foreach (var coefficient in mods.Coefficients)
+            ent.Comp.AdditiveCoefficients.Remove((source, coefficient.Key));
+
+        foreach (var modifier in mods.FlatReductions)
+            ent.Comp.AdditiveModifiers.Remove((source, modifier.Key));
+    }
+
+    #endregion Starlight
 }

Content.Shared/Magic/SharedMagicSystem.cs

@@ -613,7 +613,11 @@ private void OnSpawnItemInHand(SpawnItemInHandEvent ev)
         if(!result && ev.RequiresFreeHand)
             Del(spawnedEntity); // abort!
         else
+        {
+            if(ev.SelfDamage != null) //For dolls
+                _damageable.ChangeDamage(user, ev.SelfDamage, true);
             ev.Handled = true;
+        }
     }
 
     private void OnTowerOfBabel(TowerOfBabelEvent ev)