The Newest Furry Race [Skeletons]

Content.Client/Entry/IgnoredComponents.cs

@@ -341,7 +341,9 @@ public static class IgnoredComponents
             "EnergySword",
             "DoorRemote",
             "InteractionPopup",
-            "HealthAnalyzer"
+            "HealthAnalyzer",
+            "SkeletonBodyManager",
+            "TransferMindOnGib"
         };
     }
 }

Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs

@@ -482,6 +482,12 @@ private void OnSkinColorOnValueChanged(Range range)
                     Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));
                     break;
                 }
+                case SpeciesSkinColor.TintedHues:
+                {
+                    var color = Color.FromHsv(new Vector4(range.Value / 100.0f, 0.1f, 1.0f, 1.0f));
+                    Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));
+                    break;
+                }
             }
 
             IsDirty = true;
@@ -675,6 +681,11 @@ private void UpdateSkinColor()
                     _skinColor.Value = color.X * 100;
                     break;
                 }
+                case SpeciesSkinColor.TintedHues:
+                {
+                    _skinColor.Value = color.X * 100f;
+                    break;
+                }
             }
 
         }

Content.Server/Body/Components/BodyComponent.cs

@@ -83,9 +83,10 @@ protected override void Startup()
             }
         }
 
-        public override void Gib(bool gibParts = false)
+        public override List<SharedBodyPartComponent> Gib(bool gibParts = false)
         {
-            base.Gib(gibParts);
+            _entMan.EventBus.RaiseLocalEvent(Owner, new BeforeGibbedEvent(), false);
+            var gibs = base.Gib(gibParts);
 
             SoundSystem.Play(Filter.Pvs(Owner), _gibSound.GetSound(), _entMan.GetComponent<TransformComponent>(Owner).Coordinates, AudioHelpers.WithVariation(0.025f));
 
@@ -102,12 +103,24 @@ public override void Gib(bool gibParts = false)
                 }
             }
 
-            _entMan.EventBus.RaiseLocalEvent(Owner, new BeingGibbedEvent(), false);
+            _entMan.EventBus.RaiseLocalEvent(Owner, new BeingGibbedEvent(gibs), false);
             _entMan.QueueDeleteEntity(Owner);
+
+            return gibs;
         }
     }
 
     public sealed class BeingGibbedEvent : EntityEventArgs
+    {
+        public readonly List<SharedBodyPartComponent> GibbedParts;
+
+        public BeingGibbedEvent(List<SharedBodyPartComponent> gibbedParts)
+        {
+            GibbedParts = gibbedParts;
+        }
+    }
+
+    public sealed class BeforeGibbedEvent : EntityEventArgs
     {
     }
 }

Content.Server/Body/Components/SkeletonBodyManagerComponent.cs

@@ -0,0 +1,28 @@
+using Content.Server.Cloning;
+using Content.Shared.Body.Components;
+
+namespace Content.Server.Body.Components
+{
+    [RegisterComponent]
+    public sealed class SkeletonBodyManagerComponent : Component
+    {
+        /// <summary>
+        /// The dna entry used for reassembling the skeleton
+        /// updated before the entity is gibbed.
+        /// </summary>
+        [ViewVariables]
+        public ClonerDNAEntry? DNA = null;
+
+        /// <summary>
+        /// The default time it takes to reassemble itself
+        /// </summary>
+        [ViewVariables]
+        public float DoAfterTime = 5f;
+
+        /// <summary>
+        /// The list of body parts that are needed for reassembly
+        /// </summary>
+        [ViewVariables]
+        public List<SharedBodyPartComponent>? BodyParts = null;
+    }
+}

Content.Server/Body/Components/TransferMindOnGibComponent.cs

@@ -0,0 +1,13 @@
+namespace Content.Server.Body.Components
+{
+    [RegisterComponent]
+    public sealed class TransferMindOnGibComponent : Component
+    {
+        /// <summary>
+        /// The entity the mind will be transferred to
+        /// stored in here for use in system
+        /// </summary>
+        [ViewVariables]
+        public EntityUid? TransferTarget = null;
+    }
+}

Content.Server/Body/Systems/SkeletonBodyManagerSystem.cs

@@ -0,0 +1,187 @@
+using Content.Server.Body.Components;
+using Content.Server.Cloning;
+using Content.Server.Construction;
+using Content.Server.DoAfter;
+using Content.Server.Mind.Components;
+using Content.Server.Popups;
+using Content.Server.Preferences.Managers;
+using Content.Shared.CharacterAppearance.Systems;
+using Content.Shared.Preferences;
+using Content.Shared.Species;
+using Content.Shared.Verbs;
+using Robust.Server.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using System.Diagnostics.CodeAnalysis;
+
+/// <remarks>
+/// Fair warning, this is all kinda shitcode, but it'll have to wait for a major
+/// refactor until proper body systems get added. The current implementation is
+/// definitely not ideal and probably will be prone to weird bugs.
+/// </remarks>
+
+namespace Content.Server.Body.Systems
+{
+    public sealed class SkeletonBodyManagerSystem : EntitySystem
+    {
+        [Dependency] private readonly IEntityManager _entities = default!;
+        [Dependency] private readonly IServerPreferencesManager _prefsManager = null!;
+        [Dependency] private readonly IPrototypeManager _prototype = default!;
+        [Dependency] private readonly PopupSystem _popupSystem = default!;
+        [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
+        [Dependency] private readonly ConstructionSystem _construction = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<SkeletonBodyManagerComponent, GetVerbsEvent<AlternativeVerb>>(AddReassembleVerbs);
+            SubscribeLocalEvent<ReassembleDoAfterComplete>(Reassemble);
+        }
+
+        /// <summary>
+        /// Adds the custom verb for reassembling skeleton parts
+        /// into a full skeleton
+        /// </summary>
+        private void AddReassembleVerbs(EntityUid uid, SkeletonBodyManagerComponent component, GetVerbsEvent<AlternativeVerb> args)
+        {
+            // every time i get warned of a null refernce i add another if statement
+            if (!args.CanAccess || !args.CanInteract)
+                return;
+
+            if (!TryComp<ActorComponent?>(args.User, out var actor))
+                return;
+
+            if (!TryComp<MindComponent>(uid, out var mind) || !mind.HasMind)
+                return;
+
+            var doAfterTime = component.DoAfterTime;
+            // doubles the time if you reconstruct yourself
+            if (args.User == uid)
+                doAfterTime *= 2;
+
+            // Custom verb
+            AlternativeVerb custom = new();
+            custom.Text = Loc.GetString("skeleton-reassemble-action");
+            custom.Act = () =>
+            {
+                if (!GetNearbyParts(args.User, uid, component, out var partList))
+                    return;
+
+                if (partList == null)
+                    return;
+
+                var doAfterEventArgs = new DoAfterEventArgs(component.Owner, doAfterTime, default, component.Owner)
+                {
+                    BreakOnTargetMove = true,
+                    BreakOnUserMove = true,
+                    BreakOnDamage = true,
+                    BreakOnStun = true,
+                    NeedHand = false,
+                    BroadcastFinishedEvent = new ReassembleDoAfterComplete(uid, args.User, component, partList),
+                };
+
+                _doAfterSystem.DoAfter(doAfterEventArgs);
+            };
+            custom.IconTexture = "/Textures/Mobs/Species/Skeleton/parts.rsi/full.png";
+            custom.Priority = 1;
+            args.Verbs.Add(custom);
+        }
+
+        private bool GetNearbyParts(EntityUid user, EntityUid uid, SkeletonBodyManagerComponent component, out List<EntityUid>? partList)
+        {
+            partList = new List<EntityUid>();
+
+            if (component.BodyParts == null)
+                return false;
+
+            // Ensures all of the old body part pieces are there
+            var nearby = _construction.EnumerateNearby(user);
+            bool notFound;
+            foreach (var part in component.BodyParts)
+            {
+                notFound = true;
+                foreach (var entity in nearby)
+                {
+                    if (part.Owner == entity || part.Owner == component.Owner)
+                    {
+                        notFound = false;
+                        partList.Add(part.Owner);
+                    }
+                }
+                if (notFound)
+                {
+                    _popupSystem.PopupEntity(Loc.GetString("skeleton-reassemble-fail"), uid, Filter.Entities(uid));
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private void Reassemble(ReassembleDoAfterComplete args)
+        {
+            var uid = args.Uid;
+            var component = args.Component;
+
+            if (component.DNA == null)
+                return;
+
+            // Creates the new entity and transfers the mind component
+            var speciesProto = _prototype.Index<SpeciesPrototype>(component.DNA.Value.Profile.Species).Prototype;
+            var mob = _entities.SpawnEntity(speciesProto, _entities.GetComponent<TransformComponent>(component.Owner).MapPosition);
+
+            Get<SharedHumanoidAppearanceSystem>().UpdateFromProfile(mob, component.DNA.Value.Profile);
+            _entities.GetComponent<MetaDataComponent>(mob).EntityName = component.DNA.Value.Profile.Name;
+
+            if (TryComp<MindComponent>(uid, out var mindcomp) && mindcomp.Mind != null)
+                mindcomp.Mind.TransferTo(mob);
+
+            // Cleans up all the body part pieces
+            foreach (var entity in args.PartList)
+            {
+                _entities.DeleteEntity(entity);
+            }
+
+            _popupSystem.PopupEntity(Loc.GetString("skeleton-reassemble-success", ("user", mob)), mob, Filter.Entities(mob));
+        }
+
+        /// <summary>
+        /// Called before the skeleton entity is gibbed in order to save
+        /// the dna for reassembly later
+        /// </summary>
+        /// param name="uid"></param> the entity the mind is going to be transfered which also stores the DNA
+        /// <param name="body"></param> the entity whose DNA is being saved
+        public void UpdateDNAEntry(EntityUid uid, EntityUid body)
+        {
+            if (!TryComp<SkeletonBodyManagerComponent>(uid, out var skelBodyComp) ||
+                !TryComp<MindComponent>(body, out var mindcomp))
+                return;
+
+            if (mindcomp.Mind == null)
+                return;
+
+            if (mindcomp.Mind.UserId == null)
+                return;
+
+            var profile = (HumanoidCharacterProfile) _prefsManager.GetPreferences(mindcomp.Mind.UserId.Value).SelectedCharacter;
+            skelBodyComp.DNA = new ClonerDNAEntry(mindcomp.Mind, profile);
+        }
+
+        private sealed class ReassembleDoAfterComplete : EntityEventArgs
+        {
+            public readonly EntityUid Uid; //the entity being reassembled
+            public readonly EntityUid User; //the user performing the reassembly
+            public readonly SkeletonBodyManagerComponent Component;
+            public readonly List<EntityUid> PartList;
+
+            public ReassembleDoAfterComplete(EntityUid uid, EntityUid user, SkeletonBodyManagerComponent component, List<EntityUid> partList)
+            {
+                Uid = uid;
+                User = user;
+                Component = component;
+                PartList = partList;
+            }
+        }
+    }
+}

Content.Server/Body/Systems/TransferMindOnGibSystem.cs

@@ -0,0 +1,50 @@
+using Content.Server.Body.Components;
+using Content.Server.Mind.Components;
+
+namespace Content.Server.Body.Systems
+{
+    public sealed class TransferMindOnGibSystem : EntitySystem
+    {
+        [Dependency] private readonly SkeletonBodyManagerSystem _skeletonBodyManager = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<TransferMindOnGibComponent, BeforeGibbedEvent>(OnBeforeGibbed);
+            SubscribeLocalEvent<TransferMindOnGibComponent, BeingGibbedEvent>(OnBeingGibbed);
+        }
+
+        private void OnBeforeGibbed(EntityUid uid, TransferMindOnGibComponent component, BeforeGibbedEvent args)
+        {
+            if (TryComp<MindComponent>(uid, out var mindComp) && mindComp.Mind != null)
+            {
+                if (TryComp<BodyComponent>(uid, out var bodyComp))
+                {
+                    foreach (var part in bodyComp.Parts)
+                    {
+                        var entity = part.Key.Owner;
+                        if (HasComp<SkeletonBodyManagerComponent>(entity))
+                        {
+                            component.TransferTarget = entity;
+                            _skeletonBodyManager.UpdateDNAEntry(entity, uid);
+                            mindComp.Mind.TransferTo(entity);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <remarks>
+        /// This information has to be collected in this system because the BeingGibbedEvent
+        /// is raised locally on the entity
+        /// </remarks>
+        private void OnBeingGibbed(EntityUid uid, TransferMindOnGibComponent component, BeingGibbedEvent args)
+        {
+            if (TryComp<SkeletonBodyManagerComponent>(component.TransferTarget, out var comp))
+            {
+                comp.BodyParts = args.GibbedParts;
+            }
+        }
+    }
+}

Content.Server/Cloning/CloningSystem.cs

@@ -137,7 +137,7 @@ public void Reset(RoundRestartCleanupEvent ev)
     // For example, GameTicker should be using this, and this should be using ICharacterProfile rather than HumanoidCharacterProfile.
     // It should carry a reference or copy of itself with the mobs that it affects.
     // See TODO in MedicalScannerComponent.
-    struct ClonerDNAEntry {
+    public struct ClonerDNAEntry {
         public Mind.Mind Mind;
         public HumanoidCharacterProfile Profile;
 

Content.Server/Construction/ConstructionSystem.Initial.cs

@@ -46,7 +46,7 @@ private void InitializeInitial()
         }
 
         // LEGACY CODE. See warning at the top of the file!
-        private IEnumerable<EntityUid> EnumerateNearby(EntityUid user)
+        public IEnumerable<EntityUid> EnumerateNearby(EntityUid user)
         {
             foreach (var item in _handsSystem.EnumerateHeld(user))
             {

Content.Shared/Body/Components/SharedBodyComponent.cs

@@ -394,15 +394,19 @@ public override void HandleComponentState(ComponentState? curState, ComponentSta
             }
         }
 
-        public virtual void Gib(bool gibParts = false)
+        public virtual List<SharedBodyPartComponent> Gib(bool gibParts = false)
         {
+            var gibs = new List<SharedBodyPartComponent>();
             foreach (var part in SlotParts.Keys)
             {
+                gibs.Add(part);
                 RemovePart(part);
 
                 if (gibParts)
                     part.Gib();
             }
+
+            return gibs;
         }
     }