De-hardcode chemical metabolism of StomachComponent (#437)

* Move chemical reaction effects into Chemistry/ReactionEffects/ subfolder

* Replace hardcoded StomachComponent metabolism with IMetabolizable

The benefits of this approach are that reagent metabolism effects are not hardcoded into StomachComponent, and metabolism effects can be more easily chained together in yaml prototypes, and reagents can have different metabolism rates. One problem with this approach is that getting metabolism rates slower than 1u / second is impossible. Implementing #377 should resolve that problem.

* Fix DefaultFood and DefaultDrink so they remove reagent regardless of Hunger/ThirstComponent presence

Previously if neither of those were present the reagents wouldn't be removed from the stomach. This fixes that.

* Additional comment on function

* Make metabolizer interface implementations explicit

Also removed some unused using statements

* Make StomachComponent._reagentDeltas readonly

* Fix misleading variable names and docs for metabolizables

Changes one of the arguments for `IMetabolizable.Metabolize()` to be called `tickTime` instead of `frameTime` to more accurately reflect it's purpose. It's not really the frametime, but the time since the last metabolism tick. Also updated and expanded the docs to reflect this and to be more clear.

Content.Shared/Chemistry/DefaultMetabolizable.cs

@@ -0,0 +1,27 @@
+using System;
+using Content.Shared.Interfaces.Chemistry;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Serialization;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Chemistry
+{
+    //Default metabolism for reagents. Metabolizes the reagent with no effects
+    class DefaultMetabolizable : IMetabolizable
+    {
+        //Rate of metabolism in units / second
+        private int _metabolismRate = 1;
+        public int MetabolismRate => _metabolismRate;
+
+        void IExposeData.ExposeData(ObjectSerializer serializer)
+        {
+            serializer.DataField(ref _metabolismRate, "rate", 1);
+        }
+
+        int IMetabolizable.Metabolize(IEntity solutionEntity, string reagentId, float tickTime)
+        {
+            int metabolismAmount = (int)Math.Round(MetabolismRate * tickTime);
+            return metabolismAmount;
+        }
+    }
+}

Content.Shared/Chemistry/ReagentPrototype.cs

@@ -1,5 +1,9 @@
-using Robust.Shared.Maths;
+using System;
+using System.Collections.Generic;
+using Content.Shared.Interfaces.Chemistry;
+using Robust.Shared.Maths;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 using YamlDotNet.RepresentationModel;
 
@@ -8,18 +12,28 @@ namespace Content.Shared.Chemistry
     [Prototype("reagent")]
     public class ReagentPrototype : IPrototype, IIndexedPrototype
     {
-        public string ID { get; private set; }
-        public string Name { get; private set; }
-        public string Description { get; private set; }
-        public Color SubstanceColor { get; private set; }
+        private string _id;
+        private string _name;
+        private string _description;
+        private Color _substanceColor;
+        private List<IMetabolizable> _metabolism;
+
+        public string ID => _id;
+        public string Name => _name;
+        public string Description => _description;
+        public Color SubstanceColor => _substanceColor;
+        //List of metabolism effects this reagent has, should really only be used server-side.
+        public List<IMetabolizable> Metabolism => _metabolism;
 
         public void LoadFrom(YamlMappingNode mapping)
         {
-            ID = mapping.GetNode("id").AsString();
-            Name = mapping.GetNode("name").ToString();
-            Description = mapping.GetNode("desc").ToString();
+            var serializer = YamlObjectSerializer.NewReader(mapping);
 
-            SubstanceColor = mapping.TryGetNode("color", out var colorNode) ? colorNode.AsHexColor(Color.White) : Color.White;
+            serializer.DataField(ref _id, "id", string.Empty);
+            serializer.DataField(ref _name, "name", string.Empty);
+            serializer.DataField(ref _description, "desc", string.Empty);
+            serializer.DataField(ref _substanceColor, "color", Color.White);
+            serializer.DataField(ref _metabolism, "metabolism", new List<IMetabolizable>{new DefaultMetabolizable()});
         }
     }
 }

Content.Shared/Interfaces/Chemistry/IMetabolizable.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using Content.Shared.Chemistry;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Serialization;
+
+namespace Content.Shared.Interfaces.Chemistry
+{
+    /// <summary>
+    /// Metabolism behavior for a reagent.
+    /// </summary>
+    public interface IMetabolizable : IExposeData
+    {
+        /// <summary>
+        /// Metabolize the attached reagent. Return the amount of reagent to be removed from the solution.
+        /// You shouldn't remove the reagent yourself to avoid invalidating the iterator of the metabolism
+        /// organ that is processing it's reagents.
+        /// </summary>
+        /// <param name="solutionEntity">The entity containing the solution.</param>
+        /// <param name="reagentId">The reagent id</param>
+        /// <param name="tickTime">The time since the last metabolism tick in seconds.</param>
+        /// <returns>The amount of reagent to be removed. The metabolizing organ should handle removing the reagent.</returns>
+        int Metabolize(IEntity solutionEntity, string reagentId, float tickTime);
+    }
+}