ichni_Creator_Studio/Assets/Scripts/Graphical Animation Editor/GraphicalFlexibleFloatWindow.cs

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Eventing.Reader;
using System.Linq;
using Ichni;
using Ichni.Editor;
using Ichni.RhythmGame;
using Sirenix.OdinInspector;
using Sirenix.Utilities;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.UI;

public partial class GraphicalFlexibleFloatWindow : MovableWindow
{

    public FlexibleFloatTab unitPrefab;
    public IBaseElement connectedBaseElement;
    public List<FlexibleFloatTab> unitList;

    public UnityAction ApplyParameters;


    public float songTime => EditorManager.instance.songInformation.songTime;
    public float songBeat => EditorManager.instance.songInformation.songBeat;
    public float beatmapStartTime => -EditorManager.instance.songInformation.delay;
    public float timePerBeat => 60f / EditorManager.instance.songInformation.bpm;

    public int BeatDeviver = 100;
    public int BeatNextDeviver = 1;
    public void Initialize(IBaseElement baseElement, string title, FlexibleFloat[] FlexibleFloats, string[] Subtitles)
    {

        scalevalue = 5;
        transform.localScale = Vector3.zero;
        this.connectedBaseElement = baseElement;
        this.title.text = title;
        unitList = new List<FlexibleFloatTab>();


        closeButton.onClick.AddListener(Quit);
        StartCoroutine(WindowAnim.ShowPanelOnScale(gameObject));
        for (int i = 0; i <= FlexibleFloats.Length - 1; i++)
        {
            ClipBoard.Add(Subtitles[i], new List<AnimatedFloat>());
            AddUnit(FlexibleFloats[i], Subtitles[i]);
        }

        ApplyParameters = () =>
            {
                for (int i = 0; i <= unitList.Count - 1; i++)
                {
                    unitList[i].connectFloat.Sort();
                }

            };
        XDeviverScale("1");
    }
    public void AddUnit(FlexibleFloat flexibleFloat, string Subtitle)
    {
        flexibleFloat.Sort();
        FlexibleFloatTab flexibleFloatTab = Instantiate(unitPrefab, windowRect);
        flexibleFloatTab.FatherWindow = this;
        unitList.Add(flexibleFloatTab);
        flexibleFloatTab.Initialize(flexibleFloat, Subtitle);
    }





    public void Quit()
    {
        ApplyParameters();
        //StartCoroutine(WindowAnim.HidePanel(gameObject, true));
        Destroy(gameObject);
    }
    public float scalevalue;
    public void CurveScale(string Rawvalue)
    {
        float value = float.Parse(Rawvalue);
        scalevalue = value;
        foreach (FlexibleFloatTab i in unitList)
        {
            i.CurveScale(value);
        }
    }
    public void DeviverScale(string Rawvalue)
    {
        if (ConnectedPoint != null) ConnectedPoint.UpLoad();
        BeatDeviver = int.Parse(Rawvalue);
        ChangeValue();
        for (int i = unitList.Count - 1; i >= 0; i--)
        {
            unitList[i].Initialize(unitList[i].connectFloat, unitList[i].Title);
        }
        XDeviverScale(BeatNextDeviver.ToString());

    }
    public void XDeviverScale(string Rawvalue)
    {
        BeatNextDeviver = int.Parse(Rawvalue);
        foreach (FlexibleFloatTab i in unitList)
        {
            i.XbeatCnange(BeatNextDeviver);
        }
    }
}

public partial class GraphicalFlexibleFloatWindow
{
    [Title("AnimEditor")]
    public TMP_InputField StartText;
    public TMP_InputField EndText;
    public TMP_InputField StartValueText;
    public TMP_InputField EndValueText;

    public TMP_InputField EventMultiplier;
    public EventPoint ConnectedPoint;
    public TMP_Dropdown animationCurveTypeDropdown;
    public GameObject VisibleArea;


    public void Removed()
    {
        if (ConnectedPoint != null)
        {
            ConnectedPoint.FatherTab.remoceAnim(ConnectedPoint.animatedFloat);
            ConnectedPoint.FatherTab.eventPoints.Remove(ConnectedPoint);
            if (ConnectedPoint.LastEventPoint != null)
            {
                ConnectedPoint.LastEventPoint.NextEventPoint = ConnectedPoint.NextEventPoint;
                if (ConnectedPoint.LastEventPoint.NextEventPoint != null) ConnectedPoint.LastEventPoint.NextEventPoint.ReDraw(scalevalue);
                ConnectedPoint.LastEventPoint.ReDraw(scalevalue);
            }

            if (ConnectedPoint.NextEventPoint != null)
            {
                ConnectedPoint.NextEventPoint.LastEventPoint = ConnectedPoint.LastEventPoint;
                if (ConnectedPoint.NextEventPoint.LastEventPoint != null) ConnectedPoint.NextEventPoint.LastEventPoint.ReDraw(scalevalue);
            }

            //Destroy(ConnectedPoint.animatedFloat);

            VisibleArea.SetActive(false);

            Destroy(ConnectedPoint.gameObject);
            ApplyParameters();
        }
    }
    public void ChangeValue()


    {
        if (ConnectedPoint != null)
        {
            float startTime = float.Parse(StartText.text);
            float endTime = float.Parse(EndText.text);
            float startValue = float.Parse(StartValueText.text);
            float endValue = float.Parse(EndValueText.text);

            ConnectedPoint.animatedFloat.startTime = startTime;
            ConnectedPoint.animatedFloat.endTime = endTime;
            ConnectedPoint.animatedFloat.startValue = startValue;
            ConnectedPoint.animatedFloat.endValue = endValue;
            ConnectedPoint.animatedFloat.animationCurveType = (AnimationCurveType)animationCurveTypeDropdown.value;
            ConnectedPoint.Initialize(ConnectedPoint.animatedFloat);
            ConnectedPoint.ReDraw(scalevalue);
        }
    }

    public Dictionary<string, List<AnimatedFloat>> ClipBoard = new();
    public float MinCopyTime = 0f;

    public void Update()
    {
        if (Keyboard.current.deleteKey.isPressed && ConnectedPoint != null)
        {
            Removed();
        }

        if (Keyboard.current.shiftKey.isPressed && Keyboard.current.vKey.wasPressedThisFrame)
        {
            Paste();
        }
    }
    public void Paste()
    {
        float time = unitList[0].GetBeat();
        print(time);
        FindMinStartTime();
        foreach (KeyValuePair<string, List<AnimatedFloat>> i in ClipBoard)
        {
            foreach (AnimatedFloat j in i.Value)
            {
                AnimatedFloat newone = new AnimatedFloat(j.startTime, j.endTime, j.startValue, j.endValue, j.animationCurveType)
                {
                    startTime = j.startTime - MinCopyTime + time,
                    endTime = j.endTime - MinCopyTime + time
                };

                unitList.Find(x => x.Title == i.Key).SpawnEvent(newone);
            }
        }
    }

    public void FindMinStartTime()
    {
        MinCopyTime = float.MaxValue;
        foreach (var list in ClipBoard.Values)
        {
            foreach (var animatedFloat in list)
            {
                if (animatedFloat.startTime < MinCopyTime)
                {
                    MinCopyTime = animatedFloat.startTime;
                }
            }
        }
    }
}