net.dreditor.ui 0.0.0-stage → 0.1.6

package/ITrackableIndex.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2d2b37fe7f456b24a800f12126b2a7b1

package/IUnlockableUIOption.cs

@@ -0,0 +1,16 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+
+namespace DREditor.UI
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public interface IUnlockableUIOption
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        bool IsUnlocked();
+    }
+}

package/IUnlockableUIOption.cs.meta

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

package/IndexSelector.cs

@@ -0,0 +1,188 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using System;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Serialization;
+
+namespace DREditor.UI
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class IndexSelector : ControlledComponent, ITrackableIndex
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected int previousIndex = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] private int selectedIndex = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [ReadOnly]
+        [Tooltip("")]
+        [SerializeField] private int selectionMaximum = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [ReadOnly]
+        [Tooltip("")]
+        [SerializeField] protected int selectionRate = 1;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [ReadOnly]
+        [Tooltip("")]
+        [SerializeField] private int inputDirection = 0;
+
+
+        [Header("")]
+        [FormerlySerializedAs("OnForwardChapter")]
+        public UnityEvent OnForward;
+
+        [Header("")]
+        [FormerlySerializedAs("OnBackwardChapter")]
+        public UnityEvent OnBackward;
+
+        [Header("")]
+        public UnityEvent<int> OnNavigated;
+
+        [Header("")]
+        public UnityEvent OnReset;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        private int UpdatedIndex => SelectedIndex + InputDirection;
+
+        /// <summary>
+        ///
+        /// </summary>
+        private Action<int, int> movedIndexFrom;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual int InputDirection { get => inputDirection; private set => inputDirection = value; }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual int SelectedIndex { get => selectedIndex; protected set => selectedIndex = value; }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual int SelectionMaximum { get => selectionMaximum; set => selectionMaximum = value; }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public Action<int, int> MovedIndexFrom { get => movedIndexFrom; set => movedIndexFrom = value; }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="InputDirection"></param>
+        protected virtual void Move(int InputDirection)
+        {
+            InitializeInputtedDirection(InputDirection);
+
+            ApplyMovement();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="InputDirection"></param>
+        protected virtual void InitializeInputtedDirection(int InputDirection) => this.InputDirection = InputDirection;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ApplyMovement()
+        {
+            if (OutOfRange())
+                return;
+
+            UpdateSelectedIndexes();
+
+            InvokeMovedIndexFrom();
+
+            InvokeDirection();
+
+            InvokeNavigated();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool OutOfRange() =>
+            UpdatedIndex == SelectedIndex ||
+            UpdatedIndex > SelectionMaximum ||
+            UpdatedIndex < 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void UpdateSelectedIndexes()
+        {
+            previousIndex = selectedIndex;
+
+            selectedIndex += InputDirection;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InvokeMovedIndexFrom() => MovedIndexFrom?.Invoke(previousIndex, selectedIndex);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InvokeDirection() => (InputDirection == selectionRate ? OnForward : OnBackward)?.Invoke();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks></remarks>
+        public virtual void ResetIndexSelector()
+        {
+            ResetSelectedIndex();
+
+            InvokeNavigated();
+
+            InvokeReset();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ResetSelectedIndex() => SelectedIndex = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InvokeNavigated() => OnNavigated?.Invoke(SelectedIndex);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InvokeReset() => OnReset?.Invoke();
+    }
+}

package/IndexSelector.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 657b5640709847f4e8169004da7b7816

package/LayeredFocusCarousel.cs

@@ -0,0 +1,36 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using UnityEngine;
+
+namespace DREditor.UI
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class LayeredFocusCarousel : CarouselSelectTweening
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Space]
+        [Tooltip("")]
+        [SerializeField] protected RectTransform carouselParent;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected RectTransform focusedParent;
+
+
+        /// <inheritdoc/>
+        protected override bool IsComponentFocused(CarouselComponent component)
+        {
+            bool result = base.IsComponentFocused(component);
+
+            component.transform.SetParent(result ? focusedParent : carouselParent);
+
+            return result;
+        }
+    }
+}

package/LayeredFocusCarousel.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1bc128f8a1b82ae45aefa9dc8300999a

package/MenuGroup.cs

@@ -0,0 +1,295 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Audio;
+using DREditor.Services;
+using DREditor.UIHandling;
+using System.Collections;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace DREditor.UI
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <remarks></remarks>
+    [ClassHeader(nameof(SelectableMenuGroupBase) + 
+        "\n\n")]
+    public class MenuGroup : SelectableMenuGroupBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected bool skipSelection = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool keepLastSelectedOnReset = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool keepCanvas = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool leaveCanvasOnlyOnBack = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool popUpBackInput = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool skipBackInput = false;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected Animator animator = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected Coroutine showCoroutine;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected override void Start()
+        {
+            InitializeSelectables();
+
+            base.Start();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeSelectables()
+        {
+            if (selectables.Count == 0)
+            {
+                var childSelectables = GetComponentsInChildren<Selectable>().ToList();
+
+                foreach(var child in childSelectables)
+                    selectables.Add(child);
+            }
+
+            if (selectables.Count != 0)
+                TurnOffSelectables();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void TurnOffSelectables()
+        {
+            if (!isActive)
+                EnableSelectables(false);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="isEnabled"></param>
+        public virtual void EnableSelectables(bool isEnabled)
+        {
+            foreach (Selectable selectable in selectables)
+                selectable.enabled = isEnabled;
+        }
+
+
+        /// <inheritdoc/>
+        public override void ChangeGroup(MenuGroupBase group)
+        {
+            if (Changing)
+            {
+                UnityEngine.Debug.LogWarning("ALERT: Menu's are still changing!");
+
+                return;
+            }
+
+            ServiceLocator.GetService<MenuState>().SetChanging(true);
+
+            UnityEngine.Debug.Log($"REPORT: Group: {gameObject.name} is changing to Group: " + group.gameObject.name);
+
+            StartCoroutine(Change(group));
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="group"></param>
+        protected virtual IEnumerator Change(MenuGroupBase group)
+        {
+            LastSelected = EventSystem.current.currentSelectedGameObject;
+
+            yield return null;
+
+            EventSystem.current.SetSelectedGameObject(null);
+
+            HideProcess(group);
+
+            if (leaveCanvasOnlyOnBack && group == backGroup)
+                yield return OnMovingToBackGroup();
+
+            group.Show();
+
+            if (group != backGroup)
+                ServiceLocator.GetService<SFXManagerBase>().PlaySubmit();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator OnMovingToBackGroup()
+        {
+            HideCanvas();
+
+            yield break;
+        }
+
+
+        /// <inheritdoc/>
+        public override void Show()
+        {
+            UnityEngine.Debug.Log("REPORT: Attempting to Reveal Group: " + gameObject.name);
+
+            if (isActive)
+            {
+                UnityEngine.Debug.Log($"REPORT: {gameObject.name} was already Active");
+
+                ServiceLocator.GetService<MenuState>().SetChanging(false);
+
+                return;
+            }
+
+            EnableSelectables(true);
+
+            BeforeStart?.Invoke();
+
+            showCoroutine = StartCoroutine(ShowProcess());
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator ShowProcess()
+        {
+            UnityEngine.Debug.Log("REPORT: Starting Evaluate Selection for Group: " + gameObject.name);
+
+            if (!skipSelection)
+                yield return SetEvaluateSelection();
+
+            yield return null;
+
+            yield return null;
+
+            UnityEngine.Debug.Log("REPORT: Evaluate Selection ended for Group: " + gameObject.name);
+
+            if (!skipBackInput)
+                AddBackInput();
+
+            StartEvents?.Invoke();
+
+            SetActive(true);
+
+            ServiceLocator.GetService<MenuState>().SetChanging(false);
+        }
+
+
+        /// <inheritdoc/>
+        public override void Hide() => HideProcess();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="shownGroup"></param>
+        protected virtual void HideProcess(MenuGroupBase shownGroup = null)
+        {
+            RemoveBackInput();
+
+            EnableSelectables(false);
+
+            EndEvents?.Invoke();
+
+            if (!ServiceLocator.GetService<UIHandlerBase>().MovingToTitleScreen && popUpBackInput && backGroup != null)
+            {
+                backGroup.AddBackInput();
+
+                backGroup.SetEvaluateSelect();
+            }
+
+            if (HideCanvasEvaluation())
+                HideCanvas();
+
+            OnHideComplete();
+
+            UnityEngine.Debug.Log($"REPORT: {gameObject.name}'s Hide process finished and should now not be active.");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void HideCanvas()
+        {
+            if (GetComponent<CanvasUIVisibility>() is CanvasUIVisibility canvas)
+                canvas.Hide();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnHideComplete() => StopBeingActive();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool HideCanvasEvaluation() => !keepCanvas && !leaveCanvasOnlyOnBack;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void StopBeingActive()
+        {
+            if (showCoroutine != null)
+                StopCoroutine(showCoroutine);
+
+            SetActive(false);
+        }
+
+
+        /// <inheritdoc/>
+        protected override void ResetGroup()
+        {
+            if (!keepLastSelectedOnReset)
+                LastSelected = null;
+
+            if (isActive)
+                HideProcess();
+
+            RemoveBackInput();
+        }
+    }
+}

package/MenuGroup.cs.meta

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