Merge pull request #2 from OpenSourceUnityPackage/feature/clean

Feature/clean

Author: Renardjojo

Runtime/AContextualMenu.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+
+namespace ContextualMenuPackage
+{
+    /// <summary>
+    /// ContextualMenu is a class that allow you to manage task depending on action available by the generic type.
+    /// If you combine it with your own UI system and selection, you can process Contextual menu like an RTS.
+    /// Architecture of this class is made to be independent as possible and online friendly.
+    /// </summary>
+    /// <typeparam name="T">
+    /// Contextualizable that represent object that you will be stored on ContextualMenu and process tasks.
+    /// This object need to inheritance of interface IContextualizable
+    /// </typeparam>
+    public abstract class AContextualMenu<T> where T : IContextualizable
+    {
+        protected List<T> m_contextualizable; // ref
+        protected readonly Dictionary<string, ITask<T>> m_tasks = new Dictionary<string, ITask<T>>();
+
+        /// <summary>
+        /// Use this function to add task associate to its ID.
+        /// When the ID is invoked, this task is called
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="task"></param>
+        public virtual void AddTask(string id, ITask<T> task)
+        {
+            m_tasks.Add(id, task);
+        }
+
+        /// <summary>
+        /// Allow to invoke task thanks to it's ID.
+        /// Task will receive contextualizable that also own this ID.
+        /// </summary>
+        /// <param name="taskId"></param>
+        public abstract void InvokeTask(string taskId);
+
+        /// <summary>
+        /// Call this function to get list of task's IDs callable based on contextualizables task.
+        /// </summary>
+        /// <returns></returns>
+        public abstract string[] GetTasks();
+
+        /// <summary>
+        /// Set contextualizables to managed contextual menu.
+        /// </summary>
+        /// <param name="contextualizables">null to clear</param>
+        public virtual void SetContextualizable(in List<T> contextualizables)
+        {
+            m_contextualizable = contextualizables;
+        }
+    }
+}

Runtime/ContextualMenu.cs.meta Runtime/AContextualMenu.cs.metaRuntime/ContextualMenu.cs.meta renamed to Runtime/AContextualMenu.cs.meta

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+
+namespace ContextualMenuPackage
+{
+    /// <summary>
+    /// GlobalContextualMenu handles all task of contextualizable even if they are not shared by all.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public sealed class GlobalContextualMenu<T> : AContextualMenu<T> where T : IContextualizable
+    {
+        private readonly Dictionary<string, List<T>> m_taskOwned = new Dictionary<string, List<T>>();
+
+        public override void InvokeTask(string taskId)
+        {
+            if (m_tasks.ContainsKey(taskId) && m_taskOwned.ContainsKey(taskId))
+            {
+                m_tasks[taskId].OnInvoked(m_taskOwned[taskId]);
+            }
+        }
+
+        public override string[] GetTasks()
+        {
+            string[] str = new string[m_taskOwned.Count];
+            m_taskOwned.Keys.CopyTo(str, 0);
+            return str;
+        }
+
+        public override void SetContextualizable(in List<T> contextualizables)
+        {
+            base.SetContextualizable(contextualizables);
+            SortTasks();
+        }
+        
+        private void SortTasks()
+        {
+            m_taskOwned.Clear();
+
+            if (m_contextualizable == null)
+                return;
+            foreach (T observedSelectable in m_contextualizable)
+            {
+                List<string> tasks = observedSelectable.GetTasks();
+                foreach (string task in tasks)
+                {
+                    if (!m_taskOwned.ContainsKey(task))
+                        m_taskOwned.Add(task, new List<T>());
+
+                    m_taskOwned[task].Add(observedSelectable);
+                }
+            }
+        }
+    }
+}

Runtime/ContextualMenu.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+
+namespace ContextualMenuPackage
+{
+    /// <summary>
+    /// SharedContextualMenu only handles the shared task of contextualizables
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class SharedContextualMenu<T> : AContextualMenu<T> where T : IContextualizable
+    {
+        private readonly List<string> m_sharedTask = new List<string>();
+        
+        public override void InvokeTask(string taskId)
+        {
+            if (m_tasks.ContainsKey(taskId) && m_sharedTask.Contains(taskId))
+            {
+                m_tasks[taskId].OnInvoked(m_contextualizable);
+            }
+        }
+
+        public override string[] GetTasks()
+        {
+            return m_sharedTask.ToArray();
+        }
+
+        public override void SetContextualizable(in List<T> contextualizables)
+        {
+            base.SetContextualizable(contextualizables);
+            SortGlobalTasks();
+        }
+
+        void SortGlobalTasks()
+        {
+            m_sharedTask.Clear();
+            if (m_contextualizable == null || m_contextualizable.Count == 0)
+                return;
+            
+            foreach (KeyValuePair<string, ITask<T>> task in m_tasks)
+            {
+                m_sharedTask.Add(task.Key);
+            }
+
+            foreach (T observedSelectable in m_contextualizable)
+            {
+                List<string> tasks = observedSelectable.GetTasks();
+                for (int index = 0; index < m_sharedTask.Count;)
+                {
+                    string sharedTask = m_sharedTask[index];
+
+                    if (!tasks.Contains(sharedTask))
+                        m_sharedTask.RemoveAt(index);
+                    else
+                        ++index;
+                }
+            }
+            
+        }
+    }
+}

Runtime/GlobalContextualMenu.cs

@@ -15,25 +15,22 @@ public enum ETeam : int
 
 public class GameManager : MonoBehaviour
 {
+    private SharedContextualMenu<Unit> m_contextualMenu = new SharedContextualMenu<Unit>();
+    
+    // Uncomment to test GlobalContextMenu
+    //private GlobalContextualMenu<Unit> m_contextualMenu = new GlobalContextualMenu<Unit>();
+    private List<Unit>[] m_teamsUnits = new List<Unit>[(int) ETeam.TeamCount];
+    
     public Camera mainCamera;
     private UnitSelection<Unit> m_unitSelection = new UnitSelection<Unit>();
-    private ContextualMenu<Unit> m_contextualMenu = new ContextualMenu<Unit>();
-    private List<Unit>[] m_teamsUnits = new List<Unit>[(int) ETeam.TeamCount];
     private bool m_isSelecting;
     private EventSystem m_eventSystem;
-
-    [System.Serializable]
-    public struct TaskUIElement
-    {
-        public string task;
-        public Button button;
-    }
-
+    private int m_layerGround;
+    
     public Toggle btnMove;
     public Button btnStop;
 
     public Action<Vector3> RequestPosition { get; set; }
-    public int m_layerGround;
 
     #region Singleton