Refactor rhythm action architecture

autoload/combat_manager.gd

@@ -0,0 +1,68 @@
+extends Node
+
+
+func resolve_damage(base_attack: float, action: Resource, judgement: Dictionary, buffs: Variant = null, burst: Variant = null) -> float:
+	var action_mult := _resource_float(action, "damage_mult", 1.0)
+	var judgement_mult := _judgement_mult(judgement)
+	var buff_mult := _provider_mult(buffs, "damage_mult", action)
+	var burst_mult := _provider_mult(burst, "damage_mult", action)
+	return base_attack * action_mult * judgement_mult * buff_mult * burst_mult
+
+
+func resolve_cost(action: Resource, burst: Variant = null) -> float:
+	var base_cost := _resource_float(action, "base_cost", 0.0)
+	var cost := base_cost if base_cost > 0.0 else _resource_float(action, "energy_cost", 0.0)
+	var burst_mult := _provider_mult(burst, "cost_mult", action)
+	return maxf(0.0, cost * burst_mult)
+
+
+func resolve_move(action: Resource, judgement: Dictionary, burst: Variant = null) -> Vector2:
+	var judgement_mult := _dict_float(judgement, "move_mult", 1.0)
+	var burst_mult := _provider_mult(burst, "move_mult", action)
+	return Vector2(
+		_resource_float(action, "move_mult_x", 0.0),
+		_resource_float(action, "move_mult_y", 0.0)
+	) * judgement_mult * burst_mult
+
+
+func _judgement_damage_mult(label: StringName) -> float:
+	match label:
+		&"perfect":
+			return 1.25
+		&"good":
+			return 1.0
+		&"bad":
+			return 0.75
+		_:
+			return 0.0
+
+
+func _judgement_mult(judgement: Dictionary) -> float:
+	if judgement.has("damage_mult"):
+		return float(judgement["damage_mult"])
+	if judgement.has("label"):
+		return _judgement_damage_mult(StringName(str(judgement["label"])))
+	return 1.0
+
+
+func _resource_float(resource: Resource, property_name: String, fallback: float) -> float:
+	if resource == null:
+		return fallback
+	var value = resource.get(property_name)
+	if value == null:
+		return fallback
+	return float(value)
+
+
+func _dict_float(values: Dictionary, key: String, fallback: float) -> float:
+	if not values.has(key):
+		return fallback
+	return float(values[key])
+
+
+func _provider_mult(provider, method_name: String, action: Resource) -> float:
+	if provider == null:
+		return 1.0
+	if provider.has_method(method_name):
+		return float(provider.call(method_name, action))
+	return 1.0

autoload/combat_manager.gd.uid

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

autoload/event_bus.gd

@@ -0,0 +1,19 @@
+extends Node
+
+signal rhythm_action_requested(action_name: StringName)
+signal beat_ticked(beat_index: int)
+signal judgement_made(quality: StringName, offset_ms: float)
+signal action_judged(action_name: StringName, rating: Dictionary)
+signal chart_event_upcoming(event: Resource, time_to_event: float)
+signal chart_event_triggered(event: Resource)
+signal chart_reset(chart_id: StringName)
+
+signal skill_executed(skill: Resource, judgement: StringName)
+signal projectile_requested(projectile_scene: PackedScene, spawn_position: Vector2, direction: Vector2)
+signal damage_dealt(target: Node, amount: int, hit_type: StringName)
+
+signal player_health_changed(current: int, max_value: int)
+signal player_energy_changed(current: float, max_value: float)
+signal player_charge_changed(current: float, max_value: float, ready: bool, active: bool)
+signal combo_updated(inputs: Array[StringName])
+signal combo_cleared(reason: StringName)

autoload/event_bus.gd.uid

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

autoload/rhythm_manager.gd

@@ -0,0 +1,167 @@
+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")

autoload/rhythm_manager.gd.uid

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

docs/superpowers/plans/2026-07-02-chart-layer.md

@@ -0,0 +1,992 @@
+# Chart Layer Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a thin, testable Chart Layer that turns beat-indexed battle data into upcoming and triggered chart events for UI, enemies, hazards, and future boss patterns.
+
+**Architecture:** Keep `RhythmManager` as the only music clock and rhythm judgement service. Add chart resources plus a scene-owned `ChartRunner` that reads `RhythmManager.song_position()`, emits chart events once, and mirrors those events through `EventBus` for UI/world listeners. Do not make `ChartRunner` an autoload; a chart belongs to a song, room, or encounter, not to the whole app.
+
+**Tech Stack:** Godot 4.6, GDScript, Resource `.tres` data model, existing `EventBus`, existing `RhythmManager`, existing headless Godot test scripts.
+
+---
+
+## Current Project Reading
+
+The project already has a good player-side rhythm action foundation:
+
+- `RhythmManager` is an autoload clock and judgement provider: `autoload/rhythm_manager.gd`.
+- `EventBus` broadcasts rhythm, judgement, skill, projectile, damage, player resource, and combo UI events: `autoload/event_bus.gd`.
+- `InputComponent` creates timestamped `InputIntent` objects: `scenes/components/input_component.gd`.
+- `ActionController` owns intent judgement, combo recording, action phase timing, pending intent replacement, and startup/active/recovery flow: `scenes/components/action_controller.gd`.
+- `ComboWindow` keeps explicit inputs and explicit `Ø` Miss placeholders; it does not auto-fill empty beats: `scenes/components/combo_window.gd`.
+- `ActionData` resources and `ActionResolver` already make player actions data-driven: `resources/action_data.gd`, `resources/actions/*.tres`, `scenes/combat/action_resolver.gd`.
+- `RhythmTrack` currently reacts to `beat_ticked` and `action_judged`, but it has no knowledge of future chart events: `scenes/ui/rhythm_track.gd`.
+- `ActorsContainer` currently manages spawned projectiles only; there is not yet a real enemy container or enemy behavior layer: `scenes/stage/actors_container.gd`.
+
+The Chart Layer should therefore avoid touching the player input/action pipeline. It should add a parallel world-timeline pipeline.
+
+## The Actual Problem Chart Layer Solves
+
+Right now the project has a clock, but not a battle timeline.
+
+Current flow:
+
+```text
+RhythmManager
+  -> beat_ticked(beat_index)
+  -> UI / BurstComponent / future enemies listen directly
+```
+
+This works while the game is only a player combo sandbox. It becomes fragile when enemies, hazards, boss patterns, camera hits, accents, and tutorial prompts need to happen on specific beats.
+
+Without Chart Layer, each future system will likely write its own beat math:
+
+```gdscript
+func _on_beat_ticked(beat_index: int) -> void:
+	if beat_index % 4 == 2:
+		show_warning()
+	elif beat_index % 4 == 3:
+		attack()
+```
+
+That creates four problems:
+
+1. **Battle timing is scattered.** Enemy scripts, UI scripts, stage scripts, and boss scripts all become tiny schedule owners.
+2. **UI cannot reliably preview future danger.** A `beat_ticked` signal tells listeners what just happened, not what will happen one beat from now.
+3. **Warning and attack can drift apart.** If UI and enemy each compute their own beat offsets, one can show a warning while another opens hitboxes on a different beat.
+4. **Encounter tuning becomes code editing.** Changing "attack at beat 16" to "warning at 15.5, attack at 16, recover at 17" should be data work, not enemy-script surgery.
+
+Chart Layer centralizes that schedule.
+
+New flow:
+
+```text
+RhythmManager.song_position()
+  -> ChartRunner.update_for_song_time(song_time)
+  -> BeatChart / ChartTrack / ChartEvent
+  -> chart_event_upcoming(event, time_to_event)
+  -> chart_event_triggered(event)
+  -> EventBus mirrors both signals
+  -> RhythmTrack / EnemyBeatPlanner / Hazard / Camera listen
+```
+
+Player input remains independent:
+
+```text
+InputIntent
+  -> RhythmManager.judge(timestamp)
+  -> ActionController
+  -> ComboWindow
+  -> ActionResolver
+  -> ActionExecutor
+```
+
+Chart Layer must not force the player to press a specific key on a specific beat.
+
+## Scope for This Plan
+
+This plan implements the smallest useful Chart Layer:
+
+- Data resources:
+  - `ChartEvent`
+  - `ChartTrack`
+  - `BeatChart`
+- Runtime node:
+  - `ChartRunner`
+- Event bus signals:
+  - `chart_event_upcoming`
+  - `chart_event_triggered`
+  - `chart_reset`
+- Main scene integration:
+  - A `ChartRunner` child under `Main`
+- UI integration:
+  - `RhythmTrack` listens to upcoming/triggered chart events and can render simple future markers.
+- Tests:
+  - Resource loading
+  - event ordering
+  - upcoming events fire once
+  - triggered events fire once
+  - EventBus mirrors runner events
+  - existing player rhythm/action tests still pass
+
+This plan intentionally does not implement a full enemy AI system. It creates event hooks that a future `EnemyBeatPlanner` can consume.
+
+## Event Model
+
+First version event types:
+
+```text
+show_accent_marker
+enemy_prepare_attack
+enemy_attack_active
+enemy_recovery
+camera_pulse
+```
+
+Event payload examples:
+
+```gdscript
+{
+	"lane": "enemy",
+	"color": "ff3355",
+	"label": "ATK"
+}
+```
+
+```gdscript
+{
+	"shake": 0.35,
+	"duration_beats": 0.25
+}
+```
+
+Recommended first test chart:
+
+```text
+beat 4  show_accent_marker
+beat 6  enemy_prepare_attack target_id=test_enemy lead_beats=1
+beat 7  enemy_attack_active  target_id=test_enemy lead_beats=1
+beat 8  enemy_recovery       target_id=test_enemy lead_beats=0.5
+beat 12 camera_pulse
+beat 16 show_accent_marker
+```
+
+---
+
+## File Structure
+
+Create:
+
+- `resources/chart_event.gd`  
+  One scheduled event on a beat or subdivision.
+
+- `resources/chart_track.gd`  
+  A named collection of related events, such as `accent`, `enemy`, `camera`, or `hazard`.
+
+- `resources/beat_chart.gd`  
+  A chart resource that owns tracks and exposes all events in sorted order.
+
+- `scenes/chart/chart_runner.gd`  
+  Scene-owned runner that reads the current song time and emits upcoming/triggered events.
+
+- `tests/test_chart_layer.gd`  
+  Headless test for resources, runner timing, and EventBus mirroring.
+
+Modify:
+
+- `autoload/event_bus.gd`  
+  Add chart signals.
+
+- `scenes/main/main.tscn`  
+  Add a `ChartRunner` node as a sibling of `Stage` and `UI`.
+
+- `scenes/ui/rhythm_track.gd`  
+  Listen to chart events and maintain simple future markers.
+
+- `scenes/ui/rhythm_track.tscn`  
+  Add a `ChartMarkerContainer` node under `RhythmTrack`.
+
+- `tests/test_rhythm_action_architecture.gd`  
+  Add architecture assertions that the chart resource scripts and runner load.
+
+Optional runtime data after the scripts compile:
+
+- `resources/charts/test_song_chart.tres`
+
+---
+
+## Task 1: Add Failing Chart Layer Architecture Test
+
+**Files:**
+- Create: `tests/test_chart_layer.gd`
+- Modify: `tests/test_rhythm_action_architecture.gd`
+
+- [ ] **Step 1: Create the focused chart test**
+
+Create `tests/test_chart_layer.gd`:
+
+```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: Node = bus_script.new()
+	bus.name = "EventBus"
+	root.add_child(bus)
+
+	var mirrored_upcoming := 0
+	var mirrored_triggered := 0
+	bus.connect("chart_event_upcoming", func(_event: Resource, _time_to_event: float) -> void:
+		mirrored_upcoming += 1
+	)
+	bus.connect("chart_event_triggered", func(_event: Resource) -> void:
+		mirrored_triggered += 1
+	)
+
+	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 == 1, "ChartRunner should mirror upcoming events to EventBus")
+	_expect(mirrored_triggered == 1, "ChartRunner should mirror triggered events to EventBus")
+
+	runner.queue_free()
+	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)
+```
+
+- [ ] **Step 2: Run the focused test and verify it fails for missing files**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_chart_layer.gd
+```
+
+Expected: FAIL because `resources/chart_event.gd`, `resources/chart_track.gd`, `resources/beat_chart.gd`, and `scenes/chart/chart_runner.gd` do not exist yet.
+
+- [ ] **Step 3: Extend architecture test**
+
+In `tests/test_rhythm_action_architecture.gd`, add a new function `_check_chart_layer()` and call it from `_run()` after `_check_autoloads()`:
+
+```gdscript
+func _check_chart_layer() -> void:
+	for path: String in [
+		"res://resources/chart_event.gd",
+		"res://resources/chart_track.gd",
+		"res://resources/beat_chart.gd",
+		"res://scenes/chart/chart_runner.gd",
+	]:
+		_expect(load(path) != null, "%s should load" % path)
+	var bus_script: Script = load("res://autoload/event_bus.gd")
+	_expect(bus_script != null, "EventBus should load for chart signal checks")
+	if bus_script != null:
+		var bus: Node = bus_script.new()
+		_expect(bus.has_signal("chart_event_upcoming"), "EventBus should expose chart_event_upcoming")
+		_expect(bus.has_signal("chart_event_triggered"), "EventBus should expose chart_event_triggered")
+		_expect(bus.has_signal("chart_reset"), "EventBus should expose chart_reset")
+		bus.free()
+```
+
+Expected: architecture test fails until the scripts and EventBus signals are added.
+
+---
+
+## Task 2: Add Chart Resource Types
+
+**Files:**
+- Create: `resources/chart_event.gd`
+- Create: `resources/chart_track.gd`
+- Create: `resources/beat_chart.gd`
+- Test: `tests/test_chart_layer.gd`
+
+- [ ] **Step 1: Create `ChartEvent`**
+
+Create `resources/chart_event.gd`:
+
+```gdscript
+class_name ChartEvent
+extends Resource
+
+@export var event_id: StringName = &""
+@export var beat_index := 0
+@export var subdivision := 0
+@export var subdivisions_per_beat := 1
+@export var event_type: StringName = &""
+@export var target_id: StringName = &""
+@export var payload: Dictionary = {}
+@export var lead_beats := 1.0
+
+
+func beat_position() -> float:
+	var safe_subdivisions := maxi(1, subdivisions_per_beat)
+	return float(beat_index) + float(subdivision) / float(safe_subdivisions)
+
+
+func time_seconds(beat_time: float) -> float:
+	return beat_position() * maxf(0.001, beat_time)
+
+
+func key() -> StringName:
+	if not event_id.is_empty():
+		return event_id
+	return StringName("%s:%s:%d:%d" % [event_type, target_id, beat_index, subdivision])
+```
+
+- [ ] **Step 2: Create `ChartTrack`**
+
+Create `resources/chart_track.gd`:
+
+```gdscript
+class_name ChartTrack
+extends Resource
+
+@export var track_id: StringName = &""
+@export var track_type: StringName = &""
+@export var events: Array[ChartEvent] = []
+
+
+func sorted_events() -> Array[ChartEvent]:
+	var result: Array[ChartEvent] = []
+	for event: ChartEvent in events:
+		if event != null:
+			result.append(event)
+	result.sort_custom(func(a: ChartEvent, b: ChartEvent) -> bool:
+		return a.beat_position() < b.beat_position()
+	)
+	return result
+```
+
+- [ ] **Step 3: Create `BeatChart`**
+
+Create `resources/beat_chart.gd`:
+
+```gdscript
+class_name BeatChart
+extends Resource
+
+@export var chart_id: StringName = &""
+@export var total_beats := 0
+@export var tracks: Array[ChartTrack] = []
+
+
+func all_events() -> Array[ChartEvent]:
+	var result: Array[ChartEvent] = []
+	for track: ChartTrack in tracks:
+		if track == null:
+			continue
+		for event: ChartEvent in track.sorted_events():
+			result.append(event)
+	result.sort_custom(func(a: ChartEvent, b: ChartEvent) -> bool:
+		if is_equal_approx(a.beat_position(), b.beat_position()):
+			return str(a.event_type) < str(b.event_type)
+		return a.beat_position() < b.beat_position()
+	)
+	return result
+
+
+func is_empty() -> bool:
+	return all_events().is_empty()
+```
+
+- [ ] **Step 4: Run the focused test and verify it still fails at `ChartRunner`**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_chart_layer.gd
+```
+
+Expected: FAIL because `scenes/chart/chart_runner.gd` and EventBus chart signals are not implemented yet.
+
+---
+
+## Task 3: Add Chart Signals to EventBus
+
+**Files:**
+- Modify: `autoload/event_bus.gd`
+- Test: `tests/test_chart_layer.gd`
+- Test: `tests/test_rhythm_action_architecture.gd`
+
+- [ ] **Step 1: Add chart signals**
+
+In `autoload/event_bus.gd`, add these signals after the existing rhythm/judgement signals:
+
+```gdscript
+signal chart_event_upcoming(event: Resource, time_to_event: float)
+signal chart_event_triggered(event: Resource)
+signal chart_reset(chart_id: StringName)
+```
+
+The top of the file should become:
+
+```gdscript
+extends Node
+
+signal rhythm_action_requested(action_name: StringName)
+signal beat_ticked(beat_index: int)
+signal judgement_made(quality: StringName, offset_ms: float)
+signal action_judged(action_name: StringName, rating: Dictionary)
+signal chart_event_upcoming(event: Resource, time_to_event: float)
+signal chart_event_triggered(event: Resource)
+signal chart_reset(chart_id: StringName)
+```
+
+- [ ] **Step 2: Run architecture test**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_action_architecture.gd
+```
+
+Expected: still FAIL until `ChartRunner` exists, but EventBus chart signal assertions should pass.
+
+---
+
+## Task 4: Implement ChartRunner
+
+**Files:**
+- Create: `scenes/chart/chart_runner.gd`
+- Test: `tests/test_chart_layer.gd`
+
+- [ ] **Step 1: Create the chart directory and runner script**
+
+Create `scenes/chart/chart_runner.gd`:
+
+```gdscript
+class_name ChartRunner
+extends Node
+
+signal chart_event_upcoming(event: ChartEvent, time_to_event: float)
+signal chart_event_triggered(event: ChartEvent)
+signal chart_reset(chart_id: StringName)
+signal chart_finished(chart_id: StringName)
+
+@export var chart: BeatChart
+@export var rhythm_manager_path: NodePath
+@export var beat_time_override := 0.0
+@export var auto_run := true
+
+var running := true
+var _upcoming_keys: Dictionary = {}
+var _triggered_keys: Dictionary = {}
+
+
+func _ready() -> void:
+	running = auto_run
+
+
+func _physics_process(_delta: float) -> void:
+	if not running or chart == null:
+		return
+	var rhythm := _rhythm_manager()
+	if rhythm == null or not rhythm.has_method("song_position"):
+		return
+	update_for_song_time(float(rhythm.call("song_position")))
+
+
+func set_chart(next_chart: BeatChart) -> void:
+	chart = next_chart
+	reset()
+
+
+func reset() -> void:
+	_upcoming_keys.clear()
+	_triggered_keys.clear()
+	var chart_id := &""
+	if chart != null:
+		chart_id = chart.chart_id
+	chart_reset.emit(chart_id)
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal("chart_reset", chart_id)
+
+
+func update_for_song_time(song_time: float) -> void:
+	if chart == null:
+		return
+	var beat_time := _beat_time()
+	for event: ChartEvent in chart.all_events():
+		var event_time := event.time_seconds(beat_time)
+		var time_to_event := event_time - song_time
+		var lead_time := maxf(0.0, event.lead_beats) * beat_time
+		var event_key := event.key()
+		if not _upcoming_keys.has(event_key) and time_to_event > 0.0 and time_to_event <= lead_time:
+			_upcoming_keys[event_key] = true
+			_emit_upcoming(event, time_to_event)
+		if not _triggered_keys.has(event_key) and song_time >= event_time:
+			_triggered_keys[event_key] = true
+			_emit_triggered(event)
+
+
+func pause() -> void:
+	running = false
+
+
+func resume() -> void:
+	running = true
+
+
+func _emit_upcoming(event: ChartEvent, time_to_event: float) -> void:
+	chart_event_upcoming.emit(event, time_to_event)
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal("chart_event_upcoming", event, time_to_event)
+
+
+func _emit_triggered(event: ChartEvent) -> void:
+	chart_event_triggered.emit(event)
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal("chart_event_triggered", event)
+
+
+func _beat_time() -> float:
+	if beat_time_override > 0.0:
+		return beat_time_override
+	var rhythm := _rhythm_manager()
+	if rhythm != null:
+		return float(rhythm.get("beat_time"))
+	return 0.5
+
+
+func _rhythm_manager() -> Node:
+	if not is_inside_tree():
+		return null
+	if not rhythm_manager_path.is_empty():
+		return get_node_or_null(rhythm_manager_path)
+	return get_tree().root.get_node_or_null("RhythmManager")
+
+
+func _event_bus_or_null() -> Node:
+	if not is_inside_tree():
+		return null
+	return get_tree().root.get_node_or_null("EventBus")
+```
+
+- [ ] **Step 2: Run focused chart test**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_chart_layer.gd
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Run architecture test**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_action_architecture.gd
+```
+
+Expected: PASS after `_check_chart_layer()` assertions are satisfied.
+
+---
+
+## Task 5: Add Runtime ChartRunner Node
+
+**Files:**
+- Modify: `scenes/main/main.tscn`
+- Optional create after scripts compile: `resources/charts/test_song_chart.tres`
+- Test: `tests/test_rhythm_scene.gd`
+
+- [ ] **Step 1: Add `ChartRunner` to `Main` scene**
+
+Modify `scenes/main/main.tscn`.
+
+Add an external resource:
+
+```ini
+[ext_resource type="Script" path="res://scenes/chart/chart_runner.gd" id="6_chart_runner"]
+```
+
+Add this node between `Stage` and `UI`:
+
+```ini
+[node name="ChartRunner" type="Node" parent="."]
+script = ExtResource("6_chart_runner")
+```
+
+The intended main scene tree becomes:
+
+```text
+Main
+  ├─ Stage
+  ├─ ChartRunner
+  └─ UI
+```
+
+- [ ] **Step 2: Update scene architecture test**
+
+In `tests/test_rhythm_scene.gd`, add an assertion that main scene has `ChartRunner`:
+
+```gdscript
+var main_scene: PackedScene = load("res://scenes/main/main.tscn")
+var main := main_scene.instantiate()
+root.add_child(main)
+await process_frame
+if main.get_node_or_null("ChartRunner") == null:
+	failures.append("Main should include ChartRunner for scene-owned chart playback")
+main.free()
+```
+
+- [ ] **Step 3: Run scene test**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_scene.gd
+```
+
+Expected: PASS.
+
+- [ ] **Step 4: Add a sample chart resource through the Godot editor**
+
+After `ChartEvent`, `ChartTrack`, and `BeatChart` scripts compile, create `resources/charts/test_song_chart.tres` in the editor with:
+
+```text
+BeatChart.chart_id = test_song_chart
+BeatChart.total_beats = 32
+
+Track accent:
+  beat 4   show_accent_marker
+  beat 8   show_accent_marker
+  beat 12  show_accent_marker
+  beat 16  show_accent_marker
+
+Track enemy:
+  beat 6   enemy_prepare_attack  target_id=test_enemy  lead_beats=1.0
+  beat 7   enemy_attack_active   target_id=test_enemy  lead_beats=1.0
+  beat 8   enemy_recovery        target_id=test_enemy  lead_beats=0.5
+
+Track camera:
+  beat 12  camera_pulse          target_id=main_camera lead_beats=0.5
+```
+
+Assign this resource to `Main/ChartRunner.chart`.
+
+The plan keeps runtime playable without this sample chart because tests construct chart resources in memory. The sample chart is for visual/manual verification.
+
+---
+
+## Task 6: Let RhythmTrack Consume Chart Events
+
+**Files:**
+- Modify: `scenes/ui/rhythm_track.tscn`
+- Modify: `scenes/ui/rhythm_track.gd`
+- Test: `tests/test_rhythm_ui.gd`
+- Test: `tests/test_ui_animation_regression.gd`
+
+- [ ] **Step 1: Add marker container to scene**
+
+In `scenes/ui/rhythm_track.tscn`, add:
+
+```ini
+[node name="ChartMarkerContainer" type="Control" parent="."]
+layout_mode = 0
+offset_left = 0.0
+offset_top = 0.0
+offset_right = 1040.0
+offset_bottom = 128.0
+mouse_filter = 2
+```
+
+Keep it behind `JudgementLabel` in the file order so text remains readable.
+
+- [ ] **Step 2: Extend `RhythmTrack` script**
+
+In `scenes/ui/rhythm_track.gd`, add:
+
+```gdscript
+@onready var chart_marker_container: Control = $ChartMarkerContainer
+
+var chart_markers: Array[Control] = []
+```
+
+Connect chart signals in `_ready()`:
+
+```gdscript
+bus.connect("chart_event_upcoming", _on_chart_event_upcoming)
+bus.connect("chart_event_triggered", _on_chart_event_triggered)
+```
+
+Add these methods:
+
+```gdscript
+func _on_chart_event_upcoming(event: Resource, time_to_event: float) -> void:
+	var marker := Label.new()
+	marker.text = _chart_marker_text(event)
+	marker.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	marker.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+	marker.add_theme_font_size_override("font_size", 14)
+	marker.add_theme_color_override("font_color", _chart_marker_color(event))
+	marker.custom_minimum_size = Vector2(54, 24)
+	marker.position = _chart_marker_position(time_to_event)
+	chart_marker_container.add_child(marker)
+	chart_markers.append(marker)
+	var tween := create_tween()
+	tween.tween_property(marker, "modulate:a", 0.25, maxf(0.1, time_to_event))
+	tween.tween_callback(marker.queue_free)
+
+
+func _on_chart_event_triggered(event: Resource) -> void:
+	if StringName(str(event.get("event_type"))) == &"camera_pulse":
+		center_flash.modulate = Color(1.0, 0.84, 0.26, 1.0)
+	else:
+		center_flash.modulate = _chart_marker_color(event)
+	beat_flash = 1.0
+
+
+func _chart_marker_text(event: Resource) -> String:
+	match StringName(str(event.get("event_type"))):
+		&"show_accent_marker":
+			return "ACC"
+		&"enemy_prepare_attack":
+			return "WARN"
+		&"enemy_attack_active":
+			return "ATK"
+		&"enemy_recovery":
+			return "REC"
+		&"camera_pulse":
+			return "CAM"
+	return str(event.get("event_type")).to_upper()
+
+
+func _chart_marker_color(event: Resource) -> Color:
+	match StringName(str(event.get("event_type"))):
+		&"show_accent_marker":
+			return Color("ffd84a")
+		&"enemy_prepare_attack":
+			return Color("ff7a33")
+		&"enemy_attack_active":
+			return Color("ff3355")
+		&"enemy_recovery":
+			return Color("8aa0ff")
+		&"camera_pulse":
+			return Color("ffffff")
+	return Color("00f2ff")
+
+
+func _chart_marker_position(time_to_event: float) -> Vector2:
+	var seconds_per_beat := 60.0 / maxf(1.0, bpm)
+	var beat_distance := clampf(time_to_event / seconds_per_beat, 0.0, 4.0)
+	var x := track_center.x + beat_distance * 92.0
+	return Vector2(x - 27.0, track_center.y + 34.0)
+```
+
+- [ ] **Step 3: Add UI tests**
+
+In `tests/test_rhythm_ui.gd`, assert the marker container exists:
+
+```gdscript
+var track := ui.get_node_or_null("RhythmTrack")
+if track == null or track.get_node_or_null("ChartMarkerContainer") == null:
+	failures.append("RhythmTrack should include ChartMarkerContainer")
+```
+
+In `tests/test_ui_animation_regression.gd`, emit an upcoming event and assert a marker appears:
+
+```gdscript
+var event_script: Script = load("res://resources/chart_event.gd")
+var event: Resource = event_script.new()
+event.set("event_type", &"enemy_attack_active")
+bus.emit_signal("chart_event_upcoming", event, 0.5)
+await process_frame
+var marker_container := ui.get_node("RhythmTrack/ChartMarkerContainer")
+_expect_bool(marker_container.get_child_count() > 0, true, "Chart upcoming event should create a rhythm marker")
+```
+
+- [ ] **Step 4: Run UI tests**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_ui.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_ui_animation_regression.gd
+```
+
+Expected: PASS.
+
+---
+
+## Task 7: Full Regression Run
+
+**Files:**
+- No new files.
+
+- [ ] **Step 1: Run chart and architecture tests**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_chart_layer.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_action_architecture.gd
+```
+
+Expected:
+
+```text
+PASS chart layer
+PASS rhythm action architecture
+```
+
+- [ ] **Step 2: Run player input/action tests**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_input_component_intents.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_combo_window.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_action_controller_flow.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_player_combo_input.gd
+```
+
+Expected:
+
+```text
+PASS input component intents
+PASS combo window
+PASS action controller flow
+PASS player combo input
+```
+
+- [ ] **Step 3: Run UI tests**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_ui.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_ui_layout.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_ui_animation_regression.gd
+```
+
+Expected:
+
+```text
+PASS rhythm ui
+PASS rhythm ui layout
+PASS ui animation regression
+```
+
+---
+
+## Follow-Up After This Plan
+
+After the thin Chart Layer lands, the next feature should be a chart-driven dummy enemy:
+
+```text
+chart_event_upcoming(enemy_prepare_attack)
+  -> EnemyWarningPresenter shows overhead warning
+
+chart_event_triggered(enemy_attack_active)
+  -> EnemyActionController opens enemy hitbox
+
+chart_event_triggered(enemy_recovery)
+  -> EnemyActionController closes enemy hitbox
+```
+
+That should be a separate plan because it needs enemy scene structure, hitbox/hurtbox decisions, target IDs, and warning UI. Keeping it separate prevents the Chart Layer from becoming a hidden enemy-system rewrite.
+
+## Important Non-Goals
+
+- Do not move player input judgement into Chart Layer.
+- Do not make charts dictate required player keys.
+- Do not make `ChartRunner` an autoload.
+- Do not change `ComboWindow` empty-beat behavior.
+- Do not add full boss AI in this pass.
+- Do not use chart events to directly damage the player.
+
+## Known Adjacent Risk
+
+`RhythmManager.judge(input_timestamp_ms)` currently accepts an input timestamp in milliseconds and passes it to `get_rating_for_time(input_timestamp_ms / 1000.0)`. Chart Layer should not depend on this method; it should use `RhythmManager.song_position()` directly. A separate input-timing plan should verify whether `InputIntent.timestamp_ms` is being converted to song-relative time correctly.
+
+## Self-Review
+
+- Spec coverage: The plan covers chart data, runner behavior, EventBus mirroring, main scene integration, UI marker consumption, and regression tests.
+- Placeholder scan: The plan has no placeholder sections. Every task names exact files and expected commands.
+- Type consistency: Event resources are `ChartEvent`, tracks are `ChartTrack`, charts are `BeatChart`, and runner signals use `ChartEvent` locally plus `Resource` on `EventBus`.
+- Scope check: Enemy AI is intentionally excluded and captured as the next separate feature.
+- Current-project fit: The plan preserves the existing `RhythmManager`, `ActionController`, `ComboWindow`, `ActionResolver`, and player UI patterns.

docs/superpowers/plans/2026-07-02-godot-architecture-refactor.md

@@ -0,0 +1,116 @@
+# Godot Architecture Refactor Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Refactor `Fighting_Rthythm_game` to match the provided architecture: EventBus communication, thin Main, componentized Player, SkillData resources, UI subscenes, Stage/ActorsContainer ownership, and named 2D layers.
+
+**Architecture:** Keep the game runnable at each increment. Cross-system communication goes through `autoload/event_bus.gd`; parent-to-child orchestration uses typed references; child-to-parent requests use signals. Player becomes a coordinator over child components, while skill definitions move to `.tres` resources loaded by `InputResolver`.
+
+**Tech Stack:** Godot 4.6 GDScript, `.tscn` scenes, `.tres` resources, headless SceneTree tests.
+
+---
+
+### Task 1: Architecture Guard Tests
+
+**Files:**
+- Create: `tests/test_architecture_refactor.gd`
+- Modify: `project.godot`
+
+- [ ] **Step 1: Write failing tests**
+
+Add tests that assert EventBus is autoloaded, Main no longer hand-wires UI with `has_method`/`has_signal`, Player has child components, Player does not use raw `KEY_*`, skills load as `SkillData`, Stage owns `ActorsContainer`, UI exists as a separate scene, and project 2D layers are named.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_architecture_refactor.gd`
+
+Expected: FAIL because the current project lacks EventBus, component nodes, resource skills, UI subscenes, and Stage boundaries.
+
+### Task 2: EventBus And Rhythm Decoupling
+
+**Files:**
+- Create: `autoload/event_bus.gd`
+- Modify: `project.godot`
+- Modify: `scenes/rhythm/rhythm_conductor.gd`
+- Modify: `scenes/characters/player.gd`
+
+- [ ] Add EventBus signals for rhythm requests, beats, judgements, skills, health, energy, charge, combo, damage, and projectile requests.
+- [ ] Register EventBus as a game autoload.
+- [ ] Make RhythmConductor listen for rhythm action requests and emit EventBus judgement/beat signals.
+- [ ] Remove Player's `get_first_node_in_group("rhythm_conductor")` fallback and treat missing judgement as a miss.
+
+### Task 3: Player Components
+
+**Files:**
+- Create: `scenes/components/input_component.gd`
+- Create: `scenes/components/combo_tracker.gd`
+- Create: `scenes/components/energy_component.gd`
+- Create: `scenes/components/health_component.gd`
+- Create: `scenes/components/damage_emitter.gd`
+- Create: `scenes/components/damage_receiver.gd`
+- Create: `scenes/components/state_machine.gd`
+- Modify: `scenes/characters/player.gd`
+- Modify: `scenes/characters/player.tscn`
+- Modify: `project.godot`
+
+- [ ] Move raw input handling into InputComponent using only InputMap actions.
+- [ ] Move combo slot storage and clear timing into ComboTracker.
+- [ ] Move energy/health state into components that emit EventBus updates.
+- [ ] Add DamageEmitter and DamageReceiver Area2D components with collision-layer-based targeting.
+- [ ] Keep Player as a typed coordinator over components.
+
+### Task 4: SkillData Resources
+
+**Files:**
+- Create: `resources/skill_data.gd`
+- Create: `resources/skills/*.tres`
+- Modify: `scenes/combat/input_resolver.gd`
+- Modify: `scenes/characters/player.gd`
+
+- [ ] Define `SkillData extends Resource`.
+- [ ] Convert each hard-coded skill pattern into a `.tres` resource.
+- [ ] Make InputResolver load resources and return `SkillData`.
+- [ ] Move animation, energy cost/reward, projectile flags, clear-window behavior, and displacement into resources.
+
+### Task 5: UI Subscenes And Thin Main
+
+**Files:**
+- Create: `scenes/ui/main_ui.tscn`
+- Create: `scenes/ui/main_ui.gd`
+- Create: `scenes/ui/rhythm_track.tscn`
+- Create: `scenes/ui/rhythm_track.gd`
+- Create: `scenes/ui/combo_window_hud.tscn`
+- Create: `scenes/ui/combo_window_hud.gd`
+- Create: `scenes/ui/energy_bar.tscn`
+- Create: `scenes/ui/energy_bar.gd`
+- Modify: `scenes/main/main.gd`
+- Modify: `scenes/main/main.tscn`
+
+- [ ] Move rhythm track animation into `RhythmTrack`.
+- [ ] Move combo slot rendering into `ComboWindowHud`.
+- [ ] Move energy/health/charge display into UI nodes that subscribe to EventBus.
+- [ ] Reduce Main to typed child references and scene setup only.
+
+### Task 6: Stage And ActorsContainer
+
+**Files:**
+- Create: `scenes/stage/stage.tscn`
+- Create: `scenes/stage/stage.gd`
+- Create: `scenes/stage/actors_container.gd`
+- Create: `scenes/combat/player_projectile.tscn`
+- Modify: `scenes/combat/player_projectile.gd`
+- Modify: `scenes/characters/player.gd`
+- Modify: `scenes/main/main.tscn`
+
+- [ ] Put ground and Player under Stage/ActorsContainer.
+- [ ] Make Player emit projectile requests instead of adding children to the scene tree.
+- [ ] Make ActorsContainer instantiate projectiles, own them, and group them.
+
+### Task 7: Verification
+
+**Files:**
+- Modify: tests as needed to target public component interfaces instead of Player internals.
+
+- [ ] Run every `tests/*.gd` with Godot headless.
+- [ ] Confirm architecture guard tests cover every explicit objective item.
+- [ ] Inspect key source files to ensure raw key matching, group conductor lookup, Player projectile spawning, and Main `has_method`/`has_signal` probing are gone.

docs/superpowers/plans/2026-07-02-rhythm-action-architecture-refactor.md

@@ -0,0 +1,202 @@
+# Rhythm Action Architecture Refactor Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Refactor the project toward the architecture in `docs/架构方案.md`: global beat clock, four-slot combo window, ActionData resources, ActionResolver priority rules, Player execution components, and CombatManager formulas.
+
+**Architecture:** Keep `EventBus` for decoupled broadcast, but add `RhythmManager` and `CombatManager` as first-class autoload services. Move domain logic out of `Player` into beat-aware components and data-driven resource files while preserving current gameplay tests.
+
+**Tech Stack:** Godot 4.6 GDScript, `.tres` Resources, headless SceneTree tests.
+
+---
+
+### Task 1: Architecture Target Regression
+
+**Files:**
+- Create: `tests/test_rhythm_action_architecture.gd`
+
+- [x] **Step 1: Write the failing test**
+
+Create one test that asserts the six requested architecture artifacts exist and expose their intended behavior:
+
+```gdscript
+extends SceneTree
+
+var failures: Array[String] = []
+
+func _init() -> void:
+    _run.call_deferred()
+
+func _run() -> void:
+    _check_autoloads()
+    _check_action_data()
+    _check_combo_window()
+    _check_action_resolver()
+    _check_player_components()
+    _check_combat_manager()
+    _finish()
+```
+
+- [x] **Step 2: Run test to verify it fails**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_action_architecture.gd
+```
+
+Expected: FAIL because `RhythmManager`, `CombatManager`, `ActionData`, `ActionResolver`, `ComboWindow`, `MotionExecutor`, and `BurstComponent` do not exist yet.
+
+### Task 2: RhythmManager Autoload
+
+**Files:**
+- Create: `autoload/rhythm_manager.gd`
+- Modify: `project.godot`
+- Modify: `scenes/rhythm/rhythm_conductor.gd`
+- Modify: `tests/test_rhythm_conductor.gd`
+
+- [x] **Step 1: Implement `RhythmManager`**
+
+Create an Autoload node with `beat_ticked`, `judgement_made`, and `action_judged` signals. It owns BPM, beat length, beat index, judgement scale, beat offset, fallback clock timing, and `judge_action(action_name)`.
+
+- [x] **Step 2: Register autoload**
+
+Add:
+
+```ini
+[autoload]
+RhythmManager="*res://autoload/rhythm_manager.gd"
+```
+
+- [x] **Step 3: Preserve `RhythmConductor` compatibility**
+
+Keep `scenes/rhythm/rhythm_conductor.gd` loadable for old tests by delegating equivalent judging math to the same model or leaving it as a scene adapter.
+
+- [x] **Step 4: Run rhythm tests**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_conductor.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_rhythm_action_architecture.gd
+```
+
+Expected: rhythm conductor still passes; architecture test advances past autoload checks.
+
+### Task 3: Four-Slot ComboWindow
+
+**Files:**
+- Create: `scenes/components/combo_window.gd`
+- Modify: `scenes/characters/player.tscn`
+- Modify: `scenes/characters/player.gd`
+- Modify: `tests/test_combo_window.gd`
+
+- [x] **Step 1: Implement `ComboWindow`**
+
+`ComboWindow` extends `Node`, stores four slots, records `StringName` inputs, keeps `&"Ø"` only as an explicit Miss placeholder, clears on miss/full/action clear, and emits `combo_updated`/`combo_cleared`. It must not auto-append `&"Ø"` just because a beat passed without input.
+
+- [x] **Step 2: Replace Player node**
+
+Rename or replace `ComboTracker` with `ComboWindow` in `player.tscn`. Keep compatibility methods `get_slots()`, `get_pattern()`, `get_contiguous_pattern()`, `queue_clear()`, `flush_pending_clear()` so existing tests can continue running while behavior becomes component-based.
+
+- [x] **Step 3: Run combo tests**
+
+Run:
+
+```bash
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_combo_window.gd
+/Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s res://tests/test_player_combo_input.gd
+```
+
+Expected: existing combo behavior remains green, and the new architecture test confirms ComboWindow does not auto-append `&"Ø"` just because a beat passed without input.
+
+### Task 4: ActionData and ActionResolver
+
+**Files:**
+- Create: `resources/action_data.gd`
+- Create: `resources/actions/*.tres`
+- Create: `scenes/combat/action_resolver.gd`
+- Modify: `resources/skill_data.gd`
+- Modify: `scenes/combat/input_resolver.gd`
+- Modify: `scenes/characters/player.gd`
+- Modify: `tests/test_combo_window.gd`
+- Modify: `tests/test_architecture_refactor.gd`
+
+- [x] **Step 1: Add full `ActionData`**
+
+Create `ActionData extends Resource` with fields from `docs/架构方案.md`: `id`, `display_name`, `input_pattern`, `required_state`, `base_cost`, `damage_mult`, `move_mult_x`, `move_mult_y`, `action_beats`, `hit_type`, `range`, `target_type`, `armor_level`, `clear_window`, `can_chain`, `special`, plus compatibility fields `animation`, `energy_cost`, `energy_reward`, `spawns_projectile`, `projectile_scene`, and `displacement`.
+
+- [x] **Step 2: Convert resources**
+
+Create `resources/actions` equivalents for the current `resources/skills` files. After all tests and scripts use `ActionData`, remove the legacy `resources/skills` data.
+
+- [x] **Step 3: Implement `ActionResolver`**
+
+Load `resources/actions/*.tres`, expose `resolve(window, state_machine := null, context := {})`, `resolve_pattern(pattern, state_machine := null, context := {})`, `reload()`, and `clear_cache()`. Include an ordered rule pass for Space contexts before falling back to pattern matching.
+
+- [x] **Step 4: Remove `InputResolver` after migration**
+
+Move tests and runtime code to `ActionResolver` directly, then remove the legacy `InputResolver` adapter.
+
+### Task 5: MotionExecutor and BurstComponent
+
+**Files:**
+- Create: `scenes/components/motion_executor.gd`
+- Create: `scenes/components/burst_component.gd`
+- Modify: `scenes/characters/player.tscn`
+- Modify: `scenes/characters/player.gd`
+
+- [x] **Step 1: Add `MotionExecutor`**
+
+Expose `execute(action, direction, beat_time)` and `tick(delta)` to own action duration, lunge timing, and velocity output. Player calls it instead of hand-writing lunge windows.
+
+- [x] **Step 2: Add `BurstComponent`**
+
+Expose ready/active/cooldown state, beat-based duration, cost multiplier, damage multiplier, and judgement scale. It listens to `RhythmManager.beat_ticked` for duration and cooldown.
+
+- [x] **Step 3: Move Player logic**
+
+Replace direct charge/burst timing in `Player` with `BurstComponent`, and replace direct action displacement with `MotionExecutor`.
+
+### Task 6: CombatManager
+
+**Files:**
+- Create: `autoload/combat_manager.gd`
+- Modify: `project.godot`
+- Modify: `scenes/components/damage_emitter.gd`
+- Modify: `scenes/characters/player.gd`
+
+- [x] **Step 1: Implement formulas**
+
+`CombatManager` exposes `resolve_damage(base_attack, action, judgement, buffs := null, burst := null)`, `resolve_cost(action, burst := null)`, and `resolve_move(action, judgement, burst := null)`.
+
+- [x] **Step 2: Wire damage and cost**
+
+Player uses `CombatManager.resolve_cost` before action execution. `DamageEmitter` can accept an action context and asks `CombatManager.resolve_damage` rather than using scattered multipliers.
+
+### Task 7: Verification and Gap Audit
+
+**Files:**
+- Modify: tests as needed to cover exact behavior.
+
+- [x] **Step 1: Run full suite**
+
+Run:
+
+```bash
+for test in tests/*.gd; do
+  /Applications/Godot.app/Contents/MacOS/Godot --headless --path /Users/wxm/code/project/Fighting_Rthythm_game -s "res://$test" || exit 1
+done
+```
+
+Expected: all tests exit `0`.
+
+- [x] **Step 2: Search for architecture residue**
+
+Run:
+
+```bash
+rg -n "Timer|charge_duration|attack_lunge|InputResolver|SkillData|ComboTracker|PlayerProjectile\\.new\\(|get_first_node_in_group|has_method|\\.call\\(" autoload resources scenes tests
+```
+
+Expected: any remaining hits are compatibility adapters, tests, or UI-only visual timing, not core gameplay architecture.

docs/架构方案.md

@@ -0,0 +1,182 @@
+读完这份策划书,先说结论:前两轮的架构骨架(Autoload 总线 + 组件化 + Resource 数据驱动)完全适用,但策划书里有三个事实会**反过来修正**我之前的一些具体建议,先把它们摆清楚,因为整个架构都要围绕它们展开。
+
+**第一,拍(Beat)是全游戏唯一的时间单位。** 动作持续用 ActionBeats,Buff 持续 8 拍,爆气 16 拍、冷却 4 拍,蓄力按拍分级,敌人每 N 拍行动,连段窗口是 4 拍。这意味着 RhythmManager 不只是"判定服务",它是**全局主时钟**,所有系统的计时都应该订阅它的 `beat_ticked`,而不是各自开 Timer 数秒——这样换 BPM 时整个游戏自动变速,这正是节奏游戏该有的性质。
+
+**第二,我要收回上一轮"输入缓冲"的建议。** InputBuffer 是格斗游戏的手感工具,但在你这个设计里它是有害的:判定的本质是测量按键时刻与拍点的偏差,缓冲会把"提前按"偷偷延后消费,等于篡改了玩家的真实节奏。而且策划书的 Miss 机制天然解决了连打问题——乱按的人会大量 Miss,Miss 清空窗口、动作失败,惩罚是玩法自带的,不需要程序层再去限速。保留的只有 echo 过滤、去重和时间戳这些"让输入干净"的部分。
+
+**第三,策划书 9.1 节其实已经替你把数据模型设计好了。** 那个统一技能字段表(inputPattern、requiredState、baseCost、各倍率、hitType、clearWindow、canChain……)就是 `ActionData extends Resource` 的字段清单,而且基础动作和技能同构——A 一段斩就是一个 cost=0、pattern=[A] 的 ActionData。全游戏 30 多个动作全部变成 `.tres` 文件,代码里没有任何一张硬编码技能表。
+
+## 一、全局层:RhythmManager 作为节拍中枢RhythmManager(Autoload)的接口对应策划书 2.1 的全局单位表:
+
+```gdscript
+# autoload/rhythm_manager.gd
+signal beat_ticked(beat_index: int)
+
+var bpm: float
+var beat_time: float          # 60.0 / bpm
+var beat_index: int
+var judgement_scale := 1.0    # 爆气时 > 1,放宽判定窗口
+
+func song_position() -> float:
+    return music.get_playback_position() \
+        + AudioServer.get_time_since_last_mix() \
+        - AudioServer.get_output_latency()
+
+func judge(input_timestamp_ms: float) -> Judgement:
+    # 换算到歌曲时间,求与最近拍点的 BeatOffset
+    # 与 RhythmConfig 中的阈值比较 → perfect / good / bad / miss
+    # 阈值乘以 judgement_scale 实现爆气放宽
+```
+
+判定阈值放进 `rhythm_config.tres` 资源(Perfect/Good/Bad 各自的偏差上限)——**策划书目前没有给这组数字**,这是要找策划补的第一个洞。爆气的"判定窗口适度放宽"通过 `judgement_scale` 一个字段实现,BurstComponent 进入爆气时改它,退出时还原。
+
+CombatManager(Autoload)则是四条乘区公式的唯一归属地。策划书 2.3 的公式结构完全一致(基础值 × 动作乘区 × 节奏乘区 × Buff 乘区 × 爆气乘区),所以做一个统一的结算管线:
+
+```gdscript
+# autoload/combat_manager.gd
+func resolve_damage(atk: float, action: ActionData, j: Judgement,
+        buffs: BuffContainer, burst: BurstComponent) -> float:
+    return atk * action.damage_mult * j.damage_mult \
+        * buffs.damage_mult(action) * burst.damage_mult()
+
+# resolve_move_x / resolve_move_y / resolve_cost 同构,只换字段
+```
+
+各系统只负责"贡献自己的乘数"(比如强袭乐句 Buff 只对同方向技能生效,所以 `buffs.damage_mult(action)` 要传入动作),永远不要在 Player 或技能代码里手写 `damage * 1.25 * 1.2` 这种散落的乘法——否则第 4 条公式改一次你要全项目搜一遍。
+
+## 二、数据层:ActionData 照抄策划书 9.1
+
+```gdscript
+# resources/action_data.gd
+class_name ActionData extends Resource
+
+@export var id: StringName
+@export var display_name: String
+@export var input_pattern: Array[StringName]      # [&"A", &"A", &"space"]
+@export_enum("ground", "air", "guarding", "any") var required_state: String
+@export var base_cost := 0                        # 基础动作恒为 0
+@export var damage_mult := 1.0
+@export var move_mult_x := 0.0
+@export var move_mult_y := 0.0
+@export var action_beats := 1.0                   # W 为 2.0
+@export_enum("melee", "projectile", "circle", "counter") var hit_type: String
+@export var range := 0.0
+@export_enum("single", "area") var target_type: String
+@export var armor_level := 0
+@export var clear_window := true                  # 音刃前两段为 false
+@export var can_chain := false                    # 音刃族为 true
+@export var special: StringName                   # 破霸体、浮空等特效钩子
+```
+
+A/D 三段、W、招架、下劈、W 派生、四个方向技能、三段音刃、反击音刃、三级蓄力——全部是这个类的 `.tres` 实例,放在 `res://resources/actions/` 下。第一版验收标准 17.4 里"A Space、AA Space、AAA Space 功能不同"这种需求,变成纯粹的资源文件差异。
+
+## 三、玩家实体:组件划分随策划书调整
+
+玩家场景树在上一轮基础上,按这份策划书的系统重新切分:
+
+```
+Player (CharacterBody2D)
+├── Sprite / 骨骼动画
+├── StateMachine            # 8 个状态,照抄 3.2 节
+│   └── ground / air / guarding / charging /
+│       bladeChain / burstCharge / bursting / hitstun
+├── InputComponent          # 按下+松开事件、时间戳、长按检测
+├── ComboWindow             # 四槽连段窗口,只记录显式输入/Miss,不自动补空拍
+├── ActionResolver          # Space 优先级链 + 动作表匹配(纯逻辑)
+├── MotionExecutor          # 把位移乘区结果变成 ActionBeats 内的实际位移
+├── EnergyComponent         # 回能规则 + 空挥计数器
+├── BuffContainer           # 四个 Buff 的触发、拍计时、乘区供给
+├── BurstComponent          # 爆气条件、四态、效果开关
+├── DamageEmitter (Area2D)
+└── DamageReceiver (Area2D)
+```
+
+几个组件值得单独说透。
+
+**ComboWindow:它是连段窗口的领域对象,不是输入缓冲,也不负责空拍补位。** 这里按当前设计修正:ComboWindow 不订阅 `beat_ticked` 来自动补 Ø,某一拍没有输入就什么都不记录。它只记录两类内容:通过节奏判定的显式输入(A/D/W/S/Space),以及 Miss 时由裁决层显式写入的 Ø 占位。Miss 只是正常槽位输入,不因自身触发清空;满 4 槽清空;受击清空(监听 DamageReceiver);`clear_window == true` 的动作释放后清空;bladeChain 期间按专门规则决定是否保留窗口。识别连段时对外暴露过滤掉 Ø 的有效序列,但正常玩法里 Ø 只作为 Miss 反馈,不会因为空拍自动出现:
+
+```gdscript
+# components/combo_window.gd
+class_name ComboWindow extends Node
+signal cleared(reason: StringName)
+var slots: Array[StringName] = []
+
+func record(action: StringName) -> void:      # 判定非 Miss 后调用
+    slots.append(action)
+    if slots.size() >= 4:
+        clear(&"window_full")
+
+func record_miss() -> void:                   # 仅 Miss 裁决显式调用
+    slots.append(&"Ø")
+    clear(&"miss")
+
+func pattern() -> Array[StringName]:           # 供 ActionResolver 匹配
+    return slots.filter(func(s): return s != &"Ø")
+```
+
+这样窗口的语义会更干净:连段只由玩家真实输入构成;Miss 是显式失败反馈并清空窗口;空拍不会污染连段,也不会制造需要额外解释的隐藏槽位。
+
+**ActionResolver:Space 的六步优先级链是全项目最容易腐坏的逻辑,必须独立成模块。** 而且注意策划书 10.3 说反击音刃"优先级高于普通 S Space 音刃",但第 6 节的解析顺序里没写它——合并后的完整链条是七步:实现上把这七步写成一个有序规则数组,每条规则是"条件函数 + 产出动作",Resolver 逐条尝试、命中即返回。这样以后加 Q/E、装备技能替换(策划书 18 节的暂缓内容)只是往数组里插规则,不用动主干。
+
+**InputComponent:长按检测暴露了一个策划书没定义的关键时序问题。** S Space 短按是音刃、长按是爆气——但按下的瞬间程序不可能知道玩家会不会长按,而策划书 4.1 又要求"按键时立刻判定"。这两条规则在 Space 上是冲突的,必须由程序定义结算时机。我建议的方案是**按下即判定、延迟结算**:
+
+```gdscript
+# InputComponent 对 Space 的处理
+# 按下: 立即调用 RhythmManager.judge() 并暂存结果(pending)
+# 若在 hold_threshold(建议 0.3~0.5 拍,需策划确认)内松开:
+#     → 按短按结算,使用按下那一刻的判定结果(节奏不失真)
+# 若超过阈值仍按住:
+#     → 丢弃 pending,升级为 charging / burstCharge 状态
+#     → 松开时重新判定(策划书 11.1 / 12.4 本来就要求松开判定)
+```
+
+代价是短按的动作会比按键晚约三分之一拍才出招——对音刃这种远程投射物,可以让动画前段先演出、投射物在结算点生成来掩盖。这个点务必和策划当面对齐,它直接影响手感验收标准 17.1 的"按下后立即出动作"在 Space 上如何解释。
+
+**StateMachine 直接照抄 3.2 节的八个状态**,每个 ActionData 的 `required_state` 字段由状态机门控(W 派生只在 air 状态可解析,招架结算只在 guarding)。charging、bladeChain、burstCharge 这三个状态的本质是"改变 Space 解析结果的模式",所以 ActionResolver 每次解析都要先问状态机当前状态——优先级链的①②③本质上就是状态查询。
+
+**MotionExecutor 是这个游戏区别于普通横版的组件。** 玩家不能自由走路,意味着 Player 里**不存在**常规的"读方向键改 velocity"代码;所有位移都是动作的产物:接到一个动作的 `FinalMoveX/Y`(CombatManager 算好的乘区结果),在 `action_beats × beat_time` 的时长内用 tween 或速度曲线执行完,期间仍走 `move_and_slide` 保证碰撞。W 的 T0–T1 上升、T1 高点、T1–T2 下落也由它按拍切分,并在 T1 通知状态机开放空中派生窗口。
+
+**资源三件套(Energy / Buff / Burst)全部是 EventBus 的订阅者。** EnergyComponent 的空挥限制需要一条此前没有的反馈链:DamageEmitter 命中时经 CombatManager 广播 `hit_confirmed`,EnergyComponent 据此区分"命中回能 100% / 有效位移未命中 50% / 连续三次空挥后归零"。BuffContainer 监听判定流水(合拍、完美律动看连击流)、连段事件(强袭乐句看 AAA 终结)、招架结果(守拍反击),持续时间订阅 `beat_ticked` 递减,并暴露一个 `ticking_paused` 开关给爆气用。BurstComponent 自己是个小状态机(off/ready/active/cooldown),每次能量或连击变化时检查 12.3 的三选一条件点亮 ready,激活时做四件事:改 CombatManager 乘区、把技能 cost 乘区归零、调 `RhythmManager.judgement_scale`、暂停 BuffContainer 计时,16 拍后统一还原并清资源。
+
+## 四、世界层与敌人
+
+Stage 负责装载关卡、把曲目和 BPM 交给 RhythmManager 开始播放。ActorsContainer 统一生成三种测试敌人和**音刃投射物**(音刃是远程投射物,正好落在上一轮"实体不自己 new 实体"的规则里)。敌人 = Character 基类 + DamageReceiver(带 ArmorLevel)+ 一个极简的 EnemyBrain:
+
+```gdscript
+# EnemyBrain: 敌人和玩家订阅同一个时钟,这是设计对称性所在
+@export var data: EnemyData    # beats_per_action、行为类型
+func _on_beat(i: int) -> void:
+    if i % data.beats_per_action == 0:
+        _act()                 # 接近 / 攻击 / 远程射击
+```
+
+节奏型(1 拍、2 拍,以及未来的半拍、切分)就是 EnemyData 上的一个数字或节拍掩码,15.1 节的扩展方向零成本预留。破霸体走 DamageContext:W 派生的 ActionData 带 `armor_level` 和 `special = &"armor_break"`,Receiver 拿自己的 ArmorLevel 比较后决定是硬直、浮空还是只吃伤害。
+
+UI 层强烈建议第一版就做**四槽窗口可视化**(四个格子实时显示 A/D/W/S/Space/Ø),它同时是玩家理解连段系统的核心界面和你调试 ComboWindow 的工具。这里的 Ø 只代表显式 Miss 反馈,不是空拍占位;UI 监听 ComboWindow 的信号即可。
+
+## 五、目录结构与实施映射
+
+```
+res://
+├── autoload/          # rhythm_manager.gd / event_bus.gd / combat_manager.gd
+├── resources/
+│   ├── actions/       # 30+ 个 ActionData .tres(基础动作与技能同构)
+│   ├── buffs/         # 4 个 BuffData
+│   ├── enemies/       # EnemyData(节奏型、数值)
+│   └── rhythm_config.tres
+├── components/        # input / combo_window / resolver / motion / energy / buff / burst / damage_*
+├── scenes/
+│   ├── characters/    # player.tscn、enemy 基类、三种测试敌人
+│   ├── stage/         # stage.tscn、actors_container.tscn
+│   ├── combat/        # 音刃投射物等
+│   └── ui/            # hud.tscn、combo_slots.tscn、energy_bar.tscn
+└── tests/             # 对 ComboWindow / Resolver / CombatManager 的纯逻辑单元测试
+```
+
+对应策划书 16 节的五个阶段:阶段 1 = RhythmManager + RhythmConfig + InputComponent + ComboWindow(这四个是地基,而且全部可脱离画面单元测试);阶段 2 = StateMachine + MotionExecutor + 基础动作的 ActionData;阶段 3 = ActionResolver 优先级链 + 全部技能资源 + DamageEmitter/投射物 + ActorsContainer;阶段 4 = Energy/Buff/Burst 三组件 + 乘区管线补全;阶段 5 = EnemyBrain + 三种敌人。每个阶段结束,对应的验收标准(17 节)恰好都有明确的架构归属可以逐条勾选。
+
+## 六、需要回去和策划确认的三个洞
+
+架构做到这里,策划书有三处未定义的行为必须补上,否则程序只能自行拍板:一是**判定阈值的具体数字**(Perfect/Good/Bad 各多少毫秒或多少比例拍长),RhythmConfig 等着填;二是上面说的**长按阈值与短按结算时机**;三是**同一拍内的第二次输入**如何处理——ComboWindow 不再按拍自动补槽,但如果玩家在同一拍内按了两次,两次输入是否都独立判定、是否都进入窗口、第二次是否直接按 Miss 处理,仍需要定义。蓄力/爆气长按期间不补 Ø;这段时间窗口应冻结或在释放后按动作规则清空。
+
+整体看,这份策划书和这套架构咬合得相当好——因为它本质上已经是一份"以拍为时基、以数据表驱动"的设计,你要做的就是让代码结构诚实地反映这个事实:一个时钟(RhythmManager)、一张表(ActionData 资源集)、一条链(Resolver 优先级)、一条管线(乘区结算),其余全是订阅者。如果你想,下一步我可以把阶段 1 的四个地基模块(含单元测试)完整写出来。

project.godot

@@ -17,6 +17,9 @@ config/icon="res://icon.svg"
 
 [autoload]
 
+EventBus="*res://autoload/event_bus.gd"
+RhythmManager="*res://autoload/rhythm_manager.gd"
+CombatManager="*res://autoload/combat_manager.gd"
 MCPScreenshot="*res://addons/godot_mcp/mcp_screenshot_service.gd"
 MCPInputService="*res://addons/godot_mcp/mcp_input_service.gd"
 MCPGameInspector="*res://addons/godot_mcp/mcp_game_inspector_service.gd"
@@ -27,36 +30,49 @@ enabled=PackedStringArray("res://addons/godot_mcp/plugin.cfg")
 
 [input]
 
-jump={
-"deadzone": 0.5,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":32,"physical_keycode":32,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
-]
-}
-player_w={
-"deadzone": 0.2,
-"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
-])
-}
-player_a={
+move_left={
 "deadzone": 0.2,
 "events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ])
 }
-player_s={
-"deadzone": 0.2,
-"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
-])
-}
-player_space={
-"deadzone": 0.2,
-"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":32,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
-])
-}
-player_d={
+move_right={
 "deadzone": 0.2,
 "events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
 ])
 }
+combo_w={
+"deadzone": 0.2,
+"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+])
+}
+combo_a={
+"deadzone": 0.2,
+"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+])
+}
+combo_s={
+"deadzone": 0.2,
+"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+])
+}
+combo_space={
+"deadzone": 0.2,
+"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":32,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+])
+}
+combo_d={
+"deadzone": 0.2,
+"events": Array[InputEvent]([Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+])
+}
+
+[layer_names]
+
+2d_physics/layer_1="world"
+2d_physics/layer_2="player_hurtbox"
+2d_physics/layer_3="enemy_hurtbox"
+2d_physics/layer_4="player_hitbox"
+2d_physics/layer_5="enemy_hitbox"
 
 [physics]
 

resources/action_data.gd

@@ -0,0 +1,33 @@
+class_name ActionData
+extends Resource
+
+@export var id: StringName
+@export var display_name: String
+@export var input_pattern: Array[StringName] = []
+@export var required_state: StringName = &"any"
+@export var base_cost := 0.0
+@export var damage_mult := 1.0
+@export var move_mult_x := 0.0
+@export var move_mult_y := 0.0
+@export var action_beats := 1.0
+@export var hit_type: StringName = &"melee"
+@export var range := 0.0
+@export var target_type: StringName = &"single"
+@export var armor_level := 0
+@export var clear_window := true
+@export var can_chain := false
+@export var special: StringName = &""
+@export var startup_beats := 0.25
+@export var active_beats := 0.25
+@export var recovery_beats := 0.5
+@export_range(0.0, 1.0, 0.05) var cancel_from := 0.5
+
+@export var animation: StringName
+@export var energy_cost := 0.0
+@export var energy_reward := 0.0
+@export var spawns_projectile := false
+@export var projectile_scene: PackedScene
+@export var damage := 10
+@export var cancel_window := Vector2(0.3, 0.6)
+@export var has_super_armor := false
+@export var displacement: StringName = &""

resources/action_data.gd.uid

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

resources/actions/skill_a.tres

@@ -0,0 +1,17 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_a"
+display_name = "A"
+input_pattern = Array[StringName]([&"A"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a"
+energy_reward = 1.0
+displacement = &"left"
+clear_window = false

resources/actions/skill_a_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_a_space"
+display_name = "A+SP"
+input_pattern = Array[StringName]([&"A", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space"
+displacement = &"left"
+clear_window = true

resources/actions/skill_aa.tres

@@ -0,0 +1,17 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_aa"
+display_name = "A+A"
+input_pattern = Array[StringName]([&"A", &"A"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_aa"
+energy_reward = 1.0
+displacement = &"left"
+clear_window = false

resources/actions/skill_aa_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_aa_space"
+display_name = "A+A+SP"
+input_pattern = Array[StringName]([&"A", &"A", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space_space"
+displacement = &"left"
+clear_window = true

resources/actions/skill_aaa.tres

@@ -0,0 +1,17 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_aaa"
+display_name = "A+A+A"
+input_pattern = Array[StringName]([&"A", &"A", &"A"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_aaa"
+energy_reward = 1.0
+displacement = &"left"
+clear_window = false

resources/actions/skill_ad_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_ad_space"
+display_name = "A+D+SP"
+input_pattern = Array[StringName]([&"A", &"D", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space_space"
+displacement = &"right"
+clear_window = true

resources/actions/skill_d.tres

@@ -0,0 +1,17 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_d"
+display_name = "D"
+input_pattern = Array[StringName]([&"D"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a"
+energy_reward = 1.0
+displacement = &"right"
+clear_window = false

resources/actions/skill_d_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_d_space"
+display_name = "D+SP"
+input_pattern = Array[StringName]([&"D", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space"
+displacement = &"right"
+clear_window = true

resources/actions/skill_d_space_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_d_space_space"
+display_name = "D+SP+SP"
+input_pattern = Array[StringName]([&"D", &"SP", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space_space"
+displacement = &"right"
+clear_window = true

resources/actions/skill_da_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_da_space"
+display_name = "D+A+SP"
+input_pattern = Array[StringName]([&"D", &"A", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space_space"
+displacement = &"left"
+clear_window = true

resources/actions/skill_dd.tres

@@ -0,0 +1,17 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_dd"
+display_name = "D+D"
+input_pattern = Array[StringName]([&"D", &"D"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_aa"
+energy_reward = 1.0
+displacement = &"right"
+clear_window = false

resources/actions/skill_dd_space.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_dd_space"
+display_name = "D+D+SP"
+input_pattern = Array[StringName]([&"D", &"D", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_a_space_space"
+displacement = &"right"
+clear_window = true

resources/actions/skill_ddd.tres

@@ -0,0 +1,17 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_ddd"
+display_name = "D+D+D"
+input_pattern = Array[StringName]([&"D", &"D", &"D"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_aaa"
+energy_reward = 1.0
+displacement = &"right"
+clear_window = false

resources/actions/skill_s.tres

@@ -0,0 +1,15 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s"
+display_name = "S"
+input_pattern = Array[StringName]([&"S"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s"
+clear_window = false

resources/actions/skill_s_projectile_1.tres

@@ -0,0 +1,20 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+[ext_resource type="PackedScene" path="res://scenes/combat/player_projectile.tscn" id="2"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s_projectile_1"
+display_name = "S+SP"
+input_pattern = Array[StringName]([&"S", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s_projectile"
+energy_cost = 3.0
+spawns_projectile = true
+projectile_scene = ExtResource("2")
+clear_window = false
+can_chain = true

resources/actions/skill_s_projectile_2.tres

@@ -0,0 +1,20 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+[ext_resource type="PackedScene" path="res://scenes/combat/player_projectile.tscn" id="2"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s_projectile_2"
+display_name = "S+SP+SP"
+input_pattern = Array[StringName]([&"S", &"SP", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s_projectile"
+energy_cost = 2.0
+spawns_projectile = true
+projectile_scene = ExtResource("2")
+clear_window = false
+can_chain = true

resources/actions/skill_s_projectile_3.tres

@@ -0,0 +1,20 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+[ext_resource type="PackedScene" path="res://scenes/combat/player_projectile.tscn" id="2"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s_projectile_3"
+display_name = "S+SP+SP+SP"
+input_pattern = Array[StringName]([&"S", &"SP", &"SP", &"SP"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s_projectile"
+energy_cost = 1.0
+spawns_projectile = true
+projectile_scene = ExtResource("2")
+clear_window = false
+can_chain = true

resources/actions/skill_ss.tres

@@ -0,0 +1,15 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s"
+display_name = "S"
+input_pattern = Array[StringName]([&"S", &"S"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s"
+clear_window = false

resources/actions/skill_sss.tres

@@ -0,0 +1,15 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s"
+display_name = "S"
+input_pattern = Array[StringName]([&"S", &"S", &"S"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s"
+clear_window = false

resources/actions/skill_ssss.tres

@@ -0,0 +1,15 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_s"
+display_name = "S"
+input_pattern = Array[StringName]([&"S", &"S", &"S", &"S"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_s"
+clear_window = false

resources/actions/skill_w.tres

@@ -0,0 +1,15 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_w"
+display_name = "W"
+input_pattern = Array[StringName]([&"W"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_w"
+clear_window = false

resources/actions/skill_wa.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_wa"
+display_name = "W+A"
+input_pattern = Array[StringName]([&"W", &"A"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_wa"
+displacement = &"left"
+clear_window = false

resources/actions/skill_wd.tres

@@ -0,0 +1,16 @@
+[gd_resource type="Resource" script_class="ActionData" load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://resources/action_data.gd" id="1"]
+
+[resource]
+script = ExtResource("1")
+id = &"skill_wd"
+display_name = "W+D"
+input_pattern = Array[StringName]([&"W", &"D"])
+startup_beats = 0.25
+active_beats = 0.25
+recovery_beats = 0.5
+cancel_from = 0.5
+animation = &"warrior_wa"
+displacement = &"right"
+clear_window = false

resources/beat_chart.gd

@@ -0,0 +1,27 @@
+class_name BeatChart
+extends Resource
+
+@export var chart_id: StringName = &""
+@export var total_beats := 0
+@export var tracks: Array = []
+
+
+func all_events() -> Array:
+	var result: Array = []
+	for track in tracks:
+		if not track is Resource:
+			continue
+		for event in track.call("sorted_events"):
+			result.append(event)
+	result.sort_custom(func(a: Resource, b: Resource) -> bool:
+		var a_position := float(a.call("beat_position"))
+		var b_position := float(b.call("beat_position"))
+		if is_equal_approx(a_position, b_position):
+			return str(a.get("event_type")) < str(b.get("event_type"))
+		return a_position < b_position
+	)
+	return result
+
+
+func is_empty() -> bool:
+	return all_events().is_empty()

resources/beat_chart.gd.uid

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

resources/chart_event.gd

@@ -0,0 +1,26 @@
+class_name ChartEvent
+extends Resource
+
+@export var event_id: StringName = &""
+@export var beat_index := 0
+@export var subdivision := 0
+@export var subdivisions_per_beat := 1
+@export var event_type: StringName = &""
+@export var target_id: StringName = &""
+@export var payload: Dictionary = {}
+@export var lead_beats := 1.0
+
+
+func beat_position() -> float:
+	var safe_subdivisions := maxi(1, subdivisions_per_beat)
+	return float(beat_index) + float(subdivision) / float(safe_subdivisions)
+
+
+func time_seconds(beat_time: float) -> float:
+	return beat_position() * maxf(0.001, beat_time)
+
+
+func key() -> StringName:
+	if not event_id.is_empty():
+		return event_id
+	return StringName("%s:%s:%d:%d" % [event_type, target_id, beat_index, subdivision])

resources/chart_event.gd.uid

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

resources/chart_track.gd

@@ -0,0 +1,17 @@
+class_name ChartTrack
+extends Resource
+
+@export var track_id: StringName = &""
+@export var track_type: StringName = &""
+@export var events: Array = []
+
+
+func sorted_events() -> Array:
+	var result: Array = []
+	for event in events:
+		if event is Resource:
+			result.append(event)
+	result.sort_custom(func(a: Resource, b: Resource) -> bool:
+		return float(a.call("beat_position")) < float(b.call("beat_position"))
+	)
+	return result

resources/chart_track.gd.uid

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

scenes/characters/character.gd

@@ -131,3 +131,13 @@ func start_directional_air_attack(direction: Vector2) -> void:
 	attack_time_left = air_attack_duration
 	attack_lunge_time_left = air_attack_lunge_duration
 	velocity = Vector2(attack_x * air_attack_lunge_speed, 0.0)
+
+
+func begin_attack_motion(duration: float, next_velocity: Vector2) -> void:
+	attack_lunge_time_left = maxf(0.0, duration)
+	velocity = next_velocity
+
+
+func stop_attack_motion() -> void:
+	attack_lunge_time_left = 0.0
+	velocity = Vector2.ZERO

scenes/characters/player.gd

@@ -7,109 +7,71 @@ signal charge_changed(current: float, maximum: float, ready: bool, active: bool)
 signal energy_changed(current: int, maximum: int)
 signal health_changed(current: int, maximum: int)
 signal skill_requested(skill_id: String)
+signal projectile_requested(projectile_scene: PackedScene, spawn_position: Vector2, direction: Vector2)
 
 @export var combo_clear_display_time := 0.35
-@export var charge_duration := 1.1
 @export var max_health := 100
 @export var current_health := 100
 @export var max_energy := 10
 @export var current_energy := 0
 
-var combo_window := ComboWindow.new()
+@onready var state_machine: Node = $StateMachine
+@onready var input_component: Node = $InputComponent
+@onready var combo_window: Node = $ComboWindow
+@onready var action_controller: Node = $ActionController
+@onready var motion_executor: Node = $MotionExecutor
+@onready var burst_component: Node = $BurstComponent
+@onready var charge_component: Node = $ChargeComponent
+@onready var energy_component: Node = $EnergyComponent
+@onready var health_component: Node = $HealthComponent
+@onready var damage_receiver: Area2D = $DamageReceiver
+
 var last_requested_skill_id := ""
 var current_skill_animation := ""
-var combo_clear_timer: Timer
-var charge_value := 0.0
-var charge_ready := false
-var charge_active := false
-var _pending_combo_clear_reason := ""
-var _charge_effect_time := 0.0
-var _charge_animation_time := 0.0
-var _charge_hold_symbol := ""
-var _charge_hold_direction := Vector2.ZERO
-var _suppressed_movement_actions := {
-	"player_a": false,
-	"player_d": false,
-}
-var _last_combo_input_accepted := false
+var _held_symbols: Dictionary = {}
 
 
 func _ready() -> void:
-	combo_clear_timer = Timer.new()
-	combo_clear_timer.one_shot = true
-	combo_clear_timer.wait_time = combo_clear_display_time
-	combo_clear_timer.timeout.connect(flush_pending_combo_clear)
-	add_child(combo_clear_timer)
-	combo_window.window_cleared.connect(_on_combo_window_cleared)
-	_emit_combo_window_changed()
-	_emit_charge_changed()
-	_emit_health_changed()
-	_emit_energy_changed()
+	combo_window.clear_display_time = combo_clear_display_time
+	input_component.intent_created.connect(_on_input_intent_created)
+	action_controller.action_started.connect(_on_action_started)
+	action_controller.action_active_started.connect(_on_action_active_started)
+	action_controller.action_finished.connect(_on_action_finished)
+	action_controller.action_rejected.connect(_on_action_rejected)
+	combo_window.combo_updated.connect(_on_combo_updated)
+	combo_window.combo_cleared.connect(_on_combo_cleared)
+	charge_component.charge_changed.connect(_on_charge_component_changed)
+	charge_component.release_requested.connect(_execute_charge_release)
+	energy_component.energy_changed.connect(_on_energy_component_changed)
+	health_component.health_changed.connect(_on_health_component_changed)
+	damage_receiver.damage_received.connect(_on_damage_received)
+	energy_component.set_values(current_energy, max_energy)
+	health_component.set_values(current_health, max_health)
 
 
 func _process(delta: float) -> void:
-	_update_charge(delta)
+	charge_component.tick(delta, state == State.IDLE)
+	if charge_component.is_active():
+		state = State.IDLE
+		attack_time_left = 0.0
+		stop_attack_motion()
 
 
 func _input(event: InputEvent) -> void:
-	if _handle_combo_key_event(event):
+	if input_component.handle_input_event(event):
 		_mark_input_handled()
 
 
 func _unhandled_input(event: InputEvent) -> void:
-	if _handle_combo_key_event(event):
+	if input_component.handle_input_event(event):
 		_mark_input_handled()
 
 
-func _handle_combo_key_event(event: InputEvent) -> bool:
-	var key_event := event as InputEventKey
-	if key_event == null or key_event.echo:
-		return false
-	if not key_event.pressed:
-		if _event_matches_key(key_event, KEY_A):
-			_set_movement_action_suppressed("player_a", false)
-			_finish_charge_hold("A")
-			return true
-		elif _event_matches_key(key_event, KEY_D):
-			_set_movement_action_suppressed("player_d", false)
-			_finish_charge_hold("D")
-			return true
-		return false
-	if _event_matches_key(key_event, KEY_W):
-		_submit_combo_input_from_event("W")
-		return true
-	elif _event_matches_key(key_event, KEY_A):
-		_set_movement_action_suppressed("player_a", true)
-		heading = Vector2.LEFT
-		_submit_combo_input_from_event("A")
-		if _last_combo_input_accepted:
-			_begin_charge_hold("A", Vector2.LEFT)
-		return true
-	elif _event_matches_key(key_event, KEY_D):
-		_set_movement_action_suppressed("player_d", true)
-		heading = Vector2.RIGHT
-		_submit_combo_input_from_event("D")
-		if _last_combo_input_accepted:
-			_begin_charge_hold("D", Vector2.RIGHT)
-		return true
-	elif _event_matches_key(key_event, KEY_S):
-		_submit_combo_input_from_event("S")
-		return true
-	elif _event_matches_key(key_event, KEY_SPACE):
-		_submit_combo_input_from_event("SP")
-		return true
-	return false
-
-
 func handle_input() -> void:
-	if charge_active:
+	if charge_component.is_active():
 		velocity = Vector2.ZERO
 		return
 	_apply_horizontal_movement()
-	if Input.is_action_just_pressed("jump") and not Input.is_action_just_pressed("player_space"):
-		judge_rhythm_action("jump")
-		if can_jump():
-			start_jump()
 
 
 func set_heading() -> void:
@@ -119,90 +81,260 @@ func set_heading() -> void:
 		heading = Vector2.LEFT
 
 
-func get_combo_slots() -> Array[String]:
+func get_combo_slots() -> Array[StringName]:
 	return combo_window.get_slots()
 
 
 func get_energy() -> int:
+	current_energy = energy_component.current
 	return current_energy
 
 
 func get_max_energy() -> int:
+	max_energy = energy_component.maximum
 	return max_energy
 
 
 func get_health() -> int:
+	current_health = health_component.current
 	return current_health
 
 
 func get_max_health() -> int:
+	max_health = health_component.maximum
 	return max_health
 
 
 func get_charge() -> float:
-	return charge_value
+	return charge_component.value
 
 
 func get_max_charge() -> float:
-	return charge_duration
+	return charge_component.maximum()
 
 
 func is_charge_active() -> bool:
-	return charge_active
+	return charge_component.is_active()
 
 
 func is_charge_ready() -> bool:
-	return charge_ready
+	return charge_component.is_ready()
 
 
 func submit_combo_input(symbol: String, forced_rating := "") -> String:
+	var data := _symbol_to_intent_data(symbol)
+	if data.is_empty():
+		return ""
+	var intent: RefCounted = load("res://scenes/components/input_intent.gd").create(data["symbol"], data["rhythm_action"], &"pressed", float(Time.get_ticks_msec()))
+	if not forced_rating.is_empty():
+		intent.judgement = _rating_result(StringName(forced_rating), 0.0)
+	action_controller.submit_intent(intent)
+	return last_requested_skill_id
+
+
+func _symbol_to_intent_data(symbol: String) -> Dictionary:
 	match symbol:
 		"W":
-			return _record_combo_symbol("W", "w", forced_rating)
+			return {"symbol": &"W", "rhythm_action": &"w"}
 		"A":
-			return _record_combo_symbol("A", "a", forced_rating)
+			return {"symbol": &"A", "rhythm_action": &"a"}
 		"D":
-			return _record_combo_symbol("D", "d", forced_rating)
+			return {"symbol": &"D", "rhythm_action": &"d"}
 		"S":
-			return _record_combo_symbol("S", "s", forced_rating)
+			return {"symbol": &"S", "rhythm_action": &"s"}
 		"SP":
-			return _record_combo_symbol("SP", "space", forced_rating)
-	return ""
+			return {"symbol": &"SP", "rhythm_action": &"space"}
+	return {}
 
 
-func _record_combo_symbol(symbol: String, rhythm_action: String, forced_rating := "") -> String:
-	_last_combo_input_accepted = false
-	var rating := _rating_or_forced(judge_rhythm_action(rhythm_action), forced_rating)
-	if not _record_rated_combo_input(symbol, rating):
-		if symbol == "A" or symbol == "D":
+func flush_pending_combo_clear() -> void:
+	combo_window.flush_pending_clear()
+
+
+func _play_skill_animation(animation_name: String, displacement_direction := Vector2.ZERO, skill: Resource = null) -> void:
+	current_skill_animation = animation_name
+	anim_map[State.ATTACK] = animation_name
+	state = State.ATTACK
+	state_machine.change_state(state)
+	attack_time_left = _animation_length(animation_name)
+	if displacement_direction == Vector2.ZERO:
+		stop_attack_motion()
+	else:
+		heading = displacement_direction
+		if skill != null:
+			motion_executor.execute(skill, displacement_direction, _rhythm_beat_time(), attack_lunge_speed)
+			attack_time_left = motion_executor.duration
+			begin_attack_motion(motion_executor.duration, motion_executor.velocity)
+	if animation_player != null and animation_player.has_animation(animation_name):
+		animation_player.play(animation_name)
+
+
+func _skill_displacement_direction(skill: Resource) -> Vector2:
+	match StringName(str(skill.get("displacement"))):
+		&"left":
+			return Vector2.LEFT
+		&"right":
+			return Vector2.RIGHT
+	return Vector2.ZERO
+
+
+func _begin_charge_hold(symbol: StringName, direction: Vector2) -> void:
+	charge_component.begin_hold(symbol, direction)
+
+
+func _finish_charge_hold(symbol: StringName) -> void:
+	charge_component.finish_hold(symbol)
+
+
+func _execute_charge_release(skill_id: StringName, direction: Vector2) -> void:
+	last_requested_skill_id = str(skill_id)
+	current_skill_animation = "warrior_charge_release"
+	skill_requested.emit(last_requested_skill_id)
+	_play_skill_animation(current_skill_animation, direction)
+
+
+func _cancel_missed_direction_action() -> void:
+	stop_attack_motion()
+	attack_time_left = 0.0
+	state = State.IDLE
+	current_skill_animation = "warrior_idle"
+	if animation_player != null and animation_player.has_animation("warrior_idle"):
+		animation_player.play("warrior_idle")
+
+
+func _apply_horizontal_movement() -> void:
+	if state != State.IDLE and state != State.WALK:
+		return
+	var direction: float = input_component.get_horizontal_axis()
+	if direction < 0.0:
+		heading = Vector2.LEFT
+	elif direction > 0.0:
+		heading = Vector2.RIGHT
+	velocity.x = direction * speed
+
+
+func _animation_length(animation_name: String) -> float:
+	if animation_player != null and animation_player.has_animation(animation_name):
+		return maxf(0.1, animation_player.get_animation(animation_name).length)
+	return attack_duration
+
+
+func _request_projectile(skill: Resource) -> void:
+	var spawn_position := global_position + Vector2(heading.x * 36.0, -30.0)
+	var projectile_scene := skill.get("projectile_scene") as PackedScene
+	projectile_requested.emit(projectile_scene, spawn_position, heading)
+	_event_bus().emit_signal("projectile_requested", projectile_scene, spawn_position, heading)
+
+
+func _rhythm_beat_time() -> float:
+	var rhythm := get_tree().root.get_node_or_null("RhythmManager") if is_inside_tree() else null
+	if rhythm != null:
+		return float(rhythm.get("beat_time"))
+	return 0.5
+
+
+func _on_input_intent_created(intent) -> void:
+	if intent.is_pressed():
+		_held_symbols[intent.symbol] = true
+	elif intent.is_released():
+		_held_symbols.erase(intent.symbol)
+	action_controller.submit_intent(intent)
+	if intent.is_pressed() and (intent.symbol == &"A" or intent.symbol == &"D"):
+		input_component.set_direction_suppressed(intent.symbol, true)
+	if intent.is_released() and (intent.symbol == &"A" or intent.symbol == &"D"):
+		input_component.set_direction_suppressed(intent.symbol, false)
+		_finish_charge_hold(intent.symbol)
+
+
+func _on_action_started(action: Resource, intent) -> void:
+	current_energy = energy_component.current
+	last_requested_skill_id = str(action.get("id"))
+	current_skill_animation = str(action.get("animation"))
+	skill_requested.emit(last_requested_skill_id)
+	var displacement_direction := _skill_displacement_direction(action)
+	if displacement_direction != Vector2.ZERO:
+		heading = displacement_direction
+	_play_skill_animation(current_skill_animation)
+	if intent.is_pressed() and _is_symbol_held(intent.symbol) and (intent.symbol == &"A" or intent.symbol == &"D"):
+		_begin_charge_hold(intent.symbol, Vector2.LEFT if intent.symbol == &"A" else Vector2.RIGHT)
+
+
+func _on_action_active_started(action: Resource, intent) -> void:
+	current_energy = energy_component.current
+	_event_bus().emit_signal("skill_executed", action, StringName(str(intent.judgement.get("label", "perfect"))))
+	_start_skill_motion(action)
+	if bool(action.get("spawns_projectile")):
+		_request_projectile(action)
+
+
+func _on_action_finished(_action: Resource) -> void:
+	_set_idle_presentation()
+
+
+func _on_action_rejected(intent, reason: StringName) -> void:
+	if reason == &"miss" and (intent.symbol == &"A" or intent.symbol == &"D"):
 		_cancel_missed_direction_action()
-		return ""
-	_last_combo_input_accepted = true
-	var resolved := InputResolver.resolve(combo_window)
-	if resolved.is_empty() and _pending_combo_clear_reason == "full":
-		resolved = _resolve_full_window_fallback(symbol)
-	if not resolved.is_empty():
-		if not _execute_combo_skill(resolved):
-			return ""
-		_apply_skill_energy_reward(last_requested_skill_id)
-	if symbol == "SP" and not _is_projectile_space_chain() and _pending_combo_clear_reason.is_empty():
-		_schedule_combo_clear("space")
-	return last_requested_skill_id if not resolved.is_empty() else ""
 
 
-func _submit_combo_input_from_event(symbol: String) -> String:
-	return submit_combo_input(symbol)
+func _start_skill_motion(action: Resource) -> void:
+	var displacement_direction := _skill_displacement_direction(action)
+	if displacement_direction == Vector2.ZERO:
+		return
+	heading = displacement_direction
+	motion_executor.execute(action, displacement_direction, _rhythm_beat_time(), attack_lunge_speed)
+	attack_time_left = maxf(attack_time_left, motion_executor.duration)
+	begin_attack_motion(motion_executor.duration, motion_executor.velocity)
 
 
-func _event_matches_key(event: InputEventKey, key: Key) -> bool:
-	return event.physical_keycode == key or event.keycode == key
+func _is_symbol_held(symbol: StringName) -> bool:
+	return bool(_held_symbols.get(symbol, false))
 
 
-func _event_matches_any_key(event: InputEventKey, keys: Array[Key]) -> bool:
-	for key: Key in keys:
-		if _event_matches_key(event, key):
-			return true
-	return false
+func _set_idle_presentation() -> void:
+	stop_attack_motion()
+	attack_time_left = 0.0
+	state = State.IDLE
+	state_machine.change_state(state)
+	current_skill_animation = "warrior_idle"
+	if animation_player != null and animation_player.has_animation("warrior_idle"):
+		animation_player.play("warrior_idle")
+
+
+func _on_combo_updated(slots: Array[StringName]) -> void:
+	combo_window_changed.emit(slots)
+
+
+func _on_combo_cleared(reason: StringName) -> void:
+	combo_window_cleared.emit(str(reason))
+
+
+func _on_charge_component_changed(current: float, maximum: float, ready: bool, active: bool) -> void:
+	charge_changed.emit(current, maximum, ready, active)
+	_event_bus().emit_signal("player_charge_changed", current, maximum, ready, active)
+
+
+func _on_energy_component_changed(current: int, maximum: int) -> void:
+	current_energy = current
+	max_energy = maximum
+	energy_changed.emit(current, maximum)
+
+
+func _on_health_component_changed(current: int, maximum: int) -> void:
+	current_health = current
+	max_health = maximum
+	health_changed.emit(current, maximum)
+
+
+func _on_damage_received(amount: int, _hit_type: StringName, _from: Vector2) -> void:
+	health_component.apply_damage(amount)
+
+
+func _rating_result(label: StringName, offset_ms: float) -> Dictionary:
+	return {
+		"label": str(label),
+		"diff": offset_ms / 1000.0,
+		"abs_diff": absf(offset_ms / 1000.0),
+	}
 
 
 func _mark_input_handled() -> void:
@@ -211,338 +343,11 @@ func _mark_input_handled() -> void:
 		viewport.set_input_as_handled()
 
 
-func _record_combo_direction(symbol: String, direction: Vector2, rhythm_action: String, forced_rating := "") -> void:
-	heading = direction
-	var rating := _rating_or_forced(judge_rhythm_action(rhythm_action), forced_rating)
-	_record_rated_combo_input(symbol, rating)
-	if state == State.IDLE or state == State.WALK:
-		velocity.x = 0.0
-
-
-func _record_rated_combo_input(symbol: String, rating: Dictionary) -> bool:
-	if str(rating.get("label", "perfect")) == "miss":
-		_record_combo_input("Ø")
-		return false
-	_record_combo_input(symbol)
-	return true
-
-
-func _record_combo_input(symbol: String) -> void:
-	if combo_window.has_pending_clear() or not _pending_combo_clear_reason.is_empty():
-		if _pending_combo_clear_reason.begins_with("skill:") and not combo_window.has_pending_clear():
-			_cancel_pending_combo_clear()
-		else:
-			flush_pending_combo_clear()
-	combo_window.record(symbol)
-	_emit_combo_window_changed()
-	var reason := combo_window.consume_pending_clear_reason()
-	if not reason.is_empty():
-		_schedule_combo_clear(reason)
-
-
-func _rating_or_forced(rating: Dictionary, forced_rating: String) -> Dictionary:
-	if forced_rating.is_empty():
-		return rating
-	var forced := rating.duplicate()
-	forced["label"] = forced_rating
-	return forced
-
-
-func _execute_combo_skill(skill: Dictionary) -> bool:
-	if not _spend_skill_energy(skill):
-		return false
-	last_requested_skill_id = str(skill.get("id", ""))
-	current_skill_animation = str(skill.get("animation", "warrior_idle"))
-	skill_requested.emit(last_requested_skill_id)
-	judge_rhythm_action(last_requested_skill_id)
-	_play_skill_animation(current_skill_animation, _skill_displacement_direction(skill))
-	if bool(skill.get("projectile", false)):
-		_fire_projectile()
-	_emit_combo_window_changed()
-	if bool(skill.get("clear_window", false)):
-		_schedule_combo_clear("skill:%s" % last_requested_skill_id)
-	return true
-
-
-func _play_skill_animation(animation_name: String, displacement_direction := Vector2.ZERO) -> void:
-	var player_animation := _get_animation_player()
-	anim_map[State.ATTACK] = animation_name
-	state = State.ATTACK
-	attack_time_left = _animation_length(animation_name)
-	if displacement_direction == Vector2.ZERO:
-		attack_lunge_time_left = 0.0
-		velocity = Vector2.ZERO
-	else:
-		heading = displacement_direction
-		attack_lunge_time_left = attack_lunge_duration
-		velocity = Vector2(displacement_direction.x * attack_lunge_speed, 0.0)
-	if player_animation != null and player_animation.has_animation(animation_name):
-		player_animation.play(animation_name)
-
-
-func _skill_displacement_direction(skill: Dictionary) -> Vector2:
-	match str(skill.get("displacement", "")):
-		"left":
-			return Vector2.LEFT
-		"right":
-			return Vector2.RIGHT
-	return Vector2.ZERO
-
-
-func _apply_skill_energy_reward(skill_id: String) -> void:
-	match skill_id:
-		"skill_a", "skill_aa", "skill_aaa", "skill_d", "skill_dd", "skill_ddd":
-			_change_energy(1)
-
-
-func _spend_skill_energy(skill: Dictionary) -> bool:
-	var energy_cost := int(skill.get("energy_cost", 0))
-	if energy_cost <= 0:
-		return true
-	if current_energy < energy_cost:
-		return false
-	_change_energy(-energy_cost)
-	return true
-
-
-func _change_energy(delta: int) -> void:
-	var next_energy := clampi(current_energy + delta, 0, max_energy)
-	if next_energy == current_energy:
-		return
-	current_energy = next_energy
-	_emit_energy_changed()
-
-
-func _begin_charge_hold(symbol: String, direction: Vector2) -> void:
-	_charge_hold_symbol = symbol
-	_charge_hold_direction = direction
-
-
-func _finish_charge_hold(symbol: String) -> void:
-	if _charge_hold_symbol != symbol:
-		return
-	var release_ready := charge_active and charge_ready
-	var release_direction := _charge_hold_direction
-	var release_skill := "skill_a_charge_release" if symbol == "A" else "skill_d_charge_release"
-	_cancel_charge()
-	if release_ready:
-		_execute_charge_release(release_skill, release_direction)
-
-
-func _update_charge(delta: float) -> void:
-	if _charge_hold_symbol.is_empty():
-		return
-	if not charge_active:
-		if state != State.IDLE:
-			return
-		_start_charge()
-	if not charge_active:
-		return
-	state = State.IDLE
-	attack_time_left = 0.0
-	attack_lunge_time_left = 0.0
-	velocity = Vector2.ZERO
-	_update_charge_animation(delta)
-	charge_value = minf(charge_duration, charge_value + delta)
-	charge_ready = charge_value >= charge_duration
-	_update_charge_effect(delta)
-	_emit_charge_changed()
-
-
-func _start_charge() -> void:
-	charge_active = true
-	charge_value = 0.0
-	charge_ready = false
-	_charge_effect_time = 0.0
-	_charge_animation_time = 0.0
-	_play_charge_animation("warrior_charge_intro")
-	_update_charge_effect(0.0)
-	_emit_charge_changed()
-
-
-func _cancel_charge() -> void:
-	_charge_hold_symbol = ""
-	_charge_hold_direction = Vector2.ZERO
-	charge_active = false
-	charge_value = 0.0
-	charge_ready = false
-	_charge_animation_time = 0.0
-	_set_charge_effect_visible(false)
-	_emit_charge_changed()
-
-
-func _execute_charge_release(skill_id: String, direction: Vector2) -> void:
-	last_requested_skill_id = skill_id
-	current_skill_animation = "warrior_charge_release"
-	skill_requested.emit(last_requested_skill_id)
-	_play_skill_animation(current_skill_animation, direction)
-
-
-func _update_charge_effect(delta: float) -> void:
-	var sprite := _get_charge_effect_sprite()
-	if sprite == null:
-		return
-	sprite.visible = charge_active
-	if not charge_active:
-		return
-	_charge_effect_time += delta
-	sprite.frame = int(_charge_effect_time * 12.0) % 5
-
-
-func _update_charge_animation(delta: float) -> void:
-	_charge_animation_time += delta
-	var intro_length := _animation_length("warrior_charge_intro")
-	if _charge_animation_time < intro_length:
-		_play_charge_animation("warrior_charge_intro")
-	else:
-		_play_charge_animation("warrior_charge_loop")
-
-
-func _play_charge_animation(animation_name: String) -> void:
-	var player_animation := _get_animation_player()
-	if player_animation != null and player_animation.has_animation(animation_name) and player_animation.current_animation != animation_name:
-		player_animation.play(animation_name)
-
-
-func _set_charge_effect_visible(is_visible: bool) -> void:
-	var sprite := _get_charge_effect_sprite()
-	if sprite != null:
-		sprite.visible = is_visible
-
-
-func _get_charge_effect_sprite() -> Sprite2D:
-	if has_node("ChargeEffectSprite"):
-		return get_node("ChargeEffectSprite") as Sprite2D
-	return null
-
-
-func _resolve_full_window_fallback(symbol: String) -> Dictionary:
-	if symbol != "A" and symbol != "D":
-		return {}
-	return InputResolver.resolve_pattern(symbol)
-
-
-func _cancel_missed_direction_action() -> void:
-	velocity = Vector2.ZERO
-	attack_lunge_time_left = 0.0
-	attack_time_left = 0.0
-	state = State.IDLE
-	anim_map[State.ATTACK] = "warrior_a"
-	var player_animation := _get_animation_player()
-	if player_animation != null and player_animation.has_animation("warrior_idle"):
-		player_animation.play("warrior_idle")
-
-
-func _is_projectile_space_chain() -> bool:
-	var pattern := combo_window.get_contiguous_pattern()
-	return pattern == "SSP" or pattern == "SSPSP" or pattern == "SSPSPSP"
-
-
-func _apply_horizontal_movement() -> void:
-	if charge_active:
-		velocity.x = 0.0
-		return
-	if state != State.IDLE and state != State.WALK:
-		return
-	var direction := 0.0
-	if _is_movement_action_pressed("player_a"):
-		direction -= 1.0
-	if _is_movement_action_pressed("player_d"):
-		direction += 1.0
-	if direction < 0.0:
-		heading = Vector2.LEFT
-	elif direction > 0.0:
-		heading = Vector2.RIGHT
-	velocity.x = direction * speed
-
-
-func _set_movement_action_suppressed(action_name: String, suppressed: bool) -> void:
-	_suppressed_movement_actions[action_name] = suppressed
-
-
-func _is_movement_action_pressed(action_name: String) -> bool:
-	return Input.is_action_pressed(action_name) and not bool(_suppressed_movement_actions.get(action_name, false))
-
-
-func _animation_length(animation_name: String) -> float:
-	var player_animation := _get_animation_player()
-	if player_animation != null and player_animation.has_animation(animation_name):
-		return maxf(0.1, player_animation.get_animation(animation_name).length)
-	return attack_duration
-
-
-func _get_animation_player() -> AnimationPlayer:
-	if animation_player == null and has_node("AnimationPlayer"):
-		animation_player = get_node("AnimationPlayer") as AnimationPlayer
-	return animation_player
-
-
-func _fire_projectile() -> void:
-	var projectile := PlayerProjectile.new()
-	projectile.direction = heading
-	projectile.global_position = global_position + Vector2(heading.x * 36.0, -30.0)
-	var parent := get_parent()
-	if parent != null:
-		parent.add_child(projectile)
-	else:
-		add_child(projectile)
-	projectile.add_to_group("player_projectiles")
-
-
-func _cancel_pending_combo_clear() -> void:
-	_pending_combo_clear_reason = ""
-	if combo_clear_timer != null:
-		combo_clear_timer.stop()
-
-
-func _schedule_combo_clear(reason: String) -> void:
-	_pending_combo_clear_reason = reason
-	if combo_clear_timer == null:
-		return
-	combo_clear_timer.stop()
-	combo_clear_timer.wait_time = combo_clear_display_time
-	combo_clear_timer.start()
-
-
-func flush_pending_combo_clear() -> void:
-	var reason := _pending_combo_clear_reason
-	if reason.is_empty():
-		reason = combo_window.consume_pending_clear_reason()
-	else:
-		combo_window.consume_pending_clear_reason()
-	if reason.is_empty():
-		return
-	_pending_combo_clear_reason = ""
-	if combo_clear_timer != null:
-		combo_clear_timer.stop()
-	combo_window.clear(reason)
-
-
-func _on_combo_window_cleared(reason: String) -> void:
-	combo_window_cleared.emit(reason)
-	_emit_combo_window_changed()
-
-
-func _emit_combo_window_changed() -> void:
-	combo_window_changed.emit(combo_window.get_slots())
-
-
-func _emit_charge_changed() -> void:
-	charge_changed.emit(charge_value, charge_duration, charge_ready, charge_active)
-
-
-func _emit_energy_changed() -> void:
-	energy_changed.emit(current_energy, max_energy)
-
-
-func _emit_health_changed() -> void:
-	health_changed.emit(current_health, max_health)
-
-
-func judge_rhythm_action(action_name: String) -> Dictionary:
-	if not is_inside_tree():
-		return {"label": "perfect"}
-	var conductor: Node = get_tree().get_first_node_in_group("rhythm_conductor")
-	if conductor != null and conductor.has_method("judge_action"):
-		return conductor.call("judge_action", action_name) as Dictionary
-	return {"label": "perfect"}
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/characters/player.tscn

@@ -4,6 +4,19 @@
 [ext_resource type="Texture2D" uid="uid://bbkamgcdsw5g6" path="res://assets/art/characters/warrior_man_sheet.png" id="2_yewv4"]
 [ext_resource type="Texture2D" uid="uid://womoel71g8ae" path="res://assets/art/characters/warrior_woman_sheet.png" id="3_dyp2m"]
 [ext_resource type="Texture2D" uid="uid://1p2uqgg1jole" path="res://assets/art/effects/effect_hp_mp_sheet.png" id="4_atpat"]
+[ext_resource type="Script" path="res://scenes/components/state_machine.gd" id="5_state_machine"]
+[ext_resource type="Script" path="res://scenes/components/input_component.gd" id="6_input_component"]
+[ext_resource type="Script" path="res://scenes/components/energy_component.gd" id="8_energy_component"]
+[ext_resource type="Script" path="res://scenes/components/health_component.gd" id="9_health_component"]
+[ext_resource type="Script" path="res://scenes/components/damage_receiver.gd" id="10_damage_receiver"]
+[ext_resource type="Script" path="res://scenes/components/damage_emitter.gd" id="11_damage_emitter"]
+[ext_resource type="Script" path="res://scenes/components/combo_window.gd" id="12_combo_window"]
+[ext_resource type="Script" path="res://scenes/combat/action_resolver.gd" id="13_action_resolver"]
+[ext_resource type="Script" path="res://scenes/components/motion_executor.gd" id="14_motion_executor"]
+[ext_resource type="Script" path="res://scenes/components/burst_component.gd" id="15_burst_component"]
+[ext_resource type="Script" path="res://scenes/components/charge_component.gd" id="16_charge_component"]
+[ext_resource type="Script" path="res://scenes/components/action_executor.gd" id="17_action_executor"]
+[ext_resource type="Script" path="res://scenes/components/action_controller.gd" id="18_action_controller"]
 
 [sub_resource type="RectangleShape2D" id="RectangleShape2D_player"]
 size = Vector2(16, 36)
@@ -596,7 +609,7 @@ tracks/4/keys = {
 
 [sub_resource type="Animation" id="Animation_6eyoc"]
 resource_name = "warrior_s"
-length = 0.71428573
+length = 0.21428573
 step = 0.071428575
 tracks/0/type = "value"
 tracks/0/imported = false
@@ -653,10 +666,10 @@ tracks/4/path = NodePath("CharacterSprite:frame")
 tracks/4/interp = 1
 tracks/4/loop_wrap = true
 tracks/4/keys = {
-"times": PackedFloat32Array(0, 0.071428575, 0.14285715, 0.21428572, 0.2857143, 0.35714287, 0.42857143, 0.5, 0.5714286, 0.64285713),
-"transitions": PackedFloat32Array(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
+"times": PackedFloat32Array(0, 0.071428575, 0.14285715),
+"transitions": PackedFloat32Array(1, 1, 1),
 "update": 1,
-"values": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137]
+"values": [128, 129, 130]
 }
 
 [sub_resource type="Animation" id="Animation_eojnx"]
@@ -905,3 +918,64 @@ position = Vector2(0, -8)
 texture = ExtResource("4_atpat")
 hframes = 5
 vframes = 2
+
+[node name="StateMachine" type="Node" parent="."]
+script = ExtResource("5_state_machine")
+
+[node name="InputComponent" type="Node" parent="."]
+script = ExtResource("6_input_component")
+
+[node name="ComboWindow" type="Node" parent="."]
+script = ExtResource("12_combo_window")
+
+[node name="ActionResolver" type="Node" parent="."]
+script = ExtResource("13_action_resolver")
+
+[node name="ActionExecutor" type="Node" parent="."]
+script = ExtResource("17_action_executor")
+energy_component_path = NodePath("../EnergyComponent")
+damage_emitter_path = NodePath("../DamageEmitter")
+
+[node name="ActionController" type="Node" parent="."]
+script = ExtResource("18_action_controller")
+combo_window_path = NodePath("../ComboWindow")
+action_resolver_path = NodePath("../ActionResolver")
+action_executor_path = NodePath("../ActionExecutor")
+state_machine_path = NodePath("../StateMachine")
+burst_component_path = NodePath("../BurstComponent")
+
+[node name="MotionExecutor" type="Node" parent="."]
+script = ExtResource("14_motion_executor")
+
+[node name="BurstComponent" type="Node" parent="."]
+script = ExtResource("15_burst_component")
+
+[node name="ChargeComponent" type="Node" parent="."]
+script = ExtResource("16_charge_component")
+animation_player_path = NodePath("../AnimationPlayer")
+effect_sprite_path = NodePath("../ChargeEffectSprite")
+
+[node name="EnergyComponent" type="Node" parent="."]
+script = ExtResource("8_energy_component")
+
+[node name="HealthComponent" type="Node" parent="."]
+script = ExtResource("9_health_component")
+
+[node name="DamageReceiver" type="Area2D" parent="."]
+collision_layer = 2
+collision_mask = 0
+script = ExtResource("10_damage_receiver")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="DamageReceiver"]
+position = Vector2(0, -18)
+shape = SubResource("RectangleShape2D_player")
+
+[node name="DamageEmitter" type="Area2D" parent="."]
+collision_layer = 8
+collision_mask = 4
+monitoring = false
+script = ExtResource("11_damage_emitter")
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="DamageEmitter"]
+position = Vector2(22, -18)
+shape = SubResource("RectangleShape2D_player")

scenes/chart/chart_runner.gd

@@ -0,0 +1,110 @@
+class_name ChartRunner
+extends Node
+
+signal chart_event_upcoming(event: Resource, time_to_event: float)
+signal chart_event_triggered(event: Resource)
+signal chart_reset(chart_id: StringName)
+signal chart_finished(chart_id: StringName)
+
+const UPCOMING_TIME_EPSILON := 0.02
+
+@export var chart: Resource
+@export var rhythm_manager_path: NodePath
+@export var beat_time_override := 0.0
+@export var auto_run := true
+
+var running := true
+var _upcoming_keys: Dictionary = {}
+var _triggered_keys: Dictionary = {}
+
+
+func _ready() -> void:
+	running = auto_run
+
+
+func _physics_process(_delta: float) -> void:
+	if not running or chart == null:
+		return
+	var rhythm := _rhythm_manager()
+	if rhythm == null or not rhythm.has_method("song_position"):
+		return
+	update_for_song_time(float(rhythm.call("song_position")))
+
+
+func set_chart(next_chart: Resource) -> void:
+	chart = next_chart
+	reset()
+
+
+func reset() -> void:
+	_upcoming_keys.clear()
+	_triggered_keys.clear()
+	var chart_id := &""
+	if chart != null:
+		chart_id = StringName(str(chart.get("chart_id")))
+	chart_reset.emit(chart_id)
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal("chart_reset", chart_id)
+
+
+func update_for_song_time(song_time: float) -> void:
+	if chart == null:
+		return
+	var beat_time := _beat_time()
+	for event: Resource in chart.call("all_events"):
+		var event_time := float(event.call("time_seconds", beat_time))
+		var time_to_event := event_time - song_time
+		var lead_time := maxf(0.0, float(event.get("lead_beats"))) * beat_time
+		var event_key: StringName = event.call("key")
+		if not _upcoming_keys.has(event_key) and time_to_event > 0.0 and time_to_event <= lead_time + UPCOMING_TIME_EPSILON:
+			_upcoming_keys[event_key] = true
+			_emit_upcoming(event, time_to_event)
+		if not _triggered_keys.has(event_key) and song_time >= event_time:
+			_triggered_keys[event_key] = true
+			_emit_triggered(event)
+
+
+func pause() -> void:
+	running = false
+
+
+func resume() -> void:
+	running = true
+
+
+func _emit_upcoming(event: Resource, time_to_event: float) -> void:
+	chart_event_upcoming.emit(event, time_to_event)
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal("chart_event_upcoming", event, time_to_event)
+
+
+func _emit_triggered(event: Resource) -> void:
+	chart_event_triggered.emit(event)
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal("chart_event_triggered", event)
+
+
+func _beat_time() -> float:
+	if beat_time_override > 0.0:
+		return beat_time_override
+	var rhythm := _rhythm_manager()
+	if rhythm != null:
+		return float(rhythm.get("beat_time"))
+	return 0.5
+
+
+func _rhythm_manager() -> Node:
+	if not is_inside_tree():
+		return null
+	if not rhythm_manager_path.is_empty():
+		return get_node_or_null(rhythm_manager_path)
+	return get_tree().root.get_node_or_null("RhythmManager")
+
+
+func _event_bus_or_null() -> Node:
+	if not is_inside_tree():
+		return null
+	return get_tree().root.get_node_or_null("EventBus")

scenes/chart/chart_runner.gd.uid

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

scenes/combat/action_resolver.gd

@@ -0,0 +1,170 @@
+class_name ActionResolver
+extends Node
+
+const ACTION_DIR := "res://resources/actions"
+
+static var _loaded := false
+static var _actions_by_pattern: Dictionary = {}
+static var _actions_by_id: Dictionary = {}
+static var _space_priority_labels: Array[StringName] = [
+	&"charge_release",
+	&"burst",
+	&"counter_projectile",
+	&"blade_chain",
+	&"state_specific",
+	&"exact_pattern",
+	&"fallback",
+]
+
+
+func resolve_window(window: Variant, state_machine: Variant = null, context: Dictionary = {}) -> Resource:
+	return ActionResolver.resolve(window, state_machine, context)
+
+
+func resolve_text_pattern(pattern: String, state_machine: Variant = null, context: Dictionary = {}) -> Resource:
+	return ActionResolver.resolve_pattern(pattern, state_machine, context)
+
+
+static func resolve(window: Variant, state_machine: Variant = null, context: Dictionary = {}) -> Resource:
+	return resolve_pattern(window.get_contiguous_pattern(), state_machine, context)
+
+
+static func resolve_pattern(pattern: String, state_machine: Variant = null, context: Dictionary = {}) -> Resource:
+	_ensure_loaded()
+	var key := _normalize_pattern(pattern)
+	if key.ends_with("SP"):
+		var priority_result := _resolve_space_priority(key, state_machine, context)
+		if priority_result != null:
+			return priority_result
+	var candidates: Array = _actions_by_pattern.get(key, [])
+	var state := _state_name(state_machine, context)
+	for action: Resource in candidates:
+		if _can_use_in_state(action, state):
+			return action
+	return null
+
+
+static func get_action(action_id: StringName) -> Resource:
+	_ensure_loaded()
+	return _actions_by_id.get(action_id, null) as Resource
+
+
+static func space_priority_labels() -> Array[StringName]:
+	return _space_priority_labels.duplicate()
+
+
+static func reload(action_dir := ACTION_DIR) -> void:
+	_loaded = true
+	_actions_by_pattern.clear()
+	_actions_by_id.clear()
+	_load_dir(action_dir)
+
+
+static func clear_cache() -> void:
+	_actions_by_pattern.clear()
+	_actions_by_id.clear()
+	_loaded = false
+
+
+static func _ensure_loaded() -> void:
+	if not _loaded:
+		reload()
+
+
+static func _load_dir(action_dir: String) -> void:
+	var dir := DirAccess.open(action_dir)
+	if dir == null:
+		return
+	var files := dir.get_files()
+	files.sort()
+	for file_name: String in files:
+		if not file_name.ends_with(".tres"):
+			continue
+		var action: Resource = load("%s/%s" % [action_dir, file_name])
+		if action == null or not action.get("input_pattern") is Array:
+			continue
+		_register_action(action)
+
+
+static func _register_action(action: Resource) -> void:
+	var key := _pattern_key(action.get("input_pattern"))
+	if key.is_empty():
+		return
+	var candidates: Array = _actions_by_pattern.get(key, [])
+	candidates.append(action)
+	_actions_by_pattern[key] = candidates
+	var id := StringName(str(action.get("id")))
+	if not id.is_empty():
+		_actions_by_id[id] = action
+
+
+static func _resolve_space_priority(key: String, state_machine: Variant, context: Dictionary) -> Resource:
+	var state := _state_name(state_machine, context)
+	for action_id_key: String in [
+		"charge_release_action_id",
+		"burst_action_id",
+		"counter_action_id",
+		"blade_chain_action_id",
+	]:
+		if not context.has(action_id_key):
+			continue
+		if action_id_key == "counter_action_id" and not bool(context.get("counter_ready", false)):
+			continue
+		if action_id_key == "blade_chain_action_id" and not bool(context.get("blade_chain_active", false)):
+			continue
+		var explicit_action := get_action(StringName(str(context[action_id_key])))
+		if explicit_action != null and _can_use_in_state(explicit_action, state):
+			return explicit_action
+
+	var candidates: Array = _actions_by_pattern.get(key, [])
+	for action: Resource in candidates:
+		if _can_use_in_state(action, state):
+			return action
+	var suffix_action := _resolve_trailing_space_suffix(key, state)
+	if suffix_action != null:
+		return suffix_action
+	return null
+
+
+static func _resolve_trailing_space_suffix(key: String, state: StringName) -> Resource:
+	var best_action: Resource = null
+	var best_length := 0
+	for candidate_key: String in _actions_by_pattern.keys():
+		if candidate_key == key:
+			continue
+		if not candidate_key.ends_with("SP"):
+			continue
+		if candidate_key.length() <= best_length:
+			continue
+		if not key.ends_with(candidate_key):
+			continue
+		for action: Resource in _actions_by_pattern.get(candidate_key, []):
+			if _can_use_in_state(action, state):
+				best_action = action
+				best_length = candidate_key.length()
+				break
+	return best_action
+
+
+static func _pattern_key(pattern: Array[StringName]) -> String:
+	var key := ""
+	for symbol: StringName in pattern:
+		key += str(symbol)
+	return _normalize_pattern(key)
+
+
+static func _normalize_pattern(pattern: String) -> String:
+	return pattern.replace(" ", "").to_upper()
+
+
+static func _state_name(state_machine: Variant, context: Dictionary) -> StringName:
+	if context.has("state"):
+		return StringName(str(context["state"]))
+	if state_machine != null and state_machine.has_method("get_current_state_name"):
+		return StringName(str(state_machine.call("get_current_state_name")))
+	return &"any"
+
+
+static func _can_use_in_state(action: Resource, state: StringName) -> bool:
+	var required := StringName(str(action.get("required_state")))
+	return required.is_empty() or required == &"any" or state == &"any" or required == state

scenes/combat/action_resolver.gd.uid

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

scenes/combat/combo_window.gd

@@ -1,55 +0,0 @@
-class_name ComboWindow
-extends RefCounted
-
-signal window_cleared(reason: String)
-
-const SIZE := 4
-
-var slots: Array[String] = []
-var pending_clear_reason := ""
-
-
-func record(input: String) -> void:
-	if input.is_empty():
-		return
-	slots.append(input)
-	if slots.size() >= SIZE:
-		pending_clear_reason = "full"
-
-
-func get_slots() -> Array[String]:
-	return slots.duplicate()
-
-
-func has_pending_clear() -> bool:
-	return not pending_clear_reason.is_empty()
-
-
-func consume_pending_clear_reason() -> String:
-	var reason := pending_clear_reason
-	pending_clear_reason = ""
-	return reason
-
-
-func get_pattern() -> String:
-	var pattern := ""
-	for slot: String in slots:
-		if slot != "Ø":
-			pattern += slot
-	return pattern
-
-
-func get_contiguous_pattern() -> String:
-	var pattern := ""
-	for index: int in range(slots.size() - 1, -1, -1):
-		var slot := slots[index]
-		if slot == "Ø":
-			break
-		pattern = slot + pattern
-	return pattern
-
-
-func clear(reason := "") -> void:
-	slots.clear()
-	pending_clear_reason = ""
-	window_cleared.emit(reason)

scenes/combat/combo_window.gd.uid

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

scenes/combat/input_resolver.gd

@@ -1,157 +0,0 @@
-class_name InputResolver
-extends RefCounted
-
-const SKILLS := {
-	"W": {
-		"type": "skill",
-		"id": "skill_w",
-		"animation": "warrior_w",
-		"clear_window": false,
-	},
-	"A": {
-		"type": "skill",
-		"id": "skill_a",
-		"animation": "warrior_a",
-		"displacement": "left",
-		"clear_window": false,
-	},
-	"D": {
-		"type": "skill",
-		"id": "skill_d",
-		"animation": "warrior_a",
-		"displacement": "right",
-		"clear_window": false,
-	},
-	"WA": {
-		"type": "skill",
-		"id": "skill_wa",
-		"animation": "warrior_wa",
-		"displacement": "left",
-		"clear_window": false,
-	},
-	"WD": {
-		"type": "skill",
-		"id": "skill_wd",
-		"animation": "warrior_wa",
-		"displacement": "right",
-		"clear_window": false,
-	},
-	"AA": {
-		"type": "skill",
-		"id": "skill_aa",
-		"animation": "warrior_aa",
-		"displacement": "left",
-		"clear_window": false,
-	},
-	"DD": {
-		"type": "skill",
-		"id": "skill_dd",
-		"animation": "warrior_aa",
-		"displacement": "right",
-		"clear_window": false,
-	},
-	"AAA": {
-		"type": "skill",
-		"id": "skill_aaa",
-		"animation": "warrior_aaa",
-		"displacement": "left",
-		"clear_window": false,
-	},
-	"DDD": {
-		"type": "skill",
-		"id": "skill_ddd",
-		"animation": "warrior_aaa",
-		"displacement": "right",
-		"clear_window": false,
-	},
-	"ASP": {
-		"type": "skill",
-		"id": "skill_a_space",
-		"animation": "warrior_a_space",
-		"displacement": "left",
-		"clear_window": true,
-	},
-	"DSP": {
-		"type": "skill",
-		"id": "skill_d_space",
-		"animation": "warrior_a_space",
-		"displacement": "right",
-		"clear_window": true,
-	},
-	"ASPSP": {
-		"type": "skill",
-		"id": "skill_a_space_space",
-		"animation": "warrior_a_space_space",
-		"displacement": "left",
-		"clear_window": true,
-	},
-	"DSPSP": {
-		"type": "skill",
-		"id": "skill_d_space_space",
-		"animation": "warrior_a_space_space",
-		"displacement": "right",
-		"clear_window": true,
-	},
-	"AASP": {
-		"type": "skill",
-		"id": "skill_aa_space",
-		"animation": "warrior_a_space_space",
-		"displacement": "left",
-		"clear_window": true,
-	},
-	"ADSP": {
-		"type": "skill",
-		"id": "skill_ad_space",
-		"animation": "warrior_a_space_space",
-		"displacement": "right",
-		"clear_window": true,
-	},
-	"DASP": {
-		"type": "skill",
-		"id": "skill_da_space",
-		"animation": "warrior_a_space_space",
-		"displacement": "left",
-		"clear_window": true,
-	},
-	"DDSP": {
-		"type": "skill",
-		"id": "skill_dd_space",
-		"animation": "warrior_a_space_space",
-		"displacement": "right",
-		"clear_window": true,
-	},
-	"SSP": {
-		"type": "skill",
-		"id": "skill_s_projectile_1",
-		"animation": "warrior_s_projectile",
-		"projectile": true,
-		"energy_cost": 3,
-		"clear_window": false,
-	},
-	"SSPSP": {
-		"type": "skill",
-		"id": "skill_s_projectile_2",
-		"animation": "warrior_s_projectile",
-		"projectile": true,
-		"energy_cost": 2,
-		"clear_window": false,
-	},
-	"SSPSPSP": {
-		"type": "skill",
-		"id": "skill_s_projectile_3",
-		"animation": "warrior_s_projectile",
-		"projectile": true,
-		"energy_cost": 1,
-		"clear_window": false,
-	},
-}
-
-
-static func resolve(window: ComboWindow) -> Dictionary:
-	return resolve_pattern(window.get_contiguous_pattern())
-
-
-static func resolve_pattern(pattern: String) -> Dictionary:
-	if not SKILLS.has(pattern):
-		return {}
-	return SKILLS[pattern].duplicate()

scenes/combat/input_resolver.gd.uid

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

scenes/combat/player_projectile.tscn

@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://scenes/combat/player_projectile.gd" id="1"]
+
+[node name="PlayerProjectile" type="Node2D"]
+script = ExtResource("1")

scenes/components/action_controller.gd

@@ -0,0 +1,343 @@
+class_name ActionController
+extends Node
+
+signal action_started(action: Resource, intent)
+signal action_active_started(action: Resource, intent)
+signal action_active_finished(action: Resource)
+signal action_finished(action: Resource)
+signal action_rejected(intent, reason: StringName)
+
+enum Phase { IDLE, STARTUP, ACTIVE, RECOVERY }
+
+@export var combo_window_path: NodePath
+@export var action_resolver_path: NodePath
+@export var action_executor_path: NodePath
+@export var state_machine_path: NodePath
+@export var burst_component_path: NodePath
+
+@onready var combo_window: Node = get_node_or_null(combo_window_path)
+@onready var action_resolver: Node = get_node_or_null(action_resolver_path)
+@onready var action_executor: Node = get_node_or_null(action_executor_path)
+@onready var state_machine: Node = get_node_or_null(state_machine_path)
+@onready var burst_component: Node = get_node_or_null(burst_component_path)
+
+var phase := Phase.IDLE
+var current_action: Resource
+var current_intent
+var pending_intent
+var phase_elapsed := 0.0
+var phase_duration := 0.0
+
+
+func submit_intent(intent) -> void:
+	if intent == null:
+		return
+	var judged_intent = _ensure_judged(intent)
+	if judged_intent.is_released():
+		action_rejected.emit(judged_intent, &"release_not_action")
+		return
+	_emit_judgement_feedback(judged_intent)
+	if _judgement_label(judged_intent) == &"miss":
+		_interrupt_current_action_for_miss()
+		_record_miss(judged_intent)
+		action_rejected.emit(judged_intent, &"miss")
+		return
+	if _window_is_showing_pending_clear():
+		_store_pending_intent(judged_intent)
+		return
+	if phase == Phase.IDLE:
+		_consume_intent(judged_intent)
+		return
+	if _can_cancel_now():
+		_reset_to_idle()
+		_consume_intent(judged_intent)
+		return
+	_store_pending_intent(judged_intent)
+
+
+func _physics_process(delta: float) -> void:
+	if phase == Phase.IDLE:
+		if pending_intent != null and not _window_is_showing_pending_clear():
+			var idle_intent = pending_intent
+			pending_intent = null
+			_consume_intent(idle_intent)
+		return
+	phase_elapsed += delta
+	if phase == Phase.RECOVERY and pending_intent != null and _can_cancel_now():
+		var interrupted_action := current_action
+		var next_intent = pending_intent
+		pending_intent = null
+		_reset_to_idle()
+		action_finished.emit(interrupted_action)
+		_consume_intent(next_intent)
+		return
+	if phase_elapsed < phase_duration:
+		return
+	var carryover := maxf(0.0, phase_elapsed - phase_duration)
+	match phase:
+		Phase.STARTUP:
+			_enter_phase(Phase.ACTIVE)
+			phase_elapsed = carryover
+			if not _activate_current_action():
+				return
+		Phase.ACTIVE:
+			action_active_finished.emit(current_action)
+			_enter_phase(Phase.RECOVERY)
+			phase_elapsed = carryover
+		Phase.RECOVERY:
+			var finished_action := current_action
+			var next_intent = pending_intent
+			pending_intent = null
+			_reset_to_idle()
+			_clear_window_after_action(finished_action)
+			action_finished.emit(finished_action)
+			if next_intent != null:
+				_consume_intent(next_intent)
+
+
+func _consume_intent(intent) -> void:
+	_start_action(intent)
+
+
+func _start_action(intent) -> void:
+	if combo_window == null or action_resolver == null:
+		action_rejected.emit(intent, &"missing_component")
+		return
+	if _should_restart_blade_chain(intent):
+		combo_window.clear(&"blade_chain_restart")
+	_record_intent_symbol(intent)
+	var action: Resource = action_resolver.resolve_window(combo_window, state_machine, _resolver_context())
+	if action == null:
+		action = _resolve_fallback_action(intent)
+		if action == null:
+			action_rejected.emit(intent, &"unresolved")
+			return
+	current_action = action
+	current_intent = intent
+	_enter_phase(Phase.STARTUP)
+	action_started.emit(action, intent)
+
+
+func _activate_current_action() -> bool:
+	if current_action == null or current_intent == null:
+		_reset_to_idle()
+		return false
+	if action_executor == null:
+		action_rejected.emit(current_intent, &"missing_component")
+		_reset_to_idle()
+		return false
+	if not action_executor.execute(current_action, StringName(str(current_intent.judgement.get("label", "perfect"))), burst_component):
+		combo_window.flush_pending_clear()
+		combo_window.clear(&"action_failed")
+		action_rejected.emit(current_intent, &"execution_failed")
+		_reset_to_idle()
+		return false
+	action_active_started.emit(current_action, current_intent)
+	return true
+
+
+func _record_intent_symbol(intent) -> void:
+	if combo_window.has_pending_clear():
+		combo_window.flush_pending_clear()
+	combo_window.record(intent.symbol)
+
+
+func _record_miss(_intent) -> void:
+	if combo_window != null:
+		if combo_window.has_pending_clear():
+			combo_window.flush_pending_clear()
+		combo_window.record(&"Ø")
+
+
+func _interrupt_current_action_for_miss() -> void:
+	pending_intent = null
+	if phase == Phase.IDLE:
+		return
+	var interrupted_action := current_action
+	_reset_to_idle()
+	if interrupted_action != null:
+		action_finished.emit(interrupted_action)
+
+
+func _resolve_fallback_action(intent) -> Resource:
+	if action_resolver == null:
+		return null
+	if not action_resolver.has_method("resolve_text_pattern"):
+		return null
+	return action_resolver.call("resolve_text_pattern", str(intent.symbol), state_machine, _resolver_context()) as Resource
+
+
+func _clear_window_after_action(action: Resource) -> void:
+	if combo_window == null or action == null:
+		return
+	if bool(action.get("clear_window")):
+		combo_window.clear(StringName("skill:%s" % action.get("id")))
+
+
+func _store_pending_intent(intent) -> void:
+	if pending_intent != null:
+		action_rejected.emit(pending_intent, &"replaced")
+	pending_intent = intent
+
+
+func _should_restart_blade_chain(intent) -> bool:
+	if combo_window == null:
+		return false
+	if intent.symbol != &"S":
+		return false
+	var pattern: String = combo_window.get_contiguous_pattern()
+	return pattern == "SSP" or pattern == "SSPSP" or pattern == "SSPSPSP"
+
+
+func _enter_phase(next_phase: Phase) -> void:
+	phase = next_phase
+	phase_elapsed = 0.0
+	phase_duration = _phase_duration_seconds(next_phase)
+
+
+func _phase_duration_seconds(next_phase: Phase) -> float:
+	if current_action == null:
+		return 0.0
+	var beat_time := _beat_time()
+	match next_phase:
+		Phase.STARTUP:
+			return maxf(0.01, float(current_action.get("startup_beats")) * beat_time)
+		Phase.ACTIVE:
+			return maxf(0.01, float(current_action.get("active_beats")) * beat_time)
+		Phase.RECOVERY:
+			return maxf(0.01, float(current_action.get("recovery_beats")) * beat_time)
+	return 0.0
+
+
+func _can_cancel_now() -> bool:
+	if phase != Phase.RECOVERY or current_action == null:
+		return false
+	var duration := maxf(0.01, phase_duration)
+	var progress := clampf(phase_elapsed / duration, 0.0, 1.0)
+	return progress >= clampf(float(current_action.get("cancel_from")), 0.0, 1.0)
+
+
+func _reset_to_idle() -> void:
+	phase = Phase.IDLE
+	current_action = null
+	current_intent = null
+	phase_elapsed = 0.0
+	phase_duration = 0.0
+
+
+func _window_is_showing_pending_clear() -> bool:
+	return combo_window != null and combo_window.has_pending_clear()
+
+
+func _ensure_judged(intent):
+	if not intent.judgement.is_empty():
+		return intent.with_judgement(_judgement_with_defaults(intent.judgement))
+	var rhythm := get_tree().root.get_node_or_null("RhythmManager") if is_inside_tree() else null
+	if rhythm != null and rhythm.has_method("judge"):
+		return intent.with_judgement(_judgement_with_defaults(rhythm.call("judge", intent.timestamp_ms)))
+	return intent.with_judgement(_judgement_with_defaults({"label": "perfect", "diff": 0.0, "abs_diff": 0.0}))
+
+
+func _judgement_label(intent) -> StringName:
+	return StringName(str(intent.judgement.get("label", "miss")))
+
+
+func _emit_judgement_feedback(intent) -> void:
+	var rating := _judgement_with_defaults(intent.judgement)
+	var action_name: StringName = intent.rhythm_action if not intent.rhythm_action.is_empty() else intent.symbol
+	rating["action"] = action_name
+	var label := StringName(str(rating.get("label", "miss")))
+	var diff_ms := float(rating.get("diff", INF)) * 1000.0
+	var bus := _event_bus_or_null()
+	if bus == null:
+		return
+	bus.emit_signal("judgement_made", label, diff_ms)
+	bus.emit_signal("action_judged", action_name, rating)
+
+
+func _judgement_with_defaults(judgement: Dictionary) -> Dictionary:
+	var rating := judgement.duplicate()
+	var label := StringName(str(rating.get("label", "miss")))
+	rating["label"] = str(label)
+	if not rating.has("diff"):
+		rating["diff"] = 0.0
+	if not rating.has("abs_diff"):
+		rating["abs_diff"] = absf(float(rating.get("diff", 0.0)))
+	if not rating.has("color"):
+		rating["color"] = _judgement_color(label)
+	return rating
+
+
+func _judgement_color(label: StringName) -> Color:
+	match label:
+		&"perfect":
+			return Color("00f2ff")
+		&"good":
+			return Color("ffffff")
+		&"bad":
+			return Color("ffaa00")
+	return Color("ff0055")
+
+
+func _event_bus_or_null() -> Node:
+	if not is_inside_tree():
+		return null
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus
+
+
+func _resolver_context() -> Dictionary:
+	var state := &"any"
+	if state_machine != null and state_machine.has_method("get_current_state_name"):
+		state = StringName(str(state_machine.call("get_current_state_name")))
+	return {
+		"state": state,
+		"charge_release_action_id": _charge_release_action_id(),
+		"burst_action_id": _burst_action_id(),
+		"counter_action_id": _counter_action_id(),
+		"counter_ready": _counter_ready(),
+		"blade_chain_action_id": _blade_chain_action_id(),
+		"blade_chain_active": _blade_chain_active(),
+	}
+
+
+func _charge_release_action_id() -> StringName:
+	return &""
+
+
+func _burst_action_id() -> StringName:
+	if burst_component != null and bool(burst_component.get("burst_ready")):
+		return &"skill_burst_activate"
+	return &""
+
+
+func _counter_action_id() -> StringName:
+	return &"skill_s_counter_projectile"
+
+
+func _counter_ready() -> bool:
+	return false
+
+
+func _blade_chain_action_id() -> StringName:
+	if _blade_chain_active():
+		return &"skill_s_projectile_2"
+	return &""
+
+
+func _blade_chain_active() -> bool:
+	if current_action == null:
+		return false
+	return bool(current_action.get("can_chain"))
+
+
+func _beat_time() -> float:
+	var rhythm := get_tree().root.get_node_or_null("RhythmManager") if is_inside_tree() else null
+	if rhythm != null:
+		return float(rhythm.get("beat_time"))
+	return 0.5

scenes/components/action_controller.gd.uid

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

scenes/components/action_executor.gd

@@ -0,0 +1,42 @@
+class_name ActionExecutor
+extends Node
+
+signal action_executed(action: Resource, judgement: StringName)
+signal action_failed(action: Resource, reason: StringName)
+
+@export var energy_component_path: NodePath
+@export var damage_emitter_path: NodePath
+
+@onready var _energy_component: Node = get_node_or_null(energy_component_path)
+@onready var _damage_emitter: Node = get_node_or_null(damage_emitter_path)
+
+
+func execute(action: Resource, judgement: StringName, burst_component: Variant = null) -> bool:
+	if action == null:
+		action_failed.emit(action, &"missing_action")
+		return false
+	var cost := _resolve_cost(action, burst_component)
+	if _energy_component != null and not _energy_component.spend(cost):
+		action_failed.emit(action, &"insufficient_energy")
+		return false
+	if _damage_emitter != null and _damage_emitter.has_method("configure_hit"):
+		_damage_emitter.configure_hit(action, {"label": str(judgement)})
+	var reward := int(action.get("energy_reward"))
+	if reward != 0 and _energy_component != null:
+		_energy_component.change(reward)
+	action_executed.emit(action, judgement)
+	return true
+
+
+func _resolve_cost(action: Resource, burst_component: Variant) -> float:
+	var combat := _combat_manager_or_null()
+	if combat != null:
+		return float(combat.call("resolve_cost", action, burst_component))
+	var base_cost := float(action.get("base_cost"))
+	return base_cost if base_cost > 0.0 else float(action.get("energy_cost"))
+
+
+func _combat_manager_or_null() -> Node:
+	if not is_inside_tree():
+		return null
+	return get_tree().root.get_node_or_null("CombatManager")

scenes/components/action_executor.gd.uid

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

scenes/components/burst_component.gd

@@ -0,0 +1,68 @@
+class_name BurstComponent
+extends Node
+
+signal burst_changed(burst_ready: bool, active: bool, cooldown: int)
+
+@export var active_beats := 16
+@export var cooldown_beats := 4
+
+var burst_ready := false
+var active := false
+var cooldown := 0
+var _beats_left := 0
+
+
+func _ready() -> void:
+	var rhythm := get_tree().root.get_node_or_null("RhythmManager")
+	if rhythm != null and not rhythm.is_connected("beat_ticked", _on_beat_ticked):
+		rhythm.connect("beat_ticked", _on_beat_ticked)
+
+
+func set_ready(value: bool) -> void:
+	if active or cooldown > 0:
+		burst_ready = false
+	else:
+		burst_ready = value
+	burst_changed.emit(burst_ready, active, cooldown)
+
+
+func activate() -> bool:
+	if not burst_ready or active or cooldown > 0:
+		return false
+	burst_ready = false
+	active = true
+	_beats_left = active_beats
+	_set_rhythm_scale(1.25)
+	burst_changed.emit(burst_ready, active, cooldown)
+	return true
+
+
+func damage_mult(_action: Resource = null) -> float:
+	return 1.2 if active else 1.0
+
+
+func cost_mult(_action: Resource = null) -> float:
+	return 0.0 if active else 1.0
+
+
+func move_mult(_action: Resource = null) -> float:
+	return 1.0
+
+
+func _on_beat_ticked(_beat_index: int) -> void:
+	if active:
+		_beats_left -= 1
+		if _beats_left <= 0:
+			active = false
+			cooldown = cooldown_beats
+			_set_rhythm_scale(1.0)
+			burst_changed.emit(burst_ready, active, cooldown)
+	elif cooldown > 0:
+		cooldown -= 1
+		burst_changed.emit(burst_ready, active, cooldown)
+
+
+func _set_rhythm_scale(scale: float) -> void:
+	var rhythm := get_tree().root.get_node_or_null("RhythmManager")
+	if rhythm != null:
+		rhythm.set("judgement_scale", scale)

scenes/components/burst_component.gd.uid

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

scenes/components/charge_component.gd

@@ -0,0 +1,126 @@
+class_name ChargeComponent
+extends Node
+
+signal charge_changed(current: float, maximum: float, charge_ready: bool, active: bool)
+signal release_requested(skill_id: StringName, direction: Vector2)
+
+@export var charge_duration := 1.1
+@export var animation_player_path: NodePath
+@export var effect_sprite_path: NodePath
+
+var value := 0.0
+var charge_ready := false
+var active := false
+
+var _hold_symbol: StringName = &""
+var _hold_direction := Vector2.ZERO
+var _effect_time := 0.0
+var _animation_time := 0.0
+
+@onready var _animation_player: AnimationPlayer = get_node_or_null(animation_player_path) as AnimationPlayer
+@onready var _effect_sprite: Sprite2D = get_node_or_null(effect_sprite_path) as Sprite2D
+
+
+func begin_hold(symbol: StringName, direction: Vector2) -> void:
+	_hold_symbol = symbol
+	_hold_direction = direction
+
+
+func finish_hold(symbol: StringName) -> void:
+	if _hold_symbol != symbol:
+		return
+	var release_ready := active and charge_ready
+	var release_direction := _hold_direction
+	var release_skill := &"skill_a_charge_release" if symbol == &"A" else &"skill_d_charge_release"
+	cancel()
+	if release_ready:
+		release_requested.emit(release_skill, release_direction)
+
+
+func tick(delta: float, can_charge: bool) -> void:
+	if _hold_symbol.is_empty():
+		return
+	if not active:
+		if not can_charge:
+			return
+		_start()
+	if not active:
+		return
+	_update_charge_animation(delta)
+	value = minf(charge_duration, value + delta)
+	charge_ready = value >= charge_duration
+	_update_charge_effect(delta)
+	_emit_changed()
+
+
+func cancel() -> void:
+	_hold_symbol = &""
+	_hold_direction = Vector2.ZERO
+	active = false
+	value = 0.0
+	charge_ready = false
+	_animation_time = 0.0
+	_set_effect_visible(false)
+	_emit_changed()
+
+
+func is_active() -> bool:
+	return active
+
+
+func is_ready() -> bool:
+	return charge_ready
+
+
+func maximum() -> float:
+	return charge_duration
+
+
+func _start() -> void:
+	active = true
+	value = 0.0
+	charge_ready = false
+	_effect_time = 0.0
+	_animation_time = 0.0
+	_play_charge_animation(&"warrior_charge_intro")
+	_update_charge_effect(0.0)
+	_emit_changed()
+
+
+func _update_charge_effect(delta: float) -> void:
+	if _effect_sprite == null:
+		return
+	_effect_sprite.visible = active
+	if not active:
+		return
+	_effect_time += delta
+	_effect_sprite.frame = int(_effect_time * 12.0) % 5
+
+
+func _update_charge_animation(delta: float) -> void:
+	_animation_time += delta
+	var intro_length := _animation_length(&"warrior_charge_intro")
+	if _animation_time < intro_length:
+		_play_charge_animation(&"warrior_charge_intro")
+	else:
+		_play_charge_animation(&"warrior_charge_loop")
+
+
+func _play_charge_animation(animation_name: StringName) -> void:
+	if _animation_player != null and _animation_player.has_animation(animation_name) and _animation_player.current_animation != animation_name:
+		_animation_player.play(animation_name)
+
+
+func _animation_length(animation_name: StringName) -> float:
+	if _animation_player != null and _animation_player.has_animation(animation_name):
+		return maxf(0.1, _animation_player.get_animation(animation_name).length)
+	return 0.1
+
+
+func _set_effect_visible(is_visible: bool) -> void:
+	if _effect_sprite != null:
+		_effect_sprite.visible = is_visible
+
+
+func _emit_changed() -> void:
+	charge_changed.emit(value, charge_duration, charge_ready, active)

scenes/components/charge_component.gd.uid

@@ -0,0 +1 @@
+uid://417rdyr4hkco

scenes/components/combo_window.gd

@@ -0,0 +1,108 @@
+class_name ComboWindow
+extends Node
+
+signal combo_updated(inputs: Array[StringName])
+signal combo_cleared(reason: StringName)
+
+@export var size := 4
+@export var clear_display_time := 0.35
+
+var slots: Array[StringName] = []
+var pending_clear_reason: StringName = &""
+var _timer: Timer
+
+
+func _ready() -> void:
+	_timer = Timer.new()
+	_timer.one_shot = true
+	_timer.timeout.connect(flush_pending_clear)
+	add_child(_timer)
+
+
+func record(input: StringName) -> void:
+	if input.is_empty():
+		return
+	slots.append(input)
+	combo_updated.emit(get_slots())
+	_emit_bus_signal("combo_updated", [get_slots()])
+	if slots.size() >= size:
+		queue_clear(&"full")
+
+
+func get_slots() -> Array[StringName]:
+	return slots.duplicate()
+
+
+func has_pending_clear() -> bool:
+	return not pending_clear_reason.is_empty()
+
+
+func consume_pending_clear_reason() -> StringName:
+	var reason := pending_clear_reason
+	pending_clear_reason = &""
+	return reason
+
+
+func get_pattern() -> String:
+	var pattern := ""
+	for slot: StringName in slots:
+		if slot != &"Ø":
+			pattern += str(slot)
+	return pattern
+
+
+func get_contiguous_pattern() -> String:
+	var pattern := ""
+	for index: int in range(slots.size() - 1, -1, -1):
+		var slot := slots[index]
+		if slot == &"Ø":
+			break
+		pattern = str(slot) + pattern
+	return pattern
+
+
+func queue_clear(reason: StringName, delay := -1.0) -> void:
+	pending_clear_reason = reason
+	if _timer == null:
+		return
+	_timer.stop()
+	_timer.wait_time = clear_display_time if delay < 0.0 else delay
+	_timer.start()
+
+
+func cancel_pending_clear() -> void:
+	pending_clear_reason = &""
+	if _timer != null:
+		_timer.stop()
+
+
+func flush_pending_clear() -> void:
+	var reason := consume_pending_clear_reason()
+	if reason.is_empty():
+		return
+	if _timer != null:
+		_timer.stop()
+	clear(reason)
+
+
+func clear(reason: StringName = &"") -> void:
+	slots.clear()
+	pending_clear_reason = &""
+	combo_cleared.emit(reason)
+	_emit_bus_signal("combo_cleared", [reason])
+	combo_updated.emit(get_slots())
+	_emit_bus_signal("combo_updated", [get_slots()])
+
+
+func _emit_bus_signal(signal_name: StringName, args: Array) -> void:
+	if not is_inside_tree():
+		return
+	var bus := _event_bus_or_null()
+	if bus != null:
+		bus.emit_signal(signal_name, args[0])
+
+
+func _event_bus_or_null() -> Node:
+	if not is_inside_tree():
+		return null
+	return get_tree().root.get_node_or_null("EventBus")

scenes/components/combo_window.gd.uid

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

scenes/components/damage_emitter.gd

@@ -0,0 +1,47 @@
+class_name DamageEmitter
+extends Area2D
+
+@export var damage := 10
+@export var hit_type: StringName = &"normal"
+
+var action_context: Resource
+var judgement_context: Dictionary = {}
+
+
+func _ready() -> void:
+	area_entered.connect(_on_area_entered)
+
+
+func configure_hit(action: Resource, judgement: Dictionary) -> void:
+	action_context = action
+	judgement_context = judgement.duplicate()
+
+
+func _on_area_entered(receiver: Area2D) -> void:
+	if receiver.is_in_group("damage_receivers"):
+		var final_damage := _resolve_damage()
+		receiver.emit_signal("damage_received", final_damage, hit_type, global_position)
+		_event_bus().emit_signal("damage_dealt", receiver, final_damage, hit_type)
+
+
+func _resolve_damage() -> int:
+	var combat := _combat_manager_or_null()
+	if combat == null:
+		return damage
+	return int(round(combat.call("resolve_damage", float(damage), action_context, judgement_context, null, null)))
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus
+
+
+func _combat_manager_or_null() -> Node:
+	if not is_inside_tree():
+		return null
+	return get_tree().root.get_node_or_null("CombatManager")

scenes/components/damage_emitter.gd.uid

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

scenes/components/damage_receiver.gd

@@ -0,0 +1,23 @@
+class_name DamageReceiver
+extends Area2D
+
+signal damage_received(amount: int, hit_type: StringName, from: Vector2)
+
+
+func _ready() -> void:
+	add_to_group("damage_receivers")
+
+
+func take_damage(amount: int, hit_type: StringName, from: Vector2) -> void:
+	damage_received.emit(amount, hit_type, from)
+	_event_bus().emit_signal("damage_dealt", self, amount, hit_type)
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/components/damage_receiver.gd.uid

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

scenes/components/energy_component.gd

@@ -0,0 +1,54 @@
+class_name EnergyComponent
+extends Node
+
+signal energy_changed(current: int, maximum: int)
+
+@export var maximum := 10
+@export var current := 0
+
+
+func _ready() -> void:
+	_emit_changed()
+
+
+func set_values(next_current: int, next_maximum: int) -> void:
+	maximum = max(1, next_maximum)
+	current = clampi(next_current, 0, maximum)
+	_emit_changed()
+
+
+func set_current(next_current: int) -> void:
+	var clamped := clampi(next_current, 0, maximum)
+	if clamped == current:
+		return
+	current = clamped
+	_emit_changed()
+
+
+func change(delta: int) -> void:
+	set_current(current + delta)
+
+
+func spend(cost: float) -> bool:
+	var int_cost := int(ceil(cost))
+	if int_cost <= 0:
+		return true
+	if current < int_cost:
+		return false
+	set_current(current - int_cost)
+	return true
+
+
+func _emit_changed() -> void:
+	energy_changed.emit(current, maximum)
+	_event_bus().emit_signal("player_energy_changed", float(current), float(maximum))
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/components/energy_component.gd.uid

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

scenes/components/health_component.gd

@@ -0,0 +1,49 @@
+class_name HealthComponent
+extends Node
+
+signal health_changed(current: int, maximum: int)
+signal depleted
+
+@export var maximum := 100
+@export var current := 100
+
+
+func _ready() -> void:
+	_emit_changed()
+
+
+func set_values(next_current: int, next_maximum: int) -> void:
+	maximum = max(1, next_maximum)
+	current = clampi(next_current, 0, maximum)
+	_emit_changed()
+
+
+func apply_damage(amount: int) -> void:
+	if amount <= 0:
+		return
+	current = clampi(current - amount, 0, maximum)
+	_emit_changed()
+	if current == 0:
+		depleted.emit()
+
+
+func heal(amount: int) -> void:
+	if amount <= 0:
+		return
+	current = clampi(current + amount, 0, maximum)
+	_emit_changed()
+
+
+func _emit_changed() -> void:
+	health_changed.emit(current, maximum)
+	_event_bus().emit_signal("player_health_changed", current, maximum)
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/components/health_component.gd.uid

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

scenes/components/input_component.gd

@@ -0,0 +1,65 @@
+class_name InputComponent
+extends Node
+
+const InputIntentScript := preload("res://scenes/components/input_intent.gd")
+
+signal intent_created(intent)
+signal combo_pressed(symbol: StringName, rhythm_action: StringName)
+signal combo_released(symbol: StringName)
+
+const COMBO_ACTIONS: Dictionary = {
+	&"combo_w": [&"W", &"w"],
+	&"combo_a": [&"A", &"a"],
+	&"combo_d": [&"D", &"d"],
+	&"combo_s": [&"S", &"s"],
+	&"combo_space": [&"SP", &"space"],
+}
+
+const COMBO_ACTION_ORDER: Array[StringName] = [
+	&"combo_w",
+	&"combo_a",
+	&"combo_d",
+	&"combo_s",
+	&"combo_space",
+]
+
+var _suppressed_movement: Dictionary = {
+	&"move_left": false,
+	&"move_right": false,
+}
+
+
+func handle_input_event(event: InputEvent) -> bool:
+	var key_event := event as InputEventKey
+	if key_event != null and key_event.echo:
+		return false
+	for action_name: StringName in COMBO_ACTION_ORDER:
+		if event.is_action_pressed(action_name, false, true):
+			var data: Array = COMBO_ACTIONS[action_name]
+			var intent: RefCounted = InputIntentScript.create(data[0], data[1], &"pressed", float(Time.get_ticks_msec()))
+			intent_created.emit(intent)
+			combo_pressed.emit(data[0], data[1])
+			return true
+		if event.is_action_released(action_name, true):
+			var data: Array = COMBO_ACTIONS[action_name]
+			var intent: RefCounted = InputIntentScript.create(data[0], data[1], &"released", float(Time.get_ticks_msec()))
+			intent_created.emit(intent)
+			combo_released.emit(data[0])
+			return true
+	return false
+
+
+func set_direction_suppressed(symbol: StringName, suppressed: bool) -> void:
+	if symbol == &"A":
+		_suppressed_movement[&"move_left"] = suppressed
+	elif symbol == &"D":
+		_suppressed_movement[&"move_right"] = suppressed
+
+
+func get_horizontal_axis() -> float:
+	var axis := 0.0
+	if Input.is_action_pressed(&"move_left") and not bool(_suppressed_movement.get(&"move_left", false)):
+		axis -= 1.0
+	if Input.is_action_pressed(&"move_right") and not bool(_suppressed_movement.get(&"move_right", false)):
+		axis += 1.0
+	return axis

scenes/components/input_component.gd.uid

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

scenes/components/input_intent.gd

@@ -0,0 +1,32 @@
+class_name InputIntent
+extends RefCounted
+
+var symbol: StringName
+var rhythm_action: StringName
+var event_type: StringName
+var timestamp_ms := 0.0
+var judgement: Dictionary = {}
+
+
+static func create(next_symbol: StringName, next_rhythm_action: StringName, next_event_type: StringName, next_timestamp_ms: float) -> RefCounted:
+	var script: Script = load("res://scenes/components/input_intent.gd")
+	var intent: RefCounted = script.new()
+	intent.symbol = next_symbol
+	intent.rhythm_action = next_rhythm_action
+	intent.event_type = next_event_type
+	intent.timestamp_ms = next_timestamp_ms
+	return intent
+
+
+func is_pressed() -> bool:
+	return event_type == &"pressed"
+
+
+func is_released() -> bool:
+	return event_type == &"released"
+
+
+func with_judgement(next_judgement: Dictionary) -> RefCounted:
+	var copy: RefCounted = load("res://scenes/components/input_intent.gd").create(symbol, rhythm_action, event_type, timestamp_ms)
+	copy.judgement = next_judgement.duplicate()
+	return copy

scenes/components/input_intent.gd.uid

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

scenes/components/motion_executor.gd

@@ -0,0 +1,40 @@
+class_name MotionExecutor
+extends Node
+
+signal motion_started(action: Resource)
+signal motion_finished(action: Resource)
+
+var current_action: Resource
+var velocity := Vector2.ZERO
+var duration := 0.0
+var elapsed := 0.0
+var active := false
+
+
+func execute(action: Resource, direction: Vector2, beat_time: float, speed := 220.0) -> void:
+	current_action = action
+	duration = maxf(0.01, float(action.get("action_beats")) * maxf(0.01, beat_time))
+	elapsed = 0.0
+	active = true
+	var move_x := float(action.get("move_mult_x"))
+	if move_x == 0.0:
+		move_x = -1.0 if StringName(str(action.get("displacement"))) == &"left" else 1.0 if StringName(str(action.get("displacement"))) == &"right" else 0.0
+	velocity = Vector2(direction.x if direction.x != 0.0 else move_x, direction.y).normalized() * speed if move_x != 0.0 or direction != Vector2.ZERO else Vector2.ZERO
+	motion_started.emit(action)
+
+
+func tick(delta: float) -> Vector2:
+	if not active:
+		return Vector2.ZERO
+	elapsed += delta
+	if elapsed >= duration:
+		active = false
+		velocity = Vector2.ZERO
+		motion_finished.emit(current_action)
+	return velocity
+
+
+func cancel() -> void:
+	active = false
+	velocity = Vector2.ZERO
+	current_action = null

scenes/components/motion_executor.gd.uid

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

scenes/components/state_machine.gd

@@ -0,0 +1,34 @@
+class_name StateMachine
+extends Node
+
+signal state_changed(previous: int, current: int)
+
+var current_state := 0
+var state_names: Array[StringName] = [
+	&"ground",
+	&"ground",
+	&"air",
+	&"ground",
+	&"ground",
+	&"air",
+	&"guarding",
+	&"charging",
+	&"bladeChain",
+	&"burstCharge",
+	&"bursting",
+	&"hitstun",
+]
+
+
+func change_state(next_state: int) -> void:
+	if next_state == current_state:
+		return
+	var previous := current_state
+	current_state = next_state
+	state_changed.emit(previous, current_state)
+
+
+func get_current_state_name() -> StringName:
+	if current_state >= 0 and current_state < state_names.size():
+		return state_names[current_state]
+	return &"any"

scenes/components/state_machine.gd.uid

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

scenes/main/main.gd

@@ -1,338 +1,8 @@
 extends Node2D
 
-@onready var rhythm_conductor: Node = $RhythmConductor
-@onready var rhythm_track: Control = $RhythmFeedback/RhythmTrack
-@onready var rhythm_feedback_label: Label = $RhythmFeedback/JudgementLabel
-@onready var player: Node = $Player
-@onready var center_base: TextureRect = $RhythmFeedback/RhythmTrack/CenterBase
-@onready var center_flash: TextureRect = $RhythmFeedback/RhythmTrack/CenterFlash
-@onready var left_mover: TextureRect = $RhythmFeedback/RhythmTrack/LeftMover
-@onready var right_mover: TextureRect = $RhythmFeedback/RhythmTrack/RightMover
-@onready var combo_skill_label: Label = $RhythmFeedback/ComboSkillLabel
-@onready var health_bar: ProgressBar = $RhythmFeedback/StatusBars/HealthBar
-@onready var charge_bar: ProgressBar = $RhythmFeedback/StatusBars/ChargeBar
-@onready var energy_segments: Array[Panel] = [
-	$RhythmFeedback/StatusBars/EnergyBar/Segment0,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment1,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment2,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment3,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment4,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment5,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment6,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment7,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment8,
-	$RhythmFeedback/StatusBars/EnergyBar/Segment9,
-]
-@onready var combo_slot_panels: Array[PanelContainer] = [
-	$RhythmFeedback/ComboWindow/Slot0,
-	$RhythmFeedback/ComboWindow/Slot1,
-	$RhythmFeedback/ComboWindow/Slot2,
-	$RhythmFeedback/ComboWindow/Slot3,
-]
-@onready var combo_key_labels: Array[Label] = [
-	$RhythmFeedback/ComboWindow/Slot0/Key,
-	$RhythmFeedback/ComboWindow/Slot1/Key,
-	$RhythmFeedback/ComboWindow/Slot2/Key,
-	$RhythmFeedback/ComboWindow/Slot3/Key,
-]
-
-var combo_clear_tween: Tween
-var combo_clear_flash := 0.0
-var charge_bar_ready := false
-var charge_flash := 0.0
-
-var track_center := Vector2.ZERO
-var left_mover_start := Vector2.ZERO
-var right_mover_start := Vector2.ZERO
-var mover_size := Vector2.ZERO
-var center_flash_size := Vector2.ZERO
-var feedback_flash := 0.0
-var beat_flash := 0.0
+@onready var stage: Node = $Stage
+@onready var ui: CanvasLayer = $UI
 
 
-func _ready() -> void:
-	_cache_rhythm_track_layout()
-	rhythm_conductor.action_judged.connect(_on_rhythm_action_judged)
-	rhythm_conductor.beat.connect(_on_rhythm_beat)
-	if player.has_signal("combo_window_changed"):
-		player.connect("combo_window_changed", _on_combo_window_changed)
-	if player.has_signal("combo_window_cleared"):
-		player.connect("combo_window_cleared", _on_combo_window_cleared)
-	if player.has_signal("skill_requested"):
-		player.connect("skill_requested", _on_skill_requested)
-	if player.has_signal("energy_changed"):
-		player.connect("energy_changed", _on_energy_changed)
-	if player.has_signal("health_changed"):
-		player.connect("health_changed", _on_health_changed)
-	if player.has_signal("charge_changed"):
-		player.connect("charge_changed", _on_charge_changed)
-	rhythm_feedback_label.text = "READY"
-	_on_combo_window_changed([])
-	if player.has_method("get_energy") and player.has_method("get_max_energy"):
-		_on_energy_changed(player.call("get_energy"), player.call("get_max_energy"))
-	if player.has_method("get_health") and player.has_method("get_max_health"):
-		_on_health_changed(player.call("get_health"), player.call("get_max_health"))
-	if player.has_method("get_charge") and player.has_method("get_max_charge") and player.has_method("is_charge_ready") and player.has_method("is_charge_active"):
-		_on_charge_changed(player.call("get_charge"), player.call("get_max_charge"), player.call("is_charge_ready"), player.call("is_charge_active"))
-	_update_rhythm_track(0.0)
-
-
-func _process(delta: float) -> void:
-	_update_rhythm_track(delta)
-	_update_combo_clear_animation(delta)
-	_update_charge_bar_flash(delta)
-	if feedback_flash > 0.0:
-		feedback_flash = maxf(0.0, feedback_flash - delta * 4.0)
-		rhythm_feedback_label.scale = Vector2.ONE * (1.0 + feedback_flash * 0.18)
-
-
-func _on_rhythm_action_judged(action_name: String, rating: Dictionary) -> void:
-	var rating_name: String = str(rating.get("label", "miss"))
-	var color: Color = rating.get("color", Color("ff0055")) as Color
-	var diff: float = float(rating.get("diff", INF))
-	
-	rhythm_feedback_label.text = "%s  %s  %s" % [
-		_format_action_name(action_name),
-		rating_name.to_upper(),
-		_format_signed_ms(diff),
-	]
-	rhythm_feedback_label.modulate = color
-	feedback_flash = 1.0
-
-
-func _on_rhythm_beat(_position: int) -> void:
-	beat_flash = 1.0
-
-
-func _on_combo_window_changed(slots: Array) -> void:
-	for index: int in range(combo_key_labels.size()):
-		var filled := index < slots.size()
-		var label := combo_key_labels[index]
-		var panel := combo_slot_panels[index]
-		label.text = str(slots[index]) if filled else "·"
-		label.modulate = Color(1.0, 1.0, 1.0, 1.0 if filled else 0.32)
-		panel.modulate = Color(1.0, 1.0, 1.0, 1.0 if filled else 0.48)
-		if filled:
-			_pulse_combo_slot(panel)
-
-
-func _on_combo_window_cleared(_reason: String) -> void:
-	_play_combo_clear_animation()
-
-
-func _on_skill_requested(skill_id: String) -> void:
-	combo_skill_label.text = _format_skill_name(skill_id)
-
-
-func _on_energy_changed(current: int, maximum: int) -> void:
-	var filled_segments := clampi(current, 0, min(maximum, energy_segments.size()))
-	for index: int in range(energy_segments.size()):
-		var filled := index < filled_segments
-		var panel := energy_segments[index]
-		panel.modulate = Color(1.0, 1.0, 1.0, 1.0 if filled else 0.38)
-
-
-func _on_health_changed(current: int, maximum: int) -> void:
-	health_bar.max_value = max(1, maximum)
-	health_bar.value = clampi(current, 0, maximum)
-
-
-func _on_charge_changed(current: float, maximum: float, ready: bool, active: bool) -> void:
-	charge_bar.max_value = maxf(0.01, maximum)
-	charge_bar.value = clampf(current, 0.0, maximum)
-	charge_bar_ready = ready and active
-	if charge_bar_ready:
-		return
-	charge_bar.modulate = Color(1.0, 1.0, 1.0, 1.0 if active or current > 0.0 else 0.45)
-
-
-func _update_charge_bar_flash(delta: float) -> void:
-	if not charge_bar_ready:
-		charge_flash = 0.0
-		return
-	charge_flash = fmod(charge_flash + delta * 7.0, TAU)
-	var alpha := 0.62 + 0.38 * absf(sin(charge_flash))
-	charge_bar.modulate = Color(1.0, 1.0, 1.0, alpha)
-
-
-func _play_combo_clear_animation() -> void:
-	if combo_clear_tween != null and combo_clear_tween.is_valid():
-		combo_clear_tween.kill()
-	combo_clear_flash = 1.0
-	for panel: PanelContainer in combo_slot_panels:
-		panel.scale = Vector2(1.16, 1.16)
-		panel.modulate = Color(1.0, 1.0, 1.0, 1.0)
-
-
-func _update_combo_clear_animation(delta: float) -> void:
-	if combo_clear_flash <= 0.0:
-		return
-	combo_clear_flash = maxf(0.0, combo_clear_flash - delta * 5.0)
-	var eased := combo_clear_flash * combo_clear_flash
-	for panel: PanelContainer in combo_slot_panels:
-		panel.scale = Vector2.ONE * (1.0 + 0.16 * eased)
-		panel.modulate = Color(1.0, 1.0, 1.0, 0.48 + 0.52 * eased)
-	if combo_clear_flash <= 0.0:
-		_restore_empty_combo_slots()
-
-
-func _pulse_combo_slot(panel: PanelContainer) -> void:
-	var tween := create_tween()
-	panel.scale = Vector2(1.08, 1.08)
-	tween.tween_property(panel, "scale", Vector2.ONE, 0.09)
-
-
-func _restore_empty_combo_slots() -> void:
-	for index: int in range(combo_slot_panels.size()):
-		combo_slot_panels[index].modulate = Color(1.0, 1.0, 1.0, 0.48)
-		combo_slot_panels[index].scale = Vector2.ONE
-		combo_key_labels[index].text = "·"
-		combo_key_labels[index].modulate = Color(1.0, 1.0, 1.0, 0.32)
-
-
-func _update_rhythm_track(delta: float) -> void:
-	beat_flash = maxf(0.0, beat_flash - delta * 8.0)
-	var progress := 0.0
-	if rhythm_conductor.has_method("get_current_beat_progress"):
-		progress = float(rhythm_conductor.call("get_current_beat_progress"))
-	if beat_flash > 0.15:
-		progress = 1.0
-	
-	_set_control_center(left_mover, left_mover_start.lerp(track_center, progress), mover_size)
-	_set_control_center(right_mover, right_mover_start.lerp(track_center, progress), mover_size)
-	_set_control_center(center_flash, track_center, center_flash_size)
-	center_flash.modulate = Color(1.0, 1.0, 1.0, beat_flash)
-
-
-func _cache_rhythm_track_layout() -> void:
-	track_center = _control_center(center_base)
-	left_mover_start = _control_center(left_mover)
-	right_mover_start = _control_center(right_mover)
-	mover_size = left_mover.size
-	center_flash_size = center_flash.size
-
-
-func _control_center(control: Control) -> Vector2:
-	return Vector2(
-		(control.offset_left + control.offset_right) * 0.5,
-		(control.offset_top + control.offset_bottom) * 0.5
-	)
-
-
-func _set_control_center(control: Control, center: Vector2, size: Vector2) -> void:
-	control.offset_left = center.x - size.x * 0.5
-	control.offset_top = center.y - size.y * 0.5
-	control.offset_right = center.x + size.x * 0.5
-	control.offset_bottom = center.y + size.y * 0.5
-
-
-func _format_action_name(action_name: String) -> String:
-	match action_name:
-		"w":
-			return "W"
-		"a":
-			return "A"
-		"d":
-			return "D"
-		"s":
-			return "S"
-		"space":
-			return "SP"
-		"skill_w":
-			return "W"
-		"skill_wa":
-			return "W+A"
-		"skill_wd":
-			return "W+D"
-		"skill_s":
-			return "S"
-		"skill_a":
-			return "A"
-		"skill_d":
-			return "D"
-		"skill_aa":
-			return "A+A"
-		"skill_dd":
-			return "D+D"
-		"skill_aaa":
-			return "A+A+A"
-		"skill_ddd":
-			return "D+D+D"
-		"skill_a_space":
-			return "A+SP"
-		"skill_d_space":
-			return "D+SP"
-		"skill_a_space_space":
-			return "A+SP+SP"
-		"skill_d_space_space":
-			return "D+SP+SP"
-		"skill_aa_space":
-			return "A+A+SP"
-		"skill_ad_space":
-			return "A+D+SP"
-		"skill_da_space":
-			return "D+A+SP"
-		"skill_dd_space":
-			return "D+D+SP"
-		"skill_s_projectile_1":
-			return "S+SP"
-		"skill_s_projectile_2":
-			return "S+SP+SP"
-		"skill_s_projectile_3":
-			return "S+SP+SP+SP"
-		_:
-			return action_name.to_upper()
-
-
-func _format_skill_name(skill_id: String) -> String:
-	match skill_id:
-		"skill_w":
-			return "W"
-		"skill_wa":
-			return "W+A"
-		"skill_wd":
-			return "W+D"
-		"skill_s":
-			return "S"
-		"skill_a":
-			return "A"
-		"skill_d":
-			return "D"
-		"skill_aa":
-			return "A+A"
-		"skill_dd":
-			return "D+D"
-		"skill_aaa":
-			return "A+A+A"
-		"skill_ddd":
-			return "D+D+D"
-		"skill_a_space":
-			return "A+SP"
-		"skill_d_space":
-			return "D+SP"
-		"skill_a_space_space":
-			return "A+SP+SP"
-		"skill_d_space_space":
-			return "D+SP+SP"
-		"skill_aa_space":
-			return "A+A+SP"
-		"skill_ad_space":
-			return "A+D+SP"
-		"skill_da_space":
-			return "D+A+SP"
-		"skill_dd_space":
-			return "D+D+SP"
-		"skill_s_projectile_1":
-			return "S+SP"
-		"skill_s_projectile_2":
-			return "S+SP+SP"
-		"skill_s_projectile_3":
-			return "S+SP+SP+SP"
-		_:
-			return skill_id.to_upper()
-
-
-func _format_signed_ms(seconds: float) -> String:
-	if is_inf(seconds):
-		return "-- ms"
-	return "%+.0f ms" % (seconds * 1000.0)
+func get_player() -> Node:
+	return stage.get_node("ActorsContainer/Player")

scenes/main/main.tscn

@@ -1,550 +1,16 @@
 [gd_scene format=3 uid="uid://brx0c2va3831p"]
 
-[ext_resource type="PackedScene" uid="uid://cs0rhloanh2u4" path="res://scenes/ground/ground.tscn" id="1_ground"]
-[ext_resource type="PackedScene" uid="uid://cs3s5wy1melul" path="res://scenes/characters/player.tscn" id="2_player"]
-[ext_resource type="Script" uid="uid://3n4nkejauoim" path="res://scenes/main/main.gd" id="3_main_script"]
-[ext_resource type="Script" uid="uid://brh83qp8flq5u" path="res://scenes/rhythm/rhythm_conductor.gd" id="4_rhythm_script"]
-[ext_resource type="AudioStream" uid="uid://di5ceecn088rk" path="res://assets/audio/song.ogg" id="5_song"]
-[ext_resource type="Texture2D" uid="uid://brqr1gyyxth8p" path="res://assets/ui/rhythm/center.png" id="6_center"]
-[ext_resource type="Texture2D" uid="uid://bkqec7mh5yfrd" path="res://assets/ui/rhythm/center_flash.png" id="7_center_flash"]
-[ext_resource type="Texture2D" uid="uid://cj5pa4c3arevn" path="res://assets/ui/rhythm/rod.png" id="8_rod"]
-[ext_resource type="Texture2D" uid="uid://dbmdivnpjf48l" path="res://assets/ui/rhythm/blue_ball.png" id="9_blue_ball"]
-[ext_resource type="Texture2D" uid="uid://ewr8k3lwpcna" path="res://assets/ui/rhythm/yellow_ball.png" id="10_yellow_ball"]
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_a8run"]
-content_margin_left = 6.0
-content_margin_top = 4.0
-content_margin_right = 6.0
-content_margin_bottom = 4.0
-bg_color = Color(0.04, 0.07, 0.09, 0.82)
-border_width_left = 2
-border_width_top = 2
-border_width_right = 2
-border_width_bottom = 2
-border_color = Color(0.43, 0.78, 0.88, 0.95)
-corner_radius_top_left = 6
-corner_radius_top_right = 6
-corner_radius_bottom_right = 6
-corner_radius_bottom_left = 6
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_ouso4"]
-content_margin_left = 6.0
-content_margin_top = 4.0
-content_margin_right = 6.0
-content_margin_bottom = 4.0
-bg_color = Color(0.04, 0.07, 0.09, 0.82)
-border_width_left = 2
-border_width_top = 2
-border_width_right = 2
-border_width_bottom = 2
-border_color = Color(0.43, 0.78, 0.88, 0.95)
-corner_radius_top_left = 6
-corner_radius_top_right = 6
-corner_radius_bottom_right = 6
-corner_radius_bottom_left = 6
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_blune"]
-content_margin_left = 6.0
-content_margin_top = 4.0
-content_margin_right = 6.0
-content_margin_bottom = 4.0
-bg_color = Color(0.04, 0.07, 0.09, 0.82)
-border_width_left = 2
-border_width_top = 2
-border_width_right = 2
-border_width_bottom = 2
-border_color = Color(0.43, 0.78, 0.88, 0.95)
-corner_radius_top_left = 6
-corner_radius_top_right = 6
-corner_radius_bottom_right = 6
-corner_radius_bottom_left = 6
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_th5th"]
-content_margin_left = 6.0
-content_margin_top = 4.0
-content_margin_right = 6.0
-content_margin_bottom = 4.0
-bg_color = Color(0.04, 0.07, 0.09, 0.82)
-border_width_left = 2
-border_width_top = 2
-border_width_right = 2
-border_width_bottom = 2
-border_color = Color(0.43, 0.78, 0.88, 0.95)
-corner_radius_top_left = 6
-corner_radius_top_right = 6
-corner_radius_bottom_right = 6
-corner_radius_bottom_left = 6
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_7smn1"]
-bg_color = Color(0.12, 0.08, 0.08, 0.86)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.6, 0.12, 0.16, 0.95)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_raeie"]
-bg_color = Color(0.86, 0.11, 0.18, 1)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_hxu8e"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_nvumn"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_ou6is"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_necax"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_r4lks"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_pg34l"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_m4h2d"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_p8abn"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_s17dp"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_37hlw"]
-bg_color = Color(0.18, 0.66, 0.95, 1)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.66, 0.92, 1, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_charge_bg"]
-bg_color = Color(0.08, 0.07, 0.12, 0.86)
-border_width_left = 1
-border_width_top = 1
-border_width_right = 1
-border_width_bottom = 1
-border_color = Color(0.42, 0.36, 0.75, 0.9)
-
-[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_charge_fill"]
-bg_color = Color(0.92, 0.72, 0.25, 1)
+[ext_resource type="Script" uid="uid://3n4nkejauoim" path="res://scenes/main/main.gd" id="1_main"]
+[ext_resource type="PackedScene" path="res://scenes/stage/stage.tscn" id="4_stage"]
+[ext_resource type="PackedScene" path="res://scenes/ui/main_ui.tscn" id="5_ui"]
+[ext_resource type="Script" path="res://scenes/chart/chart_runner.gd" id="6_chart_runner"]
 
 [node name="Main" type="Node2D" unique_id=596674982]
-script = ExtResource("3_main_script")
+script = ExtResource("1_main")
 
-[node name="RhythmConductor" type="AudioStreamPlayer" parent="." unique_id=147408036]
-stream = ExtResource("5_song")
-volume_db = -10.0
-script = ExtResource("4_rhythm_script")
+[node name="Stage" parent="." instance=ExtResource("4_stage")]
 
-[node name="ground" parent="." unique_id=235100600 instance=ExtResource("1_ground")]
+[node name="ChartRunner" type="Node" parent="."]
+script = ExtResource("6_chart_runner")
 
-[node name="Player" parent="." unique_id=1027194058 instance=ExtResource("2_player")]
-position = Vector2(2047, 370)
-
-[node name="RhythmFeedback" type="CanvasLayer" parent="." unique_id=979375765]
-
-[node name="RhythmTrack" type="Control" parent="RhythmFeedback" unique_id=529739298]
-layout_mode = 3
-anchors_preset = 5
-anchor_left = 0.5
-anchor_right = 0.5
-offset_left = -520.0
-offset_top = 28.0
-offset_right = 520.0
-offset_bottom = 172.0
-grow_horizontal = 2
-
-[node name="LeftRod" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=569576128]
-layout_mode = 0
-offset_left = 64.0
-offset_top = 60.0
-offset_right = 464.0
-offset_bottom = 84.0
-texture = ExtResource("8_rod")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="LeftRod" type="TextureRect" parent="RhythmFeedback/RhythmTrack/LeftRod" unique_id=1074213105]
-layout_mode = 0
-offset_left = 127.0
-offset_top = 1.0
-offset_right = 527.0
-offset_bottom = 25.0
-texture = ExtResource("8_rod")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="RightRod" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=112177250]
-layout_mode = 0
-offset_left = 446.0
-offset_top = 62.0
-offset_right = 846.0
-offset_bottom = 86.0
-texture = ExtResource("8_rod")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="RightRod" type="TextureRect" parent="RhythmFeedback/RhythmTrack/RightRod" unique_id=1431511936]
-layout_mode = 0
-offset_left = 127.0
-offset_right = 527.0
-offset_bottom = 24.0
-texture = ExtResource("8_rod")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="BlueBallLeft1" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=649449082]
-layout_mode = 0
-offset_left = 184.0
-offset_top = 49.0
-offset_right = 228.0
-offset_bottom = 93.0
-texture = ExtResource("9_blue_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="BlueBallLeft2" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=1327939368]
-layout_mode = 0
-offset_left = 309.0
-offset_top = 50.0
-offset_right = 353.0
-offset_bottom = 94.0
-texture = ExtResource("9_blue_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="BlueBallLeft3" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=1352623059]
-layout_mode = 0
-offset_left = 427.0
-offset_top = 51.0
-offset_right = 471.0
-offset_bottom = 95.0
-texture = ExtResource("9_blue_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="BlueBallRight1" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=75338529]
-layout_mode = 0
-offset_left = 567.0
-offset_top = 52.0
-offset_right = 611.0
-offset_bottom = 96.0
-texture = ExtResource("9_blue_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="BlueBallRight2" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=484948530]
-layout_mode = 0
-offset_left = 687.0
-offset_top = 52.0
-offset_right = 731.0
-offset_bottom = 96.0
-texture = ExtResource("9_blue_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="BlueBallRight3" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=587810490]
-layout_mode = 0
-offset_left = 813.0
-offset_top = 52.0
-offset_right = 857.0
-offset_bottom = 96.0
-texture = ExtResource("9_blue_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="LeftMover" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=2070100389]
-layout_mode = 0
-offset_left = 183.0
-offset_top = 47.0
-offset_right = 227.0
-offset_bottom = 91.0
-texture = ExtResource("10_yellow_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="RightMover" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=1028576547]
-layout_mode = 0
-offset_left = 815.0
-offset_top = 52.0
-offset_right = 859.0
-offset_bottom = 96.0
-texture = ExtResource("10_yellow_ball")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="CenterBase" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=1816341281]
-layout_mode = 0
-offset_left = 464.0
-offset_top = 16.0
-offset_right = 576.0
-offset_bottom = 128.0
-texture = ExtResource("6_center")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="CenterFlash" type="TextureRect" parent="RhythmFeedback/RhythmTrack" unique_id=1764975684]
-modulate = Color(1, 1, 1, 0)
-layout_mode = 0
-offset_left = 440.0
-offset_top = -8.0
-offset_right = 600.0
-offset_bottom = 152.0
-texture = ExtResource("7_center_flash")
-expand_mode = 1
-stretch_mode = 5
-
-[node name="JudgementLabel" type="Label" parent="RhythmFeedback" unique_id=776378947]
-anchors_preset = 5
-anchor_left = 0.5
-anchor_right = 0.5
-offset_left = -240.0
-offset_top = 174.0
-offset_right = 240.0
-offset_bottom = 222.0
-grow_horizontal = 2
-theme_override_font_sizes/font_size = 24
-text = "READY"
-horizontal_alignment = 1
-vertical_alignment = 1
-
-[node name="ComboWindow" type="HBoxContainer" parent="RhythmFeedback" unique_id=1940360666]
-anchors_preset = 5
-anchor_left = 0.5
-anchor_right = 0.5
-offset_left = -148.0
-offset_top = 222.0
-offset_right = 148.0
-offset_bottom = 282.0
-pivot_offset = Vector2(148, 30)
-theme_override_constants/separation = 10
-
-[node name="Slot0" type="PanelContainer" parent="RhythmFeedback/ComboWindow" unique_id=181099068]
-modulate = Color(1, 1, 1, 0.45)
-custom_minimum_size = Vector2(64, 56)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_a8run")
-
-[node name="Key" type="Label" parent="RhythmFeedback/ComboWindow/Slot0" unique_id=1605416584]
-layout_mode = 2
-size_flags_horizontal = 3
-size_flags_vertical = 3
-theme_override_colors/font_color = Color(0.94, 0.98, 1, 1)
-theme_override_colors/font_shadow_color = Color(0, 0, 0, 0.9)
-theme_override_constants/shadow_offset_x = 2
-theme_override_constants/shadow_offset_y = 2
-theme_override_font_sizes/font_size = 26
-text = "·"
-horizontal_alignment = 1
-vertical_alignment = 1
-
-[node name="Slot1" type="PanelContainer" parent="RhythmFeedback/ComboWindow" unique_id=1398681506]
-modulate = Color(1, 1, 1, 0.45)
-custom_minimum_size = Vector2(64, 56)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_ouso4")
-
-[node name="Key" type="Label" parent="RhythmFeedback/ComboWindow/Slot1" unique_id=1841250488]
-layout_mode = 2
-size_flags_horizontal = 3
-size_flags_vertical = 3
-theme_override_colors/font_color = Color(0.94, 0.98, 1, 1)
-theme_override_colors/font_shadow_color = Color(0, 0, 0, 0.9)
-theme_override_constants/shadow_offset_x = 2
-theme_override_constants/shadow_offset_y = 2
-theme_override_font_sizes/font_size = 26
-text = "·"
-horizontal_alignment = 1
-vertical_alignment = 1
-
-[node name="Slot2" type="PanelContainer" parent="RhythmFeedback/ComboWindow" unique_id=22762864]
-modulate = Color(1, 1, 1, 0.45)
-custom_minimum_size = Vector2(64, 56)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_blune")
-
-[node name="Key" type="Label" parent="RhythmFeedback/ComboWindow/Slot2" unique_id=470444619]
-layout_mode = 2
-size_flags_horizontal = 3
-size_flags_vertical = 3
-theme_override_colors/font_color = Color(0.94, 0.98, 1, 1)
-theme_override_colors/font_shadow_color = Color(0, 0, 0, 0.9)
-theme_override_constants/shadow_offset_x = 2
-theme_override_constants/shadow_offset_y = 2
-theme_override_font_sizes/font_size = 26
-text = "·"
-horizontal_alignment = 1
-vertical_alignment = 1
-
-[node name="Slot3" type="PanelContainer" parent="RhythmFeedback/ComboWindow" unique_id=669931458]
-modulate = Color(1, 1, 1, 0.45)
-custom_minimum_size = Vector2(64, 56)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_th5th")
-
-[node name="Key" type="Label" parent="RhythmFeedback/ComboWindow/Slot3" unique_id=1939775423]
-layout_mode = 2
-size_flags_horizontal = 3
-size_flags_vertical = 3
-theme_override_colors/font_color = Color(0.94, 0.98, 1, 1)
-theme_override_colors/font_shadow_color = Color(0, 0, 0, 0.9)
-theme_override_constants/shadow_offset_x = 2
-theme_override_constants/shadow_offset_y = 2
-theme_override_font_sizes/font_size = 26
-text = "·"
-horizontal_alignment = 1
-vertical_alignment = 1
-
-[node name="ComboSkillLabel" type="Label" parent="RhythmFeedback" unique_id=246366341]
-anchors_preset = 5
-anchor_left = 0.5
-anchor_right = 0.5
-offset_left = -240.0
-offset_top = 286.0
-offset_right = 240.0
-offset_bottom = 322.0
-theme_override_colors/font_color = Color(1, 0.84, 0.26, 1)
-theme_override_colors/font_shadow_color = Color(0, 0, 0, 0.85)
-theme_override_constants/shadow_offset_x = 2
-theme_override_constants/shadow_offset_y = 2
-theme_override_font_sizes/font_size = 18
-horizontal_alignment = 1
-vertical_alignment = 1
-
-[node name="StatusBars" type="VBoxContainer" parent="RhythmFeedback" unique_id=1850079775]
-offset_left = 24.0
-offset_top = 9.0
-offset_right = 294.0
-offset_bottom = 69.0
-theme_override_constants/separation = 8
-
-[node name="HealthBar" type="ProgressBar" parent="RhythmFeedback/StatusBars" unique_id=562194184]
-custom_minimum_size = Vector2(270, 18)
-layout_mode = 2
-theme_override_styles/background = SubResource("StyleBoxFlat_7smn1")
-theme_override_styles/fill = SubResource("StyleBoxFlat_raeie")
-value = 100.0
-show_percentage = false
-
-[node name="EnergyBar" type="HBoxContainer" parent="RhythmFeedback/StatusBars" unique_id=353280285]
-custom_minimum_size = Vector2(270, 16)
-layout_mode = 2
-theme_override_constants/separation = 4
-
-[node name="Segment0" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1721101704]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_hxu8e")
-
-[node name="Segment1" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=2071238510]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_nvumn")
-
-[node name="Segment2" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=820288176]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_ou6is")
-
-[node name="Segment3" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1809879636]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_necax")
-
-[node name="Segment4" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=205364545]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_r4lks")
-
-[node name="Segment5" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1414251865]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_pg34l")
-
-[node name="Segment6" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1626363537]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_m4h2d")
-
-[node name="Segment7" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1577127808]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_p8abn")
-
-[node name="Segment8" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1597873707]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_s17dp")
-
-[node name="Segment9" type="Panel" parent="RhythmFeedback/StatusBars/EnergyBar" unique_id=1260417702]
-modulate = Color(1, 1, 1, 0.38)
-custom_minimum_size = Vector2(23, 16)
-layout_mode = 2
-theme_override_styles/panel = SubResource("StyleBoxFlat_37hlw")
-
-[node name="ChargeBar" type="ProgressBar" parent="RhythmFeedback/StatusBars" unique_id=674131167]
-modulate = Color(1, 1, 1, 0.45)
-custom_minimum_size = Vector2(270, 10)
-layout_mode = 2
-theme_override_styles/background = SubResource("StyleBoxFlat_charge_bg")
-theme_override_styles/fill = SubResource("StyleBoxFlat_charge_fill")
-max_value = 1.1
-show_percentage = false
+[node name="UI" parent="." instance=ExtResource("5_ui")]

scenes/rhythm/rhythm_conductor.gd

@@ -27,6 +27,8 @@ signal action_judged(action_name: String, rating: Dictionary)
 func _ready() -> void:
 	add_to_group("rhythm_conductor")
 	sec_per_beat = 60.0 / bpm
+	if is_inside_tree():
+		_event_bus().connect("rhythm_action_requested", _on_rhythm_action_requested)
 	if starts_on_ready:
 		start()
 
@@ -72,11 +74,9 @@ func judge_action(action_name: String) -> Dictionary:
 	var rating := get_current_rating()
 	rating["action"] = action_name
 	emit_signal("action_judged", action_name, rating)
-	print("Rhythm %s: %s (%s ms)" % [
-		action_name,
-		str(rating.get("label", "miss")),
-		_format_signed_ms(float(rating.get("diff", INF)))
-	])
+	var bus := _event_bus()
+	bus.emit_signal("judgement_made", StringName(str(rating.get("label", "miss"))), float(rating.get("diff", INF)) * 1000.0)
+	bus.emit_signal("action_judged", StringName(action_name), rating)
 	return rating
 
 
@@ -128,10 +128,25 @@ func _report_beat() -> void:
 			current_measure = 1
 		emit_signal("beat", song_position_in_beats)
 		emit_signal("measure", current_measure)
+		_event_bus().emit_signal("beat_ticked", song_position_in_beats)
 		last_reported_beat = song_position_in_beats
 		current_measure += 1
 
 
+func _on_rhythm_action_requested(action_name: StringName) -> void:
+	judge_action(str(action_name))
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus
+
+
 func _apply_beat_offset(time_seconds: float) -> float:
 	return time_seconds + beat_offset
 

scenes/stage/actors_container.gd

@@ -0,0 +1,28 @@
+class_name ActorsContainer
+extends Node2D
+
+const DEFAULT_PROJECTILE_SCENE := preload("res://scenes/combat/player_projectile.tscn")
+
+
+func _ready() -> void:
+	_event_bus().connect("projectile_requested", _on_projectile_requested)
+	$Player.connect("projectile_requested", _on_projectile_requested)
+
+
+func _on_projectile_requested(projectile_scene: PackedScene, spawn_position: Vector2, direction: Vector2) -> void:
+	var scene := projectile_scene if projectile_scene != null else DEFAULT_PROJECTILE_SCENE
+	var projectile := scene.instantiate()
+	projectile.global_position = spawn_position
+	projectile.set("direction", direction)
+	projectile.add_to_group("player_projectiles")
+	add_child(projectile)
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/stage/actors_container.gd.uid

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

scenes/stage/stage.gd

@@ -0,0 +1,8 @@
+class_name Stage
+extends Node2D
+
+@onready var actors_container: Node2D = $ActorsContainer
+
+
+func get_player() -> Node:
+	return $ActorsContainer/Player

scenes/stage/stage.gd.uid

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

scenes/stage/stage.tscn

@@ -0,0 +1,18 @@
+[gd_scene format=3]
+
+[ext_resource type="Script" path="res://scenes/stage/stage.gd" id="1_stage"]
+[ext_resource type="PackedScene" path="res://scenes/ground/ground.tscn" id="2_ground"]
+[ext_resource type="Script" path="res://scenes/stage/actors_container.gd" id="3_actors"]
+[ext_resource type="PackedScene" path="res://scenes/characters/player.tscn" id="4_player"]
+
+[node name="Stage" type="Node2D"]
+script = ExtResource("1_stage")
+
+[node name="Ground" parent="." instance=ExtResource("2_ground")]
+
+[node name="ActorsContainer" type="Node2D" parent="."]
+y_sort_enabled = true
+script = ExtResource("3_actors")
+
+[node name="Player" parent="ActorsContainer" instance=ExtResource("4_player")]
+position = Vector2(2047, 370)

scenes/ui/combo_window_hud.gd

@@ -0,0 +1,105 @@
+class_name ComboWindowHud
+extends HBoxContainer
+
+@export var slot_count := 4
+
+var panels: Array[PanelContainer] = []
+var labels: Array[Label] = []
+var clear_tween: Tween
+
+
+func _ready() -> void:
+	_build_slots()
+	var bus := _event_bus()
+	bus.connect("combo_updated", refresh)
+	bus.connect("combo_cleared", _on_combo_cleared)
+
+
+func refresh(inputs: Array) -> void:
+	if labels.is_empty():
+		_build_slots()
+	for index: int in range(labels.size()):
+		var filled := index < inputs.size()
+		labels[index].text = str(inputs[index]) if filled else "."
+		labels[index].modulate = Color(1.0, 1.0, 1.0, 1.0 if filled else 0.35)
+		panels[index].modulate = Color(1.0, 1.0, 1.0, 1.0 if filled else 0.48)
+		if filled:
+			_pulse_slot(panels[index])
+
+
+func _on_combo_cleared(_reason: StringName) -> void:
+	refresh([])
+	_flash_clear()
+
+
+func _build_slots() -> void:
+	if not labels.is_empty():
+		return
+	for index: int in range(slot_count):
+		var panel := PanelContainer.new()
+		panel.custom_minimum_size = Vector2(64, 56)
+		panel.pivot_offset = Vector2(32, 28)
+		panel.modulate = Color(1.0, 1.0, 1.0, 0.48)
+		panel.add_theme_stylebox_override("panel", _make_slot_style())
+		var label := Label.new()
+		label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+		label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+		label.text = "."
+		label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+		label.size_flags_vertical = Control.SIZE_EXPAND_FILL
+		label.add_theme_color_override("font_color", Color(0.94, 0.98, 1.0, 1.0))
+		label.add_theme_color_override("font_shadow_color", Color(0.0, 0.0, 0.0, 0.9))
+		label.add_theme_constant_override("shadow_offset_x", 2)
+		label.add_theme_constant_override("shadow_offset_y", 2)
+		label.add_theme_font_size_override("font_size", 26)
+		panel.add_child(label)
+		add_child(panel)
+		panels.append(panel)
+		labels.append(label)
+
+
+func _pulse_slot(panel: PanelContainer) -> void:
+	var tween := create_tween()
+	panel.scale = Vector2(1.08, 1.08)
+	tween.tween_property(panel, "scale", Vector2.ONE, 0.09)
+
+
+func _flash_clear() -> void:
+	if clear_tween != null and clear_tween.is_valid():
+		clear_tween.kill()
+	clear_tween = create_tween()
+	clear_tween.set_parallel(true)
+	for panel: PanelContainer in panels:
+		panel.scale = Vector2(1.16, 1.16)
+		panel.modulate = Color(1.0, 1.0, 1.0, 1.0)
+		clear_tween.tween_property(panel, "scale", Vector2.ONE, 0.20)
+		clear_tween.tween_property(panel, "modulate", Color(1.0, 1.0, 1.0, 0.48), 0.20)
+
+
+func _make_slot_style() -> StyleBoxFlat:
+	var style := StyleBoxFlat.new()
+	style.content_margin_left = 6.0
+	style.content_margin_top = 4.0
+	style.content_margin_right = 6.0
+	style.content_margin_bottom = 4.0
+	style.bg_color = Color(0.04, 0.07, 0.09, 0.82)
+	style.border_width_left = 2
+	style.border_width_top = 2
+	style.border_width_right = 2
+	style.border_width_bottom = 2
+	style.border_color = Color(0.43, 0.78, 0.88, 0.95)
+	style.corner_radius_top_left = 6
+	style.corner_radius_top_right = 6
+	style.corner_radius_bottom_right = 6
+	style.corner_radius_bottom_left = 6
+	return style
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/ui/combo_window_hud.gd.uid

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

scenes/ui/combo_window_hud.tscn

@@ -0,0 +1,7 @@
+[gd_scene format=3]
+
+[ext_resource type="Script" path="res://scenes/ui/combo_window_hud.gd" id="1"]
+
+[node name="ComboWindowHud" type="HBoxContainer"]
+theme_override_constants/separation = 10
+script = ExtResource("1")

scenes/ui/energy_bar.gd

@@ -0,0 +1,58 @@
+class_name EnergyBar
+extends HBoxContainer
+
+@export var segment_count := 10
+
+var segments: Array[Panel] = []
+
+
+func _ready() -> void:
+	_build_segments()
+	_event_bus().connect("player_energy_changed", refresh)
+
+
+func refresh(current: float, maximum: float) -> void:
+	if segments.is_empty():
+		_build_segments()
+	var filled := clampi(int(round(current)), 0, min(segment_count, int(maximum)))
+	for index: int in range(segments.size()):
+		segments[index].modulate = Color(1.0, 1.0, 1.0, 1.0 if index < filled else 0.35)
+
+
+func _build_segments() -> void:
+	if not segments.is_empty():
+		return
+	for child: Node in get_children():
+		var panel := child as Panel
+		if panel != null:
+			segments.append(panel)
+	if segments.size() >= segment_count:
+		return
+	for index: int in range(segments.size(), segment_count):
+		var panel := Panel.new()
+		panel.custom_minimum_size = Vector2(23, 16)
+		panel.modulate = Color(1.0, 1.0, 1.0, 0.35)
+		panel.add_theme_stylebox_override("panel", _make_segment_style())
+		add_child(panel)
+		segments.append(panel)
+
+
+func _make_segment_style() -> StyleBoxFlat:
+	var style := StyleBoxFlat.new()
+	style.bg_color = Color(0.18, 0.66, 0.95, 1.0)
+	style.border_width_left = 1
+	style.border_width_top = 1
+	style.border_width_right = 1
+	style.border_width_bottom = 1
+	style.border_color = Color(0.66, 0.92, 1.0, 0.9)
+	return style
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus

scenes/ui/energy_bar.gd.uid

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

scenes/ui/energy_bar.tscn

@@ -0,0 +1,75 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://scenes/ui/energy_bar.gd" id="1"]
+
+[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_segment"]
+bg_color = Color(0.18, 0.66, 0.95, 1)
+border_width_left = 1
+border_width_top = 1
+border_width_right = 1
+border_width_bottom = 1
+border_color = Color(0.66, 0.92, 1, 0.9)
+
+[node name="EnergyBar" type="HBoxContainer"]
+theme_override_constants/separation = 4
+script = ExtResource("1")
+
+[node name="Segment01" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment02" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment03" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment04" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment05" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment06" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment07" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment08" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment09" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")
+
+[node name="Segment10" type="Panel" parent="."]
+modulate = Color(1, 1, 1, 0.35)
+custom_minimum_size = Vector2(23, 16)
+layout_mode = 2
+theme_override_styles/panel = SubResource("StyleBoxFlat_segment")

scenes/ui/main_ui.gd

@@ -0,0 +1,95 @@
+class_name MainUI
+extends CanvasLayer
+
+@onready var health_bar: ProgressBar = $StatusBars/HealthBar
+@onready var charge_bar: ProgressBar = $StatusBars/ChargeBar
+@onready var combo_skill_label: Label = $ComboSkillLabel
+
+var charge_bar_ready := false
+var charge_flash := 0.0
+
+
+func _ready() -> void:
+	_apply_bar_styles()
+	var bus := _event_bus()
+	bus.connect("player_health_changed", _on_health_changed)
+	bus.connect("player_charge_changed", _on_charge_changed)
+	bus.connect("skill_executed", _on_skill_executed)
+
+
+func _process(delta: float) -> void:
+	_update_charge_bar_flash(delta)
+
+
+func _on_health_changed(current: int, maximum: int) -> void:
+	health_bar.max_value = max(1, maximum)
+	health_bar.value = clampi(current, 0, maximum)
+
+
+func _on_charge_changed(current: float, maximum: float, ready: bool, active: bool) -> void:
+	charge_bar.max_value = maxf(0.01, maximum)
+	charge_bar.value = clampf(current, 0.0, maximum)
+	charge_bar_ready = ready and active
+	if charge_bar_ready:
+		return
+	charge_bar.modulate = Color(1.0, 1.0, 1.0, 1.0 if active or ready else 0.45)
+
+
+func _on_skill_executed(skill: Resource, _judgement: StringName) -> void:
+	var display_name := str(skill.get("display_name"))
+	if display_name.is_empty():
+		display_name = str(skill.get("id")).to_upper()
+	combo_skill_label.text = display_name
+	var tween := create_tween()
+	combo_skill_label.scale = Vector2(1.12, 1.12)
+	tween.tween_property(combo_skill_label, "scale", Vector2.ONE, 0.12)
+
+
+func _update_charge_bar_flash(delta: float) -> void:
+	if not charge_bar_ready:
+		charge_flash = 0.0
+		return
+	charge_flash = fmod(charge_flash + delta * 7.0, TAU)
+	var alpha := 0.62 + 0.38 * absf(sin(charge_flash))
+	charge_bar.modulate = Color(1.0, 1.0, 1.0, alpha)
+
+
+func _apply_bar_styles() -> void:
+	health_bar.add_theme_stylebox_override(
+		"background",
+		_make_style(Color(0.12, 0.08, 0.08, 0.86), Color(0.6, 0.12, 0.16, 0.95))
+	)
+	health_bar.add_theme_stylebox_override(
+		"fill",
+		_make_style(Color(0.86, 0.11, 0.18, 1.0), Color.TRANSPARENT, false)
+	)
+	charge_bar.add_theme_stylebox_override(
+		"background",
+		_make_style(Color(0.08, 0.07, 0.12, 0.86), Color(0.42, 0.36, 0.75, 0.9))
+	)
+	charge_bar.add_theme_stylebox_override(
+		"fill",
+		_make_style(Color(0.92, 0.72, 0.25, 1.0), Color.TRANSPARENT, false)
+	)
+
+
+func _make_style(bg_color: Color, border_color: Color, has_border := true) -> StyleBoxFlat:
+	var style := StyleBoxFlat.new()
+	style.bg_color = bg_color
+	if has_border:
+		style.border_width_left = 1
+		style.border_width_top = 1
+		style.border_width_right = 1
+		style.border_width_bottom = 1
+		style.border_color = border_color
+	return style
+
+
+func _event_bus() -> Node:
+	var root := get_tree().root
+	var bus := root.get_node_or_null("EventBus")
+	if bus == null:
+		bus = load("res://autoload/event_bus.gd").new()
+		bus.name = "EventBus"
+		root.add_child(bus)
+	return bus