The Newest Furry Race [Skeletons]

Content.Client/Entry/IgnoredComponents.cs

@@ -346,6 +346,7 @@ public static class IgnoredComponents
             "DoorRemote",
             "InteractionPopup",
             "HealthAnalyzer",
+            "BodyReassemble",
             "Thirst",
             "CanEscapeInventory",
             "Wires"

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

@@ -541,6 +541,23 @@ private void OnSkinColorOnValueChanged()
                     Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));
                     break;
                 }
+                case SpeciesSkinColor.TintedHues:
+                {
+                    if (!_rgbSkinColorContainer.Visible)
+                    {
+                        _skinColor.Visible = false;
+                        _rgbSkinColorContainer.Visible = true;
+                    }
+
+                    // a little hacky in order to convert rgb --> hsv --> rgb
+                    var color = new Color(_rgbSkinColorSelector.Color.R, _rgbSkinColorSelector.Color.G, _rgbSkinColorSelector.Color.B);
+                    var newColor = Color.ToHsv(color);
+                    newColor.Y = .1f;
+                    color = Color.FromHsv(newColor);
+
+                    Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));
+                    break;
+                }
             }
 
             IsDirty = true;
@@ -753,6 +770,18 @@ private void UpdateSkinColor()
                         _rgbSkinColorContainer.Visible = true;
                     }
 
+                    // set the RGB values to the direct values otherwise
+                    _rgbSkinColorSelector.Color = Profile.Appearance.SkinColor;
+                    break;
+                }
+                case SpeciesSkinColor.TintedHues:
+                {
+                    if (!_rgbSkinColorContainer.Visible)
+                    {
+                        _skinColor.Visible = false;
+                        _rgbSkinColorContainer.Visible = true;
+                    }
+
                     // set the RGB values to the direct values otherwise
                     _rgbSkinColorSelector.Color = Profile.Appearance.SkinColor;
                     break;

Content.Server/Body/Components/BodyComponent.cs

@@ -83,11 +83,20 @@ protected override void Startup()
             }
         }
 
-        public override void Gib(bool gibParts = false)
+        public override HashSet<EntityUid> Gib(bool gibParts = false)
         {
-            base.Gib(gibParts);
+            var gibs = base.Gib(gibParts);
 
-            SoundSystem.Play(Filter.Pvs(Owner), _gibSound.GetSound(), _entMan.GetComponent<TransformComponent>(Owner).Coordinates, AudioHelpers.WithVariation(0.025f));
+            var xform = _entMan.GetComponent<TransformComponent>(Owner);
+            var coordinates = xform.Coordinates;
+
+            // These have already been forcefully removed from containers so run it here.
+            foreach (var part in gibs)
+            {
+                _entMan.EventBus.RaiseLocalEvent(part, new PartGibbedEvent(Owner, gibs));
+            }
+
+            SoundSystem.Play(Filter.Pvs(Owner, entityManager: _entMan), _gibSound.GetSound(), coordinates, AudioHelpers.WithVariation(0.025f));
 
             if (_entMan.TryGetComponent(Owner, out ContainerManagerComponent? container))
             {
@@ -96,18 +105,41 @@ public override void Gib(bool gibParts = false)
                     foreach (var ent in cont.ContainedEntities)
                     {
                         cont.ForceRemove(ent);
-                        _entMan.GetComponent<TransformComponent>(ent).Coordinates = _entMan.GetComponent<TransformComponent>(Owner).Coordinates;
+                        _entMan.GetComponent<TransformComponent>(ent).Coordinates = coordinates;
                         ent.RandomOffset(0.25f);
                     }
                 }
             }
 
-            _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 HashSet<EntityUid> GibbedParts;
+
+        public BeingGibbedEvent(HashSet<EntityUid> gibbedParts)
+        {
+            GibbedParts = gibbedParts;
+        }
+    }
+
+    /// <summary>
+    /// An event raised on all the parts of an entity when it's gibbed
+    /// </summary>
+    public sealed class PartGibbedEvent : EntityEventArgs
+    {
+        public EntityUid EntityToGib;
+        public readonly HashSet<EntityUid> GibbedParts;
+
+        public PartGibbedEvent(EntityUid entityToGib, HashSet<EntityUid> gibbedParts)
+        {
+            EntityToGib = entityToGib;
+            GibbedParts = gibbedParts;
+        }
     }
 }

Content.Server/Body/Components/BodyReassembleComponent.cs

@@ -0,0 +1,35 @@
+using System.Threading;
+using Content.Server.Cloning;
+using Content.Shared.Actions.ActionTypes;
+
+namespace Content.Server.Body.Components
+{
+    [RegisterComponent]
+    public sealed class BodyReassembleComponent : 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]
+        [DataField("delay")]
+        public float DoAfterTime = 5f;
+
+        /// <summary>
+        /// The list of body parts that are needed for reassembly
+        /// </summary>
+        [ViewVariables]
+        public HashSet<EntityUid>? BodyParts = null;
+
+        [DataField("action")]
+        public InstantAction? ReassembleAction = null;
+
+        public CancellationTokenSource? CancelToken = null;
+    }
+}

Content.Server/Body/Systems/BodyReassembleSystem.cs

@@ -0,0 +1,234 @@
+using System.Threading;
+using Content.Server.Body.Components;
+using Content.Server.Cloning;
+using Content.Server.DoAfter;
+using Content.Server.Mind.Components;
+using Content.Server.Popups;
+using Content.Server.Preferences.Managers;
+using Content.Shared.Actions;
+using Content.Shared.CharacterAppearance.Systems;
+using Content.Shared.Preferences;
+using Content.Shared.Species;
+using Content.Shared.Verbs;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+
+/// <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 BodyReassembleSystem : EntitySystem
+    {
+        [Dependency] private readonly IServerPreferencesManager _prefsManager = null!;
+        [Dependency] private readonly IPrototypeManager _prototype = default!;
+        [Dependency] private readonly SharedActionsSystem _actions = default!;
+        [Dependency] private readonly PopupSystem _popupSystem = default!;
+        [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
+        [Dependency] private readonly SharedHumanoidAppearanceSystem _humanoidAppearance = default!;
+
+        private const float SelfReassembleMultiplier = 2f;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<BodyReassembleComponent, PartGibbedEvent>(OnPartGibbed);
+            SubscribeLocalEvent<BodyReassembleComponent, ReassembleActionEvent>(StartReassemblyAction);
+
+            SubscribeLocalEvent<BodyReassembleComponent, GetVerbsEvent<AlternativeVerb>>(AddReassembleVerbs);
+            SubscribeLocalEvent<BodyReassembleComponent, ReassembleCompleteEvent>(ReassembleComplete);
+            SubscribeLocalEvent<BodyReassembleComponent, ReassembleCancelledEvent>(ReassembleCancelled);
+        }
+
+        private void StartReassemblyAction(EntityUid uid, BodyReassembleComponent component, ReassembleActionEvent args)
+        {
+            args.Handled = true;
+            StartReassembly(uid, component, SelfReassembleMultiplier);
+        }
+
+        private void ReassembleCancelled(EntityUid uid, BodyReassembleComponent component, ReassembleCancelledEvent args)
+        {
+            component.CancelToken = null;
+        }
+
+        private void OnPartGibbed(EntityUid uid, BodyReassembleComponent component, PartGibbedEvent args)
+        {
+            if (!TryComp<MindComponent>(args.EntityToGib, out var mindComp) || mindComp?.Mind == null)
+                return;
+
+            component.BodyParts = args.GibbedParts;
+            UpdateDNAEntry(uid, args.EntityToGib);
+            mindComp.Mind.TransferTo(uid);
+
+            if (component.ReassembleAction == null)
+                return;
+
+            _actions.AddAction(uid, component.ReassembleAction, null);
+        }
+
+        private void StartReassembly(EntityUid uid, BodyReassembleComponent component, float multiplier = 1f)
+        {
+            if (component.CancelToken != null)
+                return;
+
+            if (!GetNearbyParts(uid, component, out var partList))
+                return;
+
+            if (partList == null)
+                return;
+
+            var doAfterTime = component.DoAfterTime * multiplier;
+            var cancelToken = new CancellationTokenSource();
+            component.CancelToken = cancelToken;
+
+            var doAfterEventArgs = new DoAfterEventArgs(component.Owner, doAfterTime, cancelToken.Token, component.Owner)
+            {
+                BreakOnTargetMove = true,
+                BreakOnUserMove = true,
+                BreakOnDamage = true,
+                BreakOnStun = true,
+                NeedHand = false,
+                TargetCancelledEvent = new ReassembleCancelledEvent(),
+                TargetFinishedEvent = new ReassembleCompleteEvent(uid, uid, partList),
+            };
+
+            _doAfterSystem.DoAfter(doAfterEventArgs);
+        }
+
+        /// <summary>
+        /// Adds the custom verb for reassembling body parts
+        /// </summary>
+        private void AddReassembleVerbs(EntityUid uid, BodyReassembleComponent component, GetVerbsEvent<AlternativeVerb> args)
+        {
+            if (!args.CanAccess || !args.CanInteract)
+                return;
+
+            if (!TryComp<MindComponent>(uid, out var mind) ||
+                !mind.HasMind ||
+                component.CancelToken != null)
+                return;
+
+            // doubles the time if you reconstruct yourself
+            var multiplier = args.User == uid ? SelfReassembleMultiplier : 1f;
+
+            // Custom verb
+            AlternativeVerb custom = new()
+            {
+                Text = Loc.GetString("reassemble-action"),
+                Act = () =>
+                {
+                    StartReassembly(uid, component, multiplier);
+                },
+                IconEntity = uid,
+                Priority = 1
+            };
+            args.Verbs.Add(custom);
+        }
+
+        private bool GetNearbyParts(EntityUid uid, BodyReassembleComponent component, out HashSet<EntityUid>? partList)
+        {
+            partList = new HashSet<EntityUid>();
+
+            if (component.BodyParts == null)
+                return false;
+
+            // Ensures all of the old body part pieces are there
+            var xformQuery = GetEntityQuery<TransformComponent>();
+            var notFound = true;
+            var bodyXform = xformQuery.GetComponent(uid);
+
+            foreach (var part in component.BodyParts)
+            {
+                if (!xformQuery.TryGetComponent(part, out var xform) ||
+                    !bodyXform.Coordinates.InRange(EntityManager, xform.Coordinates, 2f)) continue;
+
+                notFound = false;
+                partList.Add(part);
+            }
+
+            if (notFound)
+            {
+                _popupSystem.PopupEntity(Loc.GetString("reassemble-fail"), uid, Filter.Entities(uid));
+                return false;
+            }
+
+            return true;
+        }
+
+        private void ReassembleComplete(EntityUid uid, BodyReassembleComponent component, ReassembleCompleteEvent args)
+        {
+            component.CancelToken = null;
+
+            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 = EntityManager.SpawnEntity(speciesProto, EntityManager.GetComponent<TransformComponent>(component.Owner).MapPosition);
+
+            _humanoidAppearance.UpdateFromProfile(mob, component.DNA.Value.Profile);
+            MetaData(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)
+            {
+                EntityManager.DeleteEntity(entity);
+            }
+
+            _popupSystem.PopupEntity(Loc.GetString("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"> the entity that the player will transfer to</param>
+        /// <param name="body"> the entity whose DNA is being saved</param>
+        private void UpdateDNAEntry(EntityUid uid, EntityUid body)
+        {
+            if (!TryComp<BodyReassembleComponent>(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 ReassembleCompleteEvent : EntityEventArgs
+        {
+            /// <summary>
+            /// The entity being reassembled
+            /// </summary>
+            public readonly EntityUid Uid;
+
+            /// <summary>
+            /// The user performing the reassembly
+            /// </summary>
+            public readonly EntityUid User;
+            public readonly HashSet<EntityUid> PartList;
+
+            public ReassembleCompleteEvent(EntityUid uid, EntityUid user, HashSet<EntityUid> partList)
+            {
+                Uid = uid;
+                User = user;
+                PartList = partList;
+            }
+        }
+
+        private sealed class ReassembleCancelledEvent : EntityEventArgs {}
+    }
+}
+
+public sealed class ReassembleActionEvent : InstantActionEvent { }

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;