Initial commit. Implement music sync features.

rhythm_game/music_sync/beat_update.gd

@@ -0,0 +1,26 @@
+class_name BeatUpdate
+
+## Beat this frame.
+var current: float
+
+## Beat last frame.
+var previous: float
+
+
+## Beat updated forward in time.
+func forward() -> bool:
+	return current > previous
+
+
+## Beat updated backward in time.
+func backward() -> bool:
+	return current < previous
+
+
+func new_beat() -> bool:
+	return floori(previous) != floori(current)
+
+
+func _init(current_beat: float = 0.0, previous_beat: float = 0.0) -> void:
+	current = current_beat
+	previous = previous_beat

rhythm_game/music_sync/beat_update.gd.uid

@@ -0,0 +1 @@
+uid://dyjoi5i3iha0h

rhythm_game/music_sync/conductor.gd

@@ -0,0 +1,142 @@
+## Class for playing music and providing an interface to keep events in sync.
+class_name Conductor extends Node
+
+## If true, start immediately when ready.
+@export var autostart: bool = false
+
+## Music to play.
+@export var music: Music
+
+signal started
+signal ticked(beat_update: BeatUpdate)
+signal ticked_forward(new_beat: float)
+#signal ticked_backward(new_beat: float)
+signal finished
+
+
+func start() -> void:
+	assert(music != null)
+	assert(_audio_player != null)
+	
+	_stop_playback_and_initialize()
+	_active = true
+	started.emit()
+
+
+func is_active() -> bool:
+	return _active
+
+
+func current_time() -> float:
+	return(_audio_player.get_playback_position() +
+		AudioServer.get_time_since_last_mix() +
+		_music_offset - _remaining_silence)
+
+
+func previous_time() -> float:
+	return _previous_time
+
+
+func current_beat() -> float:
+	return _sync_track.to_beat(current_time())
+
+
+func previous_beat() -> float:
+	return _previous_beat
+
+
+func current_bpm() -> float:
+	return _sync_track.bpm_at_time(current_time())
+
+
+func add_time(seconds: float) -> void:
+	if _audio_player == null:
+		return
+	_audio_player.seek(_audio_player.get_playback_position() + seconds)
+	_previous_time = current_time()
+	_previous_beat = current_beat()
+
+
+
+# ====== IMPLEMENTATION ====== #
+
+var _active: bool = false
+
+var _previous_time: float = -1.0
+var _previous_beat: float = -1.0
+
+var _audio_player: AudioStreamPlayer = null
+var _sync_track: SyncTrack = SyncTrack.new()
+
+var _music_offset: float
+var _music_playing: bool = false
+var _remaining_silence: float = 0.0
+
+
+func _ready() -> void:
+	_audio_player = AudioStreamPlayer.new()
+	add_child(_audio_player)
+	_audio_player.finished.connect(_on_music_finished)
+	
+	if autostart:
+		start()
+
+
+func _on_music_finished() -> void:
+	_music_playing = false
+	_active = false
+	finished.emit()
+
+
+func _process(delta: float) -> void:
+	if not _active:
+		return
+	
+	if _music_playing:
+		_beat_update()
+	else:
+		_update_silence(delta)
+
+
+func _update_silence(elapsed_time: float) -> void:
+	_remaining_silence -= elapsed_time
+	
+	if _remaining_silence < 0:
+		_play_music_from_offset(-_remaining_silence)
+		_remaining_silence = 0.0
+
+
+func _beat_update() -> void:
+	var _current_time = current_time()
+	
+	# _audio_player.get_playback_position() used in current_time()
+	# is not perfect and may return a lesser value than last frame.
+	# This makes sure the beat never updates backward.
+	if _current_time <= _previous_time:
+		return
+	
+	var _current_beat = _sync_track.to_beat(_current_time)
+	ticked.emit(BeatUpdate.new(_current_beat, _previous_beat))
+	ticked_forward.emit(_current_beat)
+	
+	_previous_beat = _current_beat
+	_previous_time = _current_time
+
+
+func _stop_playback_and_initialize() -> void:
+	if _audio_player.playing:
+		_audio_player.stop()
+	
+	_active = false
+	_music_playing = false
+	_previous_time = -1.0
+	_previous_beat = -1.0
+	_music_offset = music.offset
+	_remaining_silence = _music_offset
+	_audio_player.stream = music.stream
+	_sync_track.initialize(music.tempo)
+
+
+func _play_music_from_offset(offset: float) -> void:
+	_audio_player.play(offset)
+	_music_playing = true

rhythm_game/music_sync/conductor.gd.uid

@@ -0,0 +1 @@
+uid://s16dt0bu0jrg

rhythm_game/music_sync/event_layout.gd

@@ -0,0 +1,25 @@
+class_name EventLayout extends Node
+
+#var _beats: Array[float]
+#var _callables: Array[Callable]
+#var _index: int = 0
+
+### Schedule the callable to be called on the specified beat.
+#func schedule(beat: float, callable: Callable) -> void:
+	#var i := schedule_beats.find_custom(func(s_beat: float): return s_beat > beat )
+	#if i == -1:
+		#i = schedule_beats.size()
+	#schedule_beats.insert(i, beat)
+	#schedule_callables.insert(i, callable)
+#
+### Clears all scheduled callables.
+#func reset_schedule() -> void:
+	#schedule_beats.clear()
+	#schedule_callables.clear()
+	#schedule_index = 0
+
+#
+#while(schedule_index < schedule_beats.size()
+			#and get_beat() >= schedule_beats.get(schedule_index)):
+		#schedule_callables.get(schedule_index).call()
+		#schedule_index += 1

rhythm_game/music_sync/event_layout.gd.uid

@@ -0,0 +1 @@
+uid://102cl75cfpgw

rhythm_game/music_sync/sync_track.gd

@@ -0,0 +1,167 @@
+## Class for converting beats to time (since start of music) and vice versa.
+class_name SyncTrack extends Node
+
+
+func initialize(tempo: Tempo) -> void:
+	_set_bpm_data(tempo)
+	_calculate_cache()
+
+
+## Get the number of valid BPM changes.
+func size() -> int:
+	return min(_bpms.size(), _lengths.size() + 1)
+
+
+## Get the BPM at the given time (since music start).
+func bpm_at_time(time: float) -> float:
+	var i: int = _get_bpm_index_at_time(time)
+	if _types[i] == Tempo.BPM_TYPE.LINEAR:
+		var delta = inverse_lerp(_elapsed_seconds[i], _elapsed_seconds[i+1], time)
+		return lerp(_bpms[i], _bpms[i+1], delta)
+	else:
+		return _bpms.get(i)
+
+
+## Get the beat at the given time (since music start).
+func to_beat(time: float) -> float:
+	var i: int = _get_bpm_index_at_time(time)
+	
+	# If i is not the last BPM:
+	if i < _bpms.size() - 1:
+		var delta = inverse_lerp(_elapsed_seconds[i], _elapsed_seconds[i+1], time)
+		return lerp(_elapsed_beats[i], _elapsed_beats[i+1], delta)
+	
+	# Else i is the last BPM:
+	else:
+		var bps: float = _bpms[i] / 60.0
+		var remaining_seconds: float = time - _elapsed_seconds[i]
+		var remaining_beats: float = remaining_seconds * bps
+		return _elapsed_beats[i] + remaining_beats
+
+
+## Get the time (since music start) at the given beat.
+func to_time(beat: float) -> float:
+	var i: int = _get_bpm_index_at_beat(beat)
+	
+	if i == -1:
+		return -1.0
+	
+	# Else if i is not the last BPM:
+	elif i < _bpms.size() - 1:
+		var delta = inverse_lerp(_elapsed_beats[i], _elapsed_beats[i+1], beat)
+		return lerp(_elapsed_seconds[i], _elapsed_seconds[i+1], delta)
+	
+	# Else i is the last BPM:
+	else:
+		var bps: float = _bpms[i] / 60.0
+		var remaining_beats: float = beat - _elapsed_beats[i]
+		var remaining_seconds: float = remaining_beats / bps
+		return _elapsed_seconds[i] + remaining_seconds
+
+
+func _init(tempo: Tempo = Tempo.new()) -> void:
+	initialize(tempo)
+
+
+# IMPLEMENTATION
+
+# === Note about BPM data ===
+# The data for each BPM is stored in the same index
+# across the different arrays.
+# ===========================
+
+## BPM array (Beats per Minute).
+var _bpms: Array[float]
+## The duration of each BPM in beats.
+var _lengths: Array[float]
+## The BpmData.BPM_TYPE of each BPM.
+var _types: Array[Tempo.BPM_TYPE]
+
+# Cache variables that make calculations easier.
+## The duration of each BPM in seconds.
+var _length_seconds: Array[float]
+## Seconds passed before the corresponding BPM.
+var _elapsed_seconds: Array[float] = [0.0]
+## Beats passed before the corresponding BPM.
+var _elapsed_beats: Array[float] = [0.0]
+
+
+## Set the BPM data arrays.
+func _set_bpm_data(tempo: Tempo) -> void:
+	
+	_clear_bpm_data()
+	tempo.normalize()
+	_bpms = tempo.bpms
+	_lengths = tempo.lengths
+	_types = tempo.types
+
+
+func _calculate_cache() -> void:
+	_clear_cache()
+	for i: int in range(0, _bpms.size() - 1):
+		var bps: float
+		var length_in_beats: float = _lengths[i]
+		if _types[i] == Tempo.BPM_TYPE.LINEAR:
+			# Average BPS.
+			bps = (_bpms[i] + _bpms[i+1]) / 120.0
+		else:
+			bps = _bpms[i] / 60.0
+		var length_in_seconds: float = length_in_beats / bps
+		
+		_length_seconds.append(length_in_seconds)
+		_elapsed_seconds.append(_elapsed_seconds.back() + length_in_seconds)
+		_elapsed_beats.append(_elapsed_beats.back() + length_in_beats)
+	
+	if _length_seconds.size() > 0:
+		_length_seconds[-1] = -1.0
+
+
+func _clear_bpm_data() -> void:
+	_bpms = []
+	_lengths = []
+	_types = []
+
+
+func _clear_cache() -> void:
+	_length_seconds = []
+	_elapsed_seconds = [0.0]
+	_elapsed_beats = [0.0]
+
+
+func _get_bpm_index_at_time(time: float) -> int:
+	assert(_elapsed_seconds.size() > 0)
+	assert(_bpms.size() > 0)
+	
+	var _find_index: Callable = func (p_elapsed_seconds: float) -> bool:
+		return time < p_elapsed_seconds
+	
+	var index: int = _elapsed_seconds.find_custom(_find_index)
+	if index == -1:
+		index = _bpms.size() - 1
+	else:
+		index -= 1
+	return index
+
+
+func _get_bpm_index_at_beat(beat: float) -> int:
+	var _find_index: Callable = func (p_elapsed_beats: float) -> bool:
+		return beat < p_elapsed_beats
+	
+	if _elapsed_beats.size() == 0:
+		return -1
+	
+	var index: int = _elapsed_beats.find_custom(_find_index)
+	if index > 0:
+		index -= 1
+	elif index == -1:
+		index = max(0, _bpms.size()-1)
+	return index
+
+
+func _print_data() -> void:
+	print("=== SyncTrack ===")
+	print("BPMs: ", _bpms)
+	print("BPM Lengths (Beats): ", _lengths)
+	print("BPM Types: ", _types)
+	print("Elapsed Seconds: ", _elapsed_seconds)
+	print("Elapsed Beats: ", _elapsed_beats)

rhythm_game/music_sync/sync_track.gd.uid

@@ -0,0 +1 @@
+uid://wbqg55ld6py5