132 lines
4.2 KiB
GDScript
132 lines
4.2 KiB
GDScript
extends SceneTree
|
|
|
|
var failures: Array[String] = []
|
|
|
|
|
|
func _init() -> void:
|
|
_run.call_deferred()
|
|
|
|
|
|
func _run() -> void:
|
|
await process_frame
|
|
_check_resources_load()
|
|
await _check_runner_upcoming_and_triggered_once()
|
|
await _check_event_bus_mirroring()
|
|
_finish()
|
|
|
|
|
|
func _check_resources_load() -> void:
|
|
_expect(load("res://resources/chart_event.gd") != null, "ChartEvent script should load")
|
|
_expect(load("res://resources/chart_track.gd") != null, "ChartTrack script should load")
|
|
_expect(load("res://resources/beat_chart.gd") != null, "BeatChart script should load")
|
|
_expect(load("res://scenes/chart/chart_runner.gd") != null, "ChartRunner script should load")
|
|
|
|
|
|
func _make_event(beat: int, event_type: StringName, target_id := &"", lead_beats := 1.0):
|
|
var event_script: Script = load("res://resources/chart_event.gd")
|
|
var event: Resource = event_script.new()
|
|
event.set("beat_index", beat)
|
|
event.set("event_type", event_type)
|
|
event.set("target_id", target_id)
|
|
event.set("lead_beats", lead_beats)
|
|
return event
|
|
|
|
|
|
func _make_chart() -> Resource:
|
|
var chart_script: Script = load("res://resources/beat_chart.gd")
|
|
var track_script: Script = load("res://resources/chart_track.gd")
|
|
var chart: Resource = chart_script.new()
|
|
var track: Resource = track_script.new()
|
|
chart.set("chart_id", &"test_chart")
|
|
track.set("track_id", &"enemy")
|
|
track.set("track_type", &"enemy")
|
|
track.set("events", [
|
|
_make_event(2, &"enemy_prepare_attack", &"test_enemy", 1.0),
|
|
_make_event(3, &"enemy_attack_active", &"test_enemy", 1.0),
|
|
])
|
|
chart.set("tracks", [track])
|
|
return chart
|
|
|
|
|
|
func _make_runner(chart: Resource) -> Node:
|
|
var runner_script: Script = load("res://scenes/chart/chart_runner.gd")
|
|
var runner: Node = runner_script.new()
|
|
runner.set("beat_time_override", 0.5)
|
|
runner.call("set_chart", chart)
|
|
root.add_child(runner)
|
|
return runner
|
|
|
|
|
|
func _check_runner_upcoming_and_triggered_once() -> void:
|
|
var runner := _make_runner(_make_chart())
|
|
var upcoming: Array[StringName] = []
|
|
var triggered: Array[StringName] = []
|
|
runner.connect("chart_event_upcoming", func(event: Resource, _time_to_event: float) -> void:
|
|
upcoming.append(StringName(str(event.get("event_type"))))
|
|
)
|
|
runner.connect("chart_event_triggered", func(event: Resource) -> void:
|
|
triggered.append(StringName(str(event.get("event_type"))))
|
|
)
|
|
|
|
runner.call("update_for_song_time", 0.49)
|
|
_expect(upcoming == [&"enemy_prepare_attack"], "Prepare upcoming should fire at lead window")
|
|
_expect(triggered.is_empty(), "No event should trigger before event time")
|
|
|
|
runner.call("update_for_song_time", 1.0)
|
|
runner.call("update_for_song_time", 1.1)
|
|
_expect(triggered == [&"enemy_prepare_attack"], "Prepare triggered should fire once")
|
|
|
|
runner.call("update_for_song_time", 1.49)
|
|
runner.call("update_for_song_time", 1.50)
|
|
runner.call("update_for_song_time", 1.80)
|
|
_expect(upcoming.count(&"enemy_attack_active") == 1, "Attack upcoming should fire once")
|
|
_expect(triggered.count(&"enemy_attack_active") == 1, "Attack triggered should fire once")
|
|
runner.queue_free()
|
|
await process_frame
|
|
|
|
|
|
func _check_event_bus_mirroring() -> void:
|
|
var bus_script: Script = load("res://autoload/event_bus.gd")
|
|
var bus := root.get_node_or_null("EventBus")
|
|
var owns_bus := false
|
|
if bus == null:
|
|
bus = bus_script.new()
|
|
bus.name = "EventBus"
|
|
root.add_child(bus)
|
|
owns_bus = true
|
|
|
|
var mirrored_upcoming: Array[Resource] = []
|
|
var mirrored_triggered: Array[Resource] = []
|
|
bus.connect("chart_event_upcoming", func(_event: Resource, _time_to_event: float) -> void:
|
|
mirrored_upcoming.append(_event)
|
|
)
|
|
bus.connect("chart_event_triggered", func(_event: Resource) -> void:
|
|
mirrored_triggered.append(_event)
|
|
)
|
|
|
|
var runner := _make_runner(_make_chart())
|
|
runner.call("update_for_song_time", 0.49)
|
|
runner.call("update_for_song_time", 1.0)
|
|
_expect(mirrored_upcoming.size() == 2, "ChartRunner should mirror upcoming events to EventBus")
|
|
_expect(mirrored_triggered.size() == 1, "ChartRunner should mirror triggered events to EventBus")
|
|
|
|
runner.queue_free()
|
|
if owns_bus:
|
|
bus.queue_free()
|
|
await process_frame
|
|
|
|
|
|
func _expect(condition: bool, label: String) -> void:
|
|
if not condition:
|
|
failures.append(label)
|
|
|
|
|
|
func _finish() -> void:
|
|
if failures.is_empty():
|
|
print("PASS chart layer")
|
|
quit(0)
|
|
else:
|
|
for failure: String in failures:
|
|
push_error(failure)
|
|
quit(1)
|