Update to v1.1.0

Shad0wlife · Shad0wlife · commit 3743f955445e · 2021-03-29T20:29:03.000+02:00
Added the speed of input consumption. Added Configuration to disable input speed and output speed separately.
diff --git a/DSP_AssemblerUI/AssemblerSpeedUI/AssemblerSpeedUIMod.cs b/DSP_AssemblerUI/AssemblerSpeedUI/AssemblerSpeedUIMod.cs
@@ -1,4 +1,5 @@
 ﻿using BepInEx;
+using BepInEx.Configuration;
 using BepInEx.Logging;
 using HarmonyLib;
 using System;
@@ -17,27 +18,69 @@
 [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
 namespace DSP_AssemblerUI.AssemblerSpeedUI
 {
-    [BepInPlugin("dsp.assemblerUI.speedMod", "Assembler UI Speed Info Mod", "1.0.0.0")]
+    public static class ModInfo
+    {
+        public const string ModID = "dsp.assemblerUI.speedMod";
+        public const string ModName = "Assembler UI Speed Info Mod";
+        public const string majorVersion = "1";
+        public const string minorVersion = "1";
+        public const string hotfixVersion = "0";
+        public const string buildVersion = "0";
+        public const string VersionString = majorVersion + "." + minorVersion + "." + hotfixVersion + "." + buildVersion;
+    }
+
+    [BepInPlugin(ModInfo.ModID, ModInfo.ModName, ModInfo.VersionString)]
     public class AssemblerSpeedUIMod : BaseUnityPlugin
     {
         #region Main Plugin
+        internal Harmony harmony;
+
         public new static ManualLogSource Logger;
 
+        public static ConfigEntry<bool> configEnableOutputSpeeds;
+        public static ConfigEntry<bool> configEnableInputSpeeds;
+
         internal void Awake()
         {
-
             //Adding the Logger
             Logger = new ManualLogSource("AssemblerSpeedUIMod");
             BepInEx.Logging.Logger.Sources.Add(Logger);
 
-            Harmony.CreateAndPatchAll(typeof(AssemblerSpeedUIMod));
+            configEnableOutputSpeeds = Config.Bind("General", "EnableOutputSpeedInfo", true, "Enables the speed information below the output area in the Assembler Window.");
+            configEnableInputSpeeds = Config.Bind("General", "EnableInputSpeedInfo", true, "Enables the speed information above the input area in the Assembler Window.");
+
+            harmony = new Harmony(ModInfo.ModID);
+            try
+            {
+                harmony.PatchAll(typeof(AssemblerSpeedUIMod));
+            }
+            catch(Exception ex)
+            {
+                ErrorLog(ex.Message);
+                ErrorLog(ex.StackTrace);
+            }
+        }
+
+        internal void OnDestroy()
+        {
+            harmony?.UnpatchSelf();
+
+            foreach(KeyValuePair<string, ItemSpeedInfoLabel> pair in speedInfos)
+            {
+                Destroy(pair.Value.gameObject);
+            }
         }
 
         [Conditional("DEBUG")]
         static void DebugLog(string logMessage)
         {
             Logger.LogDebug(logMessage);
         }
+
+        static void ErrorLog(string logMessage)
+        {
+            Logger.LogError(logMessage);
+        }
         #endregion
 
         #region Patcher
@@ -48,13 +91,18 @@ internal class ItemSpeedInfoLabel
         }
 
         internal static Dictionary<string, ItemSpeedInfoLabel> speedInfos = new Dictionary<string, ItemSpeedInfoLabel>();
+        internal static int speedInfosOutCount = 0;
+        internal static int speedInfosInCount = 0;
 
         static readonly string TEXT_PATH = "UI Root/Overlay Canvas/In Game/Windows/Assembler Window/produce/speed/speed-text";
 
-        public static readonly string[] itemKeys = { "assembler-speed-item0", "assembler-speed-item1", "assembler-speed-item2" };
+        public const string outputKeyBase = "assembler-speed-out-item";
+        public const string inputKeyBase = "assembler-speed-in-item";
 
-        public static float[][] xLookup = new float[][]{ new float[]{ -60f }, new float[]{ -125f, -60f }, new float[] { -190f, -125f, -60f } };
-        public static Vector3? ogPos = null;
+        public static readonly string[] itemOutputKeys = { outputKeyBase + "0", outputKeyBase + "1", outputKeyBase + "2" };
+        public static readonly string[] itemInputKeys = { inputKeyBase + "0", inputKeyBase + "1", inputKeyBase + "2" };
+
+        public static Vector3? vanillaSpeedPos = null;
 
         [HarmonyPostfix, HarmonyPatch(typeof(UIAssemblerWindow), "OnAssemblerIdChange")]
         public static void OnAssemblerIdChangePostfix(UIAssemblerWindow __instance)
@@ -68,41 +116,88 @@ public static void OnRecipePickerReturnPostfix(UIAssemblerWindow __instance)
             SetupLabels(__instance);
         }
 
+        /// <summary>
+        /// Sets up all currently required and configured labels
+        /// </summary>
+        /// <param name="window">The UIAssemblerWindow for which the data shall be set up.</param>
         public static void SetupLabels(UIAssemblerWindow window)
         {
-            int? productCount = window.factorySystem?.assemblerPool[window.assemblerId].products?.Length;
-            if (!productCount.HasValue)
+            //Output
+            if (configEnableOutputSpeeds.Value)
             {
-                return;
+                int? productCount = window.factorySystem?.assemblerPool[window.assemblerId].products?.Length;
+                if (productCount.HasValue)
+                {
+                    SetupSidedLabels(productCount.Value, false);
+                }
             }
-            int loopCap = Math.Min(productCount.Value, itemKeys.Length);
+
+            //Input
+            if (configEnableInputSpeeds.Value)
+            {
+                int? inputCount = window.factorySystem?.assemblerPool[window.assemblerId].requires?.Length;
+                if (inputCount.HasValue)
+                {
+                    SetupSidedLabels(inputCount.Value, true);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets up the currently required labels for either input or output side
+        /// </summary>
+        /// <param name="itemCount">The number of items which currently need a label</param>
+        /// <param name="isInput">Whether the labels are on the input or output side of the UI</param>
+        public static void SetupSidedLabels(int itemCount, bool isInput)
+        {
+            string[] matchingKeys = isInput ? itemInputKeys : itemOutputKeys;
+            int loopCap = Math.Min(itemCount, matchingKeys.Length);
 
             for (int cnt = 0; cnt < loopCap; cnt++)
             {
-                if (!speedInfos.ContainsKey(itemKeys[cnt]))
+                if (!speedInfos.ContainsKey(matchingKeys[cnt]))
                 {
-                    AddSpeedLabel(itemKeys[cnt], cnt, loopCap);
+                    AddSpeedLabel(matchingKeys[cnt], cnt, loopCap, isInput);
+                    if (isInput)
+                    {
+                        speedInfosInCount++;
+                    }
+                    else
+                    {
+                        speedInfosOutCount++;
+                    }
                 }
             }
 
             string perMinuteString = "每分钟".Translate();
+            int matchingInfoCount = isInput ? speedInfosInCount : speedInfosOutCount;
 
-            for (int cnt2 = 0; cnt2 < speedInfos.Count; cnt2++)
+            //Iterate only over the already created text labels for the side
+            for (int cnt2 = 0; cnt2 < matchingInfoCount; cnt2++)
             {
-                if (cnt2 < productCount)
+                if (cnt2 < itemCount)
                 {
-                    speedInfos[itemKeys[cnt2]].gameObject.SetActive(true);
-                    speedInfos[itemKeys[cnt2]].value.text = "0.0" + perMinuteString;
-                    PositionSpeedLabel(speedInfos[itemKeys[cnt2]].gameObject, cnt2, loopCap);
+                    //If it is a label that should be visible, set it up
+                    speedInfos[matchingKeys[cnt2]].gameObject.SetActive(true);
+                    speedInfos[matchingKeys[cnt2]].value.text = "  0.0" + perMinuteString;
+                    PositionSpeedLabel(speedInfos[matchingKeys[cnt2]].gameObject, cnt2, loopCap, isInput);
                 }
                 else
                 {
-                    speedInfos[itemKeys[cnt2]].gameObject.SetActive(false);
+                    //If the label exists, but the current assembler doesn't use it, set it to inactive
+                    speedInfos[matchingKeys[cnt2]].gameObject.SetActive(false);
                 }
             }
         }
 
-        public static void AddSpeedLabel(string id, int num, int ofNum)
+        /// <summary>
+        /// Adds and initalizes a new speed label when it is needed.
+        /// </summary>
+        /// <param name="id">The dictionary ID of the new label</param>
+        /// <param name="num">Index of the new 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>
+        public static void AddSpeedLabel(string id, int num, int ofNum, bool input)
         {
             var originalDetailLabel = GameObject.Find(TEXT_PATH);
             if (originalDetailLabel == null)
@@ -122,15 +217,21 @@ public static void AddSpeedLabel(string id, int num, int ofNum)
             var textComponents = gameObject.GetComponentsInChildren<Text>();
             var value = textComponents[0];
 
-            if (!ogPos.HasValue)
+            if (!vanillaSpeedPos.HasValue)
             {
-                ogPos = originalDetailLabel.transform.localPosition;
+                vanillaSpeedPos = originalDetailLabel.transform.localPosition;
             }
 
             gameObject.transform.localScale = new Vector3(1f, 1f, 1f);
-            PositionSpeedLabel(gameObject, num, ofNum);
+            PositionSpeedLabel(gameObject, num, ofNum, input);
             gameObject.transform.right = originalDetailLabel.transform.right;
 
+            //Input area is smaller, decrease font size
+            if (input)
+            {
+                value.fontSize -= 2;
+            }
+
             ItemSpeedInfoLabel newItemSpeedInfo = new ItemSpeedInfoLabel()
             {
                 gameObject = gameObject,
@@ -139,32 +240,99 @@ public static void AddSpeedLabel(string id, int num, int ofNum)
             speedInfos.Add(id, newItemSpeedInfo);
         }
 
-        public static void PositionSpeedLabel(GameObject gameObject, int num, int ofNum)
+        /// <summary>
+        /// Sets the position of a given label.
+        /// </summary>
+        /// <param name="gameObject">The GameObject of the label to be moved.</param>
+        /// <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>
+        public static void PositionSpeedLabel(GameObject gameObject, int num, int ofNum, bool input)
         {
 
             DebugLog($"OgPosition:{gameObject.transform.localPosition}");
-            Vector3 shiftVector = getPosShift(num, ofNum);
+            Vector3 shiftVector = getPosShift(num, ofNum, input);
             DebugLog($"ShiftedBy:{shiftVector}");
 
-            gameObject.transform.localPosition = ogPos.Value + shiftVector;
+            gameObject.transform.localPosition = vanillaSpeedPos.Value + shiftVector;
         }
 
-        public static Vector3 getPosShift(int num, int ofNum)
+        /// <summary>
+        /// Gets the Vector3 by which the label is shifted compared to the original speed label.
+        /// </summary>
+        /// <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>
+        /// <returns>The Vector3 by which the label shall be shifted</returns>
+        public static Vector3 getPosShift(int num, int ofNum, bool input)
         {
-            return new Vector3(xLookup[ofNum - 1][num], -50f, 0f);
+            float yShift = input ? 25f : -50f;
+            float xShift = getXShift(num, ofNum, input);
+
+            return new Vector3(xShift, yShift, 0f);
         }
 
+        /// <summary>
+        /// Calculates the x-Shift of a Label, based on the label count and whether it's on the input or output side.
+        /// </summary>
+        /// <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>
+        /// <returns>The x-Shift of the label</returns>
+        private static float getXShift(int num, int ofNum, bool input)
+        {
+            //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;
+            }
+            else
+            {
+                float baseX = -60f;
+                float itemStep = -65f;
+                return baseX + (ofNum - 1 - num) * itemStep;
+            }
+        }
+
+        /// <summary>
+        /// Updates a singular label with the current speed data
+        /// </summary>
+        /// <param name="id">The Dict-ID of the label to update</param>
+        /// <param name="value">The value which to write in the label</param>
         public static void UpdateSpeedLabel(string id, float value)
         {
             string perMinuteString = "每分钟".Translate();
-            speedInfos[id].value.text = value.ToString("0.0") + perMinuteString;
+            speedInfos[id].value.text = value.ToString("0.0").PadLeft(5) + perMinuteString;
         }
 
-        public static void UpdateSpeedLabels(float baseSpeed, int[] productCounts)
+        /// <summary>
+        /// Update all the labels for the given base speed, as well as inputs and outputs
+        /// </summary>
+        /// <param name="baseSpeed">The base speed (number of recipe runs per minute)</param>
+        /// <param name="productCounts">The array with info how many items of each product are created each run</param>
+        /// <param name="requireCounts">The array with info how many items of each input are consumed each run</param>
+        public static void UpdateSpeedLabels(float baseSpeed, int[] productCounts, int[] requireCounts)
         {
-            for(int cnt = 0; cnt < Math.Min(productCounts.Length, itemKeys.Length); cnt++)
+            //Output
+            if (configEnableOutputSpeeds.Value)
+            {
+                for (int cnt = 0; cnt < Math.Min(productCounts.Length, itemOutputKeys.Length); cnt++)
+                {
+                    UpdateSpeedLabel(itemOutputKeys[cnt], productCounts[cnt] * baseSpeed);
+                }
+            }
+
+            //Input
+            if (configEnableInputSpeeds.Value)
             {
-                UpdateSpeedLabel(itemKeys[cnt], productCounts[cnt]*baseSpeed);
+                for (int cnt = 0; cnt < Math.Min(requireCounts.Length, itemInputKeys.Length); cnt++)
+                {
+                    UpdateSpeedLabel(itemInputKeys[cnt], requireCounts[cnt] * baseSpeed);
+                }
             }
         }
 
@@ -195,13 +363,17 @@ public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructio
             //ldloc.s 18
             //ldloca.s 0 //AssemblerComponent local var
             //ldfld int32[] AssemblerComponent::productCounts
+            //ldloca.s 0 //AssemblerComponent local var
+            //ldfld int32[] AssemblerComponent::requireCounts
             //call update
             //<-- endInsert
             DebugLog($"UiTextTranspiler Matcher Codes Count: {matcher.Instructions().Count}, Matcher Pos: {matcher.Pos}!");
             matcher.InsertAndAdvance(
-                new CodeInstruction(OpCodes.Ldloc_S, (byte)18),
+                new CodeInstruction(OpCodes.Ldloc_S, (byte)18), //Load base speed on stack
+                new CodeInstruction(OpCodes.Ldloca_S, (byte)0),
+                new CodeInstruction(OpCodes.Ldfld, typeof(AssemblerComponent).GetField("productCounts")), //load product counts array on stack
                 new CodeInstruction(OpCodes.Ldloca_S, (byte)0),
-                new CodeInstruction(OpCodes.Ldfld, typeof(AssemblerComponent).GetField("productCounts")),
+                new CodeInstruction(OpCodes.Ldfld, typeof(AssemblerComponent).GetField("requireCounts")), //load require counts array on stack
                 new CodeInstruction(OpCodes.Call, typeof(AssemblerSpeedUIMod).GetMethod("UpdateSpeedLabels"))
             );
 
diff --git a/DSP_AssemblerUI/Properties/AssemblyInfo.cs b/DSP_AssemblerUI/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@
 // Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
 // indem Sie "*" wie unten gezeigt eingeben:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.1.0.0")]
+[assembly: AssemblyFileVersion("1.1.0.0")]
diff --git a/README.md b/README.md
@@ -1,10 +1,14 @@
 # DSPAssemblerUI
  A Dyson Sphere Program Mod to enhance the Assembler UI Window.
  
- It shows the production speeds of the produced items below the corresponding item slots in the window.
- This way, you can plan your factory setup more easily without having to calculate your outputs yourself.
+ It shows the production speeds of the produced items below the corresponding output slots in the window, 
+ as well as the consumption speed of the input items above the input slots.
+ This way, you can plan your factory setup more easily without having to calculate your in- and outputs yourself.
 
+ The speed info for both input and output can be disabled, should you prefer not showing one of them. 
+ Or both of them - even though I don't understand why you would install this mod in the first place then...
 
 
 ## Version History
 - v1.0.0 First Version. Shows Production Speeds below Items.
+- v1.1.0 Updated to also show input consumption speeds. Added configuration to enable/disable input and output speeds separately.
