HeavenStudioPlus/Assets/Scripts/LevelEditor/Timeline/Timeline.cs

695 lines
25 KiB
C#
Raw Normal View History

2022-01-06 00:11:33 +00:00
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
2022-01-06 00:11:33 +00:00
using TMPro;
2022-01-08 16:42:48 +00:00
using Starpelly;
2022-01-06 00:11:33 +00:00
2022-03-14 14:21:05 +00:00
namespace HeavenStudio.Editor.Track
2022-01-06 00:11:33 +00:00
{
public class Timeline : MonoBehaviour
{
[Header("Song Positions")]
[SerializeField] private TMP_Text SongBeat;
[SerializeField] private TMP_Text SongPos;
[SerializeField] private TMP_Text CurrentTempo;
2022-01-06 00:11:33 +00:00
[Header("Timeline Properties")]
private float lastBeatPos = 0;
private Vector2 lastMousePos;
2022-01-13 03:59:54 +00:00
public List<TimelineEventObj> eventObjs = new List<TimelineEventObj>();
private bool lastFrameDrag;
public int LayerCount = 5;
2022-01-15 17:45:08 +00:00
public bool metronomeEnabled;
2022-01-17 19:23:18 +00:00
public bool resizable;
2022-01-29 02:26:34 +00:00
private bool movingPlayback;
public CurrentTimelineState timelineState = new CurrentTimelineState();
public float snapInterval = 0.25f; // 4/4
public static float SnapInterval() { return instance.snapInterval; }
2022-01-29 02:26:34 +00:00
2022-07-04 15:29:19 +00:00
public void SetSnap(float snap) { snapInterval = snap; }
2022-01-29 02:26:34 +00:00
public class CurrentTimelineState
{
public bool selected;
public bool tempoChange;
public bool musicVolume;
public void SetState(bool selected, bool tempoChange, bool musicVolume)
{
if (Conductor.instance.NotStopped()) return;
this.selected = selected;
this.tempoChange = tempoChange;
this.musicVolume = musicVolume;
if (selected)
instance.SelectionsBTN.transform.GetChild(0).GetComponent<Image>().color = Color.white;
else
instance.SelectionsBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
if (tempoChange)
instance.TempoChangeBTN.transform.GetChild(0).GetComponent<Image>().color = Color.white;
else
instance.TempoChangeBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
if (musicVolume)
instance.MusicVolumeBTN.transform.GetChild(0).GetComponent<Image>().color = Color.white;
else
instance.MusicVolumeBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
}
}
2022-01-06 00:11:33 +00:00
[Header("Timeline Components")]
[SerializeField] private RectTransform TimelineSlider;
2022-01-29 02:26:34 +00:00
[SerializeField] private RectTransform TimelineGridSelect;
[SerializeField] private TMP_Text TimelinePlaybackBeat;
public RectTransform TimelineContent;
[SerializeField] private RectTransform TimelineSongPosLineRef;
2022-01-09 23:35:55 +00:00
[SerializeField] private RectTransform TimelineEventObjRef;
2022-01-14 22:46:14 +00:00
[SerializeField] private RectTransform LayersRect;
2022-06-30 01:58:21 +00:00
public TempoTimeline TempoInfo;
2022-03-19 12:46:38 +00:00
public VolumeTimeline VolumeInfo;
private RectTransform TimelineSongPosLine;
2022-01-06 00:11:33 +00:00
[Header("Timeline Playbar")]
2022-01-23 03:40:53 +00:00
public Button PlayBTN;
public Button PauseBTN;
public Button StopBTN;
public Button MetronomeBTN;
public Button AutoplayBTN;
public Button SelectionsBTN;
public Button TempoChangeBTN;
public Button MusicVolumeBTN;
2022-02-03 07:28:14 +00:00
public Slider PlaybackSpeed;
2022-06-30 01:58:21 +00:00
public Vector3[] LayerCorners = new Vector3[4];
2022-01-11 00:17:29 +00:00
public static Timeline instance { get; private set; }
2022-01-08 16:42:48 +00:00
public bool userIsEditingInputField
{
get
{
var selectedGO = EventSystem.current.currentSelectedGameObject;
return selectedGO != null && (selectedGO.GetComponent<InputField>() != null || selectedGO.GetComponent<TMP_InputField>() != null);
}
}
2022-01-06 00:11:33 +00:00
#region Initializers
2022-01-30 12:03:37 +00:00
public void LoadRemix()
2022-01-06 00:11:33 +00:00
{
2022-07-04 14:28:40 +00:00
// beatmap entities
2022-01-30 12:03:37 +00:00
for (int i = 0; i < eventObjs.Count; i++)
{
Destroy(eventObjs[i].gameObject);
}
eventObjs.Clear();
2022-01-11 00:17:29 +00:00
2022-01-08 16:42:48 +00:00
for (int i = 0; i < GameManager.instance.Beatmap.entities.Count; i++)
{
2022-01-13 03:59:54 +00:00
var e = GameManager.instance.Beatmap.entities[i];
2022-01-23 03:40:53 +00:00
AddEventObject(e.datamodel, false, new Vector3(e.beat, -e.track * LayerHeight()), e, false, RandomID());
2022-01-08 16:42:48 +00:00
}
2022-07-04 14:28:40 +00:00
//tempo changes
TempoInfo.ClearTempoTimeline();
for (int i = 0; i < GameManager.instance.Beatmap.tempoChanges.Count; i++)
{
var t = GameManager.instance.Beatmap.tempoChanges[i];
TempoInfo.AddTempoChange(false, t);
}
//volume changes
2022-01-30 12:03:37 +00:00
}
public void Init()
{
instance = this;
LoadRemix();
TimelineSlider.GetChild(0).GetComponent<Image>().color = EditorTheme.theme.properties.BeatMarkerCol.Hex2RGB();
TimelineSlider.GetChild(1).GetComponent<Image>().color = EditorTheme.theme.properties.BeatMarkerCol.Hex2RGB();
TimelineSlider.GetChild(2).GetComponent<TMP_Text>().color = EditorTheme.theme.properties.BeatMarkerCol.Hex2RGB();
TimelineSlider.GetChild(3).GetComponent<TMP_Text>().color = EditorTheme.theme.properties.BeatMarkerCol.Hex2RGB();
TimelineSongPosLineRef.GetComponent<Image>().color = EditorTheme.theme.properties.CurrentTimeMarkerCol.Hex2RGB();
PlayBTN.onClick.AddListener(delegate
{
if (Conductor.instance.isPaused)
PlayCheck(false);
else
PlayCheck(true);
});
PauseBTN.onClick.AddListener(delegate
{
if (Conductor.instance.isPlaying && !Conductor.instance.isPaused)
PlayCheck(false);
});
StopBTN.onClick.AddListener(delegate
{
if (Conductor.instance.isPlaying || Conductor.instance.isPaused)
PlayCheck(true);
});
2022-01-15 17:45:08 +00:00
MetronomeBTN.onClick.AddListener(delegate
{
MetronomeToggle();
2022-01-15 17:45:08 +00:00
});
2022-01-23 03:40:53 +00:00
AutoplayBTN.onClick.AddListener(delegate
{
AutoPlayToggle();
2022-01-23 03:40:53 +00:00
});
2022-01-29 02:26:34 +00:00
SelectionsBTN.onClick.AddListener(delegate
{
timelineState.SetState(true, false, false);
});
TempoChangeBTN.onClick.AddListener(delegate
{
timelineState.SetState(false, true, false);
});
MusicVolumeBTN.onClick.AddListener(delegate
{
timelineState.SetState(false, false, true);
});
Tooltip.AddTooltip(SongBeat.gameObject, "Current Beat");
Tooltip.AddTooltip(SongPos.gameObject, "Current Time");
Tooltip.AddTooltip(CurrentTempo.gameObject, "Current Tempo (BPM)");
2022-01-18 00:40:23 +00:00
Tooltip.AddTooltip(PlayBTN.gameObject, "Play <color=#adadad>[Space]</color>");
Tooltip.AddTooltip(PauseBTN.gameObject, "Pause <color=#adadad>[Shift + Space]</color>");
Tooltip.AddTooltip(StopBTN.gameObject, "Stop <color=#adadad>[Space]</color>");
2022-01-23 03:40:53 +00:00
Tooltip.AddTooltip(MetronomeBTN.gameObject, "Metronome <color=#adadad>[M]</color>");
Tooltip.AddTooltip(AutoplayBTN.gameObject, "Autoplay <color=#adadad>[P]</color>");
Tooltip.AddTooltip(SelectionsBTN.gameObject, "Tool: Selection <color=#adadad>[1]</color>");
Tooltip.AddTooltip(TempoChangeBTN.gameObject, "Tool: Tempo Change <color=#adadad>[2]</color>");
Tooltip.AddTooltip(MusicVolumeBTN.gameObject, "Tool: Music Volume <color=#adadad>[3]</color>");
2022-02-03 07:28:14 +00:00
Tooltip.AddTooltip(PlaybackSpeed.gameObject, "The preview's playback speed. Right click to reset to 1.0");
SetTimeButtonColors(true, false, false);
2022-01-15 17:45:08 +00:00
MetronomeBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
2022-01-29 02:26:34 +00:00
timelineState.SetState(true, false, false);
AutoBtnUpdate();
}
public void FitToSong()
{
var currentSizeDelta = TimelineContent.sizeDelta;
float songBeats = Conductor.instance.SongLengthInBeats();
if (songBeats == 0) songBeats = 320;
else songBeats += 10;
TimelineContent.sizeDelta = new Vector2(songBeats, currentSizeDelta.y);
}
public void AutoBtnUpdate()
{
var animName = GameManager.instance.autoplay ? "Idle" : "Disabled";
AutoplayBTN.GetComponent<Animator>().Play(animName, 0, 0);
2022-01-06 00:11:33 +00:00
}
public void AutoPlayToggle()
{
if (!GameManager.instance.autoplay)
{
AutoplayBTN.GetComponent<Animator>().Play("Idle", 0, 0);
GameManager.instance.autoplay = true;
}
else
{
AutoplayBTN.GetComponent<Animator>().Play("Disabled", 0, 0);
GameManager.instance.autoplay = false;
}
}
public void MetronomeToggle()
{
if (!Conductor.instance.metronome)
{
MetronomeBTN.transform.GetChild(0).GetComponent<Image>().color = "009FC6".Hex2RGB();
Conductor.instance.metronome = true;
}
else
{
MetronomeBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
Conductor.instance.metronome = false;
}
}
2022-01-23 03:40:53 +00:00
public static string RandomID()
{
return Starpelly.Random.Strings.RandomString(Starpelly.Enums.Strings.StringType.Alphanumeric, 128);
}
2022-01-06 00:11:33 +00:00
#endregion
private void Update()
{
if (!Conductor.instance.isPlaying && !Conductor.instance.isPaused)
{
SongBeat.text = $"Beat {string.Format("{0:0.000}", TimelineSlider.localPosition.x)}";
SongPos.text = FormatTime(Conductor.instance.GetSongPosFromBeat(TimelineSlider.localPosition.x));
}
else
{
SongBeat.text = $"Beat {string.Format("{0:0.000}", Conductor.instance.songPositionInBeats)}";
SongPos.text = FormatTime(Conductor.instance.songPosition);
}
2022-01-06 00:11:33 +00:00
SliderControl();
2022-01-06 00:11:33 +00:00
2022-07-02 02:03:15 +00:00
#region Keyboard Shortcuts
if (!userIsEditingInputField)
2022-01-06 00:11:33 +00:00
{
2022-07-02 02:03:15 +00:00
if (Input.GetKeyDown(KeyCode.Space))
2022-01-06 00:11:33 +00:00
{
if (Input.GetKey(KeyCode.LeftShift))
{
PlayCheck(false);
}
else
{
PlayCheck(true);
}
2022-01-06 00:11:33 +00:00
}
2022-07-02 02:03:15 +00:00
if (Input.GetKeyDown(KeyCode.P))
{
AutoPlayToggle();
2022-07-02 02:03:15 +00:00
}
2022-07-02 02:03:15 +00:00
if (Input.GetKeyDown(KeyCode.M))
{
MetronomeToggle();
2022-07-02 02:03:15 +00:00
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
timelineState.SetState(true, false, false);
}
else if (Input.GetKeyDown(KeyCode.Alpha2))
{
timelineState.SetState(false, true, false);
}
else if (Input.GetKeyDown(KeyCode.Alpha3))
{
timelineState.SetState(false, false, true);
}
2022-07-02 02:03:15 +00:00
float moveSpeed = 750;
if (Input.GetKey(KeyCode.LeftShift)) moveSpeed *= 2;
if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A))
{
TimelineContent.transform.localPosition += new Vector3(moveSpeed * Time.deltaTime, 0);
}
else if (Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.D))
{
TimelineContent.transform.localPosition += new Vector3(-moveSpeed * Time.deltaTime, 0);
}
}
#endregion
2022-01-06 00:11:33 +00:00
if (Input.GetMouseButton(1) && !Conductor.instance.isPlaying && Editor.MouseInRectTransform(TimelineGridSelect))
2022-01-29 02:26:34 +00:00
{
movingPlayback = true;
}
else if (Input.GetMouseButtonUp(1) || Conductor.instance.isPlaying)
2022-01-29 02:26:34 +00:00
{
movingPlayback = false;
}
if (movingPlayback)
{
RectTransformUtility.ScreenPointToLocalPointInRectangle(TimelineContent, Input.mousePosition, Editor.instance.EditorCamera, out lastMousePos);
TimelineSlider.localPosition = new Vector3(Mathf.Max(Mathp.Round2Nearest(lastMousePos.x + 0.12f, Timeline.SnapInterval()), 0), TimelineSlider.transform.localPosition.y);
2022-01-15 18:46:50 +00:00
if (TimelineSlider.localPosition.x != lastBeatPos)
Conductor.instance.SetBeat(TimelineSlider.transform.localPosition.x);
lastBeatPos = TimelineSlider.localPosition.x;
}
2022-01-19 05:40:49 +00:00
if (Conductor.instance.isPlaying)
TimelineContent.transform.localPosition = new Vector3((-Conductor.instance.songPositionInBeats * 100) + 200, TimelineContent.transform.localPosition.y);
TimelineContent.transform.localPosition = new Vector3(Mathf.Clamp(TimelineContent.transform.localPosition.x, Mathf.NegativeInfinity, 0), TimelineContent.transform.localPosition.y);
CurrentTempo.text = $" = {Conductor.instance.songBpm}";
2022-01-29 21:59:20 +00:00
2022-06-30 01:58:21 +00:00
LayersRect.GetWorldCorners(LayerCorners);
}
public static float GetScaleModifier()
{
Camera cam = Editor.instance.EditorCamera;
2022-07-02 02:03:15 +00:00
return Mathf.Pow(cam.pixelWidth/1280f, 1f) * Mathf.Pow(cam.pixelHeight/720f, 0f);
2022-06-30 01:58:21 +00:00
}
public Vector2 LayerCornersToDist()
{
Vector3[] v = LayerCorners;
return new Vector2(Mathf.Abs(v[1].x - v[2].x), Mathf.Abs(v[3].y - v[1].y));
2022-01-06 00:11:33 +00:00
}
private void SliderControl()
{
TimelinePlaybackBeat.text = $"Beat {string.Format("{0:0.000}", TimelineSlider.localPosition.x)}";
if (TimelineSongPosLine != null)
2022-01-06 00:11:33 +00:00
{
2022-01-14 22:46:14 +00:00
TimelineSongPosLine.transform.localPosition = new Vector3(Conductor.instance.songPositionInBeats, TimelineSongPosLine.transform.localPosition.y);
TimelineSongPosLine.transform.localScale = new Vector3(1f / TimelineContent.transform.localScale.x, TimelineSongPosLine.transform.localScale.y, 1);
2022-01-06 00:11:33 +00:00
}
}
#region PlayChecks
public void PlayCheck(bool fromStart)
{
if (fromStart)
{
if (!Conductor.instance.isPlaying && !Conductor.instance.isPaused)
2022-01-08 16:42:48 +00:00
{
Play(false, TimelineSlider.transform.localPosition.x);
}
2022-01-06 00:11:33 +00:00
else
2022-01-08 16:42:48 +00:00
{
Stop(TimelineSlider.transform.localPosition.x);
}
2022-01-06 00:11:33 +00:00
}
else
{
if (!Conductor.instance.isPlaying)
2022-01-06 00:11:33 +00:00
{
if (TimelineSongPosLine == null)
{
Play(false, TimelineSlider.transform.localPosition.x);
}
else
{
Play(false, TimelineSongPosLine.transform.localPosition.x);
}
2022-01-06 00:11:33 +00:00
}
else if (!Conductor.instance.isPaused)
2022-01-06 00:11:33 +00:00
{
Pause();
}
}
}
2022-01-08 16:42:48 +00:00
public void Play(bool fromStart, float time)
2022-01-06 00:11:33 +00:00
{
2022-01-08 16:42:48 +00:00
// if (fromStart) Stop();
if (!Conductor.instance.isPaused)
{
TimelineSongPosLine = Instantiate(TimelineSongPosLineRef, TimelineSongPosLineRef.parent).GetComponent<RectTransform>();
TimelineSongPosLine.gameObject.SetActive(true);
}
GameManager.instance.Play(time);
SetTimeButtonColors(false, true, true);
2022-01-06 00:11:33 +00:00
}
public void Pause()
{
// isPaused = true;
GameManager.instance.Pause();
SetTimeButtonColors(true, false, true);
2022-01-06 00:11:33 +00:00
}
2022-01-08 16:42:48 +00:00
public void Stop(float time)
2022-01-06 00:11:33 +00:00
{
// isPaused = true;
// timelineSlider.value = 0;
if (TimelineSongPosLine != null)
Destroy(TimelineSongPosLine.gameObject);
GameManager.instance.Stop(time);
SetTimeButtonColors(true, false, false);
}
public void SetTimeButtonColors(bool playEnabled, bool pauseEnabled, bool stopEnabled)
{
if (playEnabled)
{
PlayBTN.transform.GetChild(0).GetComponent<Image>().color = Color.green;
PlayBTN.enabled = true;
}
else
{
PlayBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
PlayBTN.enabled = false;
}
if (pauseEnabled)
{
PauseBTN.enabled = true;
PauseBTN.transform.GetChild(0).GetComponent<Image>().color = Color.blue;
}
else
{ PauseBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
PauseBTN.enabled = false;
}
if (stopEnabled)
{
StopBTN.enabled = true;
StopBTN.transform.GetChild(0).GetComponent<Image>().color = Color.red;
}
else
{
StopBTN.transform.GetChild(0).GetComponent<Image>().color = Color.gray;
StopBTN.enabled = false;
}
2022-01-06 00:11:33 +00:00
}
#endregion
#region Extras
private string FormatTime(float time)
{
int minutes = (int)time / 60;
int seconds = (int)time - 60 * minutes;
int milliseconds = (int)(1000 * (time - minutes * 60 - seconds));
return string.Format("{0:00}:{1:00}:{2:000}", minutes, seconds, milliseconds);
}
2022-01-11 00:17:29 +00:00
public bool CheckIfMouseInTimeline()
{
2022-02-03 08:25:27 +00:00
return (this.gameObject.activeSelf && RectTransformUtility.RectangleContainsScreenPoint(TimelineContent.transform.parent.gameObject.GetComponent<RectTransform>(), Input.mousePosition, Editor.instance.EditorCamera));
2022-01-11 00:17:29 +00:00
}
#endregion
#region Functions
public TimelineEventObj AddEventObject(string eventName, bool dragNDrop = false, Vector3 pos = new Vector3(), Beatmap.Entity entity = null, bool addEvent = false, string eventId = "")
2022-01-11 00:17:29 +00:00
{
GameObject g = Instantiate(TimelineEventObjRef.gameObject, TimelineEventObjRef.parent);
2022-01-13 03:59:54 +00:00
g.transform.localPosition = pos;
2022-01-17 20:08:32 +00:00
g.transform.GetChild(3).GetComponent<TMP_Text>().text = eventName.Split('/')[1];
2022-01-11 00:17:29 +00:00
TimelineEventObj eventObj = g.GetComponent<TimelineEventObj>();
2022-01-15 18:46:50 +00:00
if (eventName.Split(1) == "switchGame")
eventObj.Icon.sprite = Editor.GameIcon(eventName.Split(2));
else
2022-01-11 00:17:29 +00:00
eventObj.Icon.sprite = Editor.GameIcon(eventName.Split(0));
2022-01-17 19:23:18 +00:00
Minigames.GameAction gameAction = EventCaller.instance.GetGameAction(EventCaller.instance.GetMinigame(eventName.Split(0)), eventName.Split(1));
2022-01-11 00:17:29 +00:00
if (gameAction != null)
{
2022-01-17 19:23:18 +00:00
if (gameAction.resizable == false)
{
g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength, LayerHeight());
float length = gameAction.defaultLength;
eventObj.length = length;
}
else
{
eventObj.resizable = true;
2022-01-24 02:15:23 +00:00
if (entity != null && gameAction.defaultLength != entity.length && dragNDrop == false)
2022-01-17 19:23:18 +00:00
{
g.GetComponent<RectTransform>().sizeDelta = new Vector2(entity.length, LayerHeight());
2022-01-17 19:23:18 +00:00
}
else
{
g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength, LayerHeight());
}
}
2022-01-11 00:17:29 +00:00
}
g.SetActive(true);
if (dragNDrop)
{
2022-02-03 08:25:27 +00:00
var mousePos = Editor.instance.EditorCamera.ScreenToWorldPoint(Input.mousePosition);
g.transform.position = new Vector3(mousePos.x, mousePos.y, 0);
Selections.instance.ClickSelect(eventObj);
eventObj.moving = true;
}
else
{
entity.eventObj = g.GetComponent<TimelineEventObj>();
entity.track = entity.eventObj.GetTrack();
2022-01-11 00:17:29 +00:00
}
2022-01-12 03:29:27 +00:00
if (addEvent)
{
Beatmap.Entity tempEntity = entity;
if (entity == null)
{
Beatmap.Entity en = new Beatmap.Entity();
en.datamodel = eventName;
en.eventObj = eventObj;
GameManager.instance.Beatmap.entities.Add(en);
GameManager.instance.SortEventsList();
tempEntity = en;
2022-07-04 17:09:23 +00:00
// default param value
var game = EventCaller.instance.GetMinigame(eventName.Split(0));
var ep = EventCaller.instance.GetGameAction(game, eventName.Split(1)).parameters;
2022-07-04 17:09:23 +00:00
if (ep != null)
{
2022-07-04 17:09:23 +00:00
for (int i = 0; i < ep.Count; i++)
{
2022-07-04 17:09:23 +00:00
object returnVal = ep[i].parameter;
var propertyType = returnVal.GetType();
if (propertyType == typeof(EntityTypes.Integer))
{
returnVal = ((EntityTypes.Integer)ep[i].parameter).val;
}
else if (propertyType == typeof(EntityTypes.Float))
{
returnVal = ((EntityTypes.Float)ep[i].parameter).val;
}
tempEntity[ep[i].propertyName] = returnVal;
}
}
}
2022-07-04 17:09:23 +00:00
else
{
GameManager.instance.Beatmap.entities.Add(entity);
GameManager.instance.SortEventsList();
}
}
2022-01-13 03:59:54 +00:00
eventObjs.Add(eventObj);
eventObj.eventObjID = eventId;
return eventObj;
2022-01-11 00:17:29 +00:00
}
private List<TimelineEventObj> duplicatedEventObjs = new List<TimelineEventObj>();
public TimelineEventObj CopyEventObject(TimelineEventObj e)
2022-07-04 16:57:19 +00:00
{
Beatmap.Entity clone = e.entity.DeepCopy();
2022-07-04 16:57:19 +00:00
TimelineEventObj dup = AddEventObject(clone.datamodel, false, new Vector3(clone.beat, -clone.track * Timeline.instance.LayerHeight()), clone, true, RandomID());
duplicatedEventObjs.Add(dup);
2022-07-04 16:57:19 +00:00
return dup;
}
public void FinalizeDuplicateEventStack()
{
CommandManager.instance.Execute(new Commands.Duplicate(duplicatedEventObjs));
duplicatedEventObjs = new List<TimelineEventObj>();
}
public void DestroyEventObject(Beatmap.Entity entity)
2022-01-12 03:29:27 +00:00
{
if (EventParameterManager.instance.entity == entity)
EventParameterManager.instance.Disable();
2022-01-30 12:03:37 +00:00
eventObjs.Remove(entity.eventObj);
GameManager.instance.Beatmap.entities.Remove(entity);
Timeline.instance.eventObjs.Remove(entity.eventObj);
2022-01-12 03:29:27 +00:00
Destroy(entity.eventObj.gameObject);
GameManager.instance.SortEventsList();
2022-01-12 03:29:27 +00:00
}
2022-01-13 03:59:54 +00:00
public bool IsMouseAboveEvents()
{
return Timeline.instance.eventObjs.FindAll(c => c.mouseHovering == true).Count > 0;
}
public bool InteractingWithEvents()
2022-01-13 03:59:54 +00:00
{
return eventObjs.FindAll(c => c.moving == true).Count > 0 || eventObjs.FindAll(c => c.resizing == true).Count > 0;
2022-01-13 03:59:54 +00:00
}
2022-01-14 22:46:14 +00:00
public float SnapToLayer(float y)
{
float size = LayerHeight();
return Mathf.Clamp(Mathp.Round2Nearest(y, size), -size * 4f, 0f);
2022-01-14 22:46:14 +00:00
}
public float LayerHeight()
{
return LayersRect.rect.height / 5f;
2022-01-14 22:46:14 +00:00
}
2022-02-03 07:28:14 +00:00
public void SetPlaybackSpeed(float speed)
{
float spd = Mathp.Round2Nearest(speed, Timeline.SnapInterval());
2022-02-03 07:28:14 +00:00
PlaybackSpeed.transform.GetChild(3).GetComponent<TMP_Text>().text = $"Playback Speed: {spd}x";
Conductor.instance.musicSource.pitch = spd;
PlaybackSpeed.value = spd;
}
public void ResetPlaybackSpeed()
{
if (Input.GetMouseButton(1))
{
2022-02-03 22:20:26 +00:00
PlaybackSpeed.transform.GetChild(3).GetComponent<TMP_Text>().text = $"Playback Speed: 1x";
2022-02-03 07:28:14 +00:00
PlaybackSpeed.value = 1f;
}
}
2022-01-12 03:29:27 +00:00
#endregion
#region Commands
public void Move()
{
}
public void Undo()
{
}
2022-01-06 00:11:33 +00:00
#endregion
}
}