net.dreditor.ui 0.0.0-stage → 0.1.6

package/Options/OptionToggleUI.cs

@@ -0,0 +1,253 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.EventObjectServices;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace DREditor.UI.Options
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(OptionWithEventListener<bool, BoolEvent>) +
+        "\n\n")]
+    [DefaultExecutionOrder(1)]
+    public class OptionToggleUI : OptionWithEventListener<bool, BoolEvent>
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected Selectable onSelectable = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected Selectable offSelectable = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected OptionUIGroup optionGroup = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected SelectableUIOption toggleOption;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected SelectableUIOption offOption;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected bool isOn;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Awake()
+        {
+            toggleOption = onSelectable.GetComponent<SelectableUIOption>();
+
+            optionGroup = GetComponent<OptionUIGroup>();
+
+            offOption = offSelectable.GetComponent<SelectableUIOption>();
+
+            offSelectable.interactable = false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            UpdateUIState(valueWithEvent.Value);
+
+            if (valueWithEvent != null && !valueWithEvent.Value)
+            {
+                SetToggleTo(valueWithEvent.Value);
+
+                offOption.Selection.Invoke();
+
+                optionGroup.OnSetup.AddListener(FocusOff);
+            }
+
+            optionGroup.OnBeforeSetup.AddListener(BeforeSetUp);
+
+            optionGroup.OnSetup.AddListener(FocusOff);
+
+            optionGroup.OnUnSetup.AddListener(UnSetUp);
+
+            OnValueChangedEvent.AddListener(UpdateUIState);
+
+            toggleOption.Selection.AddListener(ToggleTrue);
+
+            offOption.Selection.AddListener(ToggleFalse);
+
+            InitializeOffPiece();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks>
+        ///
+        /// </remarks>
+        protected virtual void BeforeSetUp() => offSelectable.interactable = true;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void UnSetUp() => offSelectable.interactable = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void FocusOff()
+        {
+            if (valueWithEvent != null && !valueWithEvent.Value)
+                optionGroup.RewireNavigation(offSelectable);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeOffPiece()
+        {
+            var navigation = onSelectable.navigation;
+
+            var offNav = offSelectable.navigation;
+
+            UpdateOffDirection(offNav.selectOnDown, navigation.selectOnDown, Direction.Down);
+
+            UpdateOffDirection(offNav.selectOnUp, navigation.selectOnUp, Direction.Up);
+
+            UpdateOffDirection(offNav.selectOnLeft, navigation.selectOnLeft, Direction.Left);
+
+            UpdateOffDirection(offNav.selectOnRight, navigation.selectOnRight, Direction.Right);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="current"></param>
+        /// <param name="direction"></param>
+        protected virtual void UpdateOffDirection(Selectable target, Selectable current, Direction direction)
+        {
+            if (current != offSelectable && target != onSelectable && target != current)
+                optionGroup.options.ChangeGroupNav(current, direction);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected override void OnDisable()
+        {
+            base.OnDisable();
+
+            OnValueChangedEvent.RemoveListener(UpdateUIState);
+
+            toggleOption.Selection.RemoveListener(ToggleTrue);
+
+            offOption.Selection.RemoveListener(ToggleFalse);
+
+            optionGroup.OnSetup.RemoveListener(FocusOff);
+
+            optionGroup.OnBeforeSetup.RemoveListener(BeforeSetUp);
+
+            optionGroup.OnSetup.RemoveListener(FocusOff);
+
+            optionGroup.OnUnSetup.RemoveListener(UnSetUp);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="param"></param>
+        protected virtual void UpdateUIState(bool param)
+        {
+            if (param)
+                UpdateToggleState(onSelectable, offSelectable);
+            else
+                UpdateToggleState(offSelectable, onSelectable);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectable"></param>
+        /// <param name="opposite"></param>
+        protected virtual void UpdateToggleState(Selectable selectable, Selectable opposite)
+        {
+            if (ValidObjectNotSelected(selectable))
+            {
+                if (selectable.TryGetComponent<SelectableUIOption>(out var toggleOption))
+                    toggleOption.InvokeSelect();
+
+                var oppositeSelections = opposite.GetComponents<SelectHandler>();
+
+                foreach (var selection in oppositeSelections)
+                    if (selection != null)
+                        selection.Deselect();
+
+                optionGroup.RewireNavigation(selectable);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectable"></param>
+        /// <returns></returns>
+        protected virtual bool ValidObjectNotSelected(Selectable selectable)
+            => selectable != null &&
+            EventSystem.current != null &&
+            EventSystem.current.currentSelectedGameObject != selectable.gameObject;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ToggleTrue() => SetToggleTo(true);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ToggleFalse() => SetToggleTo(false);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="to"></param>
+        /// <remarks>
+        ///
+        /// </remarks>
+        public virtual void SetToggleTo(bool to)
+        {
+            toggleOption.Selection.RemoveListener(ToggleTrue);
+
+            offOption.Selection.RemoveListener(ToggleFalse);
+
+            isOn = to;
+
+            if (valueWithEvent != null)
+                valueWithEvent.SetValue(isOn);
+
+            OnValueChangedEvent?.Invoke(isOn);
+
+            toggleOption.Selection.AddListener(ToggleTrue);
+
+            offOption.Selection.AddListener(ToggleFalse);
+        }
+    }
+}

package/Options/OptionToggleUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 44a49967ffc30314f88b3266d3b637d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Options/OptionUIGroup.cs

@@ -0,0 +1,303 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Services;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.EventSystems;
+using UnityEngine.Serialization;
+using UnityEngine.UI;
+
+namespace DREditor.UI.Options
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(OptionUIGroupBase) +
+        "\n\n")]
+    public class OptionUIGroup : OptionUIGroupBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Divider]
+        [Tooltip("")]
+        [FormerlySerializedAs("navGroups")]
+        [SerializeField] protected List<NavigationGroup> navigationGroups = new() { new NavigationGroup() };
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Divider]
+        [Tooltip("")]
+        [FormerlySerializedAs("navSelects")]
+        [SerializeField] protected List<NavigationSelect> navigationSelects = new() { new NavigationSelect() };
+
+
+        [Header("")]
+        [Divider]
+        [Header("")]
+        public UnityEvent OnBeforeSetup;
+
+        [Header("")]
+        public UnityEvent OnSetup;
+
+        [Header("")]
+        public UnityEvent OnUnSetup;
+
+
+        [Header("")]
+        [Divider]
+        [Header("")]
+        public UnityEvent Selection;
+
+        [Header("")]
+        public UnityEvent Deselection;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected Selectable lastOption = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected bool isSetup = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected bool selected = false;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void BeforeSetupGroup() => OnBeforeSetup?.Invoke();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void SetupGroup()
+        {
+            ServiceLocator.GetService<UIHandlerBase>().OnChange.AddListener(Evaluate);
+
+            SelectLastOptionOnEmpty();
+
+            isSetup = true;
+
+            if (navigationGroups.Count == 0 && navigationSelects.Count == 0)
+            {
+                ClearNavigation();
+
+                InitializeNavigation();
+            }
+            else if (lastOption != null)
+                RewireNavigation(lastOption);
+            else
+                RewireNavigation(options[0]);
+
+            OnSetup?.Invoke();
+
+            Evaluate();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeNavigation()
+        {
+            var firstOption = options[0];
+
+            List<Selectable> firstSelectables = new()
+            {
+                firstOption.navigation.selectOnDown,
+                firstOption.navigation.selectOnUp,
+                firstOption.navigation.selectOnRight,
+                firstOption.navigation.selectOnLeft,
+            };
+
+            for (int i = 0; i < firstSelectables.Count; i++)
+            {
+                if (options.Contains(firstSelectables[i]) || firstSelectables[i] == null)
+                    continue;
+
+                if (firstSelectables[i].GetComponentInParent<OptionUIGroupBase>() is OptionUIGroupBase group)
+                    navigationGroups.Add(new NavigationGroup(group, (Direction)i));
+                else
+                    navigationSelects.Add(new NavigationSelect(firstSelectables[i], (Direction)i));
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void UnSetupGroup()
+        {
+            ServiceLocator.GetService<UIHandlerBase>().OnChange.RemoveListener(Evaluate);
+
+            DisplayLastOptionSelected();
+
+            isSetup = false;
+
+            foreach (var deselect in deselectHandlers)
+                deselect.OnDeselect(null);
+
+            if (navigationGroups.Count == 0 && navigationSelects.Count == 0)
+                ClearNavigation();
+
+            OnUnSetup?.Invoke();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ClearNavigation()
+        {
+            navigationGroups.Clear();
+
+            navigationSelects.Clear();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void Evaluate() => CheckSelectionInGroup();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool CheckSelectionInGroup()
+        {
+            if (EventSystem.current.currentSelectedGameObject == null)
+                UnityEngine.Debug.LogWarning($"ALERT: {gameObject.name}: The Current Selected object was null");
+
+            foreach (Selectable selectable in options)
+                if (SelectedInGroup(selectable))
+                    return true;
+
+            NotInSelection();
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectable"></param>
+        /// <returns></returns>
+        protected virtual bool SelectedInGroup(Selectable selectable)
+        {
+            if (EventSystem.current.currentSelectedGameObject == selectable.gameObject)
+            {
+                SetGroupSelectedTo(true);
+
+                RewireNavigation(selectable);
+
+                foreach (var select in selectHandlers)
+                    select.OnSelect(null);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void NotInSelection()
+        {
+            SetGroupSelectedTo(false);
+
+            DisplayLastOptionSelected();
+
+            foreach (var deselect in deselectHandlers)
+                deselect.OnDeselect(null);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="isSelected"></param>
+        protected virtual void SetGroupSelectedTo(bool isSelected)
+        {
+            if (selected == !isSelected)
+            {
+                selected = isSelected;
+
+                UnityEvent selectionEvent = selected ? Selection : Deselection;
+
+                selectionEvent?.Invoke();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectable"></param>
+        public virtual void RewireNavigation(Selectable selectable)
+        {
+            lastOption = selectable;
+
+            RewireNavigationGroups();
+
+            RewireNavigationSelects();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void RewireNavigationGroups()
+        {
+            if (navigationGroups.Count != 0)
+                foreach (NavigationGroup nav in navigationGroups)
+                    nav.group.options.ChangeGroupNav(lastOption, nav.direction);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void RewireNavigationSelects()
+        {
+            if (navigationSelects.Count != 0)
+                foreach (NavigationSelect nav in navigationSelects)
+                    nav.selectable.ChangeNavSelects(lastOption, nav.direction);
+        }
+        
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void SelectLastOptionOnEmpty()
+        {
+            if (lastOption == null)
+            {
+                SetLastOption(options[0]);
+
+                DisplayLastOptionSelected();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DisplayLastOptionSelected()
+        {
+            if (lastOption == null)
+                return;
+
+            var lastSelectables = lastOption.GetComponents<SelectHandler>();
+
+            foreach (var selectable in lastSelectables)
+                if (selectable != null)
+                    selectable.Select();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectable"></param>
+        protected virtual void SetLastOption(Selectable selectable) => lastOption = selectable;
+    }
+}

package/Options/OptionUIGroup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: af90183f8bb2fb74d9d34dbd69d2d70d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Options/OptionUIGroupBase.cs

@@ -0,0 +1,41 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace DREditor.UI.Options
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class OptionUIGroupBase : MonoBehaviour
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        public List<Selectable> options = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ISelectHandler[] selectHandlers;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected IDeselectHandler[] deselectHandlers;
+
+
+        protected virtual void Awake()
+        {
+            selectHandlers = GetComponents<ISelectHandler>();
+
+            deselectHandlers = GetComponents<IDeselectHandler>();
+        }
+    }
+}

package/Options/OptionUIGroupBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6d7891aa7f2dfb24a91f0d9c92cdd9d0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Options/OptionUIManager.cs

@@ -0,0 +1,69 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DREditor.UI.Options
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(MenuModifier) +
+        "\n\n")]
+    public class OptionUIManager : MenuModifier
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        protected List<OptionUIGroup> groups = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected override void Awake()
+        {
+            base.Awake();
+
+            groups = GetComponentsInChildren<OptionUIGroup>().ToList();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnEnable()
+        {
+            menu.BeforeStart.AddListener(BeforeSetUpGroups);
+
+            menu.StartEvents.AddListener(SetUpGroups);
+
+            menu.EndEvents.AddListener(UnSetUpGroups);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnDisable()
+        {
+            menu.BeforeStart.RemoveListener(BeforeSetUpGroups);
+
+            menu.StartEvents.RemoveListener(SetUpGroups);
+
+            menu.EndEvents.RemoveListener(UnSetUpGroups);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void BeforeSetUpGroups() => groups.ForEach(n => n.BeforeSetupGroup());
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void SetUpGroups() => groups.ForEach(n => n.SetupGroup());
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void UnSetUpGroups() => groups.ForEach(n => n.UnSetupGroup());
+    }
+}