net.dreditor.minigames.rs 0.0.0-stage → 0.1.7

package/CrossSwordsMechanic.cs

@@ -0,0 +1,330 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Audio;
+using DREditor.EventObjects;
+using DREditor.Minigames.Debates.Mechanics;
+using DREditor.Services;
+using DREditor.UIHandling;
+using System;
+using System.Collections;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.InputSystem;
+using static UnityEngine.InputSystem.InputAction;
+
+namespace DREditor.Minigames.RS
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(ServiceHolder<ITieBreaker>) + ", " + nameof(ITieBreaker) +
+        "\n\n")]
+    public class CrossSwordsMechanic : ServiceHolder<ITieBreaker>, ITieBreaker
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference submit = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected SceneEvent duelStartedEvent;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEvent duelEndedEvent;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected UIVisibilityComponent introAnimation = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected UIVisibilityComponent successAnimation = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected UIVisibilityComponent failureAnimation = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected int totalTaps = 8;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float duelDuration = 3;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int enemyIndex = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float enemyAttackRate = 0.2f;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float damage = 5;
+
+
+        [Header("")]
+        [SerializeField] protected UnityEvent onDuelStarted = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected SoundPlayerDRE successSFX;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SoundPlayerDRE failureSFX;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SoundPlayerDRE clashingSFX;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int currentTaps = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ISplitScreen splitService;
+
+
+        protected virtual void Start() => InitializeMechanic();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeMechanic()
+        {
+            if (!InitializationValid())
+                OnInitializationFailed();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool InitializationValid() => ServiceLocator.HasService(out splitService);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnInitializationFailed()
+        {
+            UnityEngine.Debug.LogWarning($"ALERT: The {nameof(CrossSwordsMechanic)} requires " +
+                    $"an active {nameof(ISplitScreen)} service to function.\n" +
+                    $"PROPOSAL: Ensure that a service registering {nameof(ISplitScreen)} is available.");
+
+            UnityEngine.Debug.Log($"REPORT: Destroying {nameof(CrossSwordsMechanic)}.");
+
+            Destroy(gameObject);
+        }
+
+
+        /// <inheritdoc/>
+        public virtual IEnumerator TieBreakerProcess(Action<bool> result)
+        {
+            UnityEngine.Debug.Log("REPORT: Starting CrossSwords.");
+
+            InitializeDuel();
+
+            InvokeDuelStarted();
+
+            yield return DisplayStartingDuel();
+
+            RaiseEvent(duelStartedEvent);
+
+            EnablePlayerDueling();
+
+            yield return Duel();
+
+            DisablePlayerDueling();
+
+            RaiseEvent(duelEndedEvent);
+
+            yield return ResolveDuel();
+
+            result(splitService.WillAdvanceOnTie());
+
+            UnityEngine.Debug.Log("REPORT: Ending CrossSwords.");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeDuel()
+        {
+            splitService.AnimateToResetState();
+
+            currentTaps = totalTaps;
+
+            var speeds = transform.root.GetComponentsInChildren<SpeedHandlerBase>();
+
+            foreach (var speed in speeds)
+            {
+                speed.OnPanelsStopped();
+
+                speed.DeactivateControls();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual IEnumerator DisplayStartingDuel()
+        {
+            if (introAnimation != null)
+            {
+                yield return introAnimation.ShowTillComplete();
+
+                introAnimation.Hide();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneEvent"></param>
+        protected virtual void RaiseEvent(SceneEvent sceneEvent)
+        {
+            if (sceneEvent != null)
+                sceneEvent.Raise();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InvokeDuelStarted() => onDuelStarted?.Invoke();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void EnablePlayerDueling() => submit.action.started += Tap;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="ctx"></param>
+        protected virtual void Tap(CallbackContext ctx)
+        {
+            currentTaps++;
+
+            splitService.PlayerAttack(damage);
+
+            if (clashingSFX != null)
+                clashingSFX.PlaySFX();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual IEnumerator Duel()
+        {
+            float timeRemaining = duelDuration;
+
+            while (timeRemaining > 0 && currentTaps != 0 && currentTaps <= totalTaps)
+            {
+                yield return new WaitForSeconds(enemyAttackRate);
+
+                timeRemaining -= enemyAttackRate;
+
+                splitService.EnemyAttack(enemyIndex, damage);
+
+                currentTaps--;
+
+                if (clashingSFX != null)
+                    clashingSFX.PlaySFX();
+
+                UnityEngine.Debug.Log("REPORT: Enemy Attacked.");
+
+                yield return null;
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DisablePlayerDueling() => submit.action.started -= Tap;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator ResolveDuel()
+        {
+            bool playerWon = splitService.WillAdvanceOnTie();
+
+            var resultSound = playerWon ? successSFX : failureSFX;
+
+            var resultAnimation = playerWon ? successAnimation : failureAnimation;
+
+            if (playerWon)
+                splitService.PlayerAttack(damage);
+            else
+                splitService.EnemyAttack(enemyIndex, damage);
+
+            if (resultSound != null)
+                resultSound.PlaySFX();
+
+            if (resultAnimation != null)
+            {
+                yield return resultAnimation.ShowTillComplete();
+
+                resultAnimation.Hide();
+            }
+        }
+
+
+        /// <inheritdoc/>
+        protected override void OnDestroy()
+        {
+            base.OnDestroy();
+
+            DisablePlayerDueling();
+        }
+    }
+}

package/CrossSwordsMechanic.cs.meta

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

package/CutHandler.cs

@@ -0,0 +1,287 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.UIHandling;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.InputSystem;
+using static UnityEngine.InputSystem.InputAction;
+
+namespace DREditor.Minigames.RS
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <remarks></remarks>
+    [ClassHeader(nameof(ControlledComponent) +
+        "\n\n")]
+    public class CutHandler : ControlledComponent
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference swipe = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected bool outputDebugSwipeLogs = false;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected EvaluateBoolCondition preventCutsCondition;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int frameWindowForInput = 5;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float timeForSwordToCut = 0.2f;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float cutCooldown = 0.1f;
+
+
+        [Header("")]
+        [SerializeField] protected UnityEvent<Vector3, Vector3> OnSwiped;
+
+        [Header("")]
+        [SerializeField] protected UnityEvent OnHit;
+        
+        [Header("")]
+        [SerializeField] protected UnityEvent OnMissed;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly List<Vector2> inputs = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ISword cutSword;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ISwipeListener[] swipeListeners;
+
+
+        /// <inheritdoc/>
+        protected override void Awake()
+        {
+            base.Awake();
+
+            swipeListeners = transform.root.GetComponentsInChildren<ISwipeListener>();
+
+            cutSword = GetComponentsInChildren<ISword>()?.First();
+            
+            if (cutSword == null)
+                UnityEngine.Debug.LogError($"ALERT: No {nameof(ISword)} found in children of {name}");
+        }
+
+        /// <inheritdoc/>
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            cutSword?.StopDetectingCuts();
+            
+            foreach (var listener in swipeListeners)
+                if (listener != null)
+                    OnSwiped.AddListener(listener.OnSwiped);
+        }
+
+        /// <inheritdoc/>
+        protected override void OnDisable()
+        {
+            base.OnDisable();
+
+            DeactivateControls();
+
+            foreach (var listener in swipeListeners)
+                if (listener != null)
+                    OnSwiped.RemoveListener(listener.OnSwiped);
+        }
+
+        /// <inheritdoc/>
+        public override void ActivateControls()
+        {
+            inputs.Clear();
+
+            if (outputDebugSwipeLogs)
+                UnityEngine.Debug.LogWarning($"REPORT: Enabling Controls");
+
+            swipe.action.performed += Swipe;
+        }
+
+        /// <inheritdoc/>
+        public override void DeactivateControls()
+        {
+            StopAllCoroutines();
+
+            cutSword?.StopDetectingCuts();
+
+            if (outputDebugSwipeLogs)
+                UnityEngine.Debug.LogWarning($"REPORT: Disabling Controls");
+
+            swipe.action.performed -= Swipe;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="context"></param>
+        protected virtual void Swipe(CallbackContext context)
+        {
+            if (preventCutsCondition != null && preventCutsCondition.Evaluate())
+                return;
+
+            Vector2 direction = context.ReadValue<Vector2>();
+
+            if (!InputDirectionValid(direction))
+                return;
+
+            if (inputs.Count == 0)
+                StartCoroutine(BufferSwipe());
+
+            inputs.Add(direction);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="direction"></param>
+        /// <returns></returns>
+        protected virtual bool InputDirectionValid(Vector2 direction)
+        {
+            bool directionEmpty = direction == Vector2.zero;
+
+            bool roundedDirectionEmpty = Mathf.Round(direction.x) == 0 && Mathf.Round(direction.y) == 0;
+
+            bool directionValid = !directionEmpty && !roundedDirectionEmpty;
+
+            if (directionEmpty && outputDebugSwipeLogs)
+                UnityEngine.Debug.Log($"REPORT: Attempted Cut Direction was Zero");
+
+            if (roundedDirectionEmpty && outputDebugSwipeLogs)
+                UnityEngine.Debug.Log($"REPORT: Swipe Input did not reach the threshold: " + direction);
+
+            if (!directionValid)
+                StartCoroutine(Cooldown());
+
+            return directionValid;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator BufferSwipe()
+        {
+            yield return new WaitForEndOfFrame();
+
+            yield return new WaitForSecondsRealtime(Time.deltaTime * frameWindowForInput);
+            
+            DeactivateControls();
+
+            SwipeAtDirection(CombineInputDirections());
+
+            StartCoroutine(SwipeProcess());
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual Vector2 CombineInputDirections()
+        {
+            Vector2 combine = Vector2.zero;
+
+            foreach (var i in inputs)
+            {
+                combine.x += Mathf.Round(i.x);
+
+                combine.y += Mathf.Round(i.y);
+
+                if (outputDebugSwipeLogs)
+                    UnityEngine.Debug.Log($"REPORT: Input Filtered: " + i);
+            }
+
+            combine.x = Mathf.Clamp(combine.x, -1, 1);
+
+            combine.y = Mathf.Clamp(combine.y, -1, 1);
+
+            inputs.Clear();
+
+            return combine;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="direction"></param>
+        protected virtual void SwipeAtDirection(Vector2 direction)
+        {
+            if (outputDebugSwipeLogs)
+                UnityEngine.Debug.Log($"REPORT: Verified Swipe Direction is: " + direction);
+
+            OnSwiped?.Invoke(cutSword.AngleSword(direction), direction);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator SwipeProcess()
+        {
+            cutSword?.StartDetectingCuts();
+
+            yield return new WaitForSeconds(timeForSwordToCut);
+
+            cutSword?.StopDetectingCuts();
+
+            if (cutSword.RecentlyLandedHit)
+                OnHit?.Invoke();
+            else
+                OnMissed?.Invoke();
+
+            yield return Cooldown();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual IEnumerator Cooldown()
+        {
+            if (outputDebugSwipeLogs)
+                UnityEngine.Debug.Log($"REPORT: Started cooldown");
+
+            yield return new WaitForSeconds(cutCooldown);
+
+            if (outputDebugSwipeLogs)
+                UnityEngine.Debug.Log($"REPORT: Ended Cooldown");
+
+            ActivateControls();
+        }
+    }
+}

package/CutHandler.cs.meta

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

package/CutLimitMechanic.cs

@@ -0,0 +1,59 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using TMPro;
+using UnityEngine;
+
+namespace DREditor.Minigames.RS
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(ISwipeListener) +
+        "\n\n")]
+    public class CutLimitMechanic : MonoBehaviour, ISwipeListener
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent cutCount = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent outOfCuts;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected TextMeshProUGUI cutVisual = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int cutReduceAmount = 1;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="swipeStart"></param>
+        /// <param name="swipeEnd"></param>
+        public virtual void OnSwiped(Vector3 swipeStart, Vector3 swipeEnd)
+        {
+            if (cutCount == null)
+                return;
+
+            cutCount.SetValue(cutCount.Value - cutReduceAmount);
+
+            if (outOfCuts != null)
+                outOfCuts.SetValue(cutCount.Value == 0);
+
+            if (cutVisual != null)
+                cutVisual.text = cutCount.Value.ToString();
+        }
+    }
+}