net.dreditor.phraseanimations 0.0.0-stage → 0.1.7

package/Editor/PhraseTypeEditor.cs

@@ -0,0 +1,278 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+#if UNITY_EDITOR
+using DREditor.Editor.Utility;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.PhraseAnimations.Editor
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class PhraseTypeEditor : ClassEditorBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        protected PhraseAnimationTypeBase typeBaseTarget;
+
+
+        /// <inheritdoc/>
+        protected override void OnInspectorGUI()
+        {
+            typeBaseTarget = baseTarget as PhraseAnimationTypeBase;
+
+            DisplayType();
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                DisplayStartTime();
+
+                DisplayDuration();
+
+                DisplayCurveButtons();
+            }
+
+            DisplayGenerateCurves();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DisplayStartTime()
+        {
+            typeBaseTarget.SetStartTime(HandyFields.FloatField("Start Time: ", typeBaseTarget.startTime, 30));
+
+            if (typeBaseTarget.startTime < 0)
+                typeBaseTarget.SetStartTime(0);
+
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DisplayDuration()
+        {
+            float fallBackDuration = typeBaseTarget.duration;
+
+            typeBaseTarget.SetDuration(HandyFields.FloatField("Duration: ", typeBaseTarget.duration, 30));
+
+            if (typeBaseTarget.duration <= 0)
+            {
+                if (fallBackDuration == 0)
+                    typeBaseTarget.SetDuration(1);
+                else
+                    typeBaseTarget.SetDuration(fallBackDuration);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DisplayCurveButtons()
+        {
+            if (typeBaseTarget.animationCurves.Count != 0)
+            {
+                if (GUILayout.Button("Update Curves"))
+                    UpdateCurves();
+
+                if (GUILayout.Button("Reset Curves"))
+                    ResetCurves();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DisplayGenerateCurves()
+        {
+            if (typeBaseTarget.animationCurves.Count == 0)
+            {
+                if (GUILayout.Button("Generate Curves"))
+                    GenerateCurves();
+            }
+            else
+                using (new EditorGUILayout.HorizontalScope())
+                    DisplayCurves();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void GenerateCurves()
+        {
+            for (int i = 0; i < typeBaseTarget.CurveCount; i++)
+                typeBaseTarget.animationCurves.Add(new AnimationCurve());
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void DisplayType();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void DisplayCurves();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void UpdateCurves();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ResetCurves()
+        {
+            typeBaseTarget.animationCurves.Clear();
+
+            GenerateCurves();
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="curve"></param>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <returns></returns>
+        protected virtual AnimationCurve DisplayCurve(AnimationCurve curve, float start, float end)
+        {
+            if (curve.keys.Length == 0)
+            {
+                curve.AddKey(typeBaseTarget.startTime, start);
+
+                curve.AddKey(typeBaseTarget.startTime + typeBaseTarget.duration, end);
+            }
+
+            try // Clicking the curve field would call an internal unity error but still works so this try is here to mitigate that.
+            {
+                curve = EditorGUILayout.CurveField(curve);
+            }
+            catch { }
+
+            return curve;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="curve"></param>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <returns></returns>
+        protected virtual AnimationCurve UpdateKey(AnimationCurve curve, float start, float end)
+        {
+            Keyframe oldStartTimeKey = curve.keys[0];
+
+            Keyframe oldDurationTimeKey = curve.keys[^1];
+
+            curve.keys = ValidateCurves(oldStartTimeKey, oldDurationTimeKey, curve, start, end);
+
+            return curve;
+        }
+
+        #region Keyframe Validation
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="oldStart"></param>
+        /// <param name="oldDuration"></param>
+        /// <param name="curve"></param>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <returns></returns>
+        protected virtual Keyframe[] ValidateCurves(Keyframe oldStart, Keyframe oldDuration, AnimationCurve curve, float start, float end)
+        {
+            if (ValidateMovedKey(curve, start, end))
+                return curve.keys;
+
+            Keyframe[] newKeys = ValidateNewKeys(oldStart, oldDuration, curve);
+
+            newKeys[0] = new(typeBaseTarget.startTime, start);
+
+            newKeys[curve.keys.Length - 1] = new(typeBaseTarget.startTime + typeBaseTarget.duration, end);
+
+            return newKeys;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="curve"></param>
+        /// <param name="start"></param>
+        /// <param name="end"></param>
+        /// <returns></returns>
+        protected virtual bool ValidateMovedKey(AnimationCurve curve, float start, float end)
+        {
+            Keyframe newStart = new(typeBaseTarget.startTime, start);
+
+            Keyframe newDuration = new(typeBaseTarget.startTime + typeBaseTarget.duration, end);
+
+            if (curve.keys[^1].time == newDuration.time && curve.keys[0].time == newStart.time)
+            {
+                if (curve.keys[^1].value == newDuration.value && curve.keys[0].value == newStart.value)
+                    return true;
+                else
+                {
+                    curve.MoveKey(0, new(0, start));
+
+                    curve.MoveKey(curve.keys.Length - 1, new(typeBaseTarget.startTime + typeBaseTarget.duration, end));
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="oldStart"></param>
+        /// <param name="oldDuration"></param>
+        /// <param name="curve"></param>
+        /// <returns></returns>
+        protected virtual Keyframe[] ValidateNewKeys(Keyframe oldStart, Keyframe oldDuration, AnimationCurve curve)
+        {
+            Keyframe[] newKeys = new Keyframe[curve.keys.Length];
+
+            if (curve.keys.Length > 2)
+                UpdateNewKeys(newKeys, oldStart, oldDuration, curve);
+
+            return newKeys;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="newKeys"></param>
+        /// <param name="oldStart"></param>
+        /// <param name="oldDuration"></param>
+        /// <param name="curve"></param>
+        protected virtual void UpdateNewKeys(Keyframe[] newKeys, Keyframe oldStart, Keyframe oldDuration, AnimationCurve curve)
+        {
+            float startOffset = typeBaseTarget.startTime - oldStart.time;
+
+            float durationOffset = (typeBaseTarget.startTime + typeBaseTarget.duration) - oldDuration.time;
+
+            for (int i = 1; i <= newKeys.Length - 2; i++)
+                if (curve.keys[i].time <= typeBaseTarget.startTime)
+                    newKeys[i] = new(curve.keys[i].time + startOffset, curve.keys[i].value);
+                else if (curve.keys[i].time >= typeBaseTarget.startTime + typeBaseTarget.duration)
+                    newKeys[i] = new(curve.keys[i].time + durationOffset, curve.keys[i].value);
+                else
+                {
+                    float behind = curve.keys[i].time - curve.keys[i - 1].time;
+
+                    newKeys[i] = new(curve.keys[i].time + behind, curve.keys[i].value);
+                }
+        }
+
+        #endregion
+    }
+}
+#endif

package/Editor/PhraseTypeEditor.cs.meta

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

package/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 056fb7e0cf9b7944fbd458061aab0311
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/IPhraseAnimationType.cs

@@ -0,0 +1,17 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using UnityEngine;
+
+namespace DREditor.PhraseAnimations
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public interface IPhraseAnimationType
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="clip"></param>
+        void Initialize(AnimationClip clip);
+    }
+}

package/IPhraseAnimationType.cs.meta

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

package/PhraseAnimation.cs

@@ -0,0 +1,74 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Minigames.Debates;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace DREditor.PhraseAnimations
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [System.Serializable]
+    public class PhraseAnimation : IPhraseAnimationArchitecture
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        public Vector3 spawnPoint;
+
+        /// <summary>
+        ///
+        /// </summary>
+        public Vector4 spawnAngle;
+
+        /// <summary>
+        ///
+        /// </summary>
+        public List<AnimData> animations = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="spawnPoint"></param>
+        public virtual void SetSpawnPoint(Vector3 spawnPoint) => this.spawnPoint = spawnPoint;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="spawnAngle"></param>
+        public virtual void SetSpawnAngle(Vector4 spawnAngle) => this.spawnAngle = spawnAngle;
+
+
+        /// <inheritdoc/>
+        public virtual void Initialize(object o = null)
+        {
+            if (o is AnimationClip clip)
+                foreach (AnimData anim in animations)
+                    anim.Initialize(clip);
+            else
+                UnityEngine.Debug.LogWarning($"ALERT: Failed to initialize animation architecture: {nameof(PhraseAnimation)}" +
+                    $" because the sent value for initialization was not of type {nameof(AnimationClip)}.");
+        }
+
+        /// <inheritdoc/>
+        public virtual void Apply(IPhraseAnimationArchitecture architecture)
+        {
+            PhraseAnimation animation = architecture as PhraseAnimation;
+
+            spawnPoint = animation.spawnPoint;
+
+            spawnAngle = animation.spawnAngle;
+
+            foreach (var newAnimation in animation.animations)
+            {
+                if (animations.Any(animation => animation.animationType?.GetType() == newAnimation.animationType?.GetType()))
+                    UnityEngine.Debug.Log("REPORT: The phrases simple animation contains duplicate types." +
+                        "\nPROPOSAL: Test animation to ensure no animations conflict with each other.");
+
+                animations.Add(newAnimation);
+            }
+        }
+    }
+}

package/PhraseAnimation.cs.meta

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

package/PhraseAnimationCompact.cs

@@ -0,0 +1,45 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using UnityEngine.Serialization;
+
+namespace DREditor.PhraseAnimations
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [Serializable]
+    public abstract class PhraseAnimationCompact<T> : PhraseAnimationTypeBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [FormerlySerializedAs("startScale")]
+        [FormerlySerializedAs("startPosition")]
+        [FormerlySerializedAs("startRotation")]
+        [FormerlySerializedAs("startFade")]
+        public T startValue;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [FormerlySerializedAs("endScale")]
+        [FormerlySerializedAs("endPosition")]
+        [FormerlySerializedAs("endRotation")]
+        [FormerlySerializedAs("endFade")]
+        public T endValue;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="startValue"></param>
+        public virtual void SetStartValue(T startValue) => this.startValue = startValue;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="endValue"></param>
+        public virtual void SetEndValue(T endValue) => this.endValue = endValue;
+    }
+}

package/PhraseAnimationCompact.cs.meta

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

package/PhraseAnimationHandler.cs

@@ -0,0 +1,136 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Minigames.Debates;
+using DREditor.Processables;
+using TMPro;
+using UnityEngine;
+
+namespace DREditor.PhraseAnimations
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(IPhraseAnimationComponent) + ", " + nameof(IPhraseHandlerComponent) + ", " +
+        nameof(IPhraseShatterListener) + ", " + nameof(IPhraseResetter) + ", " + nameof(IPrioritizable) +
+        "\n\n")]
+    public class PhraseAnimationHandler : MonoBehaviour, IPhraseAnimationComponent, IPhraseShatterListener, IPrioritizable
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int priority = 0;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected Animation compiledAnimation;
+
+        public int Priority { get => priority; set => priority = value; }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly string animationClipName = "transform";
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected float duration;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected PhraseAnimation phraseAnimation = null;
+
+
+        protected virtual void Awake() => compiledAnimation = GetComponent<Animation>();
+
+
+        /// <inheritdoc/>
+        public virtual void StartPhrase<T>(T phrase) where T : PhraseBase
+        {
+            InitializePhraseAnimation(phrase);
+
+            if (phraseAnimation != null)
+            {
+                InitializeText();
+
+                CompilePhraseAnimation();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="phrase"></param>
+        protected virtual void InitializePhraseAnimation(PhraseBase phrase)
+        {
+            phraseAnimation = null;
+
+            foreach (var architecture in phrase.animations)
+                if (architecture is PhraseAnimation phraseDataAnimation)
+                    phraseAnimation = phraseDataAnimation;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeText()
+        {
+            var tmpText = GetComponent<TMP_Text>();
+
+            tmpText.transform.localScale = Vector3.one;
+
+            //Below makes it to where using the dolly track only works once 
+            if (phraseAnimation.spawnPoint == Vector3.zero || phraseAnimation.spawnPoint == null)
+                tmpText.transform.position = phraseAnimation.spawnPoint;
+            else
+                tmpText.transform.localPosition = phraseAnimation.spawnPoint;
+
+            Vector4 rot = phraseAnimation.spawnAngle;
+
+            tmpText.transform.localEulerAngles = new(rot.x, rot.y, rot.z);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void CompilePhraseAnimation()
+        {
+            compiledAnimation.enabled = true;
+
+            AnimationClip animationClip = new()
+            {
+                legacy = true
+            };
+
+            phraseAnimation.Initialize(animationClip);
+
+            compiledAnimation.AddClip(animationClip, animationClipName);
+
+            compiledAnimation.Play(animationClipName);
+
+            duration = animationClip.length;
+        }
+
+
+        /// <inheritdoc/>
+        public virtual void OnShattered()
+        {
+            compiledAnimation.Stop();
+
+            compiledAnimation.enabled = false;
+        }
+
+        /// <inheritdoc/>
+        public virtual float GetPhraseDuration() => duration;
+
+        /// <inheritdoc/>
+        public virtual void Reset() => compiledAnimation.enabled = false;
+    }
+}

package/PhraseAnimationHandler.cs.meta

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

package/PhraseAnimationTypeBase.cs

@@ -0,0 +1,54 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.PhraseAnimations
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [Serializable]
+    public abstract class PhraseAnimationTypeBase : IPhraseAnimationType
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [SerializeField] public float startTime;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [SerializeField] public float duration;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        public abstract int CurveCount { get; }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public List<AnimationCurve> animationCurves = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="startTime"></param>
+        public virtual void SetStartTime(float startTime) => this.startTime = startTime;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="duration"></param>
+        public virtual void SetDuration(float duration) => this.duration = duration;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="clip"></param>
+        public abstract void Initialize(AnimationClip clip);
+    }
+}

package/PhraseAnimationTypeBase.cs.meta

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