Expanded cell specialization effects

src/auto-evo/simulation/SimulationCache.cs

@@ -42,6 +42,9 @@ public class SimulationCache
     private readonly CompoundDefinition oxytoxy = SimulationParameters.GetCompound(Compound.Oxytoxy);
     private readonly CompoundDefinition mucilage = SimulationParameters.GetCompound(Compound.Mucilage);
 
+    private readonly OrganelleDefinition nucleusDefinition =
+        SimulationParameters.Instance.GetOrganelleType("nucleus");
+
     private readonly WorldGenerationSettings worldSettings;
 
 #if USE_HASHED_SCORE_KEYS
@@ -141,7 +144,8 @@ public EnergyBalanceInfoSimple GetEnergyBalanceForSpecies(MicrobeSpecies species
         var cached = new EnergyBalanceInfoSimple();
 
         // Assume here that the species specialization factor may not be up to date, so recalculate here
-        var specialization = MicrobeInternalCalculations.CalculateSpecializationBonus(species.Organelles, workMemory1);
+        var specialization = MicrobeInternalCalculations.CalculateSpecializationBonus(species.Organelles, workMemory1,
+            nucleusDefinition);
 
         // Auto-evo uses the average values of compound during the course of a simulated day
         ProcessSystem.ComputeEnergyBalanceSimple(species.Organelles, biomeConditions,
@@ -169,8 +173,14 @@ public float GetSpeedForSpecies(MicrobeSpecies species)
             return speed;
         }
 
-        var cached = MicrobeInternalCalculations.CalculateSpeed(species.Organelles.Organelles, species.MembraneType,
-            species.MembraneRigidity, species.IsBacteria, true);
+        var organelles = species.Organelles;
+
+        var specialization = MicrobeInternalCalculations.CalculateSpecializationBonus(organelles,
+            new Dictionary<OrganelleDefinition, int>(),
+            nucleusDefinition);
+
+        var cached = MicrobeInternalCalculations.CalculateSpeed(organelles.Organelles, species.MembraneType,
+            species.MembraneRigidity, species.IsBacteria, specialization, true);
 
         cachedBaseSpeeds.Add(key, cached);
         return cached;
@@ -202,7 +212,13 @@ public float GetRotationSpeedForSpecies(MicrobeSpecies species)
         // prey species by multiple predators might benefit ever so slightly, but it seems kind of unlikely).
         // A more useful thing would be to cache this directly in the species when calculating other movement cached
         // properties.
-        return MicrobeInternalCalculations.CalculateRotationSpeed(species.Organelles.Organelles);
+        var organelles = species.Organelles;
+
+        var specialization = MicrobeInternalCalculations.CalculateSpecializationBonus(organelles,
+            new Dictionary<OrganelleDefinition, int>(),
+            nucleusDefinition);
+
+        return MicrobeInternalCalculations.CalculateRotationSpeed(organelles.Organelles, specialization);
     }
 
     public float GetCompoundConversionScoreForSpecies(CompoundDefinition fromCompound, CompoundDefinition toCompound,
@@ -390,9 +406,13 @@ public float GetPredationScore(Species predatorSpecies, Species preySpecies, Bio
             }
         }
 
+        // This will likely be used at several points to mimic the effect the specialization bonus has on organelles
+        var specializationBonus = MicrobeInternalCalculations.CalculateSpecializationBonus(
+            predator.Organelles.Organelles, workMemory1, nucleusDefinition);
+
         var predatorHexSize = GetBaseHexSizeForSpecies(predator);
         var preyHexSize = GetBaseHexSizeForSpecies(prey);
-        var enzymesScore = GetEnzymesScore(predator, prey.MembraneType.DissolverEnzyme);
+        var enzymesScore = GetEnzymesScore(predator, prey.MembraneType.DissolverEnzyme, specializationBonus);
         var canDigestPrey = predatorHexSize / preyHexSize > Constants.ENGULF_SIZE_RATIO_REQ && canEngulf &&
             enzymesScore > 0.0f;
 
@@ -447,13 +467,13 @@ public float GetPredationScore(Species predatorSpecies, Species preySpecies, Bio
 
         var toxicity = predatorToolScores.AverageToxicity;
         var macrolideScore = predatorToolScores.MacrolideScore;
-        var predatorSlimeJetScore = predatorToolScores.SlimeJetScore;
-        var pullingCiliaModifier = predatorToolScores.PullingCiliaModifier;
+        var predatorSlimeJetScore = predatorToolScores.SlimeJetScore * specializationBonus;
+        var pullingCiliaModifier = predatorToolScores.PullingCiliaModifier * specializationBonus;
         var strongPullingCiliaModifier = pullingCiliaModifier * pullingCiliaModifier;
         var predatorToxinResistance = predator.MembraneType.ToxinResistance;
         var predatorPhysicalResistance = predator.MembraneType.PhysicalResistance;
 
-        var preySlimeJetScore = preyToolScores.SlimeJetScore;
+        var preySlimeJetScore = preyToolScores.SlimeJetScore * specializationBonus;
         var preyMucocystsScore = preyToolScores.MucocystsScore;
         var preyPilusScore = preyToolScores.PilusScore;
         var preyInjectisomeScore = preyToolScores.InjectisomeScore;
@@ -1222,7 +1242,7 @@ public PredationToolsRawScores GetPredationToolsRawScores(MicrobeSpecies microbe
         return predationToolsRawScores;
     }
 
-    public float GetEnzymesScore(MicrobeSpecies predator, string dissolverEnzyme)
+    public float GetEnzymesScore(MicrobeSpecies predator, string dissolverEnzyme, float specializationBonus)
     {
         // This is not cached as it is not useful at the present time (as this is only called from places that cache
         // stuff)
@@ -1263,9 +1283,9 @@ public float GetEnzymesScore(MicrobeSpecies predator, string dissolverEnzyme)
 
         // If not digestible, mark that as a 0 score
         if (!isMembraneDigestible)
-            enzymesScore = 0;
+            return 0;
 
-        return enzymesScore;
+        return enzymesScore * specializationBonus;
     }
 
     public ResolvedMicrobeTolerances GetEnvironmentalTolerances(MicrobeSpecies species,

src/microbe_stage/ICellDefinition.cs

@@ -28,6 +28,12 @@ public interface ICellDefinition : IReadOnlyCellDefinition, ISimulationPhotograp
 
     public string FormattedName { get; }
 
+    /// <summary>
+    ///   A multiplier starting from 1 and going up based on how specialized this cell type is. This is eventually
+    ///   applied to <see cref="Components.BioProcesses.OverallSpeedModifier"/>
+    /// </summary>
+    public float SpecializationBonus { get; }
+
     /// <summary>
     ///   Repositions the cell to the origin and recalculates any properties dependent on its position.
     /// </summary>
@@ -49,6 +55,8 @@ public interface IReadOnlyCellDefinition
 public interface ICellTypeDefinition : ICellDefinition, IReadOnlyCellTypeDefinition
 {
     public new int MPCost { get; set; }
+
+    public new float SpecializationBonus { get; }
 }
 
 public interface IReadOnlyCellTypeDefinition : IReadOnlyCellDefinition, IPlayerReadableName

src/microbe_stage/IOrganelleComponent.cs

@@ -19,6 +19,7 @@ public interface IOrganelleComponent
     ///   <see cref="UpdateSync"/>
     /// </summary>
     /// <param name="organelleContainer">Organelle container instance this organelle is inside</param>
+    /// <param name="specializationFactor"> Organelle effect bonus cell specialization and adjacency</param>
     /// <param name="microbeEntity">Entity reference of the entity that contains this organelle</param>
     /// <param name="worldSimulation">
     ///   The simulation this entity is in. Care needs to be taken on what operations are safe to perform here in an
@@ -27,7 +28,8 @@ public interface IOrganelleComponent
     ///   functionality.
     /// </param>
     /// <param name="delta">Time since the last update in seconds</param>
-    public void UpdateAsync(ref OrganelleContainer organelleContainer, in Entity microbeEntity,
+    public void UpdateAsync(ref OrganelleContainer organelleContainer, ref SpecializationFactor specializationFactor,
+        in Entity microbeEntity,
         IWorldSimulation worldSimulation, float delta);
 
     /// <summary>

src/microbe_stage/MicrobeEnvironmentalToleranceCalculations.cs

@@ -97,11 +97,17 @@ public static ToleranceResult CalculateTolerancesWithoutOrganelleModifiers(
     public static void ApplyOrganelleEffectsOnTolerances(IReadOnlyList<IReadOnlyOrganelleTemplate> organelles,
         ref ToleranceValues tolerances)
     {
-        float temperatureChange = 0;
-        float oxygenChange = 0;
-        float uvChange = 0;
-        float pressureMinimumChange = 0;
-        float pressureToleranceChange = 0;
+        float totalTemperatureChange = 0;
+        float totalOxygenChange = 0;
+        float totalUvChange = 0;
+        float totalPressureMinimumChange = 0;
+        float totalPressureToleranceChange = 0;
+
+        var nucleusDefinition = SimulationParameters.Instance.GetOrganelleType("nucleus");
+
+        // Note this assumes this is only used just for single cell types or microbe species!
+        var specialization = MicrobeInternalCalculations.CalculateSpecializationBonus(organelles,
+            new Dictionary<OrganelleDefinition, int>(), nucleusDefinition);
 
         int organelleCount = organelles.Count;
         for (int i = 0; i < organelleCount; ++i)
@@ -110,20 +116,35 @@ public static void ApplyOrganelleEffectsOnTolerances(IReadOnlyList<IReadOnlyOrga
 
             if (organelleDefinition.AffectsTolerances)
             {
+                var temperatureChange = organelleDefinition.ToleranceModifierTemperatureRange;
+                var oxygenChange = organelleDefinition.ToleranceModifierOxygen;
+                var uvChange = organelleDefinition.ToleranceModifierUV;
+                var pressureToleranceChange = organelleDefinition.ToleranceModifierPressureTolerance;
+
+                // apply specialization bonus
+                if (temperatureChange > 0)
+                    temperatureChange *= specialization;
+                if (oxygenChange > 0)
+                    oxygenChange *= specialization;
+                if (uvChange > 0)
+                    uvChange *= specialization;
+                if (pressureToleranceChange > 0)
+                    pressureToleranceChange *= specialization;
+
                 // Buffer all changes so that float rounding doesn't cause us issues
-                temperatureChange += organelleDefinition.ToleranceModifierTemperatureRange;
-                oxygenChange += organelleDefinition.ToleranceModifierOxygen;
-                uvChange += organelleDefinition.ToleranceModifierUV;
-                pressureToleranceChange += organelleDefinition.ToleranceModifierPressureTolerance;
+                totalTemperatureChange += temperatureChange;
+                totalOxygenChange += oxygenChange;
+                totalUvChange += uvChange;
+                totalPressureToleranceChange += pressureToleranceChange;
             }
         }
 
         // Then apply all at once
-        tolerances.TemperatureTolerance += temperatureChange;
-        tolerances.OxygenResistance += oxygenChange;
-        tolerances.UVResistance += uvChange;
-        tolerances.PressureMinimum -= pressureMinimumChange;
-        tolerances.PressureTolerance += pressureToleranceChange;
+        tolerances.TemperatureTolerance += totalTemperatureChange;
+        tolerances.OxygenResistance += totalOxygenChange;
+        tolerances.UVResistance += totalUvChange;
+        tolerances.PressureMinimum -= totalPressureMinimumChange;
+        tolerances.PressureTolerance += totalPressureToleranceChange;
     }
 
     public static void ApplyOrganelleEffectsOnTolerances(IReadOnlyCollection<IReadOnlyOrganelleTemplate> organelles,