net.dreditor.purchasing 0.0.0-stage → 0.1.6

package/BufferedSelectedUICacher.cs

@@ -0,0 +1,74 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class BufferedSelectedUICacher : SelectedUICacher
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Space]
+        [Tooltip("")]
+        [SerializeField] protected float selectBufferDuration = 0.5f;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected bool waitingThroughBuffer = false;
+
+
+        /// <inheritdoc/>
+        public override void CacheObject() => CacheObjectResponse()?.Invoke();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual Action CacheObjectResponse() => waitingThroughBuffer ? ResetBuffer : base.CacheObject;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ResetBuffer()
+        {
+            StopAllCoroutines();
+
+            SetWaitingThroughBuffer(false);
+        }
+
+
+        /// <inheritdoc/>
+        protected override bool ShouldSelectCachedObject() => !waitingThroughBuffer && base.ShouldSelectCachedObject();
+
+        /// <inheritdoc/>
+        protected override void SelectCachedObject() => StartCoroutine(BufferSelection());
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator BufferSelection()
+        {
+            SetWaitingThroughBuffer(true);
+
+            yield return new WaitForSeconds(selectBufferDuration);
+
+            base.SelectCachedObject();
+
+            ResetBuffer();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="waitingThroughBuffer"></param>
+        protected virtual void SetWaitingThroughBuffer(bool waitingThroughBuffer) => this.waitingThroughBuffer = waitingThroughBuffer;
+    }
+}

package/BufferedSelectedUICacher.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7b5aff0506d2dd2499b7fb6beb7f5895

package/DREditor.Purchasing.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "DREditor.Purchasing",
+    "rootNamespace": "",
+    "references": [
+        "Unity.InputSystem",
+        "Unity.TextMeshPro",
+        "DREditor",
+        "DREditor.EventObjectServices"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/DREditor.Purchasing.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a7cde9b5f585acb489343da39e32a0f4
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/DigitArrow.cs

@@ -0,0 +1,144 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+#if DOTWEEN
+using DG.Tweening;
+#endif
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [RequireComponent(typeof(Image))]
+    public class DigitArrow : MonoBehaviour
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Space]
+        [Header("")]
+        [Space]
+        [Tooltip("")]
+        [SerializeField] protected bool debugReset = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected Vector3 resetPosition;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Space]
+        [Tooltip("")]
+        [SerializeField] protected Vector3 direction = Vector3.up;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float duration = 0.2f;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float directionMultiplier = 7;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool ignoreTimeScale = false;
+#if DOTWEEN
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected Ease easeCurve = Ease.Linear;
+#endif
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int loops = 0;
+#if DOTWEEN
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected LoopType loopType = LoopType.Yoyo;
+#endif
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float delay = 0f;
+
+
+        protected virtual void Awake() => Initialize();
+
+        protected virtual void OnValidate() => Initialize();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Initialize() => resetPosition = transform.localPosition;
+
+
+        protected virtual void Start() => StartAnimatingArrow();
+
+        protected virtual void Update()
+        {
+            if (debugReset)
+                StartAnimatingArrow();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void StartAnimatingArrow()
+        {
+            ResetArrow();
+
+            AnimateArrow();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ResetArrow()
+        {
+            debugReset = false;
+#if DOTWEEN
+            transform.DOKill();
+#endif
+            transform.localPosition = resetPosition;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void AnimateArrow()
+        {
+#if DOTWEEN
+            transform.DOLocalMove(GetEndPosition(), duration)
+                .SetUpdate(ignoreTimeScale)
+                .SetEase(easeCurve)
+                .SetLoops(loops, loopType)
+                .SetDelay(delay);
+#endif
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual Vector3 GetEndPosition() => resetPosition + (direction * directionMultiplier);
+    }
+}

package/DigitArrow.cs.meta

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

package/DisplayCurrencyDigits.cs

@@ -0,0 +1,123 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.EventObjectServices;
+using DREditor.Saving.Handlers;
+using DREditor.Utility;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(ControlledComponent) + ", " + nameof(DisplayDigits) + 
+        "\n\n")]
+    public class DisplayCurrencyDigits : DisplayDigits
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected List<IntWithEventListener> digits = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected CurrencyHandler<int> currencyHandler = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent paidAmount = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected IDigitPlace selectedDigit;
+
+
+        /// <inheritdoc/>
+        protected override void Awake()
+        {
+            base.Awake();
+
+            paidAmount.SetValue(Zero);
+        }
+
+
+        /// <inheritdoc/>
+        protected override void InitializeSelectedDigit() =>
+            selectedDigit = digits.GetSelectedObjectOfType<IDigitPlace>();
+
+
+        /// <inheritdoc/>
+        protected override void ProcessInputAmount()
+        {
+            if (DigitsShouldBeUpdated())
+                UpdateDigitsFrom(CalculateDigitAmount());
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool DigitsShouldBeUpdated() => HandlersValid() && !DecreasingOnZero() && !IncreasingWhenDigitsMaxed();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool HandlersValid() => selectedDigit != null && currencyHandler != null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool DecreasingOnZero() => directionalRate <= Zero && paidAmount.Value == Zero;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool IncreasingWhenDigitsMaxed() =>
+            directionalRate == inputDirectionalRate && ForwardDigitsMaxed(selectedDigit);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="starting"></param>
+        /// <returns></returns>
+        protected virtual bool ForwardDigitsMaxed(IDigitPlace starting) =>
+            digits.OfType<IDigitPlace>()
+            .SkipWhile(digit => digit != starting)
+            .All(digit => digit.DisplayingMaxDigit());
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="amount"></param>
+        protected virtual void UpdateDigitsFrom(int amount)
+        {
+            if (currencyHandler.GetCurrency() + amount < Zero || paidAmount.Value + amount < Zero)
+                paidAmount.SetValue(Zero);
+            else if (paidAmount.Value + amount <= currencyHandler.GetCurrency())
+                paidAmount.SetValue(paidAmount.Value + amount);
+            else
+                paidAmount.Invoke();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual int CalculateDigitAmount() => selectedDigit.GetDigitPlace() * directionalRate;
+    }
+}

package/DisplayCurrencyDigits.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 796b32f42dac4bd4c84fa34c2c3a2a38

package/DisplayDigit.cs

@@ -0,0 +1,84 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor;
+using DREditor.EventObjectServices;
+using TMPro;
+using UnityEngine;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(IntWithEventListener) + ", " + nameof(IDigitPlace) + 
+        "\n\n")]
+    public class DisplayDigit : IntWithEventListener, IDigitPlace
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected TMP_Text digitText;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int digitPlace = 1;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Range(0, 9)]
+        [Tooltip("")]
+        [SerializeField] protected int maxDigit = 9;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        private const int DigitModulus = 10;
+
+
+        protected virtual void Awake()
+        {
+            if (DigitPlaceInvalid())
+                UnityEngine.Debug.LogError("ALERT: THE DIGIT PLACE IS NOT VALID! Valid Examples: 1, 10, 100");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool DigitPlaceInvalid() => digitPlace == 0 || (digitPlace > 1 && digitPlace % DigitModulus != 0);
+
+
+        /// <inheritdoc/>
+        protected override void OnValueChanged(int updatedValue)
+        {
+            base.OnValueChanged(updatedValue);
+
+            UpdateDisplayedDigit();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void UpdateDisplayedDigit() => digitText.text = CalculateDigit().ToString();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual int CalculateDigit() => UpdatedValue < digitPlace ? 0 : UpdatedValue / digitPlace % DigitModulus;
+
+
+        /// <inheritdoc/>
+        public virtual int GetDigitPlace() => digitPlace;
+
+        /// <inheritdoc/>
+        public virtual string GetDisplayedDigit() => digitText.text;
+
+        /// <inheritdoc/>
+        public virtual bool DisplayingMaxDigit() => GetDisplayedDigit() == maxDigit.ToString();
+    }
+}

package/DisplayDigit.cs.meta

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

package/DisplayDigits.cs

@@ -0,0 +1,148 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using static UnityEngine.InputSystem.InputAction;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class DisplayDigits : ControlledComponent
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference move = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool useHorizontalInput = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int inputDirectionalRate = 1;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float deadThreshold = 0;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int directionalRate = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected CallbackContext context;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly int Zero = 0;
+
+
+        /// <inheritdoc/>
+        public override void ActivateControls() => move.action.started += UpdateDisplayedCurrency;
+
+        /// <inheritdoc/>
+        public override void DeactivateControls() => move.action.started -= UpdateDisplayedCurrency;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="context"></param>
+        protected virtual void UpdateDisplayedCurrency(CallbackContext context)
+        {
+            InitializeOnInput(context);
+
+            ProcessInputAmount();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void ProcessInputAmount();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="context"></param>
+        protected virtual void InitializeOnInput(CallbackContext context)
+        {
+            InitializeInputContext(context);
+
+            InitializeDirectionalRate();
+
+            InitializeSelectedDigit();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="context"></param>
+        protected virtual void InitializeInputContext(CallbackContext context) => this.context = context;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeDirectionalRate() => directionalRate = inputDirectionalRate * (int)CalculateDirection();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual float CalculateDirection() => DirectionIsValid() ? Mathf.Sign(GetAxis()) : Zero;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool DirectionIsValid() => InputPastDeadZone() && !MovingAlongSelectionAxis();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool InputPastDeadZone() => Mathf.Abs(GetAxis()) > deadThreshold;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool MovingAlongSelectionAxis() => Mathf.Abs(GetOppositeAxis()) > Mathf.Abs(GetAxis());
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual float GetAxis() =>
+            useHorizontalInput ? context.ReadValue<Vector2>().x : context.ReadValue<Vector2>().y;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual float GetOppositeAxis() =>
+            GetAxis() == context.ReadValue<Vector2>().x ? context.ReadValue<Vector2>().y : context.ReadValue<Vector2>().x;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void InitializeSelectedDigit();
+    }
+}

package/DisplayDigits.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9234dde306def9d4a9be10fdc843a49b

package/EnableInputOnPurchaseComplete.cs

@@ -0,0 +1,12 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(SetInputOnSceneEvent) + ", " + nameof(SceneEventListener) +
+        "\n\n")]
+    public class EnableInputOnPurchaseComplete : SetInputOnSceneEvent { }
+}

package/EnableInputOnPurchaseComplete.cs.meta

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

package/FollowSelectedObject.cs

@@ -0,0 +1,20 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace DREditor.Purchasing
+{
+    /// <summary>
+    ///
+    /// </summary>
+	[ClassHeader("")]
+    public class FollowSelectedObject : MonoBehaviour
+    {
+        protected virtual void LateUpdate()
+        {
+            if (EventSystem.current.currentSelectedGameObject != null)
+                transform.position = EventSystem.current.currentSelectedGameObject.transform.position;
+        }
+    }
+}

package/FollowSelectedObject.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 540e4f04f2e75084a94b62d051864e74