Merge pull request #8 from DekuDesu/development

performance minor, refactored position math, refactored tracked objec…

Author: artyredd

MiniMapLibrary/Basic/Range.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MiniMapLibrary
+{
+    public class Range1D
+    {
+        public float Min { get; set; }
+
+        public float Max { get; set; }
+
+        /// <summary>
+        /// Equivalent to <see cref="Range1D.Max"/> - <see cref="Min"/>
+        /// </summary>
+        public float Difference => Max - Min;
+
+        /// <summary>
+        /// Equivalent to -<see cref="Min"/>(neg)
+        /// </summary>
+        public float Offset => -Min;
+
+        public void CheckValue(float value)
+        {
+            if (value < Min)
+            {
+                Min = value;
+                return;
+            }
+            if (value > Max)
+            {
+                Max = value;
+                return;
+            }
+        }
+
+        public void Clear()
+        {
+            Min = float.MaxValue;
+            Max = float.MinValue;
+        }
+    }
+}

MiniMapLibrary/Basic/Range3D.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+
+namespace MiniMapLibrary
+{
+    public class Range3D
+    {
+        public Range1D X { get; set; } = new Range1D();
+
+        public Range1D Y { get; set; } = new Range1D();
+
+        public Range1D Z { get; set; } = new Range1D();
+
+        public void CheckValue(Vector3 position)
+        {
+            X.CheckValue(position.x);
+            //Y.CheckValue(position.y);
+            Z.CheckValue(position.z);
+        }
+
+        public void Clear()
+        {
+            X.Clear();
+            Y.Clear();
+            Z.Clear();
+        }
+    }
+}

MiniMapMod/MiniMapPlugin.cs

@@ -21,17 +21,9 @@ public class MiniMapPlugin : BaseUnityPlugin
 
         private readonly Minimap Minimap = new();
 
-        private float GlobalMinX;
-        private float GlobalMaxX;
-        private float GlobalMinZ;
-        private float GlobalMaxZ;
+        private readonly Range3D TrackedDimensions = new();
 
-        private float XDifference;
-        private float XOffset;
-        private float ZDifference;
-        private float ZOffset;
-
-        private bool Enable = false;
+        private bool Enable = true;
 
         private bool ScannedStaticObjects = false;
 
@@ -83,11 +75,9 @@ private void Update()
                 {
                     if (TryCreateMinimap())
                     {
-                        ResetGlobalDimensions();
+                        TrackedDimensions.Clear();
 
                         ScanScene();
-
-                        CalculateMinimapConstraints();
                     }
                 }
             }
@@ -163,7 +153,7 @@ private bool TryCreateMinimap()
         private void Reset()
         {
             TrackedObjects.Clear();
-            ResetGlobalDimensions();
+            TrackedDimensions.Clear();
             Minimap.Destroy();
             ScannedStaticObjects = false;
         }
@@ -184,38 +174,38 @@ private void ScanStaticTypes()
                 return;
             }
 
-            RegisterTypes<ChestBehavior>(InteractableKind.Chest, dynamicObject: false);
+            RegisterMonobehaviorType<ChestBehavior>(InteractableKind.Chest, dynamicObject: false);
 
-            RegisterTypes<ShrineBloodBehavior>(InteractableKind.Shrine, dynamicObject: false);
+            RegisterMonobehaviorType<ShrineBloodBehavior>(InteractableKind.Shrine, dynamicObject: false);
 
-            RegisterTypes<ShrineChanceBehavior>(InteractableKind.Shrine, dynamicObject: false);
+            RegisterMonobehaviorType<ShrineChanceBehavior>(InteractableKind.Shrine, dynamicObject: false);
 
-            RegisterTypes<ShrineBossBehavior>(InteractableKind.Shrine, dynamicObject: false);
+            RegisterMonobehaviorType<ShrineBossBehavior>(InteractableKind.Shrine, dynamicObject: false);
 
-            RegisterTypes<ShrineCombatBehavior>(InteractableKind.Shrine, dynamicObject: false);
+            RegisterMonobehaviorType<ShrineCombatBehavior>(InteractableKind.Shrine, dynamicObject: false);
 
-            RegisterTypes<ShrineHealingBehavior>(InteractableKind.Shrine, dynamicObject: false);
+            RegisterMonobehaviorType<ShrineHealingBehavior>(InteractableKind.Shrine, dynamicObject: false);
 
-            RegisterTypes<ShrineRestackBehavior>(InteractableKind.Shrine, dynamicObject: false);
+            RegisterMonobehaviorType<ShrineRestackBehavior>(InteractableKind.Shrine, dynamicObject: false);
 
-            RegisterTypes<ShopTerminalBehavior>(InteractableKind.Chest, dynamicObject: false);
+            RegisterMonobehaviorType<ShopTerminalBehavior>(InteractableKind.Chest, dynamicObject: false);
 
-            RegisterTypes<BarrelInteraction>(InteractableKind.Barrel, barrel => !barrel.Networkopened, dynamicObject: false);
+            RegisterMonobehaviorType<BarrelInteraction>(InteractableKind.Barrel, barrel => !barrel.Networkopened, dynamicObject: false);
 
-            RegisterTypes<ScrapperController>(InteractableKind.Utility, dynamicObject: false);
+            RegisterMonobehaviorType<ScrapperController>(InteractableKind.Utility, dynamicObject: false);
 
-            RegisterTypes<GenericInteraction>(InteractableKind.Special, dynamicObject: false);
+            RegisterMonobehaviorType<GenericInteraction>(InteractableKind.Special, dynamicObject: false);
 
-            RegisterTypes<TeleporterInteraction>(InteractableKind.Teleporter, (teleporter) => teleporter.activationState != TeleporterInteraction.ActivationState.Charged, dynamicObject: false);
+            RegisterMonobehaviorType<TeleporterInteraction>(InteractableKind.Teleporter, (teleporter) => teleporter.activationState != TeleporterInteraction.ActivationState.Charged, dynamicObject: false);
 
-            RegisterTypes<SummonMasterBehavior>(InteractableKind.Drone, dynamicObject: false);
+            RegisterMonobehaviorType<SummonMasterBehavior>(InteractableKind.Drone, dynamicObject: false);
 
             ScannedStaticObjects = true;
         }
 
         private void ScanDynamicTypes()
         {
-            RegisterTypes<AimAssistTarget>(InteractableKind.Enemy, x => true, dynamicObject: true);
+            RegisterMonobehaviorType<AimAssistTarget>(InteractableKind.Enemy, x => true, dynamicObject: true);
         }
 
         private void ClearDynamicTrackedObjects()
@@ -237,24 +227,11 @@ private void ClearDynamicTrackedObjects()
             }
         }
 
-        private void CalculateMinimapConstraints()
-        {
-            // set the values used to calculate the scaled positions in the minimap for the items
-
-            // at this point the global mins and maxes are set determine the differences
-            XDifference = GlobalMaxX - GlobalMinX;
-            ZDifference = GlobalMaxZ - GlobalMinZ;
-
-            // since the minimap uses a scale from 0d to 1d to position elements we should get the offsets for the x and z dimensions
-            XOffset = -GlobalMinX;
-            ZOffset = -GlobalMinZ;
-        }
-
-        private void RegisterTypes<T>(InteractableKind kind, Func<T, bool> ActiveChecker = null, bool dynamicObject = true) where T : MonoBehaviour
+        private void RegisterMonobehaviorType<T>(InteractableKind kind, Func<T, bool> ActiveChecker = null, bool dynamicObject = true) where T : MonoBehaviour
         {
             IEnumerable<T> found = GameObject.FindObjectsOfType(typeof(T)).Select(x => (T)x);
 
-            RegisterTrackedObjects(found, kind, ActiveChecker, dynamicObject);
+            RegisterMonobehaviours(found, kind, ActiveChecker, dynamicObject);
         }
 
         /// <summary>
@@ -268,86 +245,52 @@ private Vector2 WorldToMinimap(Vector3 position)
 
             float z = position.z;
 
-            x += XOffset;
-            z += ZOffset;
+            x += TrackedDimensions.X.Offset;
+            z += TrackedDimensions.Z.Offset;
 
-            x /= XDifference;
-            z /= ZDifference;
+            x /= TrackedDimensions.X.Difference;
+            z /= TrackedDimensions.Z.Difference;
 
             return new(x * Settings.MinimapSize.Width, z * Settings.MinimapSize.Height);
         }
 
-        private void RegisterTrackedObjects<T>(IEnumerable<T> objects, InteractableKind Kind = InteractableKind.none, Func<T, bool> ActiveChecker = null, bool dynamicObject = true) where T : MonoBehaviour
+        private void RegisterMonobehaviours<T>(IEnumerable<T> objects, InteractableKind Kind = InteractableKind.none, Func<T, bool> ActiveChecker = null, bool dynamicObject = true) where T : MonoBehaviour
         {
+            if (Kind == InteractableKind.none)
+            {
+                return;
+            }
+
             foreach (var item in objects)
             {
-                if (Kind != InteractableKind.none)
+                if (ActiveChecker == null)
                 {
-                    ITrackedObject newObject = null;
+                    PurchaseInteraction interaction = item.gameObject.GetComponent<PurchaseInteraction>();
 
-                    if (ActiveChecker == null)
+                    if (interaction != null)
                     {
-                        PurchaseInteraction interaction = item.gameObject.GetComponent<PurchaseInteraction>();
-
-                        if (interaction != null)
-                        {
-                            newObject = new TrackedObject<PurchaseInteraction>(Kind, item.gameObject, null)
-                            {
-                                BackingObject = interaction,
-                                ActiveChecker = (interaction) => interaction.available,
-                                DynamicObject = dynamicObject
-                            };
-                        }
-                    }
+                        RegisterObject(Kind, item.gameObject, interaction, (interaction) => interaction.available, dynamicObject);
 
-                    if (newObject == null)
-                    {
-                        newObject = new TrackedObject<T>(Kind, item.gameObject, null)
-                        {
-                            BackingObject = item,
-                            ActiveChecker = ActiveChecker,
-                            DynamicObject = dynamicObject
-                        };
+                        continue;
                     }
-
-                    TrackedObjects.Add(newObject);
-
-                    CheckPositionConstraints(item.transform.position);
                 }
-            }
-        }
 
-        private void CheckPositionConstraints(Vector3 position)
-        {
-            if (position.x < GlobalMinX)
-            {
-                GlobalMinX = position.x;
-            }
-            else if (position.x > GlobalMaxX)
-            {
-                GlobalMaxX = position.x;
-            }
-
-            if (position.z < GlobalMinZ)
-            {
-                GlobalMinZ = position.z;
-            }
-            else if (position.z > GlobalMaxZ)
-            {
-                GlobalMaxZ = position.z;
+                RegisterObject(Kind, item.gameObject, item, ActiveChecker, dynamicObject);
             }
         }
 
-        private void ResetGlobalDimensions()
+        private void RegisterObject<T>(InteractableKind type, GameObject gameObject, T BackingObject, Func<T, bool> Expression, bool Dynamic)
         {
-            GlobalMinX = float.MaxValue;
-            GlobalMaxX = float.MinValue;
+            ITrackedObject newObject = new TrackedObject<T>(type, gameObject, null)
+            {
+                BackingObject = BackingObject,
+                ActiveChecker = Expression,
+                DynamicObject = Dynamic
+            };
 
-            GlobalMinZ = float.MaxValue;
-            GlobalMaxZ = float.MinValue;
+            TrackedObjects.Add(newObject);
 
-            ZOffset = 0;
-            XOffset = 0;
+            TrackedDimensions.CheckValue(gameObject.transform.position);
         }
     }
 }

README.md

@@ -38,6 +38,10 @@ https://www.autism.org/donate-autism-research-institute/
 If you have an issue, discover a bug, or have a recommendation please file an issue on my github page.
 
 ### Change Log
+Hotfix 2.04
+- enabled mini-map by default, making it so players dont need to remember to press 'M' to show it every time they start the game
+- performance minor
+
 Hotfixes 2.03
 - changed icon sizes
 - added support for colors

manifest.json

@@ -1,8 +1,8 @@
 {
   "name": "MiniMapMod",
-  "version_number": "2.0.3",
+  "version_number": "2.0.4",
   "website_url": "https://github.com/DekuDesu",
-  "description": "Adds a MiniMap to your game v2.0.3",
+  "description": "Adds a MiniMap to your game v2.0.4",
   "dependencies": [
     "bbepis-BepInExPack-5.4.9",
     "RiskofThunder-HookGenPatcher-1.2.1"