Food Rework Update

Content.Server/Body/Components/StomachComponent.cs

@@ -3,6 +3,7 @@
 using Content.Shared.Chemistry.Components;
 using Content.Shared.Chemistry.Reagent;
 using Content.Shared.Whitelist;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 
 namespace Content.Server.Body.Components
@@ -69,5 +70,11 @@ public ReagentDelta(ReagentQuantity reagentQuantity)
 
             public void Increment(TimeSpan delta) => Lifetime += delta;
         }
+
+        /// <summary>
+        ///     Frontier: digestion prototype (used for species-specific reagent replacement/effects)
+        /// </summary>
+        [DataField]
+        public ProtoId<DigestionPrototype>? Digestion = "Default";
     }
 }

Content.Server/Nutrition/Components/FoodComponent.cs

@@ -4,10 +4,11 @@
 using Content.Shared.FixedPoint;
 using Robust.Shared.Audio;
 using Robust.Shared.Prototypes;
+using Content.Server.Mail; // Frontier
 
 namespace Content.Server.Nutrition.Components;
 
-[RegisterComponent, Access(typeof(FoodSystem), typeof(FoodSequenceSystem))]
+[RegisterComponent, Access(typeof(FoodSystem), typeof(FoodSequenceSystem), typeof(MailSystem))] // Frontier
 public sealed partial class FoodComponent : Component
 {
     [DataField]
@@ -75,6 +76,14 @@ public sealed partial class FoodComponent : Component
     [DataField, ViewVariables(VVAccess.ReadWrite)]
     public bool RequireDead = true;
 
+    // New Frontiers - Digestion Rework - Add quality to add species-specific digestion
+    // This code is licensed under AGPLv3. See AGPLv3.txt
+    /// <summary>
+    /// The quality of this food, for species-specific digestion.
+    /// </summary>
+    [DataField, ViewVariables]
+    public FoodQuality Quality = FoodQuality.Normal;
+
     [DataField]
     public LocId VerbEat = "food-system-verb-eat"; // Frontier
 
@@ -96,3 +105,16 @@ public sealed partial class FoodComponent : Component
     [DataField]
     public LocId CannotEatAnyMoreOtherMessage = "food-system-you-cannot-eat-any-more-other"; // Frontier
 }
+
+/// <summary>
+/// An enumeration of the quality of given pieces of food.
+/// </summary>
+public enum FoodQuality : byte
+{
+    Toxin,
+    Nasty,
+    Junk,
+    Normal,
+    High,
+}
+// End of modified code

Content.Server/Nutrition/EntitySystems/FoodSystem.cs

@@ -33,13 +33,12 @@
 using Content.Shared.Containers.ItemSlots;
 using Robust.Server.GameObjects;
 using Content.Shared.Whitelist;
-
 namespace Content.Server.Nutrition.EntitySystems;
 
 /// <summary>
 /// Handles feeding attempts both on yourself and on the target.
 /// </summary>
-public sealed class FoodSystem : EntitySystem
+public partial class FoodSystem : EntitySystem // Frontier: sealed<partial
 {
     [Dependency] private readonly BodySystem _body = default!;
     [Dependency] private readonly FlavorProfileSystem _flavorProfile = default!;
@@ -244,12 +243,22 @@ private void OnDoAfter(Entity<FoodComponent> entity, ref ConsumeDoAfterEvent arg
 
         var split = _solutionContainer.SplitSolution(soln.Value, transferAmount);
 
+        // Frontier: food digestion
+        if (!CheckDigestablePrereqs(entity, entity.Comp, stomachs)) {
+            return;
+        }
+
         // Get the stomach with the highest available solution volume
         var highestAvailable = FixedPoint2.Zero;
         Entity<StomachComponent>? stomachToUse = null;
         foreach (var ent in stomachs)
         {
             var owner = ent.Owner;
+
+            // Frontier: check specific-stomach digestion
+            if (!IsFoodDigestibleByStomach(args.Used.Value, entity.Comp, ent.Comp1)) // Frontier: make sure food is processed by a stomach that can digest it
+                continue;
+
             if (!_stomach.CanTransferSolution(owner, split, ent.Comp1))
                 continue;
 
@@ -271,16 +280,21 @@ private void OnDoAfter(Entity<FoodComponent> entity, ref ConsumeDoAfterEvent arg
             return;
         }
 
+        var digestion = DigestFood(entity, stomachToUse.Value, split, args.Target.Value, args.User); // Frontier: species-specific digestion
+
         _reaction.DoEntityReaction(args.Target.Value, solution, ReactionMethod.Ingestion);
         _stomach.TryTransferSolution(stomachToUse!.Value.Owner, split, stomachToUse);
 
         var flavors = args.FlavorMessage;
 
         if (forceFeed)
         {
-            var targetName = Identity.Entity(args.Target.Value, EntityManager);
+            var targetName = Identity.Entity(args.Target!.Value, EntityManager);
             var userName = Identity.Entity(args.User, EntityManager);
-            _popup.PopupEntity(Loc.GetString(entity.Comp.ForceFeedSuccessMessage, ("user", userName), ("flavors", flavors)), args.Target.Value, args.Target.Value); // Frontier: entity.Owner->args.Target.Value
+
+            // TODO: revise this with napkin work
+            if (digestion.ShowFlavors) // Frontier
+                _popup.PopupEntity(Loc.GetString(entity.Comp.ForceFeedSuccessMessage, ("user", userName), ("flavors", flavors)), args.Target.Value, args.Target.Value); // Frontier: entity.Owner->args.Target.Value
 
             _popup.PopupEntity(Loc.GetString(entity.Comp.ForceFeedSuccessUserMessage, ("target", targetName)), args.User, args.User);
 
@@ -289,13 +303,14 @@ private void OnDoAfter(Entity<FoodComponent> entity, ref ConsumeDoAfterEvent arg
         }
         else
         {
-            _popup.PopupEntity(Loc.GetString(entity.Comp.EatMessage, ("food", entity.Owner), ("flavors", flavors)), args.User, args.User);
+            if (digestion.ShowFlavors) // Frontier
+                _popup.PopupEntity(Loc.GetString(entity.Comp.EatMessage, ("food", entity.Owner), ("flavors", flavors)), args.User, args.User);
 
             // log successful voluntary eating
             _adminLogger.Add(LogType.Ingestion, LogImpact.Low, $"{ToPrettyString(args.User):target} ate {ToPrettyString(entity.Owner):food}");
         }
 
-        _audio.PlayPvs(entity.Comp.UseSound, args.Target.Value, AudioParams.Default.WithVolume(-1f));
+        _audio.PlayPvs(entity.Comp.UseSound, args.Target!.Value, AudioParams.Default.WithVolume(-1f));
 
         // Try to break all used utensils
         foreach (var utensil in utensils)
@@ -416,29 +431,49 @@ public bool IsDigestibleBy(EntityUid uid, EntityUid food, FoodComponent? foodCom
     /// </summary>
     private bool IsDigestibleBy(EntityUid food, FoodComponent component, List<Entity<StomachComponent, OrganComponent>> stomachs)
     {
-        var digestible = true;
+        return GetDigestableStomach(food, component, stomachs) is not null; // Frontier: removed
+    }
 
-        // Does the mob have enough stomachs?
-        if (stomachs.Count < component.RequiredStomachs)
+    private bool CheckDigestablePrereqs(EntityUid food, FoodComponent component, List<Entity<StomachComponent, OrganComponent>> stomachs)
+    {
+        return stomachs.Count >= component.RequiredStomachs;
+    }
+
+    private bool IsFoodDigestibleByStomach(EntityUid food, FoodComponent component, StomachComponent stomach)
+    {
+        if (!component.RequiresSpecialDigestion)
+            return true;
+
+        // Check if the food is in the whitelist
+        if (_whitelistSystem.IsWhitelistPass(stomach.SpecialDigestible, food))
+            return true;
+        else
             return false;
+    }
 
+    private StomachComponent? GetDigestableStomach(EntityUid food, FoodComponent component, List<Entity<StomachComponent, OrganComponent>> stomachs)
+    {
+        if (!CheckDigestablePrereqs(food, component, stomachs)) {
+            return null;
+        }
         // Run through the mobs' stomachs
         foreach (var ent in stomachs)
         {
-            // Find a stomach with a SpecialDigestible
-            if (ent.Comp1.SpecialDigestible == null)
-                continue;
-            // Check if the food is in the whitelist
-            if (_whitelistSystem.IsWhitelistPass(ent.Comp1.SpecialDigestible, food))
-                return true;
-            // They can only eat whitelist food and the food isn't in the whitelist. It's not edible.
-            return false;
-        }
+            if (IsFoodDigestibleByStomach(food, component, ent.Comp1)) {
+                return ent.Comp1;
+            }
 
-        if (component.RequiresSpecialDigestion)
-            return false;
+            // // Find a stomach with a SpecialDigestible
+            // if (ent.Comp1.SpecialDigestible == null)
+            //     continue;
+            // // Check if the food is in the whitelist
+            // if (_whitelistSystem.IsWhitelistPass(ent.Comp1.SpecialDigestible, food))
+            //     return true;
+            // // They can only eat whitelist food and the food isn't in the whitelist. It's not edible.
+            // return false;
+        }
 
-        return digestible;
+        return null;
     }
 
     private bool TryGetRequiredUtensils(EntityUid user, FoodComponent component,

Content.Server/_NF/Nutrition/EntitySystems/FoodSystem.Digestion.cs

@@ -0,0 +1,80 @@
+// New Frontiers - This file is licensed under AGPLv3
+// Copyright (c) 2024 New Frontiers Contributors
+// See AGPLv3.txt for details.
+using Content.Server.Nutrition.Components;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Chemistry.Components;
+using Content.Server.Body.Components;
+using Robust.Shared.Prototypes;
+using Content.Shared.EntityEffects;
+using Robust.Shared.Random;
+using Content.Shared.Chemistry;
+
+namespace Content.Server.Nutrition.EntitySystems;
+
+// Frontier: extending food system to handle species-specific digestion quirks.
+public sealed partial class FoodSystem : EntitySystem // Frontier: sealed<partial
+{
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+
+    public struct DigestionResult
+    {
+        public bool ShowFlavors;
+    }
+
+    DigestionResult DigestFood(Entity<FoodComponent> food, Entity<StomachComponent> stomach, Solution eatenSolution, EntityUid target, EntityUid _)
+    {
+        var result = new DigestionResult
+        {
+            ShowFlavors = true
+        };
+
+        // Frontier - Food quality system
+        if (!_prototype.TryIndex(stomach.Comp.Digestion, out var digestion))
+        {
+            return result;
+        }
+
+        var eatenVolume = eatenSolution.Volume;
+        while (digestion != null)
+        {
+            // Iterate through effects
+            foreach (var effect in digestion.Effects)
+            {
+                // Precondition: match food quality and/or whitelist.
+                if (effect.Quality != null && effect.Quality != food.Comp.Quality)
+                    continue;
+
+                if (_whitelistSystem.IsWhitelistFail(effect.Whitelist, food.Owner))
+                    continue;
+
+                // Run reagent conversions
+                foreach (var (beforeReagent, afterDict) in effect.Conversions)
+                {
+                    var removedAmount = eatenSolution.RemoveReagent(new ReagentQuantity(beforeReagent, eatenVolume));
+                    foreach (var (afterReagent, afterRatio) in afterDict)
+                    {
+                        eatenSolution.AddReagent(new ReagentQuantity(afterReagent, removedAmount * afterRatio));
+                    }
+                }
+
+                var args = new EntityEffectReagentArgs(target, EntityManager, stomach.Owner, eatenSolution, eatenSolution.Volume, null, ReactionMethod.Ingestion, 1.0f);
+                foreach (var entEffect in effect.Effects)
+                {
+                    if (!EntityEffectExt.ShouldApply(entEffect, args, _random))
+                        continue;
+                    entEffect.Effect(args);
+                }
+            }
+
+            // Get next digestion to run
+            if (!_prototype.TryIndex(digestion.PostDigest, out digestion))
+            {
+                digestion = null;
+            }
+        }
+
+        return result;
+    }
+}

Content.Server/_NF/Nutrition/Prototypes/DigestionPrototype.cs

@@ -0,0 +1,56 @@
+using Content.Server.Nutrition.Components;
+using Content.Shared.EntityEffects;
+using Content.Shared.FixedPoint;
+using Content.Shared.Whitelist;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Chemistry.Reagent;
+
+[Prototype("digestion")]
+[DataDefinition]
+public sealed partial class DigestionPrototype : IPrototype
+{
+    [ViewVariables]
+    [IdDataField]
+    public string ID { get; private set; } = default!;
+
+    /// <summary>
+    /// The list of digestive effects that occur in this organ.
+    /// </summary>
+    [DataField]
+    public List<DigestionEffect> Effects { get; private set; } = new();
+
+    /// <summary>
+    /// The list of digestive effects that occur in this organ.
+    /// </summary>
+    [DataField]
+    public ProtoId<DigestionPrototype>? PostDigest { get; private set; } = null;
+}
+
+[DataDefinition]
+public sealed partial class DigestionEffect
+{
+    /// <summary>
+    /// The quality of food this effect occurs on.
+    /// </summary>
+    [DataField]
+    public FoodQuality? Quality { get; private set; } = null;
+
+    /// <summary>
+    /// A whitelist on the food item this bite was taken from.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? Whitelist { get; private set; } = null;
+
+    /// <summary>
+    /// A list of reagent effects that happen on the stomach solution
+    /// </summary>
+    [DataField]
+    public List<EntityEffect> Effects { get; private set; } = new();
+
+    /// <summary>
+    /// A list of conversions.  All values should be ratios of the input reagent, and the sum of their values should be <= 1.
+    /// </summary>
+    [DataField]
+    public Dictionary<ProtoId<ReagentPrototype>, Dictionary<ProtoId<ReagentPrototype>, FixedPoint2>> Conversions { get; private set; } = new();
+}

Resources/Locale/en-US/_NF/nutrition/components/food-component.ftl

@@ -12,3 +12,6 @@ food-system-verb-wipe = Wipe Face
 food-system-wipe = {CAPITALIZE(THE($user))} is trying to wipe your face.
 food-system-wipe-success = {CAPITALIZE(THE($user))} wiped your face.
 food-system-wipe-success-user = You wiped {THE($target)}'s face.
+
+food-system-nasty = That food was gross.
+food-system-toxin = That food was bad.

Resources/Locale/en-US/_NF/reagents/foods.ftl

@@ -0,0 +1,2 @@
+reagent-name-trashjuice = trash juice
+reagent-desc-trashjuice = Do you really want to know what it is?

Resources/Locale/en-US/_NF/reagents/meta/consumable/food/food.ftl

@@ -1,5 +1,8 @@
 reagent-name-flavorol = flavorol
 reagent-desc-flavorol = All the vitamins, minerals, and carbohydrates the body needs in pure form.
 
+reagent-name-bloatamine = bloatamine
+reagent-desc-bloatamine = A metabolized version of the preservatives put in junk food. Carcinogenic in large quantities.
+
 reagent-name-raisins = raisins
 reagent-desc-raisins = Are they the best or worst part of the cookie? They're a bunch of desiccated grapes is what they are.

Resources/Locale/en-US/_NF/reagents/physical-desc.ftl

@@ -0,0 +1 @@
+reagent-physical-desc-trashjuice = ... Wait.. Did it just move?

Resources/Prototypes/Body/Organs/Animal/animal.yml

@@ -4,8 +4,8 @@
   abstract: true
   components:
   - type: Organ
-  - type: Food
-#    quality: Nasty # Frontier
+  - type: Food # Frontier
+    quality: Nasty # Frontier
   - type: Sprite
     sprite: Mobs/Species/Human/organs.rsi
   - type: StaticPrice

Resources/Prototypes/Body/Organs/arachnid.yml

@@ -35,6 +35,14 @@
     sprite: Mobs/Species/Arachnid/organs.rsi
     state: stomach
   - type: Stomach
+    digestion: Arachnid # Frontier
+    # specialDigestible:
+    #   tags:
+    #   - Fruit
+    #   - Pill
+    #   - BloodFood
+    #   - Crayon
+    #   - Soup
     updateInterval: 1.5
   - type: SolutionContainerManager
     solutions: