Get Ore Markers in the Programmable Block

Sources/Sandbox.Common/ModAPI/Ingame/IMyOreDetector.cs

@@ -2,12 +2,30 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using VRageMath;
 
 namespace Sandbox.ModAPI.Ingame
 {
     public interface IMyOreDetector : IMyFunctionalBlock
     {
         float Range {get;}
         bool BroadcastUsingAntennas {get;}
+
+        /// <summary>
+        ///Returns your own List filled with visible ore markers.
+        /// </summary>        
+        void GetOreMarkers (List <MyOreMarker> outputList);        
+    }
+
+    public struct MyOreMarker
+    {
+        public readonly string ElementName;
+        public readonly Vector3D Location;
+
+        public MyOreMarker (string inputElement, Vector3D inputCoords)
+        {
+            this.ElementName = inputElement;
+            this.Location = inputCoords;
+        }
     }
 }

Sources/Sandbox.Game/Game/Entities/Blocks/MyOreDetector.cs

@@ -1,5 +1,7 @@
 #region Using
 
+using System.Collections.Generic;
+
 using Sandbox.Common.ObjectBuilders;
 using Sandbox.Definitions;
 using Sandbox.Game.Gui;
@@ -24,8 +26,9 @@ namespace Sandbox.Game.Entities.Cube
     public class MyOreDetector : MyFunctionalBlock, IMyComponentOwner<MyOreDetectorComponent>, IMyOreDetector
     {
         private MyOreDetectorDefinition m_definition;
+        private Dictionary <string, Vector3D> m_closestEachElement = new Dictionary <string, Vector3D>(); //I use the same collection to reduce heap allocations.
 
-        MyOreDetectorComponent m_oreDetectorComponent = new MyOreDetectorComponent();
+        private MyOreDetectorComponent m_oreDetectorComponent = new MyOreDetectorComponent();        
 
         Sync<bool> m_broadcastUsingAntennas;
 
@@ -154,8 +157,9 @@ public override void UpdateBeforeSimulation100()
             base.UpdateBeforeSimulation100();
             if (HasLocalPlayerAccess())
             {
-                m_oreDetectorComponent.Update(PositionComp.GetPosition());
+                m_oreDetectorComponent.Update (PositionComp.GetPosition(), false);
             }
+
             else
             {
                 m_oreDetectorComponent.Clear();
@@ -203,5 +207,54 @@ public bool BroadcastUsingAntennas
 
         bool ModAPI.Ingame.IMyOreDetector.BroadcastUsingAntennas { get { return m_oreDetectorComponent.BroadcastUsingAntennas; } }
         float ModAPI.Ingame.IMyOreDetector.Range { get { return Range; } }
+
+        public void GetOreMarkers (List <ModAPI.Ingame.MyOreMarker> usersList) //Imprinting on the reference parameter is cheaper than a return List<T> due to heap allocations. 
+        {        
+            if (base.IDModule != null)
+            {   
+                if (base.IDModule.Owner != (long) MyRelationsBetweenPlayerAndBlock.NoOwnership)
+                {                                                    
+                    usersList.Clear();
+                    Vector3D blockCoordinates = new Vector3D (base.PositionComp.GetPosition());
+                    m_oreDetectorComponent.Update (blockCoordinates, true);
+
+                    foreach (MyEntityOreDeposit deposit in m_oreDetectorComponent.DetectedDeposits)
+                    {
+                        for (int i = 0; i < deposit.Materials.Count; i++)
+                        {                                                 
+                            MyEntityOreDeposit.Data depositData = deposit.Materials[i];
+                            Vector3D cachesPosition = new Vector3D();
+                            depositData.ComputeWorldPosition (deposit.VoxelMap, out cachesPosition);                    
+                            string cachesElement = deposit.Materials[i].Material.MinedOre;
+
+                            if (m_closestEachElement.ContainsKey (cachesElement) == false)
+                            {
+                                m_closestEachElement.Add (cachesElement, cachesPosition); //I decided Dictionary was the best way to group nearest markers since all I need is two variables.                            
+                            }
+
+                            else
+                            {      
+                                Vector3D difference = blockCoordinates - cachesPosition;                        
+                                Vector3D previousDifference = m_closestEachElement[cachesElement] - cachesPosition; 
+                                float distanceToCache = (float) difference.LengthSquared(); //explicitly converted in order to estimate the actual hud markers as close as possible.                   
+                                float previousDistance = (float) previousDifference.LengthSquared();
+
+                                if (distanceToCache < previousDistance)    
+                                {                                                                             
+                                    m_closestEachElement[cachesElement] = cachesPosition; //I only want the nearest of each element. 
+                                }                                                       
+                            }
+                        }
+                    }
+
+                    foreach (KeyValuePair <string, Vector3D> marker in m_closestEachElement)
+                    {
+                        usersList.Add (new ModAPI.Ingame.MyOreMarker (marker.Key,                                  
+                                                                      marker.Value));
+                    }
+                    m_closestEachElement.Clear();
+                }
+            }
+        }       
     }
 }

Sources/Sandbox.Game/Game/Entities/Blocks/MyOreDetectorComponent.cs

@@ -180,6 +180,8 @@ class MyOreDetectorComponent
         private static readonly List<MyVoxelBase> m_inRangeCache = new List<MyVoxelBase>();
         private static readonly List<MyVoxelBase> m_notInRangeCache = new List<MyVoxelBase>();
 
+        public HashSet <MyEntityOreDeposit> DetectedDeposits { get; private set; }
+
         public delegate bool CheckControlDelegate();
 
         public float DetectionRadius { get; set; }
@@ -194,43 +196,50 @@ public MyOreDetectorComponent()
             DetectionRadius = 50;
             SetRelayedRequest = false;
             BroadcastUsingAntennas = false;
+            DetectedDeposits = new HashSet <MyEntityOreDeposit>();
         }
 
         public bool SetRelayedRequest { get; set; }
 
-        public void Update(Vector3D position, bool checkControl = true)
-        {
-            Clear();
-
-            if (!SetRelayedRequest && checkControl && !OnCheckControl())
+        public void Update (Vector3D position, bool onlyUpdateMember, bool checkControl = true)
+        {           
+            if (onlyUpdateMember == false) 
             {
-                m_depositGroupsByEntity.Clear();
-                return;
-            }
+                Clear(); //It should only clear hud markers if it's prepared to renew them.
 
-            SetRelayedRequest = false;
-
-            var sphere = new BoundingSphereD(position, DetectionRadius);
-            MyGamePruningStructure.GetAllVoxelMapsInSphere(ref sphere, m_inRangeCache);
+                if (!SetRelayedRequest && checkControl && !OnCheckControl())
+                {
+                    //m_depositGroupsByEntity.Clear(); I commented this out because it, in some states, causes DetectedDeposits to ouput as empty. m_depositGroupsByEntity seems to take more than one method one to fully update.
+                    return;
+                }
+                SetRelayedRequest = false;
+            }     
+
+            else
+            {
+                DetectedDeposits.Clear();
+            } 
+            var sphere = new BoundingSphereD (position, DetectionRadius);
+            MyGamePruningStructure.GetAllVoxelMapsInSphere (ref sphere, m_inRangeCache);
 
             { // Find voxel maps which went out of range and then remove them.
                 foreach (var voxelMap in m_depositGroupsByEntity.Keys)
                 {
-                    if (!m_inRangeCache.Contains(voxelMap))
-                        m_notInRangeCache.Add(voxelMap);
+                    if (!m_inRangeCache.Contains (voxelMap))
+                        m_notInRangeCache.Add (voxelMap);
                 }
                 foreach (var notInRange in m_notInRangeCache)
                 {
-                    m_depositGroupsByEntity.Remove(notInRange);
+                    m_depositGroupsByEntity.Remove (notInRange);
                 }
                 m_notInRangeCache.Clear();
             }
 
             { // Add voxel maps which came into range.
                 foreach (var voxelMap in m_inRangeCache)
                 {
-                    if (!m_depositGroupsByEntity.ContainsKey(voxelMap))
-                        m_depositGroupsByEntity.Add(voxelMap, new MyOreDepositGroup(voxelMap));
+                    if (!m_depositGroupsByEntity.ContainsKey (voxelMap))
+                        m_depositGroupsByEntity.Add (voxelMap, new MyOreDepositGroup(voxelMap));
                 }
                 m_inRangeCache.Clear();
             }
@@ -240,18 +249,26 @@ public void Update(Vector3D position, bool checkControl = true)
             {
                 var voxelMap = entry.Key;
                 var group = entry.Value;
-                group.UpdateDeposits(ref sphere);
+                group.UpdateDeposits (ref sphere);
 
                 foreach (var deposit in group.Deposits)
                 {
                     if (deposit != null)
-                    {
-                        MyHud.OreMarkers.RegisterMarker(deposit);
+                    {                              
+                        switch (onlyUpdateMember) //the method has been divided into these two choices because previously, oremarkers could not be fetched without a radio antenna.
+                        {
+                            case true:                                
+                                DetectedDeposits.Add (deposit);
+                                break;
+
+                            case false:      
+                                MyHud.OreMarkers.RegisterMarker (deposit);                    
+                                break;
+                        }                      
                     }
                 }
-            }
-
-            m_inRangeCache.Clear();
+            }             
+            m_inRangeCache.Clear();            
         }
 
         public void Clear()
@@ -261,11 +278,13 @@ public void Clear()
                 foreach (var deposit in group.Deposits)
                 {
                     if (deposit != null)
-                        MyHud.OreMarkers.UnregisterMarker(deposit);
+                    {
+                        MyHud.OreMarkers.UnregisterMarker (deposit);
+                    }                        
                 }
-            }
+            }          
+            DetectedDeposits.Clear();
         }
-
     }
 
     /// <summary>

Sources/Sandbox.Game/Game/Entities/Blocks/MyRadioAntenna.cs

@@ -350,7 +350,7 @@ public override List<MyHudEntityParams> GetHudParams(bool allowBlink)
                                 MyOreDetectorComponent oreDetector;
                                 if (oreDetectorOwner.GetComponent(out oreDetector) && oreDetector.BroadcastUsingAntennas)
                                 {
-                                    oreDetector.Update(terminalBlock.PositionComp.GetPosition(), false);
+                                    oreDetector.Update(terminalBlock.PositionComp.GetPosition(), false, false);
                                     oreDetector.SetRelayedRequest = true;
                                 }
                             }

Sources/Sandbox.Game/Game/Weapons/Guns/MyHandDrill.cs

@@ -391,7 +391,7 @@ public override void UpdateBeforeSimulation100()
         {
             base.UpdateBeforeSimulation100();
             m_drillBase.UpdateSoundEmitter();
-            m_oreDetectorBase.Update(PositionComp.GetPosition());
+            m_oreDetectorBase.Update (PositionComp.GetPosition(), false);
         }
 
         public void UpdateSoundEmitter()