168 lines
4.9 KiB
GDScript
168 lines
4.9 KiB
GDScript
extends AudioStreamPlayer
|
|
|
|
signal beat_ticked(beat_index: int)
|
|
signal judgement_made(quality: StringName, offset_ms: float)
|
|
signal action_judged(action_name: StringName, rating: Dictionary)
|
|
|
|
@export var bpm: float = 120.0:
|
|
set(value):
|
|
bpm = maxf(1.0, value)
|
|
beat_time = 60.0 / bpm
|
|
@export var measures := 4
|
|
@export var beat_offset := 0.0
|
|
@export var perfect_window := 0.060
|
|
@export var good_window := 0.120
|
|
@export var bad_window := 0.200
|
|
@export var judgement_scale := 1.0
|
|
@export var starts_on_ready := true
|
|
|
|
const DEFAULT_STREAM_PATH := "res://assets/audio/song.ogg"
|
|
|
|
var beat_time := 0.5
|
|
var beat_index := 0
|
|
var running := false
|
|
|
|
var _start_time_usec := 0
|
|
var _last_reported_beat := -1
|
|
|
|
|
|
func _ready() -> void:
|
|
if stream == null and DisplayServer.get_name() != "headless":
|
|
stream = load(DEFAULT_STREAM_PATH)
|
|
volume_db = -10.0
|
|
beat_time = 60.0 / maxf(1.0, bpm)
|
|
var bus := _event_bus_or_null()
|
|
if bus != null and not bus.is_connected("rhythm_action_requested", _on_rhythm_action_requested):
|
|
bus.connect("rhythm_action_requested", _on_rhythm_action_requested)
|
|
if starts_on_ready:
|
|
start()
|
|
|
|
|
|
func _physics_process(_delta: float) -> void:
|
|
if not running:
|
|
return
|
|
var adjusted_position := _apply_beat_offset(song_position())
|
|
beat_index = int(floor(adjusted_position / beat_time))
|
|
if _last_reported_beat < beat_index:
|
|
_last_reported_beat = beat_index
|
|
beat_ticked.emit(beat_index)
|
|
var bus := _event_bus_or_null()
|
|
if bus != null:
|
|
bus.emit_signal("beat_ticked", beat_index)
|
|
|
|
|
|
func configure(next_bpm: float, next_measures: int, next_beat_offset: float, next_windows := Vector3(0.060, 0.120, 0.200)) -> void:
|
|
bpm = next_bpm
|
|
measures = next_measures
|
|
beat_offset = next_beat_offset
|
|
perfect_window = next_windows.x
|
|
good_window = next_windows.y
|
|
bad_window = next_windows.z
|
|
|
|
|
|
func start() -> void:
|
|
running = true
|
|
_start_time_usec = Time.get_ticks_usec()
|
|
beat_index = 0
|
|
_last_reported_beat = -1
|
|
if stream != null and not playing:
|
|
play()
|
|
|
|
|
|
func stop_manager() -> void:
|
|
if playing:
|
|
stop()
|
|
running = false
|
|
|
|
|
|
func _exit_tree() -> void:
|
|
if playing:
|
|
stop()
|
|
stream = null
|
|
|
|
|
|
func song_position() -> float:
|
|
if running and playing:
|
|
var current_position := get_playback_position() + AudioServer.get_time_since_last_mix()
|
|
current_position -= AudioServer.get_output_latency()
|
|
return maxf(0.0, current_position)
|
|
if running:
|
|
return float(Time.get_ticks_usec() - _start_time_usec) / 1000000.0
|
|
return 0.0
|
|
|
|
|
|
func judge(input_timestamp_ms: float) -> Dictionary:
|
|
return get_rating_for_time(input_timestamp_ms / 1000.0)
|
|
|
|
|
|
func judge_action(action_name: StringName) -> Dictionary:
|
|
var rating := get_current_rating()
|
|
rating["action"] = action_name
|
|
action_judged.emit(action_name, rating)
|
|
judgement_made.emit(StringName(str(rating.get("label", "miss"))), float(rating.get("diff", INF)) * 1000.0)
|
|
var bus := _event_bus_or_null()
|
|
if bus != null:
|
|
bus.emit_signal("judgement_made", StringName(str(rating.get("label", "miss"))), float(rating.get("diff", INF)) * 1000.0)
|
|
bus.emit_signal("action_judged", action_name, rating)
|
|
return rating
|
|
|
|
|
|
func get_current_rating() -> Dictionary:
|
|
return get_rating_for_time(song_position())
|
|
|
|
|
|
func get_rating_for_time(time_seconds: float) -> Dictionary:
|
|
var adjusted_time := _apply_beat_offset(time_seconds)
|
|
if adjusted_time < 0.0:
|
|
return _rating_result(&"miss", Color("ff0055"), 0, 0.0, INF, INF)
|
|
|
|
var nearest_beat := int(round(adjusted_time / beat_time))
|
|
var nearest_beat_time := nearest_beat * beat_time
|
|
var diff := adjusted_time - nearest_beat_time
|
|
var abs_diff := absf(diff)
|
|
var scale := maxf(0.01, judgement_scale)
|
|
|
|
if abs_diff <= perfect_window * scale:
|
|
return _rating_result(&"perfect", Color("00f2ff"), nearest_beat, nearest_beat_time, diff, abs_diff)
|
|
if abs_diff <= good_window * scale:
|
|
return _rating_result(&"good", Color("ffffff"), nearest_beat, nearest_beat_time, diff, abs_diff)
|
|
if abs_diff <= bad_window * scale:
|
|
return _rating_result(&"bad", Color("ffaa00"), nearest_beat, nearest_beat_time, diff, abs_diff)
|
|
return _rating_result(&"miss", Color("ff0055"), nearest_beat, nearest_beat_time, diff, abs_diff)
|
|
|
|
|
|
func get_current_beat_progress() -> float:
|
|
return get_beat_progress_for_time(song_position())
|
|
|
|
|
|
func get_beat_progress_for_time(time_seconds: float) -> float:
|
|
var adjusted_time := _apply_beat_offset(time_seconds)
|
|
if adjusted_time < 0.0:
|
|
return 0.0
|
|
return fposmod(adjusted_time, beat_time) / beat_time
|
|
|
|
|
|
func _on_rhythm_action_requested(action_name: StringName) -> void:
|
|
judge_action(action_name)
|
|
|
|
|
|
func _apply_beat_offset(time_seconds: float) -> float:
|
|
return time_seconds + beat_offset
|
|
|
|
|
|
func _rating_result(label: StringName, color: Color, nearest_beat: int, nearest_beat_time: float, diff: float, abs_diff: float) -> Dictionary:
|
|
return {
|
|
"label": str(label),
|
|
"color": color,
|
|
"nearest_beat": nearest_beat,
|
|
"nearest_beat_time": nearest_beat_time,
|
|
"diff": diff,
|
|
"abs_diff": abs_diff,
|
|
}
|
|
|
|
|
|
func _event_bus_or_null() -> Node:
|
|
if not is_inside_tree():
|
|
return null
|
|
return get_tree().root.get_node_or_null("EventBus")
|