Beatmap Sections & Latency Reduction (#170)

* prep UI for chart section

* all special layers now on one area

todo: have buttons toggle between special layers  (selection mode shows all?), use the tabs system for this

* swapping between special timelines - prelim

* special entities can be placed

* spec. timeline base functions complete

music volume changes should work now

* attempt at input lag reduction

needs testing

* fix dsp issues

* smaller DSP buffer?

* Revert "smaller DSP buffer?"

This reverts commit 9d36db5ff9.

* make conductor clock use real time (double)

change order of execution of input-related scripts to further attempt a reduction in input latency

* start values can be changed

make the old special entity bar visible when the corresponding type is selected

* creation of Chart Sections (TODO: GO REFERENCE)

* added GO references

* section edit dialog

* disable wrapping on chart section obj

* backspace can now delete entities

* entities don't shift when duplicated

* fix PlayerActionEvent order of operations

- fixed remix loading trying to clear special timeline while it's writing to itself

* make oop check match parity

* more operation order fix

* fix Karate Man BG initialization

* show section progress in editor

todo: section progress in-game

* more fix for entity duping

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/SectionTimelineObj.cs

@@ -0,0 +1,92 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using TMPro;
+
+using DG.Tweening;
+
+namespace HeavenStudio.Editor.Track
+{
+    public class SectionTimelineObj : SpecialTimelineObj
+    {
+        [Header("Components")]
+        [SerializeField] private TMP_Text sectionLabel;
+        [SerializeField] private GameObject chartLine;
+        [SerializeField] private SectionDialog sectionDialog;
+
+        public DynamicBeatmap.ChartSection chartSection;
+
+        new private void Update()
+        {
+            base.Update();
+            if (hovering)
+            {
+                SpecialTimeline.hoveringTypes |= SpecialTimeline.HoveringTypes.SectionChange;
+            }
+
+            UpdateLabel();
+        }
+
+        public void UpdateLabel()
+        {
+            sectionLabel.text = chartSection.sectionName;
+        }
+
+        public override void Init()
+        {
+            UpdateLabel();
+        }
+
+        public override void OnLeftClick()
+        {
+            if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.ChartSection)
+                StartMove();
+        }
+
+        public override void OnRightClick()
+        {
+            if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.ChartSection)
+            {
+                sectionDialog.SetSectionObj(this);
+                sectionDialog.SwitchSectionDialog();
+            }
+        }
+
+        public override bool OnMove(float beat)
+        {
+            foreach (var sectionChange in GameManager.instance.Beatmap.beatmapSections)
+            {
+                if (this.chartSection == sectionChange)
+                    continue;
+                if (beat > sectionChange.beat - Timeline.instance.snapInterval && beat < sectionChange.beat + Timeline.instance.snapInterval)
+                    return false;
+            }
+            this.chartSection.beat = beat;
+            return true;
+        }
+
+        public override void SetVisibility(Timeline.CurrentTimelineState.State state)
+        {
+            if (state == Timeline.CurrentTimelineState.State.ChartSection || state == Timeline.CurrentTimelineState.State.Selection)
+            {
+                gameObject.SetActive(true);
+                if (state == Timeline.CurrentTimelineState.State.ChartSection)
+                {
+                    chartLine.SetActive(true);
+                    sectionLabel.gameObject.SetActive(true);
+                }
+                else
+                {
+                    chartLine.SetActive(false);
+                    sectionLabel.gameObject.SetActive(false);
+                }
+            }
+            else
+            {
+                gameObject.SetActive(false);   
+
+            }
+        }
+    }
+}

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/SectionTimelineObj.cs.meta

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

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/SpecialTimelineObj.cs

@@ -0,0 +1,103 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using TMPro;
+
+using DG.Tweening;
+
+namespace HeavenStudio.Editor.Track
+{
+    public class SpecialTimelineObj : MonoBehaviour
+    {
+        [Header("Components")]
+        [SerializeField] private RectTransform rectTransform;
+        [SerializeField] private RectTransform raycastRect;
+
+        private float startPosX;
+        private bool moving = false;
+
+        public bool hovering;
+        private float lastPosX;
+
+        private void Start()
+        {
+            rectTransform = GetComponent<RectTransform>();
+        }
+
+        protected void Update()
+        {
+            if (!Conductor.instance.NotStopped())
+            {
+                if (RectTransformUtility.RectangleContainsScreenPoint(raycastRect, Input.mousePosition, Editor.instance.EditorCamera))
+                {
+                    if (Input.GetMouseButtonDown(0))
+                    {
+                        OnLeftClick();
+                    }
+                    else if (Input.GetMouseButtonDown(1))
+                    {
+                        OnRightClick();
+                    }
+                    hovering = true;
+                }
+                else
+                {
+                    hovering = false;
+                }
+
+                if (moving)
+                {
+                    Vector3 mousePos = Editor.instance.EditorCamera.ScreenToWorldPoint(Input.mousePosition);
+
+                    transform.position = new Vector3(mousePos.x - startPosX, transform.position.y, 0);
+                    transform.localPosition = new Vector3(Mathf.Clamp(Starpelly.Mathp.Round2Nearest(transform.localPosition.x, Timeline.SnapInterval()), 0, Mathf.Infinity), transform.localPosition.y);
+
+                    if (Input.GetMouseButtonUp(0))
+                    {
+                        if (!OnMove(transform.localPosition.x))
+                            transform.localPosition = new Vector3(lastPosX, transform.localPosition.y);
+
+                        moving = false;
+                        lastPosX = transform.localPosition.x;
+                    }
+                }
+            }
+            else
+            {
+                if (moving)
+                {
+                    if (!OnMove(transform.localPosition.x))
+                            transform.localPosition = new Vector3(lastPosX, transform.localPosition.y);
+                    moving = false;
+                    lastPosX = transform.localPosition.x;
+                }
+                hovering = false;
+            }
+        }
+
+        public void StartMove()
+        {
+            Vector3 mousePos = Editor.instance.EditorCamera.ScreenToWorldPoint(Input.mousePosition);
+            startPosX = mousePos.x - transform.position.x;
+            moving = true;
+            lastPosX = transform.localPosition.x;
+        }
+
+        public void DeleteObj()
+        {
+            transform.parent.GetComponent<SpecialTimeline>().specialTimelineObjs.Remove(this);
+            Destroy(this.gameObject);
+        }
+
+        //events
+        public virtual void Init() {}
+        public virtual void OnLeftClick() {}
+        public virtual void OnRightClick() {}
+        public virtual bool OnMove(float beat)
+        {
+            return true;
+        }
+        public virtual void SetVisibility(Timeline.CurrentTimelineState.State state) {}
+    }
+}

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/SpecialTimelineObj.cs.meta

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

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/TempoTimelineObj.cs

@@ -0,0 +1,98 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using TMPro;
+
+using DG.Tweening;
+
+namespace HeavenStudio.Editor.Track
+{
+    public class TempoTimelineObj : SpecialTimelineObj
+    {
+        [Header("Components")]
+        [SerializeField] private TMP_Text tempoTXT;
+        [SerializeField] private GameObject tempoLine;
+
+        public DynamicBeatmap.TempoChange tempoChange;
+
+        new private void Update()
+        {
+            base.Update();
+            if (hovering)
+            {
+                SpecialTimeline.hoveringTypes |= SpecialTimeline.HoveringTypes.TempoChange;
+                if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.TempoChange)
+                {
+                    float newTempo = Input.mouseScrollDelta.y;
+
+                    if (Input.GetKey(KeyCode.LeftShift))
+                        newTempo *= 5f;
+                    if (Input.GetKey(KeyCode.LeftControl))
+                        newTempo /= 100f;
+
+                    tempoChange.tempo += newTempo;
+
+                    //make sure tempo is positive
+                    if (tempoChange.tempo < 1)
+                        tempoChange.tempo = 1;
+                }
+            }
+
+            UpdateTempo();
+        }
+
+        private void UpdateTempo()
+        {
+            tempoTXT.text = $"{tempoChange.tempo} BPM";
+            Timeline.instance.FitToSong();
+        }
+
+        public override void Init()
+        {
+            UpdateTempo();
+        }
+
+        public override void OnLeftClick()
+        {
+            if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.TempoChange)
+                StartMove();
+        }
+
+        public override void OnRightClick()
+        {
+            if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.TempoChange)
+            {
+                GameManager.instance.Beatmap.tempoChanges.Remove(tempoChange);
+                DeleteObj();
+            }
+        }
+
+        public override bool OnMove(float beat)
+        {
+            foreach (var tempoChange in GameManager.instance.Beatmap.tempoChanges)
+            {
+                if (this.tempoChange == tempoChange)
+                    continue;
+                if (beat > tempoChange.beat - Timeline.instance.snapInterval && beat < tempoChange.beat + Timeline.instance.snapInterval)
+                    return false;
+            }
+            this.tempoChange.beat = beat;
+            return true;
+        }
+
+        public override void SetVisibility(Timeline.CurrentTimelineState.State state)
+        {
+            if (state == Timeline.CurrentTimelineState.State.TempoChange || state == Timeline.CurrentTimelineState.State.Selection)
+            {
+                gameObject.SetActive(true);
+                if (state == Timeline.CurrentTimelineState.State.TempoChange)
+                    tempoLine.SetActive(true);
+                else
+                    tempoLine.SetActive(false);
+            }
+            else
+                gameObject.SetActive(false);   
+        }
+    }
+}

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/TempoTimelineObj.cs.meta

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

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/VolumeTimelineObj.cs

@@ -0,0 +1,96 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using TMPro;
+
+using DG.Tweening;
+
+namespace HeavenStudio.Editor.Track
+{
+    public class VolumeTimelineObj : SpecialTimelineObj
+    {
+        [Header("Components")]
+        [SerializeField] private TMP_Text volumeTXT;
+        [SerializeField] private GameObject volumeLine;
+
+        public DynamicBeatmap.VolumeChange volumeChange;
+
+        new private void Update()
+        {
+            base.Update();
+            if (hovering)
+            {
+                SpecialTimeline.hoveringTypes |= SpecialTimeline.HoveringTypes.VolumeChange;
+                if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.MusicVolume)
+                {
+                    float newVolume = Input.mouseScrollDelta.y;
+
+                    if (Input.GetKey(KeyCode.LeftShift))
+                        newVolume *= 5f;
+                    if (Input.GetKey(KeyCode.LeftControl))
+                        newVolume /= 100f;
+
+                    volumeChange.volume += newVolume;
+
+                    //make sure volume is positive
+                    volumeChange.volume = Mathf.Clamp(volumeChange.volume, 0, 100);
+                }
+            }
+
+            UpdateVolume();
+        }
+
+        private void UpdateVolume()
+        {
+            volumeTXT.text = $"{volumeChange.volume}%";
+        }
+
+        public override void Init()
+        {
+            UpdateVolume();
+        }
+
+        public override void OnLeftClick()
+        {
+            if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.MusicVolume)
+                StartMove();
+        }
+
+        public override void OnRightClick()
+        {
+            if (Timeline.instance.timelineState.currentState == Timeline.CurrentTimelineState.State.MusicVolume)
+            {
+                GameManager.instance.Beatmap.volumeChanges.Remove(volumeChange);
+                DeleteObj();
+            }
+        }
+
+        public override bool OnMove(float beat)
+        {
+            foreach (var volumeChange in GameManager.instance.Beatmap.volumeChanges)
+            {
+                if (this.volumeChange == volumeChange)
+                    continue;
+                if (beat > volumeChange.beat - Timeline.instance.snapInterval && beat < volumeChange.beat + Timeline.instance.snapInterval)
+                    return false;
+            }
+            this.volumeChange.beat = beat;
+            return true;
+        }
+
+        public override void SetVisibility(Timeline.CurrentTimelineState.State state)
+        {
+            if (state == Timeline.CurrentTimelineState.State.MusicVolume || state == Timeline.CurrentTimelineState.State.Selection)
+            {
+                gameObject.SetActive(true);
+                if (state == Timeline.CurrentTimelineState.State.MusicVolume)
+                    volumeLine.SetActive(true);
+                else
+                    volumeLine.SetActive(false);
+            }
+            else
+                gameObject.SetActive(false);   
+        }
+    }
+}

Assets/Scripts/LevelEditor/Timeline/SpecialTmeline/TimelineObjs/VolumeTimelineObj.cs.meta

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