more refactoring

Author: artyredd

MiniMapLibrary/Scanner/DefaultSorter.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using UnityEngine;
 
 #nullable enable
 namespace MiniMapLibrary.Scanner
@@ -10,13 +11,24 @@ public class DefaultSorter<T> : ISorter<T>
         public InteractableKind Kind { get; set; }
 
         private readonly Func<T, bool>? selector;
+        private readonly Func<T, GameObject> converter;
+        private readonly Func<T, bool>? activeChecker;
 
-        public DefaultSorter(InteractableKind kind, Func<T, bool>? selector = null)
+        public DefaultSorter(InteractableKind kind, 
+            Func<T, GameObject> converter, 
+            Func<T, bool>? selector = null, 
+            Func<T, bool>? activeChecker = null)
         {
             Kind = kind;
             this.selector = selector;
+            this.converter = converter;
+            this.activeChecker = activeChecker;
         }
 
         public bool IsKind(T value) => selector?.Invoke(value) ?? false;
+
+        public GameObject GetGameObject(T value) => converter(value);
+
+        public bool CheckActive(T value) => activeChecker?.Invoke(value) ?? true;
     }
 }

MiniMapLibrary/Scanner/Interfaces/IInteractibleSorter.cs

@@ -1,17 +1,19 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using UnityEngine;
 
 namespace MiniMapLibrary.Scanner
 {
     public interface IInteractibleSorter<T>
     {
         /// <summary>
         /// Attempts to find the applicable <see cref="InteractableKind"/> that the provided instance
-        /// of <see cref="T"/> should be considered
+        /// of <see cref="T"/> should be considered and returns that objects gameobject that should
+        /// be tracked to update it's position on the minimap
         /// </summary>
         /// <param name="objectToBeSorted"></param>
         /// <returns></returns>
-        bool TrySort(T objectToBeSorted, out InteractableKind kind);
+        bool TrySort(T objectToBeSorted, out InteractableKind kind, out GameObject gameObject, out Func<T, bool> activeChecker);
     }
 }

MiniMapLibrary/Scanner/Interfaces/ISorter.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using UnityEngine;
 
 namespace MiniMapLibrary.Scanner
 {
@@ -14,5 +15,19 @@ public interface ISorter<T>
         /// <param name="value"></param>
         /// <returns>true when the provided <paramref name="value"/> should be <see cref="Kind"/></returns>
         bool IsKind(T value);
+
+        /// <summary>
+        /// Retrieves the gameobject from the provided T value
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        GameObject GetGameObject(T value);
+
+        /// <summary>
+        /// Checks if the provided value is active and should be displayed as active on the minimap
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        bool CheckActive(T value);
     }
 }

MiniMapLibrary/Scanner/Interfaces/ITrackedObjectScanner.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MiniMapLibrary.Scanner
+{
+    public interface ITrackedObjectScanner
+    {
+        /// <summary>
+        /// Scans the scene for any objects that should be placed on the minimap
+        /// add the found objects to the privided list
+        /// </summary>
+        void ScanScene(IList<ITrackedObject> list);
+    }
+}

MiniMapLibrary/Scanner/MonoBehaviourSorter.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using UnityEngine;
 
+#nullable enable
 namespace MiniMapLibrary.Scanner
 {
     public class MonoBehaviourSorter<T> : IInteractibleSorter<T>
@@ -13,16 +15,24 @@ public MonoBehaviourSorter(ISorter<T>[] sorters)
             this.sorters = sorters;
         }
 
-        public bool TrySort(T value, out InteractableKind kind)
+        public bool TrySort(T value, out InteractableKind kind, out GameObject? gameObject, out Func<T, bool> activeChecker)
         {
             kind = InteractableKind.none;
+            gameObject = null;
+            activeChecker = (x) => true;
 
-            // for eah nicer looking but slghtly slower
+            // iterate though our sorters
             foreach (ISorter<T> sorter in sorters)
             {
+                // check if the provided value meets the criteria to be of this sorters
+                // kind
                 if (sorter.IsKind(value))
                 {
+                    // set the out kind and grab the gameobject
                     kind = sorter.Kind;
+                    gameObject = sorter.GetGameObject(value);
+                    activeChecker = sorter.CheckActive;
+
                     return true;
                 }
             }

MiniMapLibrary/Scanner/TrackedObjectScanner.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+
+namespace MiniMapLibrary.Scanner
+{
+    public class TrackedObjectScanner<T> : ITrackedObjectScanner
+    {
+        private readonly IScanner<T> scanner;
+        private readonly IInteractibleSorter<T> sorter;
+        private readonly bool dynamic;
+
+        public TrackedObjectScanner(bool dynamic, IScanner<T> scanner, IInteractibleSorter<T> sorter)
+        {
+            this.scanner = scanner;
+            this.sorter = sorter;
+            this.dynamic = dynamic;
+        }
+
+        public void ScanScene(IList<ITrackedObject> list)
+        {
+            IEnumerable<T> foundObjects = scanner.Scan();
+
+            foreach (var item in foundObjects)
+            {
+                if (sorter.TrySort(item, out InteractableKind kind, out GameObject gameObject, out Func<T, bool> activeChecker))
+                {
+                    list.Add(new TrackedObject<T>(kind, gameObject, null) {
+                        BackingObject = item,
+                        ActiveChecker = activeChecker,
+                        DynamicObject = dynamic
+                    });
+                }
+            }
+        }
+    }
+}

MiniMapMod/MiniMapPlugin.cs

@@ -80,13 +80,14 @@ public void Awake()
             // responsible for finding the InteractibleKind for each chest
             IInteractibleSorter<ChestBehavior> chestSorter = new MonoBehaviourSorter<ChestBehavior>(
                 new ISorter<ChestBehavior>[] {
-                    new DefaultSorter<ChestBehavior>(InteractableKind.Chest, (x) => true),
-                    new DefaultSorter<ChestBehavior>(InteractableKind.LunarPod, (x) => true),
+                    new DefaultSorter<ChestBehavior>(InteractableKind.Chest, (x) => x.gameObject, (x) => true),
+                    new DefaultSorter<ChestBehavior>(InteractableKind.LunarPod, (x) => x.gameObject, (x) => true),
                 }
             );
 
-            // TODO: Create interface/class resposible for converting these chests and their kind
-            // into tracked objects
+            ITrackedObjectScanner sceneScanner = new TrackedObjectScanner<ChestBehavior>(false, chestScanner, chestSorter);
+
+            ssceneScanner.ScanScene();
         }
 
         //The Update() method is run on every frame of the game.