DTM Trail

Assets/ThemeBundles/DepartureToMultiverse/Scripts/DTMTrail.cs

@@ -0,0 +1,226 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using DG.Tweening;
+using Ichni.Editor;
+using Ichni.RhythmGame.Beatmap;
+using Ichni.RhythmGame.ThemeBundles.Basic.Beatmap;
+using Ichni.RhythmGame.ThemeBundles.DepartureToMultiverse.Beatmap;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace Ichni.RhythmGame.ThemeBundles.DepartureToMultiverse
+{
+    public partial class DTMTrail : EnvironmentObject, IHaveTrail, IHaveInteraction
+    {
+        public GameObject headPoint, headCircle;
+        public GameObject trailBody;
+        
+        public List<Renderer> renderers;
+        public ParticleSystem headCircleParticle;
+        public TrailRenderer trailRenderer { get; set; }
+        
+        public bool isHeadEnabled;
+        public FlexibleBool enableTimes;
+        public float enableProcessTime = 0.5f;
+        public float headSize = 1f;
+        
+        public FlexibleFloat headRotateSpeed;
+         
+        public override bool haveEmission => true;
+        
+        public new static DTMTrail GenerateElement(string elementName, Guid id, List<string> tags,
+            bool isFirstGenerated, string themeBundleName, string objectName, GameElement parentElement, 
+            bool isStatic, FlexibleBool enableTimes, FlexibleFloat headRotateSpeed, float enableProcessTime, 
+            float headSize)
+        {
+            DTMTrail dtmTrail = EnvironmentObject.GenerateElement(elementName, id, tags,
+                isFirstGenerated, themeBundleName, objectName, parentElement, isStatic).GetComponent<DTMTrail>();
+            dtmTrail.trailRenderer = dtmTrail.trailBody.GetComponent<TrailRenderer>();
+            dtmTrail.isHeadEnabled = false;
+            dtmTrail.enableTimes = enableTimes;
+            dtmTrail.headRotateSpeed = headRotateSpeed;
+            dtmTrail.enableProcessTime = enableProcessTime;
+            dtmTrail.headSize = headSize;
+            dtmTrail.SetUpTweeners();
+            
+            var rotationBySpeedModule = dtmTrail.headCircleParticle.rotationBySpeed;
+            rotationBySpeedModule.z = 0;
+            
+            return dtmTrail;
+        }
+        
+        public override void Refresh()
+        {
+            base.Refresh();
+            renderers.ForEach(rend =>
+            {
+                if (colorSubmodule.emissionEnabled)
+                {
+                    rend.material.EnableKeyword("_EMISSION_ON");
+                }
+                else
+                {
+                    rend.material.DisableKeyword("_EMISSION_ON");
+                }
+
+                rend.material.SetColor("_BaseColor", colorSubmodule.currentBaseColor);
+                rend.material.SetColor("_EmissionColor",  colorSubmodule.GetCurrentEmissionColor());
+            });
+        }
+
+        private void Update()
+        {
+            float songTime = EditorManager.instance.songInformation.songTime;
+            enableTimes.UpdateFlexibleBool(songTime);
+            if(enableTimes.value && !isHeadEnabled)
+            {
+                EnableHead();
+                isHeadEnabled = true;
+            }
+            else if(!enableTimes.value && isHeadEnabled)
+            {
+                DisableHead();
+                isHeadEnabled = false;
+            }
+
+            if (isHeadEnabled && headRotateSpeed.animations.Count > 0)
+            {
+                headRotateSpeed.UpdateFlexibleFloat(songTime);
+                var rotationBySpeedModule = headCircleParticle.rotationBySpeed;
+                rotationBySpeedModule.z = headRotateSpeed.value;
+            }
+
+            if (Keyboard.current.spaceKey.wasPressedThisFrame)
+            {
+                TriggerInteraction();
+            }
+        }
+
+        private void EnableHead()
+        {
+            if(disableHeadSequence.IsPlaying())
+            {
+                disableHeadSequence.Complete();
+            }
+            
+            enableHeadSequence.Restart();
+        }
+
+        private void DisableHead()
+        {
+            if(enableHeadSequence.IsPlaying())
+            {
+                enableHeadSequence.Complete();
+            }
+            
+            disableHeadSequence.Restart();
+        }
+        
+        private Sequence enableHeadSequence;
+        private Sequence disableHeadSequence;
+        private Sequence headBounceSequence;
+        
+        public void SetUpTweeners()
+        {
+            enableHeadSequence = DOTween.Sequence();
+            enableHeadSequence.Append(headPoint.transform.DOScale(headSize, enableProcessTime).SetEase(Ease.OutQuad));
+            enableHeadSequence.Join(headCircle.transform.DOScale(headSize, enableProcessTime).SetEase(Ease.OutQuad));
+            enableHeadSequence.SetAutoKill(false);
+            
+            disableHeadSequence = DOTween.Sequence();
+            disableHeadSequence.Append(headPoint.transform.DOScale(0, enableProcessTime).SetEase(Ease.OutQuad));
+            disableHeadSequence.Join(headCircle.transform.DOScale(0, enableProcessTime).SetEase(Ease.OutQuad));
+            disableHeadSequence.SetAutoKill(false);
+            
+            headBounceSequence = DOTween.Sequence();
+            headBounceSequence.Append(headPoint.transform.DOBlendableScaleBy(Vector3.one * 0.2f, 0.2f).SetEase(Ease.OutBack));
+            headBounceSequence.Join(headCircle.transform.DOBlendableScaleBy(Vector3.one * 0.2f, 0.2f).SetEase(Ease.OutBack));
+            headBounceSequence.Append(headPoint.transform.DOBlendableScaleBy(Vector3.one * -0.2f, 0.2f).SetEase(Ease.OutBack));
+            headBounceSequence.Join(headCircle.transform.DOBlendableScaleBy(Vector3.one * -0.2f, 0.2f).SetEase(Ease.OutBack));
+            headBounceSequence.SetAutoKill(false);
+        }
+
+        public void TriggerInteraction()
+        {
+            headBounceSequence.Restart();
+        }
+    }
+    
+    public partial class DTMTrail
+    {
+        public override void SaveBM()
+        {
+            matchedBM = new DTMTrail_BM(elementName, elementGuid, tags, parentElement.matchedBM as GameElement_BM,
+                themeBundleName, objectName, isStatic, enableTimes, headRotateSpeed, enableProcessTime, headSize);
+        }
+
+        public override void SetUpInspector()
+        {
+            base.SetUpInspector();
+
+            IHaveInspection inspector = EditorManager.instance.uiManager.inspector;
+            var container = inspector.GenerateContainer("DTMTrail");
+            
+            var enableTimeListButton = inspector.GenerateButton(this, container, "Enable Head Time List", () =>
+            {
+                var ew = inspector.GenerateCompositeParameterWindow(
+                    this, "Enable Head Time List", nameof(enableTimes));
+                ew.SetAsFlexibleBool();
+            });
+            
+            var headRotateSpeedButton = inspector.GenerateButton(this, container, "Head Rotate Speed", () =>
+            {
+                var ew = inspector.GenerateCompositeParameterWindow(
+                    this, "Head Rotate Speed", nameof(headRotateSpeed));
+                ew.SetAsFlexibleFloat();
+            });
+            
+            var enableProcessTimeInputField = inspector.GenerateInputField(this, container, "Enable Process Time", nameof(enableProcessTime));
+            var headSizeInputField = inspector.GenerateInputField(this, container, "Head Size", nameof(headSize));
+        }
+    }
+
+    
+    namespace Beatmap
+    {
+        public partial class DTMTrail_BM : EnvironmentObject_BM
+        {
+            public FlexibleBool_BM enableTimes;
+            public float enableProcessTime = 0.5f;
+            public float headSize = 1f;
+            
+            public FlexibleFloat_BM headRotateSpeed;
+            
+            public DTMTrail_BM()
+            {
+                
+            }
+            
+            public DTMTrail_BM(string elementName, Guid elementGuid, List<string> tags, GameElement_BM parentElement,
+                string themeBundleName, string objectName, bool isStatic, FlexibleBool enableTimes, FlexibleFloat headRotateSpeed, 
+                float enableProcessTime, float headSize):
+                base(elementName, elementGuid, tags, parentElement, themeBundleName, objectName, isStatic)
+            {
+                this.enableTimes = enableTimes.ConvertToBM();
+                this.headRotateSpeed = headRotateSpeed.ConvertToBM();
+                this.enableProcessTime = enableProcessTime;
+                this.headSize = headSize;
+            }
+
+            public override void ExecuteBM()
+            {
+                matchedElement = DTMTrail.GenerateElement(elementName, elementGuid, tags, false,
+                    themeBundleName, objectName, GetElement(attachedElementGuid), isStatic, 
+                    enableTimes.ConvertToGameType(), headRotateSpeed?.ConvertToGameType(), enableProcessTime, headSize);
+            }
+            
+            public override GameElement DuplicateBM(GameElement parent)
+            {
+                return DTMTrail.GenerateElement(elementName, Guid.NewGuid(), tags, false,
+                    themeBundleName, objectName, parent, isStatic, enableTimes.ConvertToGameType(), 
+                    headRotateSpeed?.ConvertToGameType(), enableProcessTime, headSize);
+            }
+        }
+    }
+}

Assets/ThemeBundles/DepartureToMultiverse/Scripts/DTMTrail.cs.meta

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