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

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);
            }
        }
    }
}