Cloning (#1932)

* Add art assets for cloning

* Added a 'Scan DNA' button to the medical scanner

* Made the UI update unconditional for the medical scanner until checks for power changes are in place

* Update Medical scanner to reflect powered status and fix #1774

* added a 'scan dna' button the the medical scanner that will add the contained bodies Uid to a list in CloningSystem, fixed an issue with the menu not populating if the scanner starts in an unpowered state

* Add disabling logic to 'Scan DNA' button on medical scanner

* Removed un-used libraries

* changed scan dna button to Scan and Save DNA

* Added cloning machine code infrastructure copied from Medical Scanner

* Added a list to cloning menu containing some numbers

* Cloning Machine UI sends a message to the cloning component with the entityUID

* New scans now show up in cloning pod menu

* fixed cloning machine collision shape

* cloning machine can now spawn the right player profile assuming the attatched entity is still correct.

* refactored cloning system to use a map of integer ids to player Minds

* Added a return to body cloning loop for the ghost

* Fixed warning for _playerManager being possibly null, added TODO note for ghost return to body button acting as a toggle

* removed #nullable from cloningMachineWindow"

* Trying to get rid of nullable error

* fix CloningMachine to not initilize with it's owner components

* updated CloningMachine server component to play nice with the new nullable rules

* replace flag with eventBus message for sending a ghosts mind to a clone body

* Refactor cloning so that a popup option is used to get user consent for cloning

* Refactoring

* Reverting unused changes for cloning component

* Added proper cloning pod sprites and a visualizer so 'idle' and 'cloning' states are properly reflected

* added missing robust toolbox contents

* Added cloning NoMind State and made cloning take time

* Added cloning progress bar and mind status indicator to cloning pod

* Added missing localization calls, removeed 'returned to cloned body' from ghostUI

* Added unsubscribe for cloningStartedMessage in Mindcomponent.cs OnRemove

* Added eject button to cloningMachine and clamped the cloning progress bar to 100%

* Added condition to eject body on cloningmachine so bodies can't be ejected until cloning is done

* Add click-dragOn functionality to the medical scanner for things with a bodyManager

* Messed with scan query so it doesn't fail on dead bodies as long as Mind still owns the mob

* refactored clonning scan check on medical scanner so it doesn't do a linq query

* merge with rogue toolbox

* Change the name of Cloning Machine to the less generic Cloning Pod

* Changed Cloning Pod so it pauses cloning while the power is out

* Removed the evil LocalizationManager from the cloning menus and used the static Loc instead

* removed localization dependency from bound accpetCloning user interface

* Removed Ilocalization dependency I accidentally added to ghost ui

* Update Content.Client/GameObjects/Components/MedicalScanner/MedicalScannerComponent.cs

Co-authored-by: Exp <theexp111@gmail.com>

* Changed null check to tryget in case for cloning UiButton.Clone

* Parameterized Cloning time on serverside component

* tried to reset Robust toolbox module to current master

* Added null check to ghost client component message handling, unsubscribe to the mind component listening to the cloning question ui, fixed _clonningProgress typo, moved CloningPod component dependencies to actually be dependencies, removed un-needed disposals of cloning windows, added disposals missing in boundUserInterfaces.

* Reset submodule

* corrected exception for cloning pod visualizer to refer to cloning pod state and not medical scanner state

* Fix typo

* Unsubscribe from onUiReceiveMessage in mindcomponent in the onRemove function, not the acceptcloningui function

* unsubscribe from OnUiReceiveMessage in CloningPodComponent

* unssubscribe from ghostreturn message in cloningpodComponent onRemove

Co-authored-by: Exp <theexp111@gmail.com>
Co-authored-by: DrSmugleaf <DrSmugleaf@users.noreply.github.com>

Content.Server/GameObjects/Components/Medical/CloningPodComponent.cs

@@ -0,0 +1,235 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Server.GameObjects.Components.Mobs;
+using Content.Server.GameObjects.Components.Observer;
+using Content.Server.GameObjects.Components.Power.ApcNetComponents;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces;
+using Content.Server.Mobs;
+using Content.Server.Utility;
+using Content.Shared.GameObjects.Components.Damage;
+using Content.Shared.GameObjects.Components.Medical;
+using Content.Shared.Interfaces.GameObjects.Components;
+using Content.Shared.Preferences;
+using Robust.Server.GameObjects;
+using Robust.Server.GameObjects.Components.Container;
+using Robust.Server.GameObjects.Components.UserInterface;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Server.Interfaces.Player;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Network;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.GameObjects.Components.Medical
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class CloningPodComponent : SharedCloningPodComponent, IActivate
+    {
+        [Dependency] private readonly IServerPreferencesManager _prefsManager = null!;
+        [Dependency] private readonly IEntityManager _entityManager = null!;
+        [Dependency] private readonly IPlayerManager _playerManager = null!;
+
+        [ViewVariables]
+        private bool Powered => !Owner.TryGetComponent(out PowerReceiverComponent? receiver) || receiver.Powered;
+
+        [ViewVariables]
+        private BoundUserInterface? UserInterface =>
+            Owner.GetUIOrNull(CloningPodUIKey.Key);
+
+        private ContainerSlot _bodyContainer = default!;
+        private Mind? _capturedMind;
+        private CloningPodStatus _status;
+        private float _cloningProgress = 0;
+        private float _cloningTime;
+
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(ref _cloningTime, "cloningTime", 10f);
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage += OnUiReceiveMessage;
+            }
+
+            _bodyContainer = ContainerManagerComponent.Ensure<ContainerSlot>($"{Name}-bodyContainer", Owner);
+
+            //TODO: write this so that it checks for a change in power events for GORE POD cases
+            var newState = GetUserInterfaceState();
+            UserInterface?.SetState(newState);
+
+            UpdateUserInterface();
+
+            Owner.EntityManager.EventBus.SubscribeEvent<GhostComponent.GhostReturnMessage>(EventSource.Local, this,
+                HandleGhostReturn);
+        }
+
+        public void Update(float frametime)
+        {
+            if (_bodyContainer.ContainedEntity != null &&
+                Powered)
+            {
+                _cloningProgress += frametime;
+                _cloningProgress = MathHelper.Clamp(_cloningProgress, 0f, _cloningTime);
+            }
+
+            if (_cloningProgress >= _cloningTime &&
+                _bodyContainer.ContainedEntity != null &&
+                _capturedMind?.Session.AttachedEntity == _bodyContainer.ContainedEntity &&
+                Powered)
+            {
+                _bodyContainer.Remove(_bodyContainer.ContainedEntity);
+                _capturedMind = null;
+                _cloningProgress = 0f;
+
+                _status = CloningPodStatus.Idle;
+                UpdateAppearance();
+            }
+
+            UpdateUserInterface();
+        }
+
+        public override void OnRemove()
+        {
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage -= OnUiReceiveMessage;
+            }
+
+            Owner.EntityManager.EventBus.UnsubscribeEvent<GhostComponent.GhostReturnMessage>(EventSource.Local, this);
+
+            base.OnRemove();
+        }
+
+        private void UpdateUserInterface()
+        {
+            if (!Powered) return;
+
+            UserInterface?.SetState(GetUserInterfaceState());
+        }
+
+        private CloningPodBoundUserInterfaceState GetUserInterfaceState()
+        {
+            return new CloningPodBoundUserInterfaceState(CloningSystem.getIdToUser(), _cloningProgress,
+                (_status == CloningPodStatus.Cloning));
+        }
+
+        private void UpdateAppearance()
+        {
+            if (Owner.TryGetComponent(out AppearanceComponent? appearance))
+            {
+                appearance.SetData(CloningPodVisuals.Status, _status);
+            }
+        }
+
+        public void Activate(ActivateEventArgs eventArgs)
+        {
+            if (!Powered ||
+                !eventArgs.User.TryGetComponent(out IActorComponent? actor))
+            {
+                return;
+            }
+
+            UserInterface?.Open(actor.playerSession);
+        }
+
+        private async void OnUiReceiveMessage(ServerBoundUserInterfaceMessage obj)
+        {
+            if (!(obj.Message is CloningPodUiButtonPressedMessage message)) return;
+
+            switch (message.Button)
+            {
+                case UiButton.Clone:
+
+                    if (message.ScanId == null) return;
+
+                    if (_bodyContainer.ContainedEntity != null ||
+                        !CloningSystem.Minds.TryGetValue(message.ScanId.Value, out var mind))
+                    {
+                        return;
+                    }
+
+                    var dead =
+                        mind.OwnedEntity.TryGetComponent<IDamageableComponent>(out var damageable) &&
+                        damageable.CurrentDamageState == DamageState.Dead;
+                    if (!dead) return;
+
+
+                    var mob = _entityManager.SpawnEntity("HumanMob_Content", Owner.Transform.MapPosition);
+                    var client = _playerManager
+                        .GetPlayersBy(x => x.SessionId == mind.SessionId).First();
+                    mob.GetComponent<HumanoidAppearanceComponent>()
+                        .UpdateFromProfile(GetPlayerProfileAsync(client.Name).Result);
+                    mob.Name = GetPlayerProfileAsync(client.Name).Result.Name;
+
+                    _bodyContainer.Insert(mob);
+                    _capturedMind = mind;
+
+                    Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
+                        new CloningStartedMessage(_capturedMind));
+                    _status = CloningPodStatus.NoMind;
+                    UpdateAppearance();
+
+                    break;
+
+                case UiButton.Eject:
+                    if (_bodyContainer.ContainedEntity == null || _cloningProgress < _cloningTime) break;
+
+                    _bodyContainer.Remove(_bodyContainer.ContainedEntity!);
+                    _capturedMind = null;
+                    _cloningProgress = 0f;
+                    _status = CloningPodStatus.Idle;
+                    UpdateAppearance();
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public class CloningStartedMessage : EntitySystemMessage
+        {
+            public CloningStartedMessage(Mind capturedMind)
+            {
+                CapturedMind = capturedMind;
+            }
+
+            public Mind CapturedMind { get; }
+        }
+
+
+        private async Task<HumanoidCharacterProfile> GetPlayerProfileAsync(string username)
+        {
+            return (HumanoidCharacterProfile) (await _prefsManager.GetPreferencesAsync(username))
+                .SelectedCharacter;
+        }
+
+        private void HandleGhostReturn(GhostComponent.GhostReturnMessage message)
+        {
+            if (message.Sender == _capturedMind)
+            {
+                //If the captured mind is in a ghost, we want to get rid of it.
+                _capturedMind.VisitingEntity?.Delete();
+
+                //Transfer the mind to the new mob
+                _capturedMind.TransferTo(_bodyContainer.ContainedEntity);
+
+                _status = CloningPodStatus.Cloning;
+                UpdateAppearance();
+            }
+        }
+    }
+}

Content.Server/GameObjects/Components/Medical/MedicalScannerComponent.cs

@@ -1,9 +1,14 @@
 #nullable enable
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using Content.Server.GameObjects.Components.Body;
+using Content.Server.GameObjects.Components.Mobs;
 using Content.Server.GameObjects.Components.Power.ApcNetComponents;
 using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Players;
 using Content.Server.Utility;
+using Content.Shared.Damage;
 using Content.Shared.GameObjects.Components.Damage;
 using Content.Shared.GameObjects.Components.Medical;
 using Content.Shared.GameObjects.EntitySystems;
@@ -13,21 +18,24 @@ using Robust.Server.GameObjects;
 using Robust.Server.GameObjects.Components.Container;
 using Robust.Server.GameObjects.Components.UserInterface;
 using Robust.Server.Interfaces.GameObjects;
+using Robust.Server.Interfaces.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Maths;
-using Content.Shared.Damage;
+using Robust.Shared.IoC;
 using Robust.Shared.Localization;
+using Robust.Shared.Maths;
 using Robust.Shared.ViewVariables;
 
 namespace Content.Server.GameObjects.Components.Medical
 {
     [RegisterComponent]
     [ComponentReference(typeof(IActivate))]
-    public class MedicalScannerComponent : SharedMedicalScannerComponent, IActivate
+    public class MedicalScannerComponent : SharedMedicalScannerComponent, IActivate, IDragDropOn
     {
         private ContainerSlot _bodyContainer = default!;
         private readonly Vector2 _ejectOffset = new Vector2(-0.5f, 0f);
+
+        [Dependency] private readonly IPlayerManager _playerManager = null!;
         public bool IsOccupied => _bodyContainer.ContainedEntity != null;
 
         [ViewVariables]
@@ -68,13 +76,12 @@ namespace Content.Server.GameObjects.Components.Medical
                 if (Owner.TryGetComponent(out AppearanceComponent? appearance))
                 {
                     appearance?.SetData(MedicalScannerVisuals.Status, MedicalScannerStatus.Open);
-                };
+                }
 
                 return EmptyUIState;
             }
 
-            if (!body.TryGetComponent(out IDamageableComponent? damageable) ||
-                damageable.CurrentDamageState == DamageState.Dead)
+            if (!body.TryGetComponent(out IDamageableComponent? damageable))
             {
                 return EmptyUIState;
             }
@@ -82,7 +89,14 @@ namespace Content.Server.GameObjects.Components.Medical
             var classes = new Dictionary<DamageClass, int>(damageable.DamageClasses);
             var types = new Dictionary<DamageType, int>(damageable.DamageTypes);
 
-            return new MedicalScannerBoundUserInterfaceState(body.Uid, classes, types, CloningSystem.HasUid(body.Uid));
+            if (_bodyContainer.ContainedEntity?.Uid == null)
+            {
+                return new MedicalScannerBoundUserInterfaceState(body.Uid, classes, types, true);
+            }
+
+
+            return new MedicalScannerBoundUserInterfaceState(body.Uid, classes, types,
+                CloningSystem.HasDnaScan(_bodyContainer.ContainedEntity.GetComponent<MindComponent>().Mind));
         }
 
         private void UpdateUserInterface()
@@ -207,22 +221,41 @@ namespace Content.Server.GameObjects.Components.Medical
 
         private void OnUiReceiveMessage(ServerBoundUserInterfaceMessage obj)
         {
-            if (!(obj.Message is UiButtonPressedMessage message))
-            {
-                return;
-            }
+            if (!(obj.Message is UiButtonPressedMessage message)) return;
 
             switch (message.Button)
             {
                 case UiButton.ScanDNA:
                     if (_bodyContainer.ContainedEntity != null)
                     {
-                        CloningSystem.AddToScannedUids(_bodyContainer.ContainedEntity.Uid);
+                        //TODO: Show a 'ERROR: Body is completely devoid of soul' if no Mind owns the entity.
+                        CloningSystem.AddToDnaScans(_playerManager
+                            .GetPlayersBy(playerSession =>
+                            {
+                                var mindOwnedMob = playerSession.ContentData()?.Mind?.OwnedEntity;
+
+                                return mindOwnedMob != null && mindOwnedMob ==
+                                    _bodyContainer.ContainedEntity;
+                            }).Single()
+                            .ContentData()
+                            ?.Mind);
                     }
+
                     break;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
         }
+
+        public bool CanDragDropOn(DragDropEventArgs eventArgs)
+        {
+            return eventArgs.Dropped.HasComponent<BodyManagerComponent>();
+        }
+
+        public bool DragDropOn(DragDropEventArgs eventArgs)
+        {
+            _bodyContainer.Insert(eventArgs.Dropped);
+            return true;
+        }
     }
 }

Content.Server/GameObjects/Components/Mobs/MindComponent.cs

@@ -1,9 +1,16 @@
 #nullable enable
+using System;
+using Content.Server.GameObjects.Components.Body;
+using Content.Server.GameObjects.Components.Medical;
 using Content.Server.GameObjects.Components.Observer;
 using Content.Server.Interfaces.GameTicking;
 using Content.Server.Mobs;
+using Content.Server.Utility;
+using Content.Shared.GameObjects.Components;
 using Content.Shared.GameObjects.Components.Damage;
+using Content.Shared.GameObjects.Components.Mobs;
 using Content.Shared.GameObjects.EntitySystems;
+using Robust.Server.GameObjects.Components.UserInterface;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.Interfaces.Map;
@@ -14,6 +21,7 @@ using Robust.Shared.Serialization;
 using Robust.Shared.Timers;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
+using Serilog.Debugging;
 
 namespace Content.Server.GameObjects.Components.Mobs
 {
@@ -50,6 +58,45 @@ namespace Content.Server.GameObjects.Components.Mobs
             set => _showExamineInfo = value;
         }
 
+        [ViewVariables]
+        private BoundUserInterface? UserInterface =>
+            Owner.GetUIOrNull(SharedAcceptCloningComponent.AcceptCloningUiKey.Key);
+
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            Owner.EntityManager.EventBus.SubscribeEvent<CloningPodComponent.CloningStartedMessage>(
+                EventSource.Local, this,
+                HandleCloningStartedMessage);
+
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage += OnUiAcceptCloningMessage;
+            }
+        }
+
+        private void HandleCloningStartedMessage(CloningPodComponent.CloningStartedMessage ev)
+        {
+            if (ev.CapturedMind == Mind)
+            {
+                UserInterface?.Open(Mind.Session);
+            }
+        }
+
+        private void OnUiAcceptCloningMessage(ServerBoundUserInterfaceMessage obj)
+        {
+            if (!(obj.Message is SharedAcceptCloningComponent.UiButtonPressedMessage message)) return;
+            Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new GhostComponent.GhostReturnMessage(Mind));
+        }
+
+        public override void OnRemove()
+        {
+            base.OnRemove();
+            Owner.EntityManager.EventBus.UnsubscribeEvent<CloningPodComponent.CloningStartedMessage>(EventSource.Local, this);
+            if (UserInterface != null) UserInterface.OnReceiveMessage -= OnUiAcceptCloningMessage;
+        }
+
         /// <summary>
         ///     Don't call this unless you know what the hell you're doing.
         ///     Use <see cref="Mind.TransferTo(IEntity)"/> instead.
@@ -133,13 +180,19 @@ namespace Content.Server.GameObjects.Components.Mobs
             if (!HasMind)
             {
                 message.AddMarkup(!dead
-                    ? $"[color=red]" + Loc.GetString("{0:They} {0:are} totally catatonic. The stresses of life in deep-space must have been too much for {0:them}. Any recovery is unlikely.", Owner) + "[/color]"
+                    ? $"[color=red]" +
+                      Loc.GetString(
+                          "{0:They} {0:are} totally catatonic. The stresses of life in deep-space must have been too much for {0:them}. Any recovery is unlikely.",
+                          Owner) + "[/color]"
                     : $"[color=purple]" + Loc.GetString("{0:Their} soul has departed.", Owner) + "[/color]");
             }
             else if (Mind?.Session == null)
             {
-                if(!dead)
-                    message.AddMarkup("[color=yellow]" + Loc.GetString("{0:They} {0:have} a blank, absent-minded stare and appears completely unresponsive to anything. {0:They} may snap out of it soon.", Owner) + "[/color]");
+                if (!dead)
+                    message.AddMarkup("[color=yellow]" +
+                                      Loc.GetString(
+                                          "{0:They} {0:have} a blank, absent-minded stare and appears completely unresponsive to anything. {0:They} may snap out of it soon.",
+                                          Owner) + "[/color]");
             }
         }
     }

Content.Server/GameObjects/Components/Observer/GhostComponent.cs

@@ -1,4 +1,6 @@
-using Content.Server.Players;
+using Content.Server.GameObjects.Components.Mobs;
+using Content.Server.Mobs;
+using Content.Server.Players;
 using Content.Shared.GameObjects.Components.Observer;
 using Robust.Server.GameObjects;
 using Robust.Server.GameObjects.Components;
@@ -31,7 +33,7 @@ namespace Content.Server.GameObjects.Components.Observer
         {
             base.Initialize();
 
-            Owner.EnsureComponent<VisibilityComponent>().Layer = (int)VisibilityFlags.Ghost;
+            Owner.EnsureComponent<VisibilityComponent>().Layer = (int) VisibilityFlags.Ghost;
         }
 
         public override ComponentState GetComponentState() => new GhostComponentState(CanReturnToBody);
@@ -43,18 +45,19 @@ namespace Content.Server.GameObjects.Components.Observer
             switch (message)
             {
                 case PlayerAttachedMsg msg:
-                    msg.NewPlayer.VisibilityMask |= (int)VisibilityFlags.Ghost;
+                    msg.NewPlayer.VisibilityMask |= (int) VisibilityFlags.Ghost;
                     Dirty();
                     break;
                 case PlayerDetachedMsg msg:
-                    msg.OldPlayer.VisibilityMask &= ~(int)VisibilityFlags.Ghost;
+                    msg.OldPlayer.VisibilityMask &= ~(int) VisibilityFlags.Ghost;
                     break;
                 default:
                     break;
             }
         }
 
-        public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession session = null)
+        public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel,
+            ICommonSession session = null)
         {
             base.HandleNetworkMessage(message, netChannel, session);
 
@@ -67,10 +70,29 @@ namespace Content.Server.GameObjects.Components.Observer
                         actor.playerSession.ContentData().Mind.UnVisit();
                         Owner.Delete();
                     }
+
+                    break;
+                case ReturnToCloneComponentMessage reenter:
+
+                    if (Owner.TryGetComponent(out VisitingMindComponent mind))
+                    {
+                        Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new GhostReturnMessage(mind.Mind));
+                    }
+
                     break;
                 default:
                     break;
             }
         }
+
+        public class GhostReturnMessage : EntitySystemMessage
+        {
+            public GhostReturnMessage(Mind sender)
+            {
+                Sender = sender;
+            }
+
+            public Mind Sender { get; }
+        }
     }
 }