Biomass (#10313)

* Material

* good prototype

* Fix material storage

* You can insert biomass into the cloner

* ok, basic biomass subtraction works

* amogus

* ok chance works

* Alright, the biomass and genetic stuff works

* feedback for cloning

* more reclaimer polish

* ship it

* starting biomass + fix lathes

* I changed my mind on rat mass and these guys are definitely getting ground up

* Doafter

* clean up, sync the two

* fix naming, fix mass

* technology + construction

* additional logging, stop unanchoring when active

* fix event / logs

* dont gib dead salvage

* auto eject

* fix deconstruction behavior

* make warning message better, temporarily disable cancer scanner

* fix biomass stacks

* add easy mode CVAR

* stack cleanup, make biomass 2x as fast

* bugfix

* new sprite from hyenh

* fix tests

* hello? :smilethink:

* :smilethink:

* medical scanner gets antirotting

* fix cloner and medical scanner

Co-authored-by: Moony <moonheart08@users.noreply.github.com>

Content.Server/Cloning/CloningConsoleSystem.cs

@@ -7,8 +7,8 @@ using Content.Server.Mind.Components;
 using Content.Server.MachineLinking.System;
 using Content.Server.MachineLinking.Events;
 using Content.Server.UserInterface;
-using Content.Shared.MobState.Components;
 using Content.Server.MobState;
+using Content.Shared.MobState.Components;
 using Content.Server.Power.EntitySystems;
 using Robust.Server.GameObjects;
 using Robust.Server.Player;
@@ -55,10 +55,6 @@ namespace Content.Server.Cloning.Systems
                     if (consoleComponent.GeneticScanner != null && consoleComponent.CloningPod != null)
                         TryClone(uid, consoleComponent.CloningPod.Value, consoleComponent.GeneticScanner.Value, consoleComponent: consoleComponent);
                     break;
-                case UiButton.Eject:
-                    if (consoleComponent.CloningPod != null)
-                        TryEject(uid, consoleComponent.CloningPod.Value, consoleComponent: consoleComponent);
-                    break;
             }
             UpdateUserInterface(consoleComponent);
         }
@@ -123,14 +119,6 @@ namespace Content.Server.Cloning.Systems
             _uiSystem.GetUiOrNull(consoleComponent.Owner, CloningConsoleUiKey.Key)?.SetState(newState);
         }
 
-        public void TryEject(EntityUid uid, EntityUid clonePodUid, CloningPodComponent? cloningPod = null, CloningConsoleComponent? consoleComponent = null)
-        {
-            if (!Resolve(uid, ref consoleComponent) || !Resolve(clonePodUid, ref cloningPod))
-                return;
-
-            _cloningSystem.Eject(clonePodUid, cloningPod);
-        }
-
         public void TryClone(EntityUid uid, EntityUid cloningPodUid, EntityUid scannerUid, CloningPodComponent? cloningPod = null, MedicalScannerComponent? scannerComp = null, CloningConsoleComponent? consoleComponent = null)
         {
             if (!Resolve(uid, ref consoleComponent) || !Resolve(cloningPodUid, ref cloningPod)  || !Resolve(scannerUid, ref scannerComp))
@@ -222,9 +210,10 @@ namespace Content.Server.Cloning.Systems
                 EntityUid? cloneBody = clonePod.BodyContainer.ContainedEntity;
 
                 clonerMindPresent = clonePod.Status == CloningPodStatus.Cloning;
-                if (cloneBody != null)
+                if (HasComp<ActiveCloningPodComponent>(consoleComponent.CloningPod))
                 {
-                    cloneBodyInfo = Identity.Name(cloneBody.Value, EntityManager);
+                    if (cloneBody != null)
+                        cloneBodyInfo = Identity.Name(cloneBody.Value, EntityManager);
                     clonerStatus = ClonerStatus.ClonerOccupied;
                 }
             }
@@ -244,5 +233,6 @@ namespace Content.Server.Cloning.Systems
                 clonerInRange
                 );
         }
+
     }
 }

Content.Server/Cloning/CloningSystem.cs

@@ -1,19 +1,35 @@
-using Content.Server.Cloning.Components;
-using Content.Server.Mind.Components;
-using Content.Server.Power.EntitySystems;
 using Content.Shared.GameTicking;
 using Content.Shared.CharacterAppearance.Systems;
 using Content.Shared.CharacterAppearance.Components;
 using Content.Shared.Species;
-using Robust.Server.Player;
-using Robust.Shared.Prototypes;
-using Content.Server.EUI;
-using Robust.Shared.Containers;
-using Robust.Server.Containers;
+using Content.Shared.Damage;
+using Content.Shared.Stacks;
+using Content.Shared.Examine;
 using Content.Shared.Cloning;
+using Content.Shared.Atmos;
+using Content.Shared.CCVar;
+using Content.Server.Cloning.Components;
+using Content.Server.Mind.Components;
+using Content.Server.Power.EntitySystems;
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.EUI;
 using Content.Server.MachineLinking.System;
 using Content.Server.MachineLinking.Events;
 using Content.Server.MobState;
+using Content.Server.Lathe.Components;
+using Content.Shared.Chemistry.Components;
+using Content.Server.Fluids.EntitySystems;
+using Content.Server.Chat.Systems;
+using Content.Server.Construction.Components;
+using Content.Server.Stack;
+using Robust.Server.GameObjects;
+using Robust.Server.Containers;
+using Robust.Server.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Configuration;
+using Robust.Shared.Containers;
+
 
 namespace Content.Server.Cloning.Systems
 {
@@ -28,17 +44,29 @@ namespace Content.Server.Cloning.Systems
         [Dependency] private readonly ContainerSystem _containerSystem = default!;
         [Dependency] private readonly MobStateSystem _mobStateSystem = default!;
         [Dependency] private readonly PowerReceiverSystem _powerReceiverSystem = default!;
+        [Dependency] private readonly IRobustRandom _robustRandom = default!;
+        [Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
+        [Dependency] private readonly TransformSystem _transformSystem = default!;
+        [Dependency] private readonly SharedStackSystem _stackSystem = default!;
+        [Dependency] private readonly StackSystem _serverStackSystem = default!;
+        [Dependency] private readonly SpillableSystem _spillableSystem = default!;
+        [Dependency] private readonly ChatSystem _chatSystem = default!;
+        [Dependency] private readonly IConfigurationManager _configManager = default!;
+
         public readonly Dictionary<Mind.Mind, EntityUid> ClonesWaitingForMind = new();
+        public const float EasyModeCloningCost = 0.7f;
 
         public override void Initialize()
         {
             base.Initialize();
 
             SubscribeLocalEvent<CloningPodComponent, ComponentInit>(OnComponentInit);
+            SubscribeLocalEvent<CloningPodComponent, MachineDeconstructedEvent>(OnDeconstruct);
             SubscribeLocalEvent<RoundRestartCleanupEvent>(Reset);
             SubscribeLocalEvent<BeingClonedComponent, MindAddedMessage>(HandleMindAdded);
             SubscribeLocalEvent<CloningPodComponent, PortDisconnectedEvent>(OnPortDisconnected);
             SubscribeLocalEvent<CloningPodComponent, AnchorStateChangedEvent>(OnAnchor);
+            SubscribeLocalEvent<CloningPodComponent, ExaminedEvent>(OnExamined);
         }
 
         private void OnComponentInit(EntityUid uid, CloningPodComponent clonePod, ComponentInit args)
@@ -47,6 +75,14 @@ namespace Content.Server.Cloning.Systems
             _signalSystem.EnsureReceiverPorts(uid, CloningPodComponent.PodPort);
         }
 
+        private void OnDeconstruct(EntityUid uid, CloningPodComponent component, MachineDeconstructedEvent args)
+        {
+            if (!TryComp<MaterialStorageComponent>(uid, out var storage))
+                return;
+
+            _serverStackSystem.SpawnMultiple(storage.GetMaterialAmount("Biomass"), 100, "Biomass", Transform(uid).Coordinates);
+        }
+
         private void UpdateAppearance(CloningPodComponent clonePod)
         {
             if (TryComp<AppearanceComponent>(clonePod.Owner, out var appearance))
@@ -97,11 +133,23 @@ namespace Content.Server.Cloning.Systems
             _cloningConsoleSystem.UpdateUserInterface(console);
         }
 
+        private void OnExamined(EntityUid uid, CloningPodComponent component, ExaminedEvent args)
+        {
+            if (!args.IsInDetailsRange || !_powerReceiverSystem.IsPowered(uid))
+                return;
+
+            if (TryComp<MaterialStorageComponent>(uid, out var storage))
+                args.PushMarkup(Loc.GetString("cloning-pod-biomass", ("number", storage.GetMaterialAmount("Biomass"))));
+        }
+
         public bool TryCloning(EntityUid uid, EntityUid bodyToClone, Mind.Mind mind, CloningPodComponent? clonePod)
         {
             if (!Resolve(uid, ref clonePod) || bodyToClone == null)
                 return false;
 
+            if (HasComp<ActiveCloningPodComponent>(uid))
+                return false;
+
             if (ClonesWaitingForMind.TryGetValue(mind, out var clone))
             {
                 if (EntityManager.EntityExists(clone) &&
@@ -120,11 +168,56 @@ namespace Content.Server.Cloning.Systems
             if (mind.UserId == null || !_playerManager.TryGetSessionById(mind.UserId.Value, out var client))
                 return false; // If we can't track down the client, we can't offer transfer. That'd be quite bad.
 
+            if (!TryComp<MaterialStorageComponent>(clonePod.Owner, out var podStorage))
+                return false;
+
             if (!TryComp<HumanoidAppearanceComponent>(bodyToClone, out var humanoid))
                 return false; // whatever body was to be cloned, was not a humanoid
 
-            var speciesProto = _prototype.Index<SpeciesPrototype>(humanoid.Species).Prototype;
-            var mob = Spawn(speciesProto, Transform(clonePod.Owner).MapPosition);
+            if (!_prototype.TryIndex<SpeciesPrototype>(humanoid.Species, out var speciesPrototype))
+                return false;
+
+            if (!TryComp<PhysicsComponent>(bodyToClone, out var physics))
+                return false;
+
+            int cloningCost = (int) physics.FixturesMass;
+
+            if (_configManager.GetCVar(CCVars.BiomassEasyMode))
+                cloningCost = (int) Math.Round(cloningCost * EasyModeCloningCost);
+
+            // biomass checks
+            var biomassAmount = podStorage.GetMaterialAmount("Biomass");
+
+            if (biomassAmount < cloningCost)
+            {
+                if (clonePod.ConnectedConsole != null)
+                    _chatSystem.TrySendInGameICMessage(clonePod.ConnectedConsole.Value, Loc.GetString("cloning-console-chat-error", ("units", cloningCost)), InGameICChatType.Speak, false);
+                return false;
+            }
+
+            podStorage.RemoveMaterial("Biomass", cloningCost);
+            clonePod.UsedBiomass = cloningCost;
+            // end of biomass checks
+
+            // genetic damage checks
+            if (TryComp<DamageableComponent>(bodyToClone, out var damageable) &&
+                damageable.Damage.DamageDict.TryGetValue("Cellular", out var cellularDmg))
+            {
+                var chance = Math.Clamp((float) (cellularDmg / 100), 0, 1);
+                if (cellularDmg > 0 && clonePod.ConnectedConsole != null)
+                    _chatSystem.TrySendInGameICMessage(clonePod.ConnectedConsole.Value, Loc.GetString("cloning-console-cellular-warning", ("percent", Math.Round(100 - (chance * 100)))), InGameICChatType.Speak, false);
+
+                if (_robustRandom.Prob(chance))
+                {
+                    UpdateStatus(CloningPodStatus.Gore, clonePod);
+                    clonePod.FailedClone = true;
+                    AddComp<ActiveCloningPodComponent>(uid);
+                    return true;
+                }
+            }
+            // end of genetic damage checks
+
+            var mob = Spawn(speciesPrototype.Prototype, Transform(clonePod.Owner).MapPosition);
             _appearanceSystem.UpdateAppearance(mob, humanoid.Appearance);
             _appearanceSystem.UpdateSexGender(mob, humanoid.Sex, humanoid.Gender);
 
@@ -156,16 +249,17 @@ namespace Content.Server.Cloning.Systems
                 if (!_powerReceiverSystem.IsPowered(cloning.Owner))
                     continue;
 
-                if (cloning.BodyContainer.ContainedEntity != null)
-                {
-                    cloning.CloningProgress += frameTime;
-                    cloning.CloningProgress = MathHelper.Clamp(cloning.CloningProgress, 0f, cloning.CloningTime);
-                }
+                if (cloning.BodyContainer.ContainedEntity == null && !cloning.FailedClone)
+                    continue;
 
-                if (cloning.CapturedMind?.Session?.AttachedEntity == cloning.BodyContainer.ContainedEntity)
-                {
+                cloning.CloningProgress += frameTime;
+                if (cloning.CloningProgress < cloning.CloningTime)
+                    continue;
+
+                if (cloning.FailedClone)
+                    EndFailedCloning(cloning.Owner, cloning);
+                else
                     Eject(cloning.Owner, cloning);
-                }
             }
         }
 
@@ -181,10 +275,40 @@ namespace Content.Server.Cloning.Systems
             clonePod.BodyContainer.Remove(entity);
             clonePod.CapturedMind = null;
             clonePod.CloningProgress = 0f;
+            clonePod.UsedBiomass = 0;
             UpdateStatus(CloningPodStatus.Idle, clonePod);
             RemCompDeferred<ActiveCloningPodComponent>(uid);
         }
 
+        private void EndFailedCloning(EntityUid uid, CloningPodComponent clonePod)
+        {
+            clonePod.FailedClone = false;
+            clonePod.CloningProgress = 0f;
+            UpdateStatus(CloningPodStatus.Idle, clonePod);
+            var transform = Transform(uid);
+            var indices = _transformSystem.GetGridOrMapTilePosition(uid);
+
+            var tileMix = _atmosphereSystem.GetTileMixture(transform.GridUid, null, indices, true);
+
+            Solution bloodSolution = new();
+
+            int i = 0;
+            while (i < 1)
+            {
+                tileMix?.AdjustMoles(Gas.Miasma, 6f);
+                bloodSolution.AddReagent("Blood", 50);
+                if (_robustRandom.Prob(0.2f))
+                    i++;
+            }
+            _spillableSystem.SpillAt(uid, bloodSolution, "PuddleBlood");
+
+            var biomassStack = Spawn("MaterialBiomass", transform.Coordinates);
+            _stackSystem.SetCount(biomassStack, _robustRandom.Next(1, (int) (clonePod.UsedBiomass / 2.5)));
+
+            clonePod.UsedBiomass = 0;
+            RemCompDeferred<ActiveCloningPodComponent>(uid);
+        }
+
         public void Reset(RoundRestartCleanupEvent ev)
         {
             ClonesWaitingForMind.Clear();

Content.Server/Cloning/Components/CloningPodComponent.cs

@@ -10,6 +10,8 @@ namespace Content.Server.Cloning.Components
         [ViewVariables] public ContainerSlot BodyContainer = default!;
         [ViewVariables] public Mind.Mind? CapturedMind;
         [ViewVariables] public float CloningProgress = 0;
+        [ViewVariables] public int UsedBiomass = 70;
+        [ViewVariables] public bool FailedClone = false;
         [DataField("cloningTime")]
         [ViewVariables] public float CloningTime = 30f;
         [ViewVariables] public CloningPodStatus Status;