Merge remote-tracking branch 'upstream/master' into 20-10-30-admins

Content.Server/GameObjects/Components/Body/Behavior/BrainBehavior.cs

@@ -1,22 +1,14 @@
 #nullable enable
 using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.Mobs;
 using Content.Shared.GameObjects.Components.Body;
-using Content.Shared.GameObjects.Components.Body.Behavior;
 using Content.Shared.GameObjects.Components.Body.Part;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.ComponentDependencies;
 using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Log;
-using Robust.Shared.ViewVariables;
 
 namespace Content.Server.GameObjects.Components.Body.Behavior
 {
-    [RegisterComponent]
-    public class BrainBehaviorComponent : MechanismBehaviorComponent
+    public class BrainBehavior : MechanismBehavior
     {
-        public override string Name => "Brain";
-
         protected override void OnAddedToBody(IBody body)
         {
             base.OnAddedToBody(body);
@@ -66,9 +58,5 @@ namespace Content.Server.GameObjects.Components.Body.Behavior
 
             oldMind.Mind?.TransferTo(newEntity);
         }
-
-        public override void Update(float frameTime)
-        {
-        }
     }
 }

Content.Server/GameObjects/Components/Body/Behavior/HeartBehavior.cs

@@ -1,20 +1,17 @@
 using Content.Shared.GameObjects.Components.Body.Behavior;
 using Content.Shared.GameObjects.Components.Body.Networks;
-using Robust.Shared.GameObjects;
 
 namespace Content.Server.GameObjects.Components.Body.Behavior
 {
-    [RegisterComponent]
-    [ComponentReference(typeof(SharedHeartBehaviorComponent))]
-    public class HeartBehaviorComponent : SharedHeartBehaviorComponent
+    public class HeartBehavior : MechanismBehavior
     {
         private float _accumulatedFrameTime;
 
         public override void Update(float frameTime)
         {
             // TODO BODY do between pre and metabolism
-            if (Mechanism?.Body == null ||
-                !Mechanism.Body.Owner.HasComponent<SharedBloodstreamComponent>())
+            if (Parent.Body == null ||
+                !Parent.Body.Owner.HasComponent<SharedBloodstreamComponent>())
             {
                 return;
             }

Content.Server/GameObjects/Components/Body/Behavior/LungBehavior.cs

@@ -8,19 +8,15 @@ using Content.Server.GameObjects.Components.Body.Respiratory;
 using Content.Server.Utility;
 using Content.Shared.Atmos;
 using Content.Shared.GameObjects.Components.Body.Behavior;
-using Robust.Shared.GameObjects;
 using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
-using Robust.Shared.Log;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
 
 namespace Content.Server.GameObjects.Components.Body.Behavior
 {
-    [RegisterComponent]
-    [ComponentReference(typeof(SharedLungBehaviorComponent))]
-    public class LungBehaviorComponent : SharedLungBehaviorComponent
+    public class LungBehavior : MechanismBehavior
     {
         [Dependency] private readonly IGameTiming _gameTiming = default!;
 
@@ -30,18 +26,24 @@ namespace Content.Server.GameObjects.Components.Body.Behavior
 
         [ViewVariables] public GasMixture Air { get; set; } = default!;
 
-        [ViewVariables] public override float Temperature => Air.Temperature;
+        [ViewVariables] public float Temperature => Air.Temperature;
 
-        [ViewVariables] public override float Volume => Air.Volume;
+        [ViewVariables] public float Volume => Air.Volume;
 
         [ViewVariables] public TimeSpan GaspPopupCooldown { get; private set; }
 
+        [ViewVariables] public LungStatus Status { get; set; }
+
+        [ViewVariables] public float CycleDelay { get; set; }
+
         public override void ExposeData(ObjectSerializer serializer)
         {
             base.ExposeData(serializer);
 
             Air = new GasMixture {Temperature = Atmospherics.NormalBodyTemperature};
 
+            serializer.DataField(this, l => l.CycleDelay, "cycleDelay", 2);
+
             serializer.DataReadWriteFunction(
                 "volume",
                 6,
@@ -61,7 +63,7 @@ namespace Content.Server.GameObjects.Components.Body.Behavior
                 () => GaspPopupCooldown.TotalSeconds);
         }
 
-        public override void Gasp()
+        public void Gasp()
         {
             if (_gameTiming.CurTime >= _lastGaspPopupTime + GaspPopupCooldown)
             {
@@ -148,7 +150,7 @@ namespace Content.Server.GameObjects.Components.Body.Behavior
             _accumulatedFrameTime = absoluteTime - delay;
         }
 
-        public override void Inhale(float frameTime)
+        public void Inhale(float frameTime)
         {
             if (Body != null && Body.Owner.TryGetComponent(out InternalsComponent? internals)
                              && internals.BreathToolEntity != null && internals.GasTankEntity != null
@@ -176,7 +178,7 @@ namespace Content.Server.GameObjects.Components.Body.Behavior
             ToBloodstream(Air);
         }
 
-        public override void Exhale(float frameTime)
+        public void Exhale(float frameTime)
         {
             if (!Owner.Transform.Coordinates.TryGetTileAir(out var tileAir))
             {
@@ -218,4 +220,11 @@ namespace Content.Server.GameObjects.Components.Body.Behavior
             Air.Merge(lungRemoved);
         }
     }
+
+    public enum LungStatus
+    {
+        None = 0,
+        Inhaling,
+        Exhaling
+    }
 }

Content.Server/GameObjects/Components/Body/Behavior/MechanismBehavior.cs

@@ -0,0 +1,112 @@
+#nullable enable
+using Content.Shared.GameObjects.Components.Body;
+using Content.Shared.GameObjects.Components.Body.Behavior;
+using Content.Shared.GameObjects.Components.Body.Mechanism;
+using Content.Shared.GameObjects.Components.Body.Part;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Server.GameObjects.Components.Body.Behavior
+{
+    public abstract class MechanismBehavior : IMechanismBehavior
+    {
+        public IBody? Body => Part?.Body;
+
+        public IBodyPart? Part => Parent.Part;
+
+        public IMechanism Parent { get; private set; } = default!;
+
+        public IEntity Owner => Parent.Owner;
+
+        public virtual void ExposeData(ObjectSerializer serializer) { }
+
+        public virtual void Initialize(IMechanism parent)
+        {
+            Parent = parent;
+        }
+
+        public virtual void Startup()
+        {
+            if (Part == null)
+            {
+                return;
+            }
+
+            if (Body == null)
+            {
+                AddedToPart(Part);
+            }
+            else
+            {
+                AddedToPartInBody(Body, Part);
+            }
+        }
+
+        public void AddedToBody(IBody body)
+        {
+            DebugTools.AssertNotNull(Body);
+            DebugTools.AssertNotNull(body);
+
+            OnAddedToBody(body);
+        }
+
+        public void AddedToPart(IBodyPart part)
+        {
+            DebugTools.AssertNotNull(Part);
+            DebugTools.AssertNotNull(part);
+
+            OnAddedToPart(part);
+        }
+
+        public void AddedToPartInBody(IBody body, IBodyPart part)
+        {
+            DebugTools.AssertNotNull(Body);
+            DebugTools.AssertNotNull(body);
+            DebugTools.AssertNotNull(Part);
+            DebugTools.AssertNotNull(part);
+
+            OnAddedToPartInBody(body, part);
+        }
+
+        public void RemovedFromBody(IBody old)
+        {
+            DebugTools.AssertNull(Body);
+            DebugTools.AssertNotNull(old);
+
+            OnRemovedFromBody(old);
+        }
+
+        public void RemovedFromPart(IBodyPart old)
+        {
+            DebugTools.AssertNull(Part);
+            DebugTools.AssertNotNull(old);
+
+            OnRemovedFromPart(old);
+        }
+
+        public void RemovedFromPartInBody(IBody oldBody, IBodyPart oldPart)
+        {
+            DebugTools.AssertNull(Body);
+            DebugTools.AssertNull(Part);
+            DebugTools.AssertNotNull(oldBody);
+            DebugTools.AssertNotNull(oldPart);
+
+            OnRemovedFromPartInBody(oldBody, oldPart);
+        }
+
+        protected virtual void OnAddedToBody(IBody body) { }
+
+        protected virtual void OnAddedToPart(IBodyPart part) { }
+
+        protected virtual void OnAddedToPartInBody(IBody body, IBodyPart part) { }
+
+        protected virtual void OnRemovedFromBody(IBody old) { }
+
+        protected virtual void OnRemovedFromPart(IBodyPart old) { }
+
+        protected virtual void OnRemovedFromPartInBody(IBody oldBody, IBodyPart oldPart) { }
+
+        public virtual void Update(float frameTime) { }
+    }
+}

Content.Server/GameObjects/Components/Body/Behavior/MechanismExtensions.cs

@@ -0,0 +1,74 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Content.Shared.GameObjects.Components.Body;
+using Content.Shared.GameObjects.Components.Body.Behavior;
+using Content.Shared.GameObjects.Components.Body.Part;
+
+namespace Content.Server.GameObjects.Components.Body.Behavior
+{
+    public static class MechanismExtensions
+    {
+        public static bool HasMechanismBehavior<T>(this IBody body) where T : IMechanismBehavior
+        {
+            return body.Parts.Values.Any(p => p.HasMechanismBehavior<T>());
+        }
+
+        public static bool HasMechanismBehavior<T>(this IBodyPart part) where T : IMechanismBehavior
+        {
+            return part.Mechanisms.Any(m => m.HasBehavior<T>());
+        }
+
+        public static IEnumerable<IMechanismBehavior> GetMechanismBehaviors(this IBody body)
+        {
+            foreach (var part in body.Parts.Values)
+            foreach (var mechanism in part.Mechanisms)
+            foreach (var behavior in mechanism.Behaviors.Values)
+            {
+                yield return behavior;
+            }
+        }
+
+        public static bool TryGetMechanismBehaviors(this IBody body,
+            [NotNullWhen(true)] out List<IMechanismBehavior>? behaviors)
+        {
+            behaviors = body.GetMechanismBehaviors().ToList();
+
+            if (behaviors.Count == 0)
+            {
+                behaviors = null;
+                return false;
+            }
+
+            return true;
+        }
+
+        public static IEnumerable<T> GetMechanismBehaviors<T>(this IBody body) where T : class, IMechanismBehavior
+        {
+            foreach (var part in body.Parts.Values)
+            foreach (var mechanism in part.Mechanisms)
+            foreach (var behavior in mechanism.Behaviors.Values)
+            {
+                if (behavior is T tBehavior)
+                {
+                    yield return tBehavior;
+                }
+            }
+        }
+
+        public static bool TryGetMechanismBehaviors<T>(this IBody entity, [NotNullWhen(true)] out List<T>? behaviors)
+            where T : class, IMechanismBehavior
+        {
+            behaviors = entity.GetMechanismBehaviors<T>().ToList();
+
+            if (behaviors.Count == 0)
+            {
+                behaviors = null;
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

Content.Server/GameObjects/Components/Body/Behavior/StomachBehavior.cs

@@ -0,0 +1,183 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.GameObjects.Components.Chemistry;
+using Content.Shared.Chemistry;
+using Content.Shared.GameObjects.Components.Body.Networks;
+using Content.Shared.GameObjects.Components.Chemistry;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Log;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.GameObjects.Components.Body.Behavior
+{
+    /// <summary>
+    /// Where reagents go when ingested. Tracks ingested reagents over time, and
+    /// eventually transfers them to <see cref="SharedBloodstreamComponent"/> once digested.
+    /// </summary>
+    public class StomachBehavior : MechanismBehavior
+    {
+        private float _accumulatedFrameTime;
+
+        /// <summary>
+        ///     Updates digestion status of ingested reagents.
+        ///     Once reagents surpass _digestionDelay they are moved to the
+        ///     bloodstream, where they are then metabolized.
+        /// </summary>
+        /// <param name="frameTime">
+        ///     The time since the last update in seconds.
+        /// </param>
+        public override void Update(float frameTime)
+        {
+            if (Body == null)
+            {
+                return;
+            }
+
+            _accumulatedFrameTime += frameTime;
+
+            // Update at most once per second
+            if (_accumulatedFrameTime < 1)
+            {
+                return;
+            }
+
+            _accumulatedFrameTime -= 1;
+
+            if (!Owner.TryGetComponent(out SharedSolutionContainerComponent? solution) ||
+                !Body.Owner.TryGetComponent(out SharedBloodstreamComponent? bloodstream))
+            {
+                return;
+            }
+
+            // Add reagents ready for transfer to bloodstream to transferSolution
+            var transferSolution = new Solution();
+
+            // Use ToList here to remove entries while iterating
+            foreach (var delta in _reagentDeltas.ToList())
+            {
+                //Increment lifetime of reagents
+                delta.Increment(1);
+                if (delta.Lifetime > _digestionDelay)
+                {
+                    solution.TryRemoveReagent(delta.ReagentId, delta.Quantity);
+                    transferSolution.AddReagent(delta.ReagentId, delta.Quantity);
+                    _reagentDeltas.Remove(delta);
+                }
+            }
+
+            // Transfer digested reagents to bloodstream
+            bloodstream.TryTransferSolution(transferSolution);
+        }
+
+        /// <summary>
+        ///     Max volume of internal solution storage
+        /// </summary>
+        public ReagentUnit MaxVolume
+        {
+            get => Owner.TryGetComponent(out SharedSolutionContainerComponent? solution) ? solution.MaxVolume : ReagentUnit.Zero;
+            set
+            {
+                if (Owner.TryGetComponent(out SharedSolutionContainerComponent? solution))
+                {
+                    solution.MaxVolume = value;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Initial internal solution storage volume
+        /// </summary>
+        [ViewVariables]
+        protected ReagentUnit InitialMaxVolume { get; private set; }
+
+        /// <summary>
+        ///     Time in seconds between reagents being ingested and them being
+        ///     transferred to <see cref="SharedBloodstreamComponent"/>
+        /// </summary>
+        [ViewVariables]
+        private float _digestionDelay;
+
+        /// <summary>
+        ///     Used to track how long each reagent has been in the stomach
+        /// </summary>
+        [ViewVariables]
+        private readonly List<ReagentDelta> _reagentDeltas = new List<ReagentDelta>();
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(this, s => s.InitialMaxVolume, "maxVolume", ReagentUnit.New(100));
+            serializer.DataField(ref _digestionDelay, "digestionDelay", 20);
+        }
+
+        public override void Startup()
+        {
+            base.Startup();
+
+            if (!Owner.EnsureComponent(out SolutionContainerComponent solution))
+            {
+                Logger.Warning($"Entity {Owner} at {Owner.Transform.MapPosition} didn't have a {nameof(SolutionContainerComponent)}");
+            }
+
+            solution.MaxVolume = InitialMaxVolume;
+        }
+
+        public bool CanTransferSolution(Solution solution)
+        {
+            if (!Owner.TryGetComponent(out SharedSolutionContainerComponent? solutionComponent))
+            {
+                return false;
+            }
+
+            // TODO: For now no partial transfers. Potentially change by design
+            if (!solutionComponent.CanAddSolution(solution))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        public bool TryTransferSolution(Solution solution)
+        {
+            if (!CanTransferSolution(solution))
+                return false;
+
+            if (!Owner.TryGetComponent(out SharedSolutionContainerComponent? solutionComponent))
+            {
+                return false;
+            }
+
+            // Add solution to _stomachContents
+            solutionComponent.TryAddSolution(solution, false, true);
+            // Add each reagent to _reagentDeltas. Used to track how long each reagent has been in the stomach
+            foreach (var reagent in solution.Contents)
+            {
+                _reagentDeltas.Add(new ReagentDelta(reagent.ReagentId, reagent.Quantity));
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        ///     Used to track quantity changes when ingesting & digesting reagents
+        /// </summary>
+        protected class ReagentDelta
+        {
+            public readonly string ReagentId;
+            public readonly ReagentUnit Quantity;
+            public float Lifetime { get; private set; }
+
+            public ReagentDelta(string reagentId, ReagentUnit quantity)
+            {
+                ReagentId = reagentId;
+                Quantity = quantity;
+                Lifetime = 0.0f;
+            }
+
+            public void Increment(float delta) => Lifetime += delta;
+        }
+    }
+}

Content.Server/GameObjects/Components/Body/Behavior/StomachBehaviorComponent.cs

@@ -1,24 +0,0 @@
-using Content.Server.GameObjects.Components.Chemistry;
-using Content.Shared.GameObjects.Components.Body.Behavior;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Log;
-
-namespace Content.Server.GameObjects.Components.Body.Behavior
-{
-    [RegisterComponent]
-    [ComponentReference(typeof(SharedStomachBehaviorComponent))]
-    public class StomachBehaviorComponent : SharedStomachBehaviorComponent
-    {
-        protected override void Startup()
-        {
-            base.Startup();
-
-            if (!Owner.EnsureComponent(out SolutionContainerComponent solution))
-            {
-                Logger.Warning($"Entity {Owner} at {Owner.Transform.MapPosition} didn't have a {nameof(SolutionContainerComponent)}");
-            }
-
-            solution.MaxVolume = InitialMaxVolume;
-        }
-    }
-}