Make decimal places configurable

Make decimal places configurable (from 0 to 3) and make the text scaling and positioning work with the variable label sizes.

No code changes for dark fog were needed, only a rebuild against the new game files.

Author: Shad0wlife

DSP_AssemblerUI/AssemblerSpeedUI/AssemblerSpeedUIMod.cs

@@ -19,6 +19,7 @@ public class AssemblerSpeedUIMod : BaseUnityPlugin
         public static ConfigEntry<bool> configInputSpeedsPerSecond;
         public static ConfigEntry<bool> configOutputSpeedsPerSecond;
         public static ConfigEntry<bool> configShowLiveSpeed;
+        public static ConfigEntry<uint> configShownDecimalPlaces;
 
         public static ConfigEntry<bool> configShowMinerSpeed;
         public static ConfigEntry<bool> configShowMinerLiveSpeed;
@@ -39,6 +40,13 @@ internal void Awake()
 
             configShowLiveSpeed = Config.Bind("General", "ShowLiveSpeedInfo", false, "True: shows current speed of production building. False: shows regular recipe speed of production building.");
 
+            configShownDecimalPlaces = Config.Bind("General", "NumberOfDecimalsShown", (uint)1,
+                new ConfigDescription(
+                    $"Sets the number of decimal places shown for speed values. Value must be in range [{Constants.MIN_DECIMAL_PLACES},{Constants.MAX_DECIMAL_PLACES}].",
+                    new AcceptableValueRange<uint>(Constants.MIN_DECIMAL_PLACES, Constants.MAX_DECIMAL_PLACES)
+                )
+            );
+
             configShowMinerSpeed = Config.Bind("Miner", "EnableMinerSpeedInfo", true, "Enables the speed information below the output area in the Miner Window.");
             configShowMinerLiveSpeed = Config.Bind("Miner", "ShowMinerLiveSpeedInfo", false, "True: shows current speed of production building. False: shows regular recipe speed of production building.");
             configMinerSpeedsPerSecond = Config.Bind("Miner", "EnableMinerOutputSpeedInfoPerSecond", false, "Sets the output speeds shown in Miners to items/s (default: items/min).");

DSP_AssemblerUI/AssemblerSpeedUI/Constants.cs

@@ -7,5 +7,23 @@ internal static class Constants
         public static readonly string AssemblerWindowSpeedTextPath = $"{AssemblerWindowPath}/produce/speed/speed-text";
         public static readonly string MinerWindowPath = $"{BaseWindowsPath}/Miner Window";
         public static readonly string MinerWindowSpeedTextPath = $"{MinerWindowPath}/produce/speed/speed-text";
+
+        public const uint MIN_DECIMAL_PLACES = 0;
+        public const uint MAX_DECIMAL_PLACES = 3;
+
+
+        public const float INPUT_YPOS = 25f;
+        public const float OUTPUT_YPOS = -50f;
+
+        public const float INPUT_FIRST_X_OFFSET = 130f; //Text width/2 is deducted from this so that text is justified right
+        public const float OUTPUT_FIRST_X_OFFSET = 1f;
+
+        public const float INPUT_X_ITEMSIZE = 50f;
+        public const float OUTPUT_X_ITEMSIZE = 64f;
+
+        public const float INPUT_MAXWIDTH = 48f;
+        public const float OUTPUT_MAXWIDTH = 62f;
+
+        public const int MAX_FONTSIZE = 12;
     }
 }

DSP_AssemblerUI/AssemblerSpeedUI/ModInfo.cs

@@ -5,8 +5,8 @@ public static class ModInfo
         public const string ModID = "dsp.assemblerUI.speedMod";
         public const string ModName = "Assembler UI Speed Info Mod";
         public const string majorVersion = "2";
-        public const string minorVersion = "2";
-        public const string hotfixVersion = "1";
+        public const string minorVersion = "3";
+        public const string hotfixVersion = "0";
         public const string buildVersion = "0";
         public const string VersionString = majorVersion + "." + minorVersion + "." + hotfixVersion + "." + buildVersion;
     }

DSP_AssemblerUI/AssemblerSpeedUI/Patchers/UiAssemblerWindowPatch.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
 using BepInEx.Configuration;
@@ -11,6 +12,12 @@ public static class UiAssemblerWindowPatch
     {
         internal static AdditionalSpeedLabels additionalSpeedLabels;
 
+        /// <summary>
+        /// This has no call shown in visual studio, but is manually called by the transpiler with a CALL-Operation.
+        /// </summary>
+        /// <param name="baseSpeed"></param>
+        /// <param name="productCounts"></param>
+        /// <param name="requireCounts"></param>
         public static void UpdateSpeedLabels(float baseSpeed, int[] productCounts, int[] requireCounts)
         {
             additionalSpeedLabels.UpdateSpeedLabels(baseSpeed, productCounts, requireCounts);
@@ -162,7 +169,10 @@ public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructio
                 new CodeInstruction(OpCodes.Ldfld, typeof(AssemblerComponent).GetField("productCounts")), //load product counts array on stack
                 new CodeInstruction(OpCodes.Ldloc_0),
                 new CodeInstruction(OpCodes.Ldfld, typeof(AssemblerComponent).GetField("requireCounts")), //load require counts array on stack
-                new CodeInstruction(OpCodes.Call, typeof(UiAssemblerWindowPatch).GetMethod("UpdateSpeedLabels")) //UpdateSpeedLabels(baseSpeed, productCounts[], requireCounts[])
+                new CodeInstruction(OpCodes.Call, typeof(UiAssemblerWindowPatch).GetMethod(
+                    "UpdateSpeedLabels", 
+                    new Type[] { typeof(float), typeof(int[]), typeof(int[]) })
+                ) //UpdateSpeedLabels(baseSpeed, productCounts[], requireCounts[])
             );
 
             AssemblerSpeedUIMod.ModLogger.DebugLog($"UIAssemblerWindowTranspiler Matcher Codes Count: {matcher.Instructions().Count}, Matcher Pos: {matcher.Pos}!");

DSP_AssemblerUI/AssemblerSpeedUI/Patchers/UiMinerWindowPatch.cs

@@ -159,6 +159,10 @@ public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructio
             return matcher.Instructions();
         }
 
+        /// <summary>
+        /// This has no call shown in visual studio, but is manually called by the transpiler with a CALL-Operation.
+        /// </summary>
+        /// <param name="baseSpeed"></param>
         public static void UpdateSpeedLabel(float baseSpeed)
         {
             additionalSpeedLabels.UpdateSpeedLabel($"assembler-speed-out-item0", baseSpeed, AssemblerSpeedUIMod.configMinerSpeedsPerSecond.Value);

DSP_AssemblerUI/AssemblerSpeedUI/Util/AdditionalSpeedLabels.cs

@@ -18,16 +18,44 @@ public class AdditionalSpeedLabels
         private int speedInfosInCount = 0;
         private Vector3? vanillaSpeedPos = null;
 
+        private int currentOutputs = 1;
+        private int currentInputs = 1;
+
         private ModLogger modLogger;
         private bool setupOutputLabels;
         private bool setupInputLabels;
+
+        /// <summary>
+        /// The actual formatstring. Gets the value directly to avoid the extra call to ShownDecimals' getter.
+        /// No idea if that would even affect anything, but still.
+        /// </summary>
+        private string DecimalFormatString
+        {
+            get
+            {
+                return "F" + AssemblerSpeedUIMod.configShownDecimalPlaces.Value;
+            }
+        }
 
         public AdditionalSpeedLabels(ModLogger modLogger, bool setupOutputLabels, bool setupInputLabels, string speedTextPath)
         {
             this.modLogger = modLogger;
             this.setupOutputLabels = setupOutputLabels;
             this.setupInputLabels = setupInputLabels;
             this.speedTextPath = speedTextPath;
+
+            //Devices without inputs will be created with 0 current inputs, just in case
+            this.currentInputs = setupInputLabels ? 1 : 0;
+        }
+
+        /// <summary>
+        /// Pad The numbers with 2 leading spaces so that there is spacing between values.
+        /// </summary>
+        /// <param name="f">The value to be formatted.</param>
+        /// <returns>The formatted string.</returns>
+        private string MakeFormattedPaddedLabelString(float f)
+        {
+            return "  " + f.ToString(DecimalFormatString);
         }
 
         private static string ItemInputKey(int index)
@@ -74,6 +102,15 @@ public void SetupSidedLabels(int itemCount, bool isInput)
             Func<int, string> keyFunc = isInput ? (Func<int, string>)ItemInputKey : ItemOutputKey;
             int loopCap = Math.Min(itemCount, safetyIndexLimit);
 
+            if (isInput)
+            {
+                currentInputs = loopCap;
+            }
+            else
+            {
+                currentOutputs = loopCap;
+            }
+
             for (int cnt = 0; cnt < loopCap; cnt++)
             {
                 if (!speedInfos.ContainsKey(keyFunc(cnt)))
@@ -99,9 +136,9 @@ public void SetupSidedLabels(int itemCount, bool isInput)
                 if (cnt2 < itemCount)
                 {
                     //If it is a label that should be visible, set it up
-                    PositionSpeedLabel(speedInfos[keyFunc(cnt2)].GameObject, cnt2, loopCap, isInput);
+                    speedInfos[keyFunc(cnt2)].Value.text = MakeFormattedPaddedLabelString(0f) + perMinuteString;
                     speedInfos[keyFunc(cnt2)].GameObject.SetActive(true);
-                    speedInfos[keyFunc(cnt2)].Value.text = "  0.0" + perMinuteString;
+                    TryStartPositioningOnLabel(speedInfos[keyFunc(cnt2)], loopCap);
                 }
                 else
                 {
@@ -128,10 +165,17 @@ public void AddSpeedLabel(string id, int num, int ofNum, bool input)
 
             GameObject gameObject = null;
             var originalDetailLabelText = originalDetailLabel.GetComponent<Text>();
+            modLogger.DebugLog($"originalDetailLabelText was:{originalDetailLabelText.text}");
 
+            //Object.Instantiate creates a copy of an original object
             gameObject = Object.Instantiate(originalDetailLabel, originalDetailLabel.transform.position, Quaternion.identity);
             Object.Destroy(gameObject.GetComponentInChildren<Localizer>());
 
+            //ContentSizeFitter to somewhat accurately measure text label size
+            ContentSizeFitter fitter = gameObject.AddComponent<ContentSizeFitter>();
+            fitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
             gameObject.name = id;
             gameObject.transform.SetParent(originalDetailLabel.transform.parent);
 
@@ -144,21 +188,19 @@ public void AddSpeedLabel(string id, int num, int ofNum, bool input)
             }
 
             gameObject.transform.localScale = new Vector3(1f, 1f, 1f);
-            PositionSpeedLabel(gameObject, num, ofNum, input);
             gameObject.transform.right = originalDetailLabel.transform.right;
 
-            //Input area is smaller, decrease font size
-            if (input || ofNum > 1)
-            {
-                value.fontSize -= 2;
-            }
-
             ItemSpeedInfoLabel newItemSpeedInfo = new ItemSpeedInfoLabel()
             {
                 GameObject = gameObject,
-                Value = value
+                Value = value,
+                Index = num,
+                IsInput = input,
+                Fitter = fitter
             };
             speedInfos.Add(id, newItemSpeedInfo);
+
+            TryStartPositioningOnLabel(newItemSpeedInfo, ofNum);
         }
 
         /// <summary>
@@ -168,14 +210,50 @@ public void AddSpeedLabel(string id, int num, int ofNum, bool input)
         /// <param name="num">Index of the label (0-based)</param>
         /// <param name="ofNum">Count of total labels (max index + 1)</param>
         /// <param name="input">Whether the label is on the input or output side.</param>
-        private void PositionSpeedLabel(GameObject gameObject, int num, int ofNum, bool input)
+        private System.Collections.IEnumerator PositionSpeedLabel(ItemSpeedInfoLabel labelData, int ofNum)
         {
+            modLogger.DebugLog($"Working on label {labelData.GameObject.name} which is input? {labelData.IsInput}");
+            modLogger.DebugLog($"OgPosition:{labelData.Fitter.transform.localPosition}");
+
+            RectTransform targetTransform = (RectTransform)labelData.Fitter.transform;
+            float sizeLimit = labelData.IsInput ? Constants.INPUT_MAXWIDTH : Constants.OUTPUT_MAXWIDTH;
+
+            yield return null;
+
+            //Increase somewhat fast up to 12
+            while(targetTransform.rect.width < (sizeLimit - 5) && labelData.Value.fontSize < 12)
+            {
+                labelData.Value.fontSize = Math.Min(12, labelData.Value.fontSize + 4);
+                yield return null;
+            }
+
+            //Approach size from above
+            while(targetTransform.rect.width > sizeLimit)
+            {
+                labelData.Value.fontSize -= 1;
+                yield return null;
+            }
+
+            Vector3 shiftVector = GetPos(labelData.Index, ofNum, labelData.IsInput, vanillaSpeedPos.Value.z, targetTransform.rect.width);
 
-            modLogger.DebugLog($"OgPosition:{gameObject.transform.localPosition}");
-            Vector3 shiftVector = GetPosShift(num, ofNum, input);
-            modLogger.DebugLog($"ShiftedBy:{shiftVector}");
+            modLogger.DebugLog($"Shifted to:{shiftVector} from {targetTransform.localPosition}");
 
-            gameObject.transform.localPosition = vanillaSpeedPos.Value + shiftVector;
+            targetTransform.localPosition = shiftVector;
+        }
+
+        /// <summary>
+        /// Safely call the coroutine on the labels.
+        /// This is done by checking if the corresponding GameObject is acually active before starting the coroutine.
+        /// </summary>
+        /// <param name="labelData">The label to position.</param>
+        /// <param name="ofNum">The number of given labels.</param>
+        private void TryStartPositioningOnLabel(ItemSpeedInfoLabel labelData, int ofNum)
+        {
+            if (labelData.GameObject.activeInHierarchy)
+            {
+                modLogger.DebugLog($"Starting coroutine on {labelData.GameObject.name} since it is active and all its parents are too.");
+                labelData.Fitter.StartCoroutine(PositionSpeedLabel(labelData, ofNum));
+            }
         }
 
         /// <summary>
@@ -185,12 +263,13 @@ private void PositionSpeedLabel(GameObject gameObject, int num, int ofNum, bool
         /// <param name="ofNum">Count of total labels (max index + 1)</param>
         /// <param name="input">Whether the label is on the input or output side.</param>
         /// <returns>The Vector3 by which the label shall be shifted</returns>
-        private static Vector3 GetPosShift(int num, int ofNum, bool input)
+        private static Vector3 GetPos(int num, int ofNum, bool input, float z, float width)
         {
-            float yShift = input ? 25f : -50f;
-            float xShift = GetXShift(num, ofNum, input);
 
-            return new Vector3(xShift, yShift, 0f);
+            float yPos = input ? Constants.INPUT_YPOS : Constants.OUTPUT_YPOS;
+            float xPos = GetXShift(num, ofNum, input, width);
+
+            return new Vector3(xPos, yPos, z);
         }
 
         /// <summary>
@@ -200,22 +279,19 @@ private static Vector3 GetPosShift(int num, int ofNum, bool input)
         /// <param name="ofNum">Count of total labels (max index + 1)</param>
         /// <param name="input">Whether the label is on the input or output side.</param>
         /// <returns>The x-Shift of the label</returns>
-        private static float GetXShift(int num, int ofNum, bool input)
+        private static float GetXShift(int num, int ofNum, bool input, float width)
         {
-            //based on:
-            //float[][] xOutputLookup = new float[][] { new float[] { -60f }, new float[] { -125f, -60f }, new float[] { -190f, -125f, -60f } };
-            //float[][] xInputLookup = new float[][] { new float[] { 74 }, new float[] { 74f, 125f }, new float[] { 74f, 125f, 176f } };
             if (input)
             {
-                float baseX = 74f;
-                float itemStep = 49f;
-                return baseX + num * itemStep;
+                float baseX = Constants.INPUT_FIRST_X_OFFSET;
+                float itemStep = Constants.INPUT_X_ITEMSIZE;
+                return baseX - width/2 + num * itemStep;
             }
             else
             {
-                float baseX = -60f;
-                float itemStep = -65f;
-                return baseX + (ofNum - 1 - num) * itemStep;
+                float baseX = Constants.OUTPUT_FIRST_X_OFFSET;
+                float itemStep = -Constants.OUTPUT_X_ITEMSIZE;
+                return baseX - width/2 + (ofNum - 1 - num) * itemStep;
             }
         }
 
@@ -232,14 +308,20 @@ public void UpdateSpeedLabel(string id, float value, bool perSecond)
             string speedText;
             if (perSecond)
             {
-                speedText = (value/60f).ToString("0.0").PadLeft(5) + perSecondString;
+                speedText = MakeFormattedPaddedLabelString(value/60f) + perSecondString;
             }
             else
             {
-                speedText = value.ToString("0.0").PadLeft(5) + perMinuteString;
+                speedText = MakeFormattedPaddedLabelString(value) + perMinuteString;
             }
 
-            speedInfos[id].Value.text = speedText;
+            bool labelChange = speedText != speedInfos[id].Value.text;
+
+            if (labelChange)
+            {
+                speedInfos[id].Value.text = speedText;
+                TryStartPositioningOnLabel(speedInfos[id], speedInfos[id].IsInput ? currentInputs : currentOutputs);
+            }
         }
 
         public void UpdateSpeedLabels(float baseSpeed, int[] productCounts, int[] requireCounts)

DSP_AssemblerUI/AssemblerSpeedUI/Util/ItemSpeedInfoLabel.cs

@@ -7,5 +7,8 @@ internal class ItemSpeedInfoLabel
     {
         public GameObject GameObject { get; set; }
         public Text Value { get; set; }
+        public int Index { get; set; }
+        public bool IsInput { get; set; }
+        public ContentSizeFitter Fitter { get; set; }
     }
 }

README.md

@@ -11,7 +11,7 @@
  You can also decide whether you want to display the speed with which the device currently creates or consumes resources, 
  or if you want to display the recipe speed for the device without impact of power and full or empty slots.
 
- Speeds can also be configured to show in an items/s scale instead of items/min.
+ Speeds can also be configured to show in an items/s scale instead of items/min, and can be configured to use 0 to 3 decimal places.
 
 
 ## Version History
@@ -22,3 +22,4 @@
 - v2.1.0 Updated to be compatible with new game version and be more resistant to future updates. Restructured Project files and code.
 - v2.2.0 Updated to avoid a rare error when pasting recipes under specific circumstances. Should also ensure more compatibility with Nebula when another player changes the recipe of an open Assembler Window.
 - v2.2.1 Updated for compatibility with the Mecha Customization Update due to the changes added to production buffs.
+- v2.3.0 Updated to allow for configurable decimal places and adaptive text positioning. The release for this version will be built against the Dark Fog Update. It should also be possible to manually build it against older versions of the game, if needed.