Merge branch 'main' of https://github.com/ihsoft/TimberbornMods

Author: ihsoft

TimberCommons/Common/Configurator.cs

@@ -0,0 +1,33 @@
+// Timberborn Mod: Timberborn Commons
+// Author: igor.zavoychinskiy@gmail.com
+// License: Public Domain
+
+using System.Reflection;
+using Bindito.Core;
+using TimberApi.ConfiguratorSystem;
+using TimberApi.SceneSystem;
+using Timberborn.PrefabOptimization;
+using UnityDev.Utils.LogUtilsLite;
+
+namespace IgorZ.TimberCommons.Common {
+
+[Configurator(SceneEntrypoint.All)]
+// ReSharper disable once UnusedType.Global
+sealed class Configurator : IConfigurator {
+  public void Configure(IContainerDefinition containerDefinition) {
+    if (Features.DebugExVerboseLogging && DebugEx.LoggingSettings.VerbosityLevel < 5) {
+      DebugEx.LoggingSettings.VerbosityLevel = 5;
+    }
+    if (Features.PrefabOptimizerMaxExpectedRegistrySize != -1) {
+      var fieldInfo = typeof(EnvironmentVertexColorPrefabOptimizer).GetField(
+          "MaxExpectedRegistrySize", BindingFlags.Static | BindingFlags.NonPublic);
+      if (fieldInfo != null) {
+        fieldInfo.SetValue(null, Features.PrefabOptimizerMaxExpectedRegistrySize);
+      } else {
+        DebugEx.Warning("Cannot override EnvironmentVertexColorPrefabOptimizer.MaxExpectedRegistrySize");
+      }
+    }
+  }
+}
+
+}

TimberCommons/Common/Features.cs

@@ -0,0 +1,66 @@
+// Timberborn Mod: Timberborn Commons
+// Author: igor.zavoychinskiy@gmail.com
+// License: Public Domain
+
+using IgorZ.TimberDev.UI;
+using IgorZ.TimberDev.Utils;
+using Timberborn.GoodConsumingBuildingSystem;
+using UnityDev.Utils.LogUtilsLite;
+
+namespace IgorZ.TimberCommons.Common {
+
+static class Features {
+  /// <summary>Indicates that <see cref="DebugEx.Fine"/> methods should emit record to the log.</summary>
+  public static bool DebugExVerboseLogging;
+
+  /// <summary>
+  /// Indicates that duration in the "supply lasts for" message on <see cref="GoodConsumingBuilding"/> UI should be
+  /// formatted as "Xd Yh" instead of "XX hours".
+  /// </summary>
+  /// <seealso cref="CommonFormats.DaysHoursFormat"/>
+  public static bool GoodConsumingBuildingUIDaysHoursForAll;
+
+  /// <summary>
+  /// Indicates that durations for the growth time for all growables should be formatted as "Xd Yh" instead of rounding
+  /// to days.
+  /// </summary>
+  /// <seealso cref="CommonFormats.DaysHoursFormat"/>
+  public static bool GrowableGrowthTimeUIDaysHoursViewForAll;
+
+  /// <summary>Indicates whether recipe durations exceeding 24 hours should be displayed in days/hours format.</summary>
+  /// <seealso cref="CommonFormats.DaysHoursFormat"/>
+  public static bool ShowDaysHoursForSlowRecipes;
+
+  /// <summary>
+  /// Specifies whether fuel rates below 0.1 should be displayed with increased precision in the recipe UI.
+  /// </summary>
+  /// <seealso cref="CommonFormats.FormatSmallValue"/>
+  public static bool ShowLongValueForLowFuelConsumptionRecipes;
+
+  /// <summary>Overrides the maximum registry size for PrefabOptimizer to suppress log complaints.</summary>
+  public static int PrefabOptimizerMaxExpectedRegistrySize = -1;
+
+  static Features() {
+    FeatureController.ReadFeatures(Consume);
+  }
+
+  static bool Consume(string name, bool enabled, string value) {
+    return name switch {
+        "DebugEx.VerboseLogging" =>
+            FeatureController.SetFlag(ref DebugExVerboseLogging, name, enabled, value),
+        "GoodConsumingBuildingUI.DaysHoursViewForAllBuildings" =>
+            FeatureController.SetFlag(ref GoodConsumingBuildingUIDaysHoursForAll, name, enabled, value),
+        "GrowableGrowthTimeUI.DaysHoursViewForAllGrowables" =>
+            FeatureController.SetFlag(ref GrowableGrowthTimeUIDaysHoursViewForAll, name, enabled, value),
+        "RecipesUI.ShowDaysHoursForSlowRecipes" =>
+            FeatureController.SetFlag(ref ShowDaysHoursForSlowRecipes, name, enabled, value),
+        "RecipesUI.ShowLongValueForLowFuelConsumptionRecipes" =>
+            FeatureController.SetFlag(ref ShowLongValueForLowFuelConsumptionRecipes, name, enabled, value),
+        "PrefabOptimizer.MaxExpectedRegistrySize" =>
+            FeatureController.SetValue(ref PrefabOptimizerMaxExpectedRegistrySize, name, enabled, value),
+        _ => false
+    };
+  }
+}
+
+}

TimberCommons/Common/ISupplyLeftProvider.cs

@@ -0,0 +1,27 @@
+// Timberborn Mod: Timberborn Commons
+// Author: igor.zavoychinskiy@gmail.com
+// License: Public Domain
+
+namespace IgorZ.TimberCommons.Common {
+
+/// <summary>Interface that enables "supply lasts for XX" progress bar in UI for manufactories.</summary>
+/// <remarks>
+/// It's expected that only one component on the building will implement it. If there is such a component and it returns
+/// non "null" values, then the UI fragment gets a "progress bar" that tells player how long the buildings would work on
+/// the existing inventory reserves.
+/// </remarks>
+public interface ISupplyLeftProvider {
+  /// <summary>Returns the stats or indicates that the progress bar should be hidden.</summary>
+  /// <remarks>
+  /// This method will be called from the UI fragment code, which happens every frame. Avoid doing expensive stuff in
+  /// this method.
+  /// </remarks>
+  /// <returns>
+  /// The progress as a value in range [0; 1] and the message to show on the progress bar. The progress must be greater
+  /// than zero and the message must not be <c>null</c>. If any of these conditions is not met, the progress bar will be
+  /// hidden in the UI.
+  /// </returns>
+  public (float progress, string progressBarMsg) GetStats();
+}
+
+}

TimberCommons/IrrigationSystem/BlockContaminationRangeEffect.cs

@@ -2,7 +2,7 @@
 // Author: igor.zavoychinskiy@gmail.com
 // License: Public Domain
 
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using Bindito.Core;
 using IgorZ.TimberCommons.WaterService;
 using Timberborn.BaseComponentSystem;
@@ -24,6 +24,8 @@ public sealed class BlockContaminationRangeEffect : BaseComponent, IRangeEffect
 
   /// <inheritdoc cref="EffectGroup"/>
   [SerializeField]
+  [Tooltip(
+      "The name by which this effect can be found by the other components. Multiple effects can have the same name.")]
   string _effectGroupName = "BlockContamination";
 
   // ReSharper restore InconsistentNaming
@@ -35,7 +37,7 @@ public sealed class BlockContaminationRangeEffect : BaseComponent, IRangeEffect
   public string EffectGroup => _effectGroupName;
 
   /// <inheritdoc/>
-  public void ApplyEffect(IEnumerable<Vector2Int> tiles) {
+  public void ApplyEffect(ImmutableHashSet<Vector2Int> tiles) {
     ResetEffect();
     _contaminationOverrideIndex = _directSoilMoistureSystemAccessor.AddContaminationOverride(tiles);
   }

TimberCommons/IrrigationSystem/Configurator.cs

@@ -0,0 +1,27 @@
+// Timberborn Mod: Timberborn Commons
+// Author: igor.zavoychinskiy@gmail.com
+// License: Public Domain
+
+using Bindito.Core;
+using TimberApi.ConfiguratorSystem;
+using TimberApi.SceneSystem;
+using Timberborn.Growing;
+using Timberborn.TemplateSystem;
+
+namespace IgorZ.TimberCommons.IrrigationSystem {
+
+[Configurator(SceneEntrypoint.InGame)]
+// ReSharper disable once UnusedType.Global
+sealed class Configurator : IConfigurator {
+  public void Configure(IContainerDefinition containerDefinition) {
+    containerDefinition.MultiBind<TemplateModule>().ToProvider(ProvideTemplateModule).AsSingleton();
+  }
+
+  static TemplateModule ProvideTemplateModule() {
+    var builder = new TemplateModule.Builder();
+    builder.AddDecorator<Growable, GrowthRateModifier>();
+    return builder.Build();
+  }
+}
+
+}

TimberCommons/IrrigationSystem/GoodConsumingIrrigationTower.cs

@@ -8,7 +8,6 @@
 using Timberborn.Buildings;
 using Timberborn.GoodConsumingBuildingSystem;
 using Timberborn.Localization;
-using UnityEngine;
 
 namespace IgorZ.TimberCommons.IrrigationSystem {
 
@@ -50,8 +49,8 @@ protected override bool CanMoisturize() {
   }
 
   /// <inheritdoc/>
-  protected override void IrrigationStarted(IEnumerable<Vector2Int> tiles) {
-    _rangeEffects.ForEach(x => x.ApplyEffect(tiles));
+  protected override void IrrigationStarted() {
+    _rangeEffects.ForEach(x => x.ApplyEffect(ReachableTiles));
   }
 
   /// <inheritdoc/>

TimberCommons/IrrigationSystem/GrowthRateModifier.cs

@@ -0,0 +1,125 @@
+// Timberborn Mod: Timberborn Commons
+// Author: igor.zavoychinskiy@gmail.com
+// License: Public Domain
+
+using System.Collections.Generic;
+using System.Linq;
+using Bindito.Core;
+using Timberborn.BaseComponentSystem;
+using Timberborn.Growing;
+using Timberborn.TimeSystem;
+using UnityDev.Utils.LogUtilsLite;
+using UnityEngine;
+
+namespace IgorZ.TimberCommons.IrrigationSystem {
+
+/// <summary>Component that can change the growth rate on the "growable" entities.</summary>
+/// <remarks>
+/// It's added to every growable entity in the game. Any code can access it and register its own modifications rates.
+/// However, only the worst "moderator" and the best "boost" will be considered. The effects are not adding up.
+/// </remarks>
+/// <seealso cref="ModifyGrowableGrowthRangeEffect"/>
+public sealed class GrowthRateModifier : BaseComponent {
+
+  #region API properties
+  // ReSharper disable InconsistentNaming
+  // ReSharper disable MemberCanBePrivate.Global
+
+  /// <summary>The actual modifier to the growth rate as a positive or negative percent value.</summary>
+  /// <seealso cref="WorstModerator"/>
+  /// <seealso cref="BestBooster"/>
+  public float EffectiveModifier { get; private set; }
+
+  /// <summary>Indicates that growable is actively growing, so the rate modifier makes sense.</summary>
+  public bool IsLiveAndGrowing => !_growable.IsGrown && !_growable.IsDead;
+
+  /// <summary>Specifies if the growable is growing or has grown at the non-stock rate.</summary>
+  public bool RateIsModified { get; private set; }
+
+  /// <summary>The <i>worst</i> moderator rate modifier.</summary>
+  public float WorstModerator { get; private set; }
+
+  /// <summary>The <i>best</i> boost rate modifier.</summary>
+  public float BestBooster { get; private set; }
+
+  // ReSharper restore InconsistentNaming
+  // ReSharper restore MemberCanBePrivate.Global
+  #endregion
+
+  #region API methods
+
+  /// <summary>Records the owner's request for the growth modification.</summary>
+  /// <remarks>The final rate applied may be different if there are more than one owners registered.</remarks>
+  /// <param name="ownerId">A unique ID of the caller that applies the modifier.</param>
+  /// <param name="modifier">
+  /// The rate modifer as a positive or negative value in percents. E.g. <c>15.5</c> (+15.5%) or <c>-8.5</c> (-8.5%).
+  /// </param>
+  public void RegisterModifier(string ownerId, float modifier) {
+    if (!IsLiveAndGrowing) {
+      return;
+    }
+    if (modifier > 0) {
+      _registeredBoosts[ownerId] = modifier;
+    } else if (modifier < 0) {
+      _registeredModerators[ownerId] = modifier;
+    } else {
+      HostedDebugLog.Warning(this, "Ignoring zero modifier from owner: {0}", ownerId);
+    }
+    UpdateRate();
+  }
+
+  /// <summary>Removes any modifications from the owner.</summary>
+  /// <param name="ownerId">
+  /// The ID of the owner that applied the modifiers. Only the modifiers applied by this owner will be deleted.
+  /// </param>
+  public void UnregisterModifier(string ownerId) {
+    _registeredBoosts.Remove(ownerId);
+    _registeredModerators.Remove(ownerId);
+    UpdateRate();
+  }
+
+  #endregion
+
+  #region Implementation
+
+  ITimeTriggerFactory _timeTriggerFactory;
+  Growable _growable;
+  readonly Dictionary<string, float> _registeredBoosts = new();
+  readonly Dictionary<string, float> _registeredModerators = new();
+  float _originalGrowthTimeInDays;
+
+  /// <summary>It must be public for the injection logic to work.</summary>
+  [Inject]
+  public void InjectDependencies(ITimeTriggerFactory timeTriggerFactory) {
+    _timeTriggerFactory = timeTriggerFactory;
+  }
+
+  void Awake() {
+    _growable = GetComponentFast<Growable>();
+    _originalGrowthTimeInDays = _growable._growthTimeInDays;
+  }
+
+  /// <summary>Calculates the effective multiplier and updates the growable settings.</summary>
+  /// <seealso cref="EffectiveModifier"/>
+  void UpdateRate() {
+    BestBooster = _registeredBoosts.Count > 0 ? _registeredBoosts.Values.Max() : 0f;
+    WorstModerator = _registeredModerators.Count > 0 ? _registeredModerators.Values.Min() : 0f;
+    EffectiveModifier = BestBooster + WorstModerator;
+    if (!IsLiveAndGrowing) {
+      return; // The growable is in the invalid state.
+    }
+    var newGrowthTime = _originalGrowthTimeInDays / (1f + EffectiveModifier / 100f);
+    var progressDone = _growable.GrowthProgress;
+    var newTrigger = _timeTriggerFactory.Create(() => _growable.Grow(), newGrowthTime);
+    newTrigger.FastForwardProgress(progressDone);
+    _growable._timeTrigger.Reset();
+    _growable._timeTrigger = newTrigger;
+    _growable._timeTrigger.Resume();
+    RateIsModified = Mathf.Abs(_originalGrowthTimeInDays - newGrowthTime) > float.Epsilon;
+    _growable._growthTimeInDays = newGrowthTime;
+  }  
+
+  #endregion
+}
+
+}

TimberCommons/IrrigationSystem/IRangeEffect.cs

@@ -2,7 +2,7 @@
 // Author: igor.zavoychinskiy@gmail.com
 // License: Public Domain
 
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using UnityEngine;
 
 namespace IgorZ.TimberCommons.IrrigationSystem {
@@ -22,7 +22,7 @@ public interface IRangeEffect {
 
   /// <summary>Applies affect to the specified tiles.</summary>
   /// <param name="tiles">The tiles to apply effect to.</param>
-  public void ApplyEffect(IEnumerable<Vector2Int> tiles);
+  public void ApplyEffect(ImmutableHashSet<Vector2Int> tiles);
 
   /// <summary>Resets all effects that were applied in the last call to <see cref="ApplyEffect"/></summary>
   public void ResetEffect();