clean up yt link

Relocate the Blender working files into art/blender/ (Godot-ignored via
the .gdignore that travels with them) and lowercase the ANIM_* files to
snake_case: anim_bull, anim_bull2, anim_matador, anim_publik_mees. Drop
the stray matador2.gd.uid (no matador2.gd exists).

Repoint .gitignore (preview + blend-backup patterns), render_anim_preview.py
and CLAUDE.md at art/blender/, and update the anim-doc references from the
deleted matador_v02 to matador_v03.

No game impact: art/blender/ sits outside Godot's import graph (confirmed:
no .blend imported, preview stays gitignored, menu boots clean).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FBbGXbzg3SD6ZBSadPPF5H

CLAUDE.md

@@ -43,9 +43,7 @@ art/                            all raw art, grouped by role (snake_case):
 | `levels/arena_level.tscn` | The arena **level module**: floor + wall colliders, arena meshes, `MatadorSpawner` (with child `Node3D` spawn points placed by the designer), lighting, audience (`PublikNode`). Instanced into the shell's `LevelRoot` |
 | `levels/bear_level.tscn` | The Bear's Den **level module**: bear-arena mesh, its own floor collider, lighting, and a `BearSpawner` (`bear_spawn.gd`) that places the bear at center. Instanced into the shell's `LevelRoot` |
 | `actors/player/player.tscn` | Player scene root (`CharacterBody3D`) |
-| `actors/player/player.gd` | Movement, charge, turning, and abilities (kick/dash/slam/roll). Ability & movement particle FX are **not** built here — they're authored scenes in `systems/fx/` (`bull_*.tscn`), fired via `Fx.spawn()` (one-shots) / `Fx.attach()` (continuous) |
-| `actors/player/bull_impact_fx.gd` | Bull's coded, non-particle impact FX (the slam shockwave rings + kick flash-pop — tweened meshes, not CPUParticles3D, so they can't be `systems/fx/` scenes). Created by `player.gd` |
-| `actors/player/bull_legs.gd` | Bull body-wobble + tail Verlet-chain simulation. Created by `player.gd` |
+| `actors/player/player.gd` | Movement, charge, turning logic |
 | `camera_spring_arm.gd` | Mouse-look pivot (`Node3D` + `SpringArm3D`) |
 | `camera_follow.gd` | Smooth camera follow (`Camera3D`) |
 | `actors/matador/matador.gd` | Matador AI (wander / ragdoll state machine) |
@@ -54,8 +52,10 @@ art/                            all raw art, grouped by role (snake_case):
 | `actors/bear/bear.tscn` / `actors/bear/bear.gd` | Dark-Souls-style bear boss (`CharacterBody3D`). Routine state machine (wind-up → active → recovery) picking telegraphed moves by range band: Double Swipe / Overhead Smash (close), Leap Slam (mid-far), plus Stalk (2-leg walk-in) / Prowl (4-leg lope) positioning. Melee steps in during the swing (`bear_lunge_speed`) + tracks the bull; the leap is frame-synced to JUMP_SMASH so the paws hit ground on the impact frame (`bear_leap_impact_frame`); slams kick up dust + shake. Combos chain, hyper-armour mid-swing + poise (`bear_stagger_cd`), phase 2 enrage under `bear_enrage_frac` HP. Never damages the bull by colliding — only swings/slams. A horns-first bull charge wounds it (`_sweep_bull_ram`: swept prev→now so a tunnelling/point-blank charge still lands, gated by `bear_ram_reach` + `bull_gore_arc`, edge-triggered = one charge per wound). Joins `&"matador"` so bull abilities already hit it. Tuning under the `Bear` DP section |
 | `actors/bear/bear_attack_hitboxes.tscn` | The bear's attack colliders as a self-contained sub-scene (instanced under `bear_model`): a `LeapSlamHitbox` (Hitbox + cylinder = ground circle) and `SmashHitbox` (Hitbox + box = forward shockwave lane), plus an `AnimationPlayer` whose `leap_slam` / `smash_travel` clips author each collider's size + travel — scrub to tweak, like `Bear_FX`. `actors/bear/bear.gd` only fires the clip, arms the knock-up shaping, and sweeps for overlaps while it runs (see `_setup_attack_hitboxes` / `_start_attack_hitbox`) |
 | `actors/matador/sword.tscn` / `systems/combat/hitbox.gd` | The matador's sword wrapper (glb + editor-tweakable `BladeHitbox`). `systems/combat/hitbox.gd` (`class_name Hitbox`, Area3D) is the shared attack collider: `activate()`/`deactivate()` gate an active window, `sweep()` catches bodies already inside (AoE), and knock-up can ramp by distance (`knock_up_min_dist`/`_max_dist`) for the bear's outer-ring launch / further-hit-flies-higher |
-| `levels/run_state.gd` | Run progression autoload (`Run`) — the lobby hub and which level is being fought, across scene reloads |
-| `levels/level_def.gd` | `LevelDef` resource — a level's name / `scene_path` (always the shell) / `level_scene` (the level module instanced into the shell) / optional `enemy_scene` (arena wave vs. a boss like the bear) |
+| `levels/run_state.gd` | Run progression autoload (`Run`) — Slay-the-Spire map + player position across fights |
+| `levels/level_def.gd` | `LevelDef` resource — a level's name / map colour / `scene_path` (always the shell) / `level_scene` (the level module instanced into the shell) / optional `enemy_scene` (arena wave vs. a boss like the bear) |
+| `levels/map_node.gd` | `MapNode` — one runtime node on the run map (position, level, links) |
+| `levels/MapScreen.tscn` / `levels/map_screen.gd` | Between-fights map screen; win → pick a node → next level |
 | `systems/crowd/crowd_marker.gd` | `CrowdMarker` (`@tool Node3D`, `class_name`) — designer drops one per billboard spectator via the editor's Add-Node dialog; picks one of six 60°-spaced facings from the `orientation` dropdown. Draws an editor-only preview (slab + forward arrow, never serialised) and joins the `&"crowd_marker"` group |
 | `systems/crowd/crowd_billboards.gd` / `systems/crowd/crowd_billboard.gdshader` | `MultiMeshInstance3D` that harvests every `CrowdMarker` (group `&"crowd_marker"`) into one draw call, using each marker's world position + chosen facing. Front/back sprite sheet baked by `tools/bake_crowd_sheet.gd`; falls back to a generated inward-facing ring when no markers are placed |
 | `systems/debug/debug_params.gd` | Runtime-tunable parameter registry (autoload `DP`). Mobile-relevant flags: `force_touch_controls`, `touch_debug` (also enabled on-device with `?debug=1` in the page URL — shows the live profiler overlay in `systems/input/touch_controls.gd`), and `use_rigid_skin` (default **off** — native GPU skinning everywhere now that the 4.7 web templates fixed the Mali/ANGLE invisible-skinning bug; `systems/render/rigid_skin.gd` is a retained opt-in fallback). Rigid-skin is gated through `Controls.rigid_skin_enabled()`, which a page URL param overrides for on-device A/B with no console: `?skin=1` forces the workaround on (for a device where native skinning still fails), `?noskin=1` forces native off. Turning the workaround off also removes its per-spawn SurfaceTool rebuild, which was the arena's matador-spawn lag |
@@ -101,7 +101,7 @@ art/                            all raw art, grouped by role (snake_case):
 
 ## Animation & bone conventions
 
-### Blender rig (matador)
+### Blender rig (matador_v03)
 - **Armature bones:** `matador` (root) → `COG` → `chest` → `head`, `collarbone_L/R` → `arm_L/R` → `forearm_L/R` → `hand_L/R`, `leg_L/R` → `shin_L/R` → `foot_L/R`
 - **Rotation mode:** All animated bones use **XYZ Euler** (set in `create_matador_anims.py`)
 - **Bone-local axes:** Swing (forward/back) is on **local X**. Arm lowering from T-pose is on **local Y** (positive = left arm down, negative = right arm down). Knee bend is **positive X** (shins only bend backward).
@@ -119,7 +119,7 @@ After FBX import, animations appear as `Armature|walk` and `Armature|idle` in An
 
 ### Verification workflow
 1. Edit bones/animations in Blender (`create_matador_anims.py`)
-2. Run render preview: `blender --background art/blender/matador.blend --python art/blender/render_anim_preview.py`
+2. Run render preview: `blender --background art/blender/matador_v03.blend --python art/blender/render_anim_preview.py`
 3. Inspect PNGs in `art/blender/preview/` — check bone orientations **before** exporting to Godot
 4. Export FBX (done automatically by `create_matador_anims.py`)
 5. Re-import in Godot and test in-game

actors/bear/bear.gd

@@ -26,11 +26,11 @@ var _phase: Phase = Phase.WINDUP
 var _bull: CharacterBody3D = null
 var _skeleton: Skeleton3D = null
 var _anim_player: AnimationPlayer = null
-# Separate player baked into art/fx/bear_fx.glb: each clip scales one FX mesh up from 0
+# Separate player baked into Assets/fx/Bear_FX.glb: each clip scales one FX mesh up from 0
 # and back at its strike frame (self-hiding), so bear.gd just fires the matching clip.
 var _fx_player: AnimationPlayer = null
 var _fx_root: Node = null
-# Shaped attack colliders live in bear_attack_hitboxes.tscn (under bear_model, so they track the
+# Shaped attack colliders live in BearAttackHitboxes.tscn (under bear_model, so they track the
 # bear's facing): a ground-circle cylinder for the leap slam and a forward box lane for the smash.
 # Their sizes AND their travel/pop motion are authored in that scene's AnimationPlayer (clips
 # "leap_slam" / "smash_travel") — scrub them there to tweak. bear.gd only fires the clip, sets the
@@ -635,7 +635,7 @@ func _try_hit(reach: float) -> bool:
 	return true
 
 
-# Grab the designer-authored collider sub-scene (bear_attack_hitboxes.tscn instanced under
+# Grab the designer-authored collider sub-scene (BearAttackHitboxes.tscn instanced under
 # bear_model) and park both hitboxes deactivated. Shapes + travel are authored in that scene.
 func _setup_attack_hitboxes() -> void:
 	var root := _mesh.get_node_or_null("AttackHitboxes") if _mesh else null
@@ -920,6 +920,18 @@ func _die(hit_dir: Vector3) -> void:
 	velocity = Vector3.ZERO
 	_blood_burst.burst(global_position + Vector3(0.0, 1.4, 0.0), hit_dir)
 	_play(_anim_death)
+	# No death clip on the rig — topple the beast onto its side (about the hit direction,
+	# so it falls the way it was struck) and sink it away, then free.
+	#var fall_axis := Vector3(-hit_dir.z, 0.0, hit_dir.x)
+	#if fall_axis.length() < 0.01:
+	#	fall_axis = Vector3.RIGHT
+	#var tween := create_tween()
+	#tween.tween_property(_mesh, "rotation",
+	#	_mesh.rotation + fall_axis.normalized() * deg_to_rad(88.0), 0.7)\
+	#	.set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
+	#tween.tween_interval(2.5)
+	#tween.tween_property(_mesh, "position:y", _mesh.position.y - 3.0, 1.0)
+	#tween.tween_callback(queue_free)
 
 
 # ── Interface shared with the matador (guarded elsewhere via has_method) ─────────────

actors/matador/matador.gd

@@ -74,7 +74,7 @@ const _ANIM_TAUNTS: Array[StringName] = [&"Taunt", &"Taunt_B", &"Taunt_C"]
 # reparents from holster to hand at this point in the animation.
 const _DRAW_GRAB_AT: float = 0.55
 
-# Wrapper scenes (glb + an editor-tweakable hitbox / collider) — see sword.tscn / spear.tscn.
+# Wrapper scenes (glb + an editor-tweakable hitbox / collider) — see Sword.tscn / Spear.tscn.
 const _SWORD_SCENE: PackedScene = preload("res://actors/matador/sword.tscn")
 const _SPEAR_SCENE: PackedScene = preload("res://actors/matador/spear.tscn")
 
@@ -603,7 +603,7 @@ func _tick_attack(delta: float) -> void:
 	if _swing_timer > 0.0:
 		_decelerate(22.0, delta)
 		_play_anim(_ANIM_ATTACK)
-		# Damage off the sword's own BladeHitbox (sword.tscn), riding the animated blade — gored only
+		# Damage off the sword's own BladeHitbox (Sword.tscn), riding the animated blade — gored only
 		# when the thrust reaches it. Arm at the thrust (mat_stab_strike_at) and sweep for the overlap.
 		if _sword_blade_area != null and _swing_phase() >= DP.f("mat_stab_strike_at"):
 			_sword_blade_area.activate()
@@ -1189,7 +1189,7 @@ func _spawn_sword() -> void:
 	_drawing = false
 	_apply_sword_grip()
 
-	# The blade hitbox (sword.tscn, hitbox.gd) is armed only during the ATTACK thrust (see
+	# The blade hitbox (Sword.tscn, hitbox.gd) is armed only during the ATTACK thrust (see
 	# _tick_attack); off while merely carried, so brushing a drawn matador never gores the bull.
 	_sword_blade_area = _sword_node.get_node_or_null("BladeHitbox") as Hitbox
 	if _sword_blade_area != null:

actors/player/bull_impact_fx.gd

@@ -1,110 +0,0 @@
-extends Node
-## Procedural (non-particle) bull impact FX: the expanding ground-slam shockwave rings and the
-## kick flash-pop. These are tween-animated MeshInstance3D flashes, not CPUParticles3D, so they
-## can't be authored as systems/fx/ scenes and live in code here. Created by player.gd; the
-## transient meshes are parented into the level (the bull's parent) so they hold their world
-## position while the bull keeps moving.
-
-var _player: Node3D
-var _ring_mesh: ArrayMesh = null
-
-
-func setup(player: Node3D) -> void:
-	_player = player
-
-
-# Three nested shockwave rings racing outward from a ground slam, each fading as it grows.
-func slam_rings(origin: Vector3, max_r: float) -> void:
-	if _ring_mesh == null:
-		_ring_mesh = _make_ring_mesh()
-	_launch_ring(origin, max_r, 0.00, 0.55, Color(1.0, 0.70, 0.10, 0.85))
-	_launch_ring(origin, max_r, 0.10, 0.52, Color(1.0, 0.50, 0.10, 0.65))
-	_launch_ring(origin, max_r, 0.20, 0.48, Color(0.9, 0.30, 0.10, 0.50))
-
-
-# A quick bright flash-pop at the kick's contact point.
-func kick_flash(origin: Vector3) -> void:
-	var mat := _flat_material(Color(1.0, 0.97, 0.40, 0.0))
-	var sphere := SphereMesh.new()
-	sphere.radius = 1.0
-	sphere.height = 2.0
-	sphere.radial_segments = 8
-	sphere.rings = 4
-	sphere.material = mat
-
-	var mi := MeshInstance3D.new()
-	mi.mesh = sphere
-	mi.material_override = mat
-	mi.scale = Vector3(0.05, 0.05, 0.05)
-	_host().add_child(mi)
-	mi.global_position = origin
-
-	var tween := create_tween()
-	tween.set_parallel(true)
-	tween.tween_property(mi, "scale", Vector3(0.7, 0.7, 0.7), 0.13)\
-		.set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
-	var fade := func(a: float) -> void: mat.albedo_color.a = a
-	tween.tween_method(fade, 0.92, 0.0, 0.14)\
-		.set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)
-	tween.tween_callback(mi.queue_free).set_delay(0.16)
-
-
-func _launch_ring(origin: Vector3, max_r: float, delay: float, duration: float, col: Color) -> void:
-	var mat := _flat_material(Color(col.r, col.g, col.b, 0.0))
-	var mi := MeshInstance3D.new()
-	mi.mesh = _ring_mesh
-	mi.material_override = mat
-	mi.scale = Vector3(0.02, 1.0, 0.02)
-	_host().add_child(mi)
-	mi.global_position = origin
-
-	var tween := create_tween()
-	tween.set_parallel(true)
-	tween.tween_property(mi, "scale", Vector3(max_r, 1.0, max_r), duration)\
-		.set_delay(delay).set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
-	var fade := func(a: float) -> void: mat.albedo_color.a = a
-	tween.tween_method(fade, col.a, 0.0, duration)\
-		.set_delay(delay).set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)
-	tween.tween_callback(mi.queue_free).set_delay(delay + duration + 0.05)
-
-
-func _flat_material(color: Color) -> StandardMaterial3D:
-	var mat := StandardMaterial3D.new()
-	mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
-	mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
-	mat.cull_mode = BaseMaterial3D.CULL_DISABLED
-	mat.albedo_color = color
-	return mat
-
-
-# A flat annulus in the XZ plane (unit radius), scaled up at runtime into the shockwave ring.
-func _make_ring_mesh() -> ArrayMesh:
-	const INNER_R: float = 0.82
-	const OUTER_R: float = 1.00
-	const SEGMENTS: int = 48
-
-	var verts := PackedVector3Array()
-	var indices := PackedInt32Array()
-	for i: int in SEGMENTS:
-		var a0 := i / float(SEGMENTS) * TAU
-		var a1 := (i + 1) / float(SEGMENTS) * TAU
-		var vi := i * 4
-		verts.append(Vector3(cos(a0) * INNER_R, 0.0, sin(a0) * INNER_R))
-		verts.append(Vector3(cos(a0) * OUTER_R, 0.0, sin(a0) * OUTER_R))
-		verts.append(Vector3(cos(a1) * OUTER_R, 0.0, sin(a1) * OUTER_R))
-		verts.append(Vector3(cos(a1) * INNER_R, 0.0, sin(a1) * INNER_R))
-		indices.append_array([vi, vi + 2, vi + 1, vi, vi + 3, vi + 2])
-
-	var arrays: Array = []
-	arrays.resize(Mesh.ARRAY_MAX)
-	arrays[Mesh.ARRAY_VERTEX] = verts
-	arrays[Mesh.ARRAY_INDEX] = indices
-	var mesh := ArrayMesh.new()
-	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
-	return mesh
-
-
-func _host() -> Node:
-	if _player != null and _player.get_parent() != null:
-		return _player.get_parent()
-	return _player

actors/player/bull_impact_fx.gd.uid

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

actors/player/player.gd

@@ -8,7 +8,7 @@ const HOOF_OFFSETS: Array = [
 	Vector3( 0.30, -0.25,  0.60),
 ]
 
-# Bull animation clips (Armature|* action names in art/characters/bull.fbx). IDLE is the
+# Bull animation clips (Armature|* action names in Assets/bull.fbx). IDLE is the
 # looping base pose; the others are one-shot ability clips that return to it.
 const _ANIM_IDLE: StringName = &"Armature|IDLE"
 const _ANIM_KICK: StringName = &"Armature|KICK"
@@ -27,11 +27,12 @@ var _legs: Node
 var _was_on_floor: bool         = false
 var _pre_slide_vel_y: float     = 0.0
 
-# Built once and reused: a fresh StandardMaterial3D/SphereMesh per spawn makes a mobile WebGL
-# driver recompile the shader + re-upload the mesh — a hitch "when attacking" absent on desktop.
+var _slam_ring_mesh: ArrayMesh = null
+# Attack-FX resources are identical every swing, so build them once and reuse. Recreating a fresh
+# StandardMaterial3D / SphereMesh per attack makes a mobile WebGL driver recompile the shader and
+# re-upload the mesh each time — a main-thread hitch "when attacking" that never shows on desktop.
 var _unshaded_mat: StandardMaterial3D = null
 var _particle_sphere_cache: Dictionary = {}   # "radius:seg:ring" -> SphereMesh (shared)
-var _impact_fx: Node = null   # bull_impact_fx.gd — the coded (non-particle) slam rings + kick flash
 
 # Ability system — kick=0, dash=1, slam=2, roll=3
 var ability_cd:      Array[float] = [0.0, 0.0, 0.0, 0.0]
@@ -82,12 +83,8 @@ var _huff_timer:      float               = 0.0
 
 enum DustState { NONE, WALK, CHARGE }
 var _dust_state: DustState = DustState.NONE
-# Hoof-dust scale/velocity per state (the look — mesh, colour, curve — lives in bull_hoof_dust.tscn).
-# A charge sprint kicks up bigger, faster dust than a walk.
-const _WALK_DUST_SCALE:   Vector2 = Vector2(0.20, 0.40)
-const _WALK_DUST_VEL:     Vector2 = Vector2(0.8, 1.8)
-const _CHARGE_DUST_SCALE: Vector2 = Vector2(0.35, 0.70)
-const _CHARGE_DUST_VEL:   Vector2 = Vector2(2.8, 5.5)
+var _walk_dust_ramp:   Gradient = null
+var _charge_dust_ramp: Gradient = null
 
 
 const RigidSkin = preload("res://systems/render/rigid_skin.gd")
@@ -109,7 +106,6 @@ func _ready() -> void:
 	_max_hp += _bonus_hp
 	_hp += _bonus_hp
 	_cube_scale = cube_guy.scale
-	_setup_impact_fx()
 	_setup_hoof_dust()
 	_setup_legs()
 	_setup_charge_trail()
@@ -117,6 +113,7 @@ func _ready() -> void:
 	_setup_audio()
 	_bull_anim = _find_anim_player(cube_guy)
 	_setup_bull_idle()
+	DP.any_changed.connect(_on_dp_changed)
 
 
 func _setup_legs() -> void:
@@ -126,35 +123,113 @@ func _setup_legs() -> void:
 	_legs.call(&"setup", self, cube_guy)
 
 
-func _setup_impact_fx() -> void:
-	_impact_fx = Node.new()
-	_impact_fx.set_script(load("res://actors/player/bull_impact_fx.gd"))
-	add_child(_impact_fx)
-	_impact_fx.call(&"setup", self)
-
-
-# The bull's ability/movement particle effects are authored as scenes in systems/fx/ (so Siim can
-# tune them in the inspector). The continuous ones follow the bull — instanced once here as
-# children, then toggled via `emitting`. The one-shots are fired on demand through Fx.spawn().
 func _setup_hoof_dust() -> void:
+	var sphere := _particle_sphere(0.07, 4, 2, _unshaded_material())
+
+	_walk_dust_ramp = Gradient.new()
+	_walk_dust_ramp.set_color(0, Color(0.94, 0.90, 0.83, 1.0))
+	_walk_dust_ramp.set_color(1, Color(0.94, 0.90, 0.83, 0.0))
+
+	# White-beige dust while running
+	_charge_dust_ramp = Gradient.new()
+	_charge_dust_ramp.set_color(0, Color(0.94, 0.90, 0.83, 1.0))
+	_charge_dust_ramp.set_color(1, Color(0.94, 0.90, 0.83, 0.0))
+
+	var scale_curve := Curve.new()
+	scale_curve.add_point(Vector2(0.0, 0.2))
+	scale_curve.add_point(Vector2(0.4, 1.0))
+	scale_curve.add_point(Vector2(1.0, 0.0))
+
 	for offset: Vector3 in HOOF_OFFSETS:
-		var p := Fx.attach(&"bull_hoof_dust", cube_guy) as CPUParticles3D
-		if p == null:
-			continue
+		var p := CPUParticles3D.new()
 		p.position = offset
+		p.emitting = false
+		p.amount = 12
+		p.lifetime = DP.f("dust_lifetime")
+		p.explosiveness = DP.f("dust_explosiveness")
+		p.randomness = 0.6
+		p.local_coords = false
+		p.direction = Vector3(0.0, 1.0, 0.0)
+		p.spread = DP.f("dust_spread")
+		p.gravity = Vector3(0.0, DP.f("dust_gravity_y"), 0.0)
+		p.initial_velocity_min = DP.f("walk_vel_min")
+		p.initial_velocity_max = DP.f("walk_vel_max")
+		p.scale_amount_min = DP.f("walk_scale_min")
+		p.scale_amount_max = DP.f("walk_scale_max")
+		p.mesh = sphere
+		p.color_ramp = _walk_dust_ramp
+		p.scale_amount_curve = scale_curve
+		cube_guy.add_child(p)
 		_hoof_emitters.append(p)
 
 
 func _setup_charge_trail() -> void:
-	_charge_trail_emitter = Fx.attach(&"bull_charge_trail", cube_guy) as CPUParticles3D
-	if _charge_trail_emitter != null:
+	# Blue energy trail — streams backward during a fast run / roll
+	var trail_sphere := _particle_sphere(0.065, 4, 2, _unshaded_material())
+
+	var trail_ramp := Gradient.new()
+	trail_ramp.set_color(0, Color(0.30, 0.65, 1.0, 1.0))
+	trail_ramp.set_color(1, Color(0.30, 0.65, 1.0, 0.0))
+
+	var trail_scale := Curve.new()
+	trail_scale.add_point(Vector2(0.0, 1.0))
+	trail_scale.add_point(Vector2(0.6, 0.8))
+	trail_scale.add_point(Vector2(1.0, 0.0))
+
+	_charge_trail_emitter = CPUParticles3D.new()
 	_charge_trail_emitter.position = Vector3(0.0, 0.25, 0.3)
+	_charge_trail_emitter.emitting = false
+	_charge_trail_emitter.one_shot = false
+	_charge_trail_emitter.amount = 18
+	_charge_trail_emitter.lifetime = 0.30
+	_charge_trail_emitter.randomness = 0.4
+	_charge_trail_emitter.local_coords = false
+	_charge_trail_emitter.direction = Vector3(0.0, 0.2, 1.0).normalized()
+	_charge_trail_emitter.spread = 25.0
+	_charge_trail_emitter.gravity = Vector3(0.0, 2.0, 0.0)
+	_charge_trail_emitter.initial_velocity_min = 4.0
+	_charge_trail_emitter.initial_velocity_max = 9.0
+	_charge_trail_emitter.scale_amount_min = 0.4
+	_charge_trail_emitter.scale_amount_max = 1.2
+	_charge_trail_emitter.mesh = trail_sphere
+	_charge_trail_emitter.color_ramp = trail_ramp
+	_charge_trail_emitter.scale_amount_curve = trail_scale
+	cube_guy.add_child(_charge_trail_emitter)
 
 
 func _setup_roll_sparks() -> void:
-	_roll_spark_emitter = Fx.attach(&"bull_roll_sparks", cube_guy) as CPUParticles3D
-	if _roll_spark_emitter != null:
+	# Rammus Powerball ground spray — dirt/sparks flung outward from the spinning
+	# ball. World-space (local_coords off) so they peel off into a trail behind it.
+	var spark := _particle_sphere(0.05, 4, 2, _unshaded_material())
+
+	var ramp := Gradient.new()
+	ramp.set_color(0, Color(1.00, 0.78, 0.32, 1.0))
+	ramp.set_color(1, Color(0.70, 0.42, 0.14, 0.0))
+
+	var sc := Curve.new()
+	sc.add_point(Vector2(0.0, 0.30))
+	sc.add_point(Vector2(0.3, 1.00))
+	sc.add_point(Vector2(1.0, 0.00))
+
+	_roll_spark_emitter = CPUParticles3D.new()
 	_roll_spark_emitter.position = Vector3(0.0, 0.10, 0.0)
+	_roll_spark_emitter.emitting = false
+	_roll_spark_emitter.one_shot = false
+	_roll_spark_emitter.amount = 46
+	_roll_spark_emitter.lifetime = 0.45
+	_roll_spark_emitter.randomness = 0.7
+	_roll_spark_emitter.local_coords = false
+	_roll_spark_emitter.direction = Vector3(0.0, 1.0, 0.0)
+	_roll_spark_emitter.spread = 180.0
+	_roll_spark_emitter.gravity = Vector3(0.0, -6.0, 0.0)
+	_roll_spark_emitter.initial_velocity_min = 3.0
+	_roll_spark_emitter.initial_velocity_max = 8.0
+	_roll_spark_emitter.scale_amount_min = 0.5
+	_roll_spark_emitter.scale_amount_max = 1.3
+	_roll_spark_emitter.mesh = spark
+	_roll_spark_emitter.color_ramp = ramp
+	_roll_spark_emitter.scale_amount_curve = sc
+	cube_guy.add_child(_roll_spark_emitter)
 
 
 func _setup_audio() -> void:
@@ -176,20 +251,42 @@ func _setup_audio() -> void:
 		add_child(_crowd_player)
 
 
-# Toggle the hoof emitters and swap their scale/velocity for the walk vs charge feel. The blue
-# charge trail is the roll/dash ability's, driven from the roll loop, not by dust state.
 func _set_dust_state(new_state: DustState) -> void:
 	if new_state == _dust_state:
 		return
 	_dust_state = new_state
-	var scale := _CHARGE_DUST_SCALE if new_state == DustState.CHARGE else _WALK_DUST_SCALE
-	var vel := _CHARGE_DUST_VEL if new_state == DustState.CHARGE else _WALK_DUST_VEL
 	for p: CPUParticles3D in _hoof_emitters:
-		p.scale_amount_min = scale.x
-		p.scale_amount_max = scale.y
-		p.initial_velocity_min = vel.x
-		p.initial_velocity_max = vel.y
-		p.emitting = new_state != DustState.NONE
+		p.lifetime = DP.f("dust_lifetime")
+		p.explosiveness = DP.f("dust_explosiveness")
+		p.spread = DP.f("dust_spread")
+		p.gravity = Vector3(0.0, DP.f("dust_gravity_y"), 0.0)
+		match new_state:
+			DustState.NONE:
+				p.emitting = false
+			DustState.WALK:
+				p.color_ramp = _walk_dust_ramp
+				p.scale_amount_min = DP.f("walk_scale_min")
+				p.scale_amount_max = DP.f("walk_scale_max")
+				p.initial_velocity_min = DP.f("walk_vel_min")
+				p.initial_velocity_max = DP.f("walk_vel_max")
+				p.emitting = true
+			DustState.CHARGE:
+				p.color_ramp = _charge_dust_ramp
+				p.scale_amount_min = DP.f("charge_scale_min")
+				p.scale_amount_max = DP.f("charge_scale_max")
+				p.initial_velocity_min = DP.f("charge_vel_min")
+				p.initial_velocity_max = DP.f("charge_vel_max")
+				p.emitting = true
+	# Blue energy trail belongs to the roll/dash ability only, not to fast WASD
+	# running — driven explicitly in the roll loop / _end_roll, not by dust state.
+
+
+func _on_dp_changed(_key: String, _val: Variant) -> void:
+	if _hoof_emitters.is_empty() or _dust_state == DustState.NONE:
+		return
+	var prev := _dust_state
+	_dust_state = DustState.NONE
+	_set_dust_state(prev)
 
 
 func _find_anim_player(node: Node) -> AnimationPlayer:
@@ -584,10 +681,13 @@ func _hit_matadors_radius(range_m: float, strength: float, up_boost: float = 0.0
 		mat.call(&"apply_ability_hit", (away + Vector3.UP * 0.6).normalized(), strength, up_boost)
 
 
-# ── Blood-spurt particle helpers ──────────────────────────────────────────────
-# The ability effects now live in systems/fx/; only the spear-wound blood below is still built in
-# code. Shared material, built once so the mobile driver compiles this particle shader a single
-# time (colour comes per-particle from the colour_ramp via vertex colour, not this material).
+# ── Particle helpers ──────────────────────────────────────────────────────────
+# All FX in this script use unshaded, vertex-coloured, alpha-blended particles;
+# these three helpers remove the boilerplate each spawn function used to repeat.
+
+# One shared unshaded material for every particle FX (per-particle colour comes from the
+# CPUParticles3D colour_ramp via vertex colour, not the material) — built once so the mobile
+# driver compiles this shader a single time instead of on every attack.
 func _unshaded_material() -> StandardMaterial3D:
 	if _unshaded_mat == null:
 		_unshaded_mat = StandardMaterial3D.new()
@@ -598,7 +698,8 @@ func _unshaded_material() -> StandardMaterial3D:
 	return _unshaded_mat
 
 
-# Low-poly particle-sphere mesh (height = diameter), cached per size so repeats reuse one GPU upload.
+# Low-poly sphere sized for a particle mesh (height is always the diameter). Cached per size so
+# repeat attacks reuse the same mesh (one GPU upload) instead of generating + uploading a new one.
 func _particle_sphere(radius: float, segments: int, rings: int, mat: Material) -> SphereMesh:
 	var key := "%.4f:%d:%d" % [radius, segments, rings]
 	var cached: SphereMesh = _particle_sphere_cache.get(key)
@@ -623,31 +724,281 @@ func _free_after(node: Node, delay: float) -> void:
 
 
 func _spawn_slam_fx() -> void:
+	if not _slam_ring_mesh:
+		_slam_ring_mesh = _make_slam_ring_mesh()
+	var max_r  := DP.f("slam_range")
 	var origin := global_position + Vector3(0.0, -0.5, 0.0)
-	_impact_fx.call(&"slam_rings", origin, DP.f("slam_range"))
-	Fx.spawn(&"bull_slam", Transform3D(Basis(), origin))
+	_launch_slam_ring(origin, max_r, 0.00, 0.55, Color(1.00, 0.70, 0.10, 0.85))
+	_launch_slam_ring(origin, max_r, 0.10, 0.52, Color(1.00, 0.50, 0.10, 0.65))
+	_launch_slam_ring(origin, max_r, 0.20, 0.48, Color(0.90, 0.30, 0.10, 0.50))
+	_spawn_slam_dust(origin)
 	camera_pivot.call(&"trigger_hit", 0.60)
 
 
+func _launch_slam_ring(origin: Vector3, max_r: float,
+		delay: float, duration: float, col: Color) -> void:
+	var mat := StandardMaterial3D.new()
+	mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+	mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
+	mat.albedo_color = Color(col.r, col.g, col.b, 0.0)
+	mat.cull_mode    = BaseMaterial3D.CULL_DISABLED
+
+	var mi := MeshInstance3D.new()
+	mi.mesh              = _slam_ring_mesh
+	mi.material_override = mat
+	mi.scale             = Vector3(0.02, 1.0, 0.02)
+	get_parent().add_child(mi)
+	mi.global_position   = origin
+
+	var tween := create_tween()
+	tween.set_parallel(true)
+	tween.tween_property(mi, "scale",
+			Vector3(max_r, 1.0, max_r), duration)\
+		.set_delay(delay)\
+		.set_trans(Tween.TRANS_EXPO)\
+		.set_ease(Tween.EASE_OUT)
+	var fade := func(a: float) -> void: mat.albedo_color.a = a
+	tween.tween_method(fade, col.a, 0.0, duration)\
+		.set_delay(delay)\
+		.set_trans(Tween.TRANS_SINE)\
+		.set_ease(Tween.EASE_IN)
+	tween.tween_callback(mi.queue_free).set_delay(delay + duration + 0.05)
+
+
+func _spawn_slam_dust(origin: Vector3) -> void:
+	var sphere := _particle_sphere(0.09, 4, 2, _unshaded_material())
+
+	var ramp := Gradient.new()
+	ramp.set_color(0, Color(0.88, 0.74, 0.46, 1.0))
+	ramp.set_color(1, Color(0.88, 0.74, 0.46, 0.0))
+
+	var scale_curve := Curve.new()
+	scale_curve.add_point(Vector2(0.0, 0.25))
+	scale_curve.add_point(Vector2(0.35, 1.6))
+	scale_curve.add_point(Vector2(1.00, 0.0))
+
+	var p := CPUParticles3D.new()
+	p.one_shot             = true
+	p.explosiveness        = 0.85
+	p.amount               = 48
+	p.lifetime             = 1.1
+	p.randomness           = 0.5
+	p.local_coords         = false
+	p.direction            = Vector3.UP
+	p.spread               = 85.0
+	p.gravity              = Vector3(0.0, -7.0, 0.0)
+	p.initial_velocity_min = 3.5
+	p.initial_velocity_max = 10.0
+	p.scale_amount_min     = 0.5
+	p.scale_amount_max     = 2.0
+	p.mesh                 = sphere
+	p.color_ramp           = ramp
+	p.scale_amount_curve   = scale_curve
+	get_parent().add_child(p)
+	p.global_position = origin
+	p.restart()
+	_free_after(p, 2.5)
+
+
 func _spawn_kick_fx(back_dir: Vector3) -> void:
 	var origin := global_position + back_dir * 0.55 + Vector3(0.0, -0.25, 0.0)
-	Fx.spawn(&"bull_kick", _aimed_xform(origin, back_dir))
-	_impact_fx.call(&"kick_flash", origin)
+	_spawn_kick_dust(origin, back_dir)
+	_spawn_kick_stones(origin, back_dir)
+	_spawn_kick_sparks(origin, back_dir)
+	_spawn_kick_flash(origin)
 	camera_pivot.call(&"trigger_hit", 0.35)
 
 
+func _spawn_kick_dust(origin: Vector3, back_dir: Vector3) -> void:
+	var sphere := _particle_sphere(0.12, 4, 2, _unshaded_material())
+
+	var ramp := Gradient.new()
+	ramp.set_color(0, Color(1.0, 0.78, 0.18, 0.95))
+	ramp.set_color(1, Color(1.0, 0.45, 0.05, 0.0))
+
+	var scale_curve := Curve.new()
+	scale_curve.add_point(Vector2(0.0, 0.3))
+	scale_curve.add_point(Vector2(0.3, 1.5))
+	scale_curve.add_point(Vector2(1.0, 0.0))
+
+	var p := CPUParticles3D.new()
+	p.one_shot             = true
+	p.explosiveness        = 0.80
+	p.amount               = 40
+	p.lifetime             = 1.2
+	p.randomness           = 0.5
+	p.local_coords         = false
+	p.direction            = (back_dir + Vector3(0.0, 0.7, 0.0)).normalized()
+	p.spread               = 65.0
+	p.gravity              = Vector3(0.0, -6.0, 0.0)
+	p.initial_velocity_min = 3.0
+	p.initial_velocity_max = 9.0
+	p.scale_amount_min     = 0.5
+	p.scale_amount_max     = 2.2
+	p.mesh                 = sphere
+	p.color_ramp           = ramp
+	p.scale_amount_curve   = scale_curve
+	get_parent().add_child(p)
+	p.global_position = origin
+	p.restart()
+	_free_after(p, 2.5)
+
+
+func _spawn_kick_stones(origin: Vector3, back_dir: Vector3) -> void:
+	var sphere := _particle_sphere(0.055, 3, 1, _unshaded_material())
+
+	var ramp := Gradient.new()
+	ramp.set_color(0, Color(0.62, 0.58, 0.52, 1.0))
+	ramp.set_color(1, Color(0.62, 0.58, 0.52, 0.0))
+
+	var scale_curve := Curve.new()
+	scale_curve.add_point(Vector2(0.0, 1.0))
+	scale_curve.add_point(Vector2(0.6, 1.0))
+	scale_curve.add_point(Vector2(1.0, 0.0))
+
+	var p := CPUParticles3D.new()
+	p.one_shot             = true
+	p.explosiveness        = 0.92
+	p.amount               = 14
+	p.lifetime             = 0.65
+	p.randomness           = 0.6
+	p.local_coords         = false
+	p.direction            = (back_dir + Vector3(0.0, 0.35, 0.0)).normalized()
+	p.spread               = 45.0
+	p.gravity              = Vector3(0.0, -9.8, 0.0)
+	p.initial_velocity_min = 5.0
+	p.initial_velocity_max = 14.0
+	p.scale_amount_min     = 0.5
+	p.scale_amount_max     = 1.8
+	p.mesh                 = sphere
+	p.color_ramp           = ramp
+	p.scale_amount_curve   = scale_curve
+	get_parent().add_child(p)
+	p.global_position = origin
+	p.restart()
+	_free_after(p, 2.0)
+
+
+func _spawn_kick_flash(origin: Vector3) -> void:
+	var mat := _unshaded_material()
+	mat.albedo_color = Color(1.0, 0.97, 0.40, 0.0)
+
+	var sphere := _particle_sphere(1.0, 8, 4, mat)
+
+	var mi := MeshInstance3D.new()
+	mi.mesh              = sphere
+	mi.material_override = mat
+	mi.scale             = Vector3(0.05, 0.05, 0.05)
+	get_parent().add_child(mi)
+	mi.global_position = origin
+
+	var tween := create_tween()
+	tween.set_parallel(true)
+	tween.tween_property(mi, "scale", Vector3(0.7, 0.7, 0.7), 0.13)\
+		.set_trans(Tween.TRANS_EXPO).set_ease(Tween.EASE_OUT)
+	var fade := func(a: float) -> void: mat.albedo_color.a = a
+	tween.tween_method(fade, 0.92, 0.0, 0.14)\
+		.set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)
+	tween.tween_callback(mi.queue_free).set_delay(0.16)
+
+
 func _spawn_dash_burst() -> void:
-	Fx.spawn(&"bull_dash", _aimed_xform(global_position + Vector3(0.0, 0.2, 0.0), _dash_dir))
+	var box := BoxMesh.new()
+	box.size = Vector3(0.045, 0.045, 0.30)
+	box.material = _unshaded_material()
+
+	var ramp := Gradient.new()
+	ramp.set_color(0, Color(0.50, 0.82, 1.0, 1.0))
+	ramp.set_color(1, Color(0.50, 0.82, 1.0, 0.0))
+
+	var scale_curve := Curve.new()
+	scale_curve.add_point(Vector2(0.0, 1.0))
+	scale_curve.add_point(Vector2(1.0, 0.0))
+
+	var p := CPUParticles3D.new()
+	p.one_shot             = true
+	p.explosiveness        = 0.92
+	p.amount               = 18
+	p.lifetime             = 0.22
+	p.randomness           = 0.15
+	p.local_coords         = false
+	p.direction            = _dash_dir
+	p.spread               = 15.0
+	p.gravity              = Vector3.ZERO
+	p.initial_velocity_min = 18.0
+	p.initial_velocity_max = 35.0
+	p.scale_amount_min     = 0.8
+	p.scale_amount_max     = 2.8
+	p.mesh                 = box
+	p.color_ramp           = ramp
+	p.scale_amount_curve   = scale_curve
+	get_parent().add_child(p)
+	p.global_position = global_position + Vector3(0.0, 0.2, 0.0)
+	p.restart()
+	_free_after(p, 0.6)
 
 
-# A transform at `origin` whose local -Z faces `forward` (flattened to horizontal). The kick/dash
-# effects bake their spray in local space, so aiming the spawn transform points the burst the
-# right way. Falls back to an unrotated transform when `forward` has no horizontal component.
-func _aimed_xform(origin: Vector3, forward: Vector3) -> Transform3D:
-	var flat := Vector3(forward.x, 0.0, forward.z)
-	if flat.length_squared() < 0.0001:
-		return Transform3D(Basis(), origin)
-	return Transform3D(Basis(), origin).looking_at(origin + flat.normalized(), Vector3.UP)
+func _spawn_kick_sparks(origin: Vector3, back_dir: Vector3) -> void:
+	var sphere := _particle_sphere(0.04, 3, 1, _unshaded_material())
+
+	var ramp := Gradient.new()
+	ramp.set_color(0, Color(1.0, 0.98, 0.60, 1.0))
+	ramp.set_color(1, Color(1.0, 1.0, 1.0, 0.0))
+
+	var scale_curve := Curve.new()
+	scale_curve.add_point(Vector2(0.0, 1.0))
+	scale_curve.add_point(Vector2(0.5, 0.6))
+	scale_curve.add_point(Vector2(1.0, 0.0))
+
+	var p := CPUParticles3D.new()
+	p.one_shot             = true
+	p.explosiveness        = 0.95
+	p.amount               = 22
+	p.lifetime             = 0.28
+	p.randomness           = 0.4
+	p.local_coords         = false
+	p.direction            = (back_dir + Vector3(0.0, 0.5, 0.0)).normalized()
+	p.spread               = 30.0
+	p.gravity              = Vector3(0.0, -14.0, 0.0)
+	p.initial_velocity_min = 8.0
+	p.initial_velocity_max = 18.0
+	p.scale_amount_min     = 0.6
+	p.scale_amount_max     = 2.0
+	p.mesh                 = sphere
+	p.color_ramp           = ramp
+	p.scale_amount_curve   = scale_curve
+	get_parent().add_child(p)
+	p.global_position = origin
+	p.restart()
+	_free_after(p, 1.0)
+
+
+func _make_slam_ring_mesh() -> ArrayMesh:
+	const INNER_R:  float = 0.82
+	const OUTER_R:  float = 1.00
+	const SEGMENTS: int   = 48
+
+	var verts   := PackedVector3Array()
+	var indices := PackedInt32Array()
+
+	for i: int in SEGMENTS:
+		var a0 := i       / float(SEGMENTS) * TAU
+		var a1 := (i + 1) / float(SEGMENTS) * TAU
+		var vi := i * 4
+		verts.append(Vector3(cos(a0) * INNER_R, 0.0, sin(a0) * INNER_R))
+		verts.append(Vector3(cos(a0) * OUTER_R, 0.0, sin(a0) * OUTER_R))
+		verts.append(Vector3(cos(a1) * OUTER_R, 0.0, sin(a1) * OUTER_R))
+		verts.append(Vector3(cos(a1) * INNER_R, 0.0, sin(a1) * INNER_R))
+		indices.append_array([vi, vi + 2, vi + 1, vi, vi + 3, vi + 2])
+
+	var arrays: Array = []
+	arrays.resize(Mesh.ARRAY_MAX)
+	arrays[Mesh.ARRAY_VERTEX] = verts
+	arrays[Mesh.ARRAY_INDEX]  = indices
+
+	var mesh := ArrayMesh.new()
+	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
+	return mesh
 
 
 func _physics_process(delta: float) -> void:
@@ -761,14 +1112,23 @@ func _physics_process(delta: float) -> void:
 			velocity.z   = flat_n.z * exit_spd
 			pre_wall_vel = Vector3(velocity.x, 0.0, velocity.z)
 
-			# Ram straight through a barrel that formed the wall we bounced off.
-			var hit := col.get_collider()
-			if hit != null and hit.has_method(&"destroy_barrel"):
-				hit.call(&"destroy_barrel")
+					# --- ADD THIS BREAKABLE BARREL DETECTION CODE ---
+			var collision = get_slide_collision(i)
+			var collider = collision.get_collider()
+
+			# Check if the object we hit has the "destroy_barrel" function
+			if collider and collider.has_method("destroy_barrel"):
+			# Optional: Only break if moving fast (e.g., sprinting or dashing)
+			# if velocity.length() > 5.0:
+				collider.destroy_barrel()
 
 	# ── Landing. Don't bounce ─────────────────────────────────────────────────────
 	if is_on_floor() and not _was_on_floor:
 		velocity.y = 0.0
+		#Bouncing landing below
+		#var impact := -_pre_slide_vel_y
+		#if impact > DP.f("bounce_min_impact") and not _slam_pending:
+			#velocity.y = impact * DP.f("bounce_restitution")
 
 	# ── Slam landing ──────────────────────────────────────────────────────────
 	if _slam_pending and is_on_floor() and not _was_on_floor:
@@ -797,6 +1157,8 @@ func _physics_process(delta: float) -> void:
 		if vel_flat.length_squared() > 0.1:
 			_charge_trail_emitter.direction = (-vel_flat.normalized() + Vector3(0.0, 0.25, 0.0)).normalized()
 
+	# ── Hoof sounds ───────────────────────────────────────────────────────────
+
 
 func get_hp() -> int:
 	return _hp
@@ -912,6 +1274,7 @@ func _spawn_blood(hit_pos: Vector3) -> void:
 	_free_after(p, 1.5)
 
 
+#hit flashing
 func _hit_flash() -> void:
 	var meshes := find_children("*", "MeshInstance3D", true, false)
 

actors/player/player.tscn

@@ -23,7 +23,7 @@ script = ExtResource("2_camera_iso")
 [node name="bull" parent="." unique_id=1386495166 instance=ExtResource("4_e80uo")]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -0.655, 0.23)
 
-[node name="Skeleton3D" parent="bull/Armature" parent_id_path=PackedInt32Array(1386495166, 1057197468) index="0" unique_id=840295370]
+[node name="Skeleton3D" parent="bull/Armature" parent_id_path=PackedInt32Array(1386495166, 1942410469) index="0" unique_id=550138996]
 bones/0/position = Vector3(0, 0, 0.009963839)
 bones/0/rotation = Quaternion(0.7071068, 0, 0, 0.7071067)
 bones/0/scale = Vector3(1, 1, 1)

actors/player/player_follow_light.gd

@@ -1,14 +0,0 @@
-extends Node3D
-
-var player: Node3D = null
-
-func _process(delta: float) -> void:
-	# If we don't have the player yet, try to find them in the group
-	if not is_instance_valid(player):
-		var players = get_tree().get_nodes_in_group("player")
-		if players.size() > 0:
-			player = players[0] as Node3D
-	
-	# If the player exists, follow their position
-	if is_instance_valid(player):
-		global_position = player.global_position

actors/player/player_follow_light.gd.uid

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

actors/player/player_follow_light.tscn

@@ -1,14 +0,0 @@
-[gd_scene format=3 uid="uid://4v25hb0qu5l0"]
-
-[ext_resource type="Script" uid="uid://cmapsaj010q40" path="res://actors/player/player_follow_light.gd" id="1_w7wrt"]
-
-[node name="PlayerFollowLight" type="Node3D" unique_id=1889971494]
-script = ExtResource("1_w7wrt")
-
-[node name="SpotLight3D" type="SpotLight3D" parent="." unique_id=1523840927]
-transform = Transform3D(1, 0, 0, 0, -4.371139e-08, 1, 0, -1, -4.371139e-08, 0, 2.6136062, 1.0431258e-07)
-light_color = Color(0.9999998, 0.8702623, 0.60548127, 1)
-light_energy = 8.0
-shadow_enabled = true
-distance_fade_length = 30.45
-spot_angle = 72.62192

art/blender/create_matador_anims.py

@@ -1,6 +1,6 @@
 """
-Blender 5.1 script: create walk + idle animations for matador.
-Run:  blender --background matador.blend --python create_matador_anims.py
+Blender 5.1 script: create walk + idle animations for matador_v03.
+Run:  blender --background matador_v03.blend --python create_matador_anims.py
 """
 import bpy, math, os
 
@@ -130,7 +130,7 @@ ti.name = 'idle'
 si = ti.strips.new('idle', 0, idle)
 
 # ── export FBX ─────────────────────────────────────────────────────────────────
-fbx_path = os.path.join(os.path.dirname(bpy.data.filepath), 'matador.fbx')
+fbx_path = os.path.join(os.path.dirname(bpy.data.filepath), 'matador_v03.fbx')
 bpy.ops.export_scene.fbx(
     filepath=fbx_path,
     use_selection=False,

art/blender/render_anim_preview.py

@@ -1,6 +1,6 @@
 """
 Blender 5.1 script: render preview frames of matador animations to PNG.
-Run:  blender --background matador.blend --python render_anim_preview.py
+Run:  blender --background matador_v03.blend --python render_anim_preview.py
 
 Outputs to art/blender/preview/ directory:
   walk_frame_00.png .. walk_frame_09.png

levels/MapScreen.tscn

@@ -0,0 +1,10 @@
+[gd_scene format=3 uid="uid://map_screen_v1"]
+
+[ext_resource type="Script" path="res://levels/map_screen.gd" id="1_map"]
+
+[node name="MapScreen" type="Control"]
+layout_mode = 3
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+script = ExtResource("1_map")

levels/level_def.gd

@@ -1,8 +1,9 @@
 class_name LevelDef
 extends Resource
-## Definition of one playable level — the arena, the bear's den, the lobby hub, and later
-## a china shop to smash. The flow code never hard-codes a scene: a level is a LevelDef
-## (plus its scene) built in run_state.gd and served through the lobby.
+## Definition of one playable level on the run map — the arena today, later a cave with
+## a bear, a china shop to smash, and so on. Every map node references a LevelDef, and
+## the map/flow code never hard-codes a scene: adding a level is a new LevelDef (plus its
+## scene) handed out by the map generator in run_state.gd.
 
 @export var id: StringName = &""
 @export var display_name: String = "Level"
@@ -14,10 +15,14 @@ extends Resource
 ## colliders and any level-specific subscripts. Swapped wholesale between levels so no
 ## previous level's geometry (or its colliders) can leak into the next.
 @export var level_scene: PackedScene = null
+## Placeholder pip tint on the map until per-level icon art exists.
+@export var color: Color = Color(0.80, 0.62, 0.24)
 ## Camera framing multiplier when this level loads — 1.0 is the shell camera's default
 ## shot; >1 dollies the camera back for a wider view (the lobby pulls out so the whole
 ## hub reads). Applied by game_shell; independent of the player's scroll-wheel zoom.
 @export var camera_zoom: float = 1.0
+## A boss level caps a run — its node is drawn larger and clearing it ends the map.
+@export var is_boss: bool = false
 ## The enemy this level pits the bull against. Null → the usual matador wave (the
 ## spawner's default). Set → a single boss enemy of this scene is spawned instead (e.g.
 ## the bear), and the fight is won when it falls. The arena scene is shared either way;

levels/lobby_level.tscn

@@ -2,7 +2,6 @@
 
 [ext_resource type="PackedScene" uid="uid://bbfvwolhomilp" path="res://props/torch.tscn" id="1_w7uyf"]
 [ext_resource type="PackedScene" uid="uid://bd56iuttyiypv" path="res://props/barrel_simple.tscn" id="2_3o0md"]
-[ext_resource type="PackedScene" uid="uid://4v25hb0qu5l0" path="res://actors/player/player_follow_light.tscn" id="2_8bh2m"]
 [ext_resource type="PackedScene" uid="uid://dctmlh4hnuux1" path="res://art/levels/lobby.glb" id="2_w7uyf"]
 [ext_resource type="Script" uid="uid://cwbf7jfkr8j10" path="res://levels/lobby_underground.gd" id="4_73452"]
 [ext_resource type="Script" uid="uid://dn77mjyxllgl6" path="res://levels/to_the_bear_level.gd" id="5_6j2sa"]
@@ -46,8 +45,8 @@ size = Vector3(4.1274414, 8.299622, 6.9958496)
 
 [node name="DirectionalLight3D" type="DirectionalLight3D" parent="Lights" unique_id=955995990]
 transform = Transform3D(-0.502238, -0.82287306, 0.26577574, 0.36594617, 0.07621761, 0.9275096, -0.78347975, 0.5630903, 0.26284787, 0, 0, 0)
-light_color = Color(0.5266291, 0.5549962, 0.9999985, 1)
-light_energy = 0.466
+light_color = Color(0.78431374, 0.8117647, 1, 1)
+light_energy = 0.228
 shadow_enabled = true
 
 [node name="SpotLight3D" type="SpotLight3D" parent="Lights" unique_id=1783040386]
@@ -100,9 +99,6 @@ transform = Transform3D(-4.371139e-08, 0, -1, 0, 1, 0, 1, 0, -4.371139e-08, -0.3
 [node name="Torch8" parent="Lights/Torches" unique_id=987701581 instance=ExtResource("1_w7uyf")]
 transform = Transform3D(-4.371139e-08, 0, -1, 0, 1, 0, 1, 0, -4.371139e-08, -0.349617, 1.9073486e-06, -0.31505227)
 
-[node name="PlayerFollowLight" parent="Lights" unique_id=1889971494 instance=ExtResource("2_8bh2m")]
-transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2.1712027, 0)
-
 [node name="WorldEnvironment" type="WorldEnvironment" parent="." unique_id=939963056]
 environment = SubResource("Environment_lobby")
 
@@ -244,7 +240,7 @@ transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 2.1928787, 0.11255789, 2.8063
 transform = Transform3D(-4.371139e-08, 0, -1, 0, 1, 0, 1, 0, -4.371139e-08, 0, 0, 0)
 script = ExtResource("4_73452")
 
-[node name="Plane" parent="Lobby_underground" index="1" unique_id=2038841618]
+[node name="Plane" parent="Lobby_underground" index="1" unique_id=1962555538]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.2352347, 0)
 
 [node name="AnimationPlayer" type="AnimationPlayer" parent="Lobby_underground" unique_id=2070502042]

levels/map_node.gd

@@ -0,0 +1,13 @@
+class_name MapNode
+extends RefCounted
+## One node on the run map. Regenerated every run and never persisted, so RefCounted
+## rather than Resource. `pos` is normalized (0-1) so the map screen can lay the node out
+## at any resolution; `links` are column indices in the *next* row this node connects to
+## (the Slay-the-Spire branching path).
+
+var row: int = 0
+var col: int = 0
+var pos: Vector2 = Vector2.ZERO
+var level: LevelDef = null
+var links: PackedInt32Array = PackedInt32Array()
+var cleared: bool = false

levels/map_node.gd.uid

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

levels/map_screen.gd

@@ -0,0 +1,280 @@
+extends Control
+## Slay-the-Spire-style run map shown between fights. Placeholder art — coloured pips
+## joined by paths — but fully interactive: the player picks one of the reachable nodes
+## and is sent into that level. Every node is the arena for now (see run_state.gd); the
+## screen is level-agnostic, so richer levels just need a LevelDef with its own colour.
+
+const _GOLD  := Color(1.00, 0.78, 0.22)
+const _CREAM := Color(0.93, 0.88, 0.72)
+const _EDGE_DIM    := Color(0.45, 0.36, 0.18, 0.55)
+const _EDGE_ACTIVE := Color(1.00, 0.82, 0.32, 0.95)
+
+const _NODE_SIZE := 58.0
+const _BOSS_SIZE := 88.0
+
+const _MENU_SCENE := "res://ui/main_menu.tscn"
+
+var _map_area: Control
+var _completion: PanelContainer
+
+
+func _ready() -> void:
+	Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
+	get_tree().paused = false
+	Run.ensure_run()
+	_build_ui()
+	_relayout.call_deferred()  # defer so _map_area has its real size first
+
+
+func _build_ui() -> void:
+	set_anchors_preset(Control.PRESET_FULL_RECT)
+
+	var bg := ColorRect.new()
+	bg.set_anchors_preset(Control.PRESET_FULL_RECT)
+	bg.color = Color(0.09, 0.06, 0.03)  # opaque leather, no scene showing through
+	bg.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	add_child(bg)
+
+	var title := Label.new()
+	title.text = "Choose Your Path"
+	title.set_anchors_preset(Control.PRESET_TOP_WIDE)
+	title.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	title.offset_top = 22.0
+	title.add_theme_font_override("font", UiFonts.title())
+	title.add_theme_font_size_override("font_size", 46)
+	title.add_theme_color_override("font_color", _GOLD)
+	title.add_theme_color_override("font_outline_color", Color(0, 0, 0, 0.9))
+	title.add_theme_constant_override("outline_size", 6)
+	title.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	add_child(title)
+
+	_map_area = Control.new()
+	_map_area.set_anchors_preset(Control.PRESET_FULL_RECT)
+	_map_area.offset_top = 108.0
+	_map_area.offset_bottom = -92.0
+	_map_area.offset_left = 48.0
+	_map_area.offset_right = -48.0
+	_map_area.clip_contents = false
+	add_child(_map_area)
+	_map_area.resized.connect(_relayout)
+
+	var menu_btn := _make_button("Main Menu")
+	menu_btn.set_anchors_preset(Control.PRESET_BOTTOM_LEFT)
+	menu_btn.grow_vertical = Control.GROW_DIRECTION_BEGIN
+	menu_btn.offset_left = 32.0
+	menu_btn.offset_bottom = -26.0
+	menu_btn.pressed.connect(_to_menu)
+	add_child(menu_btn)
+
+	_build_completion()
+
+
+# ── Layout ──────────────────────────────────────────────────────────────────
+# Rebuilt from the run state on first show and whenever the map area resizes. Edges are
+# added first so the node pips draw on top of the paths.
+
+func _relayout() -> void:
+	if _map_area == null:
+		return
+	for child in _map_area.get_children():
+		child.queue_free()
+	var size := _map_area.size
+	if size.x <= 0.0 or size.y <= 0.0:
+		return
+
+	var reachable := Run.reachable()
+	var reach_set := {}
+	for n: MapNode in reachable:
+		reach_set[n] = true
+
+	var here := Run.current_node()
+	if Run.player_row < 0:
+		var start_pos := Vector2(size.x * 0.5, size.y - 8.0)
+		_add_start_pip(start_pos)
+		for n: MapNode in reachable:
+			_add_edge(start_pos, _local(n, size), true)
+	for row: Array in Run.map:
+		for from_node: MapNode in row:
+			for to_col: int in from_node.links:
+				var to_node := Run.node_at(from_node.row + 1, to_col)
+				if to_node == null:
+					continue
+				var active := from_node == here and reach_set.has(to_node)
+				_add_edge(_local(from_node, size), _local(to_node, size), active)
+
+	for row: Array in Run.map:
+		for node: MapNode in row:
+			_add_node(node, size, reach_set.has(node))
+
+	_completion.visible = Run.run_complete() or reachable.is_empty()
+
+
+func _local(node: MapNode, size: Vector2) -> Vector2:
+	return Vector2(node.pos.x * size.x, node.pos.y * size.y)
+
+
+func _add_edge(a: Vector2, b: Vector2, active: bool) -> void:
+	var line := Line2D.new()
+	line.add_point(a)
+	line.add_point(b)
+	line.width = 4.0 if active else 2.5
+	line.default_color = _EDGE_ACTIVE if active else _EDGE_DIM
+	line.antialiased = true
+	_map_area.add_child(line)
+
+
+func _add_start_pip(center: Vector2) -> void:
+	var pip := PanelContainer.new()
+	var sz := 22.0
+	pip.custom_minimum_size = Vector2(sz, sz)
+	pip.size = Vector2(sz, sz)
+	pip.position = center - Vector2(sz, sz) * 0.5
+	pip.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	pip.add_theme_stylebox_override("panel", UiTheme.disc(_GOLD, _CREAM, 2))
+	_map_area.add_child(pip)
+
+
+func _add_node(node: MapNode, size: Vector2, is_reachable: bool) -> void:
+	var is_current := node.row == Run.player_row and node.col == Run.player_col
+	var sz := _BOSS_SIZE if node.level.is_boss else _NODE_SIZE
+	var center := _local(node, size)
+
+	var btn := Button.new()
+	btn.custom_minimum_size = Vector2(sz, sz)
+	btn.size = Vector2(sz, sz)
+	btn.position = center - Vector2(sz, sz) * 0.5
+	btn.focus_mode = Control.FOCUS_NONE
+	btn.disabled = not is_reachable
+	btn.mouse_filter = Control.MOUSE_FILTER_STOP if is_reachable else Control.MOUSE_FILTER_IGNORE
+
+	var fill := node.level.color
+	var border := UiTheme.BORDER
+	if is_current:
+		border = _CREAM
+	elif is_reachable:
+		border = _GOLD
+	elif node.cleared:
+		fill = fill.darkened(0.35)
+		border = Color(_GOLD.r, _GOLD.g, _GOLD.b, 0.5)
+	else:  # locked — a future row not yet reachable
+		fill = fill.darkened(0.6)
+		border = Color(0.40, 0.34, 0.20, 0.6)
+
+	var border_w := 4 if (is_reachable or is_current) else 2
+	var normal := UiTheme.disc(fill, border, border_w)
+	var hover := UiTheme.disc(fill.lightened(0.18), _CREAM, border_w)
+	btn.add_theme_stylebox_override("normal", normal)
+	btn.add_theme_stylebox_override("hover", hover)
+	btn.add_theme_stylebox_override("pressed", hover)
+	btn.add_theme_stylebox_override("disabled", normal)
+	_map_area.add_child(btn)
+
+	if is_reachable:
+		btn.pressed.connect(_enter_node.bind(node))
+		_pulse(btn)
+
+	if is_reachable or is_current or node.level.is_boss:
+		_add_caption(node.level.display_name, center + Vector2(0.0, sz * 0.5 + 6.0), is_reachable)
+	if is_current:
+		_add_caption("You are here", center - Vector2(0.0, sz * 0.5 + 18.0), false)
+
+
+func _add_caption(text: String, center_top: Vector2, bright: bool) -> void:
+	var lbl := Label.new()
+	lbl.text = text
+	lbl.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	lbl.size = Vector2(200.0, 0.0)
+	lbl.position = center_top - Vector2(100.0, 0.0)
+	lbl.add_theme_font_override("font", UiFonts.body())
+	lbl.add_theme_font_size_override("font_size", 15)
+	lbl.add_theme_color_override("font_color", _CREAM if bright else UiTheme.MUTED)
+	lbl.add_theme_color_override("font_outline_color", Color(0, 0, 0, 0.9))
+	lbl.add_theme_constant_override("outline_size", 4)
+	lbl.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	_map_area.add_child(lbl)
+
+
+# Slow glow on the reachable pips so the eye lands on where the player can go next.
+func _pulse(node: CanvasItem) -> void:
+	var tw := create_tween().set_loops()
+	tw.tween_property(node, "modulate:a", 0.6, 0.75).set_trans(Tween.TRANS_SINE)
+	tw.tween_property(node, "modulate:a", 1.0, 0.75).set_trans(Tween.TRANS_SINE)
+
+
+# ── Actions ───────────────────────────────────────────────────────────────────
+
+func _enter_node(node: MapNode) -> void:
+	Run.select_node(node)
+	get_tree().paused = false
+	get_tree().change_scene_to_file(node.level.scene_path)
+
+
+func _to_menu() -> void:
+	get_tree().paused = false
+	Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
+	get_tree().change_scene_to_file(_MENU_SCENE)
+
+
+# ── Run-complete overlay ──────────────────────────────────────────────────────
+
+func _build_completion() -> void:
+	_completion = PanelContainer.new()
+	_completion.set_anchors_preset(Control.PRESET_CENTER)
+	_completion.grow_horizontal = Control.GROW_DIRECTION_BOTH
+	_completion.grow_vertical = Control.GROW_DIRECTION_BOTH
+	_completion.add_theme_stylebox_override(
+		"panel", UiTheme.plaque(UiTheme.LEATHER, _GOLD, 4, 32.0, 24.0)
+	)
+	_completion.visible = false
+	add_child(_completion)
+
+	var col := VBoxContainer.new()
+	col.add_theme_constant_override("separation", 16)
+	col.alignment = BoxContainer.ALIGNMENT_CENTER
+	_completion.add_child(col)
+
+	var heading := Label.new()
+	heading.text = "Run Complete!"
+	heading.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	heading.add_theme_font_override("font", UiFonts.title())
+	heading.add_theme_font_size_override("font_size", 40)
+	heading.add_theme_color_override("font_color", _GOLD)
+	heading.add_theme_color_override("font_outline_color", Color(0, 0, 0, 0.9))
+	heading.add_theme_constant_override("outline_size", 5)
+	col.add_child(heading)
+
+	var row := HBoxContainer.new()
+	row.alignment = BoxContainer.ALIGNMENT_CENTER
+	row.add_theme_constant_override("separation", 16)
+	col.add_child(row)
+
+	var again := _make_button("New Run")
+	again.pressed.connect(_new_run)
+	row.add_child(again)
+
+	var menu := _make_button("Main Menu")
+	menu.pressed.connect(_to_menu)
+	row.add_child(menu)
+
+
+func _new_run() -> void:
+	Run.start_new_run()
+	_relayout()
+
+
+# Shared thematic button, matching the HUD / menu plaques.
+func _make_button(text: String) -> Button:
+	var btn := Button.new()
+	btn.text = text
+	btn.focus_mode = Control.FOCUS_NONE
+	btn.add_theme_stylebox_override(
+		"normal", UiTheme.plaque(Color(0.10, 0.07, 0.03, 0.90), _GOLD, 3, 18.0, 9.0)
+	)
+	var hover := UiTheme.plaque(Color(0.16, 0.10, 0.04, 0.96), _CREAM, 3, 18.0, 9.0)
+	btn.add_theme_stylebox_override("hover", hover)
+	btn.add_theme_stylebox_override("pressed", hover)
+	btn.add_theme_font_override("font", UiFonts.body())
+	btn.add_theme_color_override("font_color", _GOLD)
+	btn.add_theme_color_override("font_hover_color", _CREAM)
+	btn.add_theme_font_size_override("font_size", 18)
+	return btn

levels/map_screen.gd.uid

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

levels/run_state.gd

@@ -1,11 +1,12 @@
 extends Node
-## Persistent run progression across scene changes — which hub/level the player is in.
-## The level scene is reloaded for every fight, so this state must outlive scene changes:
-## genuinely global run state earns an autoload (`Run`).
+## Persistent run progression across scene changes — the Slay-the-Spire-style map and
+## where the player sits on it. The arena scene is reloaded for every fight, so this
+## state must outlive scene changes: genuinely global run state earns an autoload (`Run`).
 ##
-## Flow: menu Play → start_new_run() → lobby hub → enter a gate → that level → win →
-## return_to_lobby() (clearing a level opens its follow-on gates, e.g. clearing the arena
-## unlocks the bear). Adding a level is a new LevelDef in the catalog plus a lobby gate.
+## Flow: menu Play → start_new_run() → arena (intro fight) → win → MapScreen shows the
+## first frontier → pick a node → its level scene → win → back to MapScreen advanced one
+## row, and on until a boss node ends the map. Every node is the arena for now; adding a
+## level later is a new LevelDef in the catalog and pointing the generator at it.
 
 signal run_started
 
@@ -16,7 +17,21 @@ const _ARENA_LEVEL := preload("res://levels/arena_level.tscn")
 const _BEAR_LEVEL := preload("res://levels/bear_level.tscn")
 const _LOBBY_LEVEL := preload("res://levels/lobby_level.tscn")
 
-## Debug override — when set, active_level() returns this regardless of run state.
+# Map shape. Small + placeholder for now; the final row is a single boss node.
+const _ROWS := 5
+const _MIN_PER_ROW := 2
+const _MAX_PER_ROW := 4
+
+## map[row] is an Array[MapNode]; empty until a run starts.
+var map: Array = []
+## Node the player currently occupies. (-1, -1) = the start gate below the first row —
+## i.e. straight after the intro fight, before any map node has been chosen.
+var player_row: int = -1
+var player_col: int = -1
+## Node picked on the map whose level is being played now; committed to on the next win.
+var pending_row: int = -1
+var pending_col: int = -1
+## Debug override — when set, active_level() returns this regardless of map state.
 ## Set via the console `level` command; cleared on start_new_run().
 var debug_level_override: LevelDef = null
 ## The lobby is the hub the run starts and returns to: a walk-around room whose gates lead
@@ -34,21 +49,10 @@ var cleared: Dictionary = {}
 var bonus_hp: int = 0
 const BONUS_HP_CAP: int = 2
 
-## Wall-clock run timer: starts the moment the player walks through the arena gate (the
-## run's first fight) and freezes the instant the bear falls, so the completion screen can
-## show a final time. Time.get_ticks_msec()-based — real time, not delta-summed — so it
-## keeps ticking correctly across the scene reload between the arena and the bear's den.
-var _timer_start_msec: int = -1
-var _timer_end_msec: int = -1
-var _timer_running: bool = false
-## True once start_new_run() has built a run. Lets ensure_run() avoid wiping an active run
-## when the shell reloads for each fight.
-var _run_active: bool = false
-
 # Level catalog. Every level shares the shell scene; what changes is the level module
 # (its geometry + spawners) and the opponent. The arena (matador wave, normal + boss
-# flavours) and the bear (a lone boss enemy) live here. Future levels — china shop — slot
-# in the same way: a new module + a LevelDef entry.
+# flavours) and the bear (a lone boss enemy that can turn up as a normal node) live here.
+# Future levels — china shop — slot in the same way: a new module + a LevelDef entry.
 const _BEAR_SCENE := preload("res://actors/bear/bear.tscn")
 
 var _arena: LevelDef
@@ -58,27 +62,33 @@ var _lobby: LevelDef
 
 
 func _ready() -> void:
-	_arena = _make_level(&"arena", "The Arena", _ARENA_LEVEL)
-	_arena_boss = _make_level(&"arena_boss", "Grand Arena", _ARENA_LEVEL)
-	_bear = _make_level(&"bear", "Bear's Den", _BEAR_LEVEL)
+	_arena = _make_level(&"arena", "The Arena", _ARENA_LEVEL, Color(0.80, 0.62, 0.24), false)
+	_arena_boss = _make_level(
+		&"arena_boss", "Grand Arena", _ARENA_LEVEL, Color(0.88, 0.30, 0.20), true
+	)
+	_bear = _make_level(&"bear", "Bear's Den", _BEAR_LEVEL, Color(0.55, 0.38, 0.22), false)
 	_bear.enemy_scene = _BEAR_SCENE
 	# The lobby is a fightless hub — no enemy_scene, so no wave spawns and no win/lose.
-	_lobby = _make_level(&"lobby", "Lobby", _LOBBY_LEVEL)
+	_lobby = _make_level(&"lobby", "Lobby", _LOBBY_LEVEL, Color(0.62, 0.66, 0.72), false)
 	# It's a roomy hub with nothing to fight — pull the camera back so more of it reads.
 	_lobby.camera_zoom = 1.6
 
 
-func _make_level(id: StringName, level_name: String, level_scene: PackedScene) -> LevelDef:
+func _make_level(
+	id: StringName, level_name: String, level_scene: PackedScene, color: Color, boss: bool
+) -> LevelDef:
 	var l := LevelDef.new()
 	l.id = id
 	l.display_name = level_name
 	l.scene_path = _SHELL_SCENE
 	l.level_scene = level_scene
+	l.color = color
+	l.is_boss = boss
 	return l
 
 
-## The level being served right now: debug override wins, then the lobby hub or the level
-## picked at a gate, falling back to the plain arena for a direct scene launch.
+## The level being fought right now: debug override wins, then the pending/current map
+## node, falling back to the plain arena for the intro fight or a direct scene launch.
 func active_level() -> LevelDef:
 	if debug_level_override != null:
 		return debug_level_override
@@ -86,7 +96,10 @@ func active_level() -> LevelDef:
 		return _lobby
 	if lobby_choice != null:
 		return lobby_choice
-	return _arena
+	var n := node_at(pending_row, pending_col)
+	if n == null:
+		n = current_node()
+	return n.level if n != null and n.level != null else _arena
 
 
 ## Return a level by id, or null if unknown. Used by the debug console `level` command.
@@ -104,30 +117,80 @@ func level_ids() -> Array[StringName]:
 	return [&"arena", &"arena_boss", &"bear", &"lobby"]
 
 
-## Begin a fresh run: reset progression and open in the lobby hub. Called from the main-menu
-## Play button, not from a level scene (which reloads for every fight).
+## Begin a fresh run: build a new map and place the player at the start gate. Called from
+## the main-menu Play button, not from the arena scene (which reloads for every fight).
 func start_new_run() -> void:
+	_generate_map()
+	player_row = -1
+	player_col = -1
+	pending_row = -1
+	pending_col = -1
 	debug_level_override = null
 	# The run opens in the lobby hub; its gates lead into the fights.
 	enter_lobby = true
 	lobby_choice = null
 	cleared = {}
 	bonus_hp = 0
-	_timer_start_msec = -1
-	_timer_end_msec = -1
-	_timer_running = false
-	_run_active = true
 	run_started.emit()
 
 
-## Build a run if none is active — a safety net for entering a level directly (e.g. running
-## game_shell.tscn straight from the editor) without coming through the menu. Guarded so the
-## shell reloading for each fight doesn't wipe the run in progress.
+## Build a run if none exists — a safety net for entering the map or arena directly (e.g.
+## running scene.tscn straight from the editor) without coming through the menu.
 func ensure_run() -> void:
-	if not _run_active:
+	if map.is_empty():
 		start_new_run()
 
 
+func has_run() -> bool:
+	return not map.is_empty()
+
+
+func node_at(row: int, col: int) -> MapNode:
+	if row < 0 or row >= map.size():
+		return null
+	var r: Array = map[row]
+	if col < 0 or col >= r.size():
+		return null
+	return r[col]
+
+
+func current_node() -> MapNode:
+	return node_at(player_row, player_col)
+
+
+## Nodes the player may pick next: the whole first row from the start gate, otherwise the
+## nodes the current node links forward to.
+func reachable() -> Array:
+	if map.is_empty():
+		return []
+	if player_row < 0:
+		return (map[0] as Array).duplicate()
+	var here := current_node()
+	if here == null or player_row + 1 >= map.size():
+		return []
+	var out: Array = []
+	for c: int in here.links:
+		var n := node_at(player_row + 1, c)
+		if n != null:
+			out.append(n)
+	return out
+
+
+## True once the player has cleared a boss node — the map is finished.
+func run_complete() -> bool:
+	var here := current_node()
+	return here != null and here.level != null and here.level.is_boss
+
+
+## Mark a node as the one being played (its level scene is about to load).
+func select_node(node: MapNode) -> void:
+	if node == null:
+		return
+	enter_lobby = false
+	pending_row = node.row
+	pending_col = node.col
+
+
 ## Send the player to the lobby hub instead of a fight — active_level() serves the lobby
 ## until a gate is entered.
 func go_to_lobby() -> void:
@@ -167,37 +230,87 @@ func add_bonus_hp(amount: int) -> int:
 	return bonus_hp - before
 
 
-## Begin the run clock. No-op while the clock is already running, so walking back through
-## the arena gate mid-run can't restart it — but once it's been stopped (the bear is dead
-## and the player has looped back to the arena to go again), the next call restarts it from
-## zero rather than staying stuck showing the previous run's final time.
-func start_run_timer() -> void:
-	if _timer_running:
+## Commit the level just won: move the player onto the pending node (or leave them at the
+## start gate after the intro fight, which has no pending node).
+func complete_current_level() -> void:
+	if pending_row >= 0:
+		player_row = pending_row
+		player_col = pending_col
+		var n := current_node()
+		if n != null:
+			n.cleared = true
+	pending_row = -1
+	pending_col = -1
+
+
+# ── Map generation ────────────────────────────────────────────────────────────
+# A small branching lattice: each row gets a handful of nodes, each node links to the
+# nearest node(s) in the next row, and every next-row node is guaranteed a parent so the
+# path is always connected (no orphan the player can never reach). The final row is a
+# single boss node the whole map funnels toward.
+
+func _generate_map() -> void:
+	map.clear()
+	for r: int in _ROWS:
+		var count := 1 if r == _ROWS - 1 else randi_range(_MIN_PER_ROW, _MAX_PER_ROW)
+		var y := 1.0 - float(r + 1) / float(_ROWS + 1)  # row 0 near the bottom, boss on top
+		var row_nodes: Array = []
+		for c: int in count:
+			var node := MapNode.new()
+			node.row = r
+			node.col = c
+			node.pos = Vector2(_column_x(c, count), y)
+			# Boss row is always the Grand Arena; normal nodes are a mix of matador
+			# arenas and the occasional Bear's Den for variety.
+			if r == _ROWS - 1:
+				node.level = _arena_boss
+			else:
+				node.level = _bear if randf() < 0.35 else _arena
+			row_nodes.append(node)
+		map.append(row_nodes)
+	_link_rows()
+
+
+func _column_x(col: int, count: int) -> float:
+	if count <= 1:
+		return 0.5
+	return lerpf(0.18, 0.82, float(col) / float(count - 1))
+
+
+func _link_rows() -> void:
+	for r: int in _ROWS - 1:
+		var cur: Array = map[r]
+		var nxt: Array = map[r + 1]
+		var incoming := PackedInt32Array()
+		incoming.resize(nxt.size())  # zero-filled
+		for from_node: MapNode in cur:
+			var nearest := _nearest_index(from_node, nxt)
+			_add_link(from_node, nearest, incoming)
+			# Occasionally fan out to an adjacent next-row node so paths branch.
+			if nxt.size() > 1 and randf() < 0.45:
+				var step := 1 if randf() < 0.5 else -1
+				_add_link(from_node, clampi(nearest + step, 0, nxt.size() - 1), incoming)
+		# Guarantee every next-row node has at least one parent (no orphans).
+		for c: int in nxt.size():
+			if incoming[c] == 0:
+				_add_link(cur[_nearest_index(nxt[c], cur)], c, incoming)
+
+
+func _add_link(from_node: MapNode, to_col: int, incoming: PackedInt32Array) -> void:
+	if to_col in from_node.links:
 		return
-	_timer_start_msec = Time.get_ticks_msec()
-	_timer_end_msec = -1
-	_timer_running = true
+	from_node.links.append(to_col)
+	incoming[to_col] += 1
 
 
-## Freeze the run clock — called the instant the bear falls, so the recorded time is the
-## kill moment itself, not whatever the win-screen's celebratory delay adds on top.
-func stop_run_timer() -> void:
-	if not _timer_running:
-		return
-	_timer_end_msec = Time.get_ticks_msec()
-	_timer_running = false
-
-
-## Seconds elapsed since the timer started (live while running, held steady once
-## stop_run_timer() has been called). 0 before the timer has ever started.
-func run_elapsed() -> float:
-	if _timer_start_msec < 0:
-		return 0.0
-	var end_msec := Time.get_ticks_msec() if _timer_running else _timer_end_msec
-	return float(end_msec - _timer_start_msec) / 1000.0
-
-
-## Whether the run clock has been started (the player has entered the arena at least once
-## this run). Lets the HUD hide the timer readout until there's a time worth showing.
-func run_timer_started() -> bool:
-	return _timer_start_msec >= 0
+# Index of the node in `others` whose column position is closest to `node` on the x axis —
+# used both to link a node forward and to adopt an orphan back to its nearest parent.
+func _nearest_index(node: MapNode, others: Array) -> int:
+	var best := 0
+	var best_d := INF
+	for i: int in others.size():
+		var d: float = absf((others[i] as MapNode).pos.x - node.pos.x)
+		if d < best_d:
+			best_d = d
+			best = i
+	return best

levels/to_the_arena_level.gd

@@ -8,6 +8,5 @@ func _ready() -> void:
 func _on_body_entered(body: Node3D) -> void:
 	if not body.is_in_group("player"):
 		return
-	Run.start_run_timer()
 	Run.choose_level(&"arena")
 	get_tree().change_scene_to_file(Run.active_level().scene_path)

project.godot

@@ -11,7 +11,7 @@ config_version=5
 [application]
 
 config/name="Bullosseum"
-config/version="0.5.0"
+config/version="0.4.0"
 run/main_scene="uid://bmnmenu0intr1"
 config/features=PackedStringArray("4.7", "GL Compatibility")
 boot_splash/bg_color=Color(0, 0, 0, 1)

props/torch.tscn

@@ -167,7 +167,6 @@ transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -9.011785, -2.371254, 16.2322
 [node name="OmniLight3D" type="OmniLight3D" parent="MeshInstance3D/TorchLight" unique_id=1094582672]
 transform = Transform3D(0.9999986, -0.001596809, 0.00045388562, 0.0014380338, 0.96984345, 0.24372463, -0.00082937966, -0.24372365, 0.9698444, 9.096397, 6.2542057, -15.77264)
 light_color = Color(0.92773837, 0.6304423, 0, 1)
-light_energy = 2.0
 shadow_enabled = true
 omni_range = 13.657384
 

systems/debug/debug_params.gd

@@ -46,10 +46,21 @@ func _register_all() -> void:
 	# (The dash ability bypasses this.)
 	_reg_f("Bull",     "bull_gore_arc",      75.0,  10.0, 180.0, 5.0)
 	# ── Dust speed thresholds ─────────────────────────────────────────────────
-	# The dust LOOK (colour, size, velocity) lives in systems/fx/bull_hoof_dust.tscn now; these
-	# two only decide when walk vs charge dust kicks in by ground speed.
 	_reg_f("Dust",     "dust_walk_spd",       1.5,  0.1,  10.0)
 	_reg_f("Dust",     "dust_charge_spd",     7.0,  1.0,  20.0)
+	# ── Dust ──────────────────────────────────────────────────────────────────
+	_reg_f("Dust",     "dust_lifetime",       0.9,  0.1,   4.0)
+	_reg_f("Dust",     "dust_explosiveness",  0.35, 0.0,   1.0)
+	_reg_f("Dust",     "dust_spread",        45.0,  5.0,  90.0)
+	_reg_f("Dust",     "dust_gravity_y",     -1.5,-15.0,   0.0)
+	_reg_f("Dust",     "walk_scale_min",      0.20, 0.05,  3.0)
+	_reg_f("Dust",     "walk_scale_max",      0.40, 0.05,  3.0)
+	_reg_f("Dust",     "walk_vel_min",        0.8,  0.1,  12.0)
+	_reg_f("Dust",     "walk_vel_max",        1.8,  0.1,  12.0)
+	_reg_f("Dust",     "charge_scale_min",    0.35, 0.05,  6.0)
+	_reg_f("Dust",     "charge_scale_max",    0.70, 0.05,  6.0)
+	_reg_f("Dust",     "charge_vel_min",      2.8,  0.1,  20.0)
+	_reg_f("Dust",     "charge_vel_max",      5.5,  0.1,  20.0)
 	# ── Tail ──────────────────────────────────────────────────────────────────
 	_reg_f("Tail",     "tail_gravity",        9.8,   0.0, 30.0)
 	_reg_f("Tail",     "tail_damping",        0.08,  0.0,  0.5, 0.01)

systems/fx/README.md

@@ -6,9 +6,8 @@ change to how a hit *feels* is a `.tscn` Siim edits in the inspector — no code
 
 ```gdscript
 # anywhere in gameplay code
-Fx.spawn(&"blood_burst", global_transform)          # one-shot: fire and forget (self-frees)
+Fx.spawn(&"blood_burst", global_transform)          # at a node
 Fx.spawn(&"slam_dust", Transform3D(Basis(), point)) # at a world point
-var trail := Fx.attach(&"bull_charge_trail", node)  # continuous: caller keeps it + toggles .emitting
 ```
 
 ## Siim's workflow
@@ -26,33 +25,6 @@ var trail := Fx.attach(&"bull_charge_trail", node)  # continuous: caller keeps i
 New effect? Add a `fx/<name>.tscn` (root = `CPUParticles3D` with `one_shot_effect.gd` attached — copy
 an existing one), then register its name → path in `fx/fx.gd`.
 
-## Bull ability effects
-
-The bull's moves are wired to effect scenes here, so **you can retune every one in the inspector** —
-open the `.tscn`, drag its colour ramp / curves / emission, save. No code.
-
-| Ability | Effect scene(s) | Kind |
-|---|---|---|
-| Ground slam | `bull_slam.tscn` (dust) | one-shot burst |
-| Back-kick | `bull_kick.tscn` — dust **+** its `stones` and `sparks` child emitters | one-shot burst |
-| Dash / roll launch | `bull_dash.tscn` | one-shot burst |
-| Hoof dust (walking / sprinting) | `bull_hoof_dust.tscn` | continuous |
-| Charge trail (the blue streak) | `bull_charge_trail.tscn` | continuous |
-| Roll sparks | `bull_roll_sparks.tscn` | continuous |
-
-**Two kinds, edited the same way.** *One-shot* effects fire once and clean themselves up — they show
-up in the gallery, so preview and tune them there. *Continuous* effects follow the bull and switch on
-and off with what it's doing (dust while moving, the trail during a roll); the gallery can't show
-those, so preview one by opening its `.tscn` and ticking **Emitting** on in the inspector's viewport.
-
-Two things stay in code and aren't yours to tune here: the slam's expanding shockwave **rings** and the
-kick's white **flash-pop** — those are stretched flat meshes, not particles (`actors/player/bull_impact_fx.gd`).
-The dust's *walk-vs-sprint size* is also code (a fixed multiplier); its colour and shape are the `.tscn`.
-
-**Composite effect** (like the kick): one scene, several `CPUParticles3D` — a root plus child emitters.
-`one_shot_effect.gd` fires every emitter in the scene together, so you can build a layered hit
-(dust + debris + sparks) as one file and tune each layer separately.
-
 ## House style (keep effects reading as one game)
 
 **Palette** — pull from these, don't invent per-effect colours:
@@ -80,9 +52,8 @@ the inspector and safe on-device. Keep this constraint when adding effects.
 
 | File | What it is |
 |---|---|
-| `fx.gd` | The `Fx` autoload — `spawn()` (one-shot) / `attach()` (continuous); name→path registry |
-| `one_shot_effect.gd` | Root helper: fires every emitter in the scene once, frees it when done |
+| `fx.gd` | The `Fx` autoload — `spawn(name, xform, parent=null)`; name→path registry |
+| `one_shot_effect.gd` | Root helper: fires the emitter(s) once, frees the scene when done |
 | `blood_burst.tscn` etc. | The effects themselves — **edit these** |
-| `bull_*.tscn` | The bull's ability effects (see the table above) — **edit these** |
 | `effect_gallery.tscn` | Preview stage (run it to review) |
 | `_seed_placeholders.gd` | One-off generator that wrote the first-draft defaults; not used at runtime |

systems/fx/bull_charge_trail.tscn

@@ -1,42 +0,0 @@
-[gd_scene format=3]
-
-; Bull charge trail — the blue energy streak that streams off the bull during a roll/dash.
-; Continuous: the player instances it once under the bull, toggles `emitting`, and steers
-; `direction` opposite the travel direction each frame. Tune the look here; see README.md.
-
-[sub_resource type="StandardMaterial3D" id="mat"]
-transparency = 1
-cull_mode = 2
-shading_mode = 0
-vertex_color_use_as_albedo = true
-
-[sub_resource type="SphereMesh" id="mesh"]
-material = SubResource("mat")
-radius = 0.065
-height = 0.13
-radial_segments = 4
-rings = 2
-
-[sub_resource type="Curve" id="curve"]
-_data = [Vector2(0, 1), 0.0, 0.0, 0, 0, Vector2(0.6, 0.8), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="grad"]
-colors = PackedColorArray(0.3, 0.65, 1, 1, 0.3, 0.65, 1, 0)
-
-[node name="bull_charge_trail" type="CPUParticles3D"]
-emitting = false
-amount = 18
-lifetime = 0.3
-local_coords = false
-randomness = 0.4
-mesh = SubResource("mesh")
-direction = Vector3(0, 0.2, 1)
-spread = 25.0
-gravity = Vector3(0, 2, 0)
-initial_velocity_min = 4.0
-initial_velocity_max = 9.0
-scale_amount_min = 0.4
-scale_amount_max = 1.2
-scale_amount_curve = SubResource("curve")
-color_ramp = SubResource("grad")

systems/fx/bull_dash.tscn

@@ -1,44 +0,0 @@
-[gd_scene format=3]
-
-; Bull dash burst — the one-shot streak of speed shards left when a dash/roll launches. Fired
-; via Fx.spawn(&"bull_dash", xform); the spawn transform aims local -Z along the dash direction,
-; so the shards streak the right way. Tune the look here; see systems/fx/README.md.
-
-[ext_resource type="Script" path="res://systems/fx/one_shot_effect.gd" id="oneshot"]
-
-[sub_resource type="StandardMaterial3D" id="mat"]
-transparency = 1
-cull_mode = 2
-shading_mode = 0
-vertex_color_use_as_albedo = true
-
-[sub_resource type="BoxMesh" id="mesh"]
-material = SubResource("mat")
-size = Vector3(0.045, 0.045, 0.3)
-
-[sub_resource type="Curve" id="curve"]
-_data = [Vector2(0, 1), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 2
-
-[sub_resource type="Gradient" id="grad"]
-colors = PackedColorArray(0.5, 0.82, 1, 1, 0.5, 0.82, 1, 0)
-
-[node name="bull_dash" type="CPUParticles3D"]
-emitting = false
-amount = 18
-lifetime = 0.22
-one_shot = true
-local_coords = false
-explosiveness = 0.92
-randomness = 0.15
-mesh = SubResource("mesh")
-direction = Vector3(0, 0, -1)
-spread = 15.0
-gravity = Vector3(0, 0, 0)
-initial_velocity_min = 18.0
-initial_velocity_max = 35.0
-scale_amount_min = 0.8
-scale_amount_max = 2.8
-scale_amount_curve = SubResource("curve")
-color_ramp = SubResource("grad")
-script = ExtResource("oneshot")

systems/fx/bull_hoof_dust.tscn

@@ -1,43 +0,0 @@
-[gd_scene format=3]
-
-; Bull hoof dust — the little kick-up under each hoof while moving. Continuous (not one-shot):
-; the player instances one per hoof, positions it, and toggles `emitting`. Charge sprint bumps
-; scale/velocity in code. Tune the look here; see systems/fx/README.md.
-
-[sub_resource type="StandardMaterial3D" id="mat"]
-transparency = 1
-cull_mode = 2
-shading_mode = 0
-vertex_color_use_as_albedo = true
-
-[sub_resource type="SphereMesh" id="mesh"]
-material = SubResource("mat")
-radius = 0.07
-height = 0.14
-radial_segments = 4
-rings = 2
-
-[sub_resource type="Curve" id="curve"]
-_data = [Vector2(0, 0.2), 0.0, 0.0, 0, 0, Vector2(0.4, 1), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="grad"]
-colors = PackedColorArray(0.94, 0.9, 0.83, 1, 0.94, 0.9, 0.83, 0)
-
-[node name="bull_hoof_dust" type="CPUParticles3D"]
-emitting = false
-amount = 12
-lifetime = 0.9
-local_coords = false
-explosiveness = 0.35
-randomness = 0.6
-mesh = SubResource("mesh")
-direction = Vector3(0, 1, 0)
-spread = 45.0
-gravity = Vector3(0, -1.5, 0)
-initial_velocity_min = 0.8
-initial_velocity_max = 1.8
-scale_amount_min = 0.2
-scale_amount_max = 0.4
-scale_amount_curve = SubResource("curve")
-color_ramp = SubResource("grad")

systems/fx/bull_kick.tscn

@@ -1,115 +0,0 @@
-[gd_scene format=3]
-
-; Bull back-kick impact — the one-shot combined dust + stones + sparks thrown behind the kick.
-; A composite effect: the root emitter is the dust; the "stones" and "sparks" child emitters fire
-; with it (one_shot_effect.gd arms every CPUParticles3D in the scene). Fired via
-; Fx.spawn(&"bull_kick", xform); the spawn transform aims local -Z along the kick-back direction.
-; The bright flash-pop is a separate coded effect (bull_impact_fx.gd). Tune all three looks here.
-
-[ext_resource type="Script" path="res://systems/fx/one_shot_effect.gd" id="oneshot"]
-
-[sub_resource type="StandardMaterial3D" id="mat"]
-transparency = 1
-cull_mode = 2
-shading_mode = 0
-vertex_color_use_as_albedo = true
-
-[sub_resource type="SphereMesh" id="dust_mesh"]
-material = SubResource("mat")
-radius = 0.12
-height = 0.24
-radial_segments = 4
-rings = 2
-
-[sub_resource type="Curve" id="dust_curve"]
-_data = [Vector2(0, 0.3), 0.0, 0.0, 0, 0, Vector2(0.3, 1.5), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="dust_grad"]
-colors = PackedColorArray(1, 0.78, 0.18, 0.95, 1, 0.45, 0.05, 0)
-
-[sub_resource type="SphereMesh" id="stone_mesh"]
-material = SubResource("mat")
-radius = 0.055
-height = 0.11
-radial_segments = 3
-rings = 1
-
-[sub_resource type="Curve" id="stone_curve"]
-_data = [Vector2(0, 1), 0.0, 0.0, 0, 0, Vector2(0.6, 1), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="stone_grad"]
-colors = PackedColorArray(0.62, 0.58, 0.52, 1, 0.62, 0.58, 0.52, 0)
-
-[sub_resource type="SphereMesh" id="spark_mesh"]
-material = SubResource("mat")
-radius = 0.04
-height = 0.08
-radial_segments = 3
-rings = 1
-
-[sub_resource type="Curve" id="spark_curve"]
-_data = [Vector2(0, 1), 0.0, 0.0, 0, 0, Vector2(0.5, 0.6), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="spark_grad"]
-colors = PackedColorArray(1, 0.98, 0.6, 1, 1, 1, 1, 0)
-
-[node name="bull_kick" type="CPUParticles3D"]
-emitting = false
-amount = 40
-lifetime = 1.2
-one_shot = true
-local_coords = false
-explosiveness = 0.8
-randomness = 0.5
-mesh = SubResource("dust_mesh")
-direction = Vector3(0, 0.7, -1)
-spread = 65.0
-gravity = Vector3(0, -6, 0)
-initial_velocity_min = 3.0
-initial_velocity_max = 9.0
-scale_amount_min = 0.5
-scale_amount_max = 2.2
-scale_amount_curve = SubResource("dust_curve")
-color_ramp = SubResource("dust_grad")
-script = ExtResource("oneshot")
-
-[node name="stones" type="CPUParticles3D" parent="."]
-emitting = false
-amount = 14
-lifetime = 0.65
-one_shot = true
-local_coords = false
-explosiveness = 0.92
-randomness = 0.6
-mesh = SubResource("stone_mesh")
-direction = Vector3(0, 0.35, -1)
-spread = 45.0
-gravity = Vector3(0, -9.8, 0)
-initial_velocity_min = 5.0
-initial_velocity_max = 14.0
-scale_amount_min = 0.5
-scale_amount_max = 1.8
-scale_amount_curve = SubResource("stone_curve")
-color_ramp = SubResource("stone_grad")
-
-[node name="sparks" type="CPUParticles3D" parent="."]
-emitting = false
-amount = 22
-lifetime = 0.28
-one_shot = true
-local_coords = false
-explosiveness = 0.95
-randomness = 0.4
-mesh = SubResource("spark_mesh")
-direction = Vector3(0, 0.5, -1)
-spread = 30.0
-gravity = Vector3(0, -14, 0)
-initial_velocity_min = 8.0
-initial_velocity_max = 18.0
-scale_amount_min = 0.6
-scale_amount_max = 2.0
-scale_amount_curve = SubResource("spark_curve")
-color_ramp = SubResource("spark_grad")

systems/fx/bull_roll_sparks.tscn

@@ -1,42 +0,0 @@
-[gd_scene format=3]
-
-; Bull roll sparks — the dirt/ember spray flung outward from the spinning roll ("Powerball").
-; Continuous: the player instances it once under the bull and toggles `emitting` during a roll.
-; World-space so the spray peels off into a trail. Tune the look here; see README.md.
-
-[sub_resource type="StandardMaterial3D" id="mat"]
-transparency = 1
-cull_mode = 2
-shading_mode = 0
-vertex_color_use_as_albedo = true
-
-[sub_resource type="SphereMesh" id="mesh"]
-material = SubResource("mat")
-radius = 0.05
-height = 0.1
-radial_segments = 4
-rings = 2
-
-[sub_resource type="Curve" id="curve"]
-_data = [Vector2(0, 0.3), 0.0, 0.0, 0, 0, Vector2(0.3, 1), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="grad"]
-colors = PackedColorArray(1, 0.78, 0.32, 1, 0.7, 0.42, 0.14, 0)
-
-[node name="bull_roll_sparks" type="CPUParticles3D"]
-emitting = false
-amount = 46
-lifetime = 0.45
-local_coords = false
-randomness = 0.7
-mesh = SubResource("mesh")
-direction = Vector3(0, 1, 0)
-spread = 180.0
-gravity = Vector3(0, -6, 0)
-initial_velocity_min = 3.0
-initial_velocity_max = 8.0
-scale_amount_min = 0.5
-scale_amount_max = 1.3
-scale_amount_curve = SubResource("curve")
-color_ramp = SubResource("grad")

systems/fx/bull_slam.tscn

@@ -1,47 +0,0 @@
-[gd_scene format=3]
-
-; Bull ground-slam dust — the one-shot dirt burst thrown up when the slam lands. Fired via
-; Fx.spawn(&"bull_slam", xform) at the impact point. The expanding shockwave RINGS are a
-; separate coded effect (actors/player/bull_impact_fx.gd), not this. Tune the look here.
-
-[ext_resource type="Script" path="res://systems/fx/one_shot_effect.gd" id="oneshot"]
-
-[sub_resource type="StandardMaterial3D" id="mat"]
-transparency = 1
-cull_mode = 2
-shading_mode = 0
-vertex_color_use_as_albedo = true
-
-[sub_resource type="SphereMesh" id="mesh"]
-material = SubResource("mat")
-radius = 0.09
-height = 0.18
-radial_segments = 4
-rings = 2
-
-[sub_resource type="Curve" id="curve"]
-_data = [Vector2(0, 0.25), 0.0, 0.0, 0, 0, Vector2(0.35, 1.6), 0.0, 0.0, 0, 0, Vector2(1, 0), 0.0, 0.0, 0, 0]
-point_count = 3
-
-[sub_resource type="Gradient" id="grad"]
-colors = PackedColorArray(0.88, 0.74, 0.46, 1, 0.88, 0.74, 0.46, 0)
-
-[node name="bull_slam" type="CPUParticles3D"]
-emitting = false
-amount = 48
-lifetime = 1.1
-one_shot = true
-local_coords = false
-explosiveness = 0.85
-randomness = 0.5
-mesh = SubResource("mesh")
-direction = Vector3(0, 1, 0)
-spread = 85.0
-gravity = Vector3(0, -7, 0)
-initial_velocity_min = 3.5
-initial_velocity_max = 10.0
-scale_amount_min = 0.5
-scale_amount_max = 2.0
-scale_amount_curve = SubResource("curve")
-color_ramp = SubResource("grad")
-script = ExtResource("oneshot")

systems/fx/effect_gallery.gd

@@ -4,10 +4,7 @@ extends Node3D
 ## press Play, then edit any effect .tscn in the inspector and re-run to compare. See fx/README.md.
 
 const _CYCLE_SEC := 1.6
-const _EFFECTS: Array[StringName] = [
-	&"blood_burst", &"slam_dust", &"spark", &"hit_flash",
-	&"bull_slam", &"bull_kick", &"bull_dash",
-]
+const _EFFECTS: Array[StringName] = [&"blood_burst", &"slam_dust", &"spark", &"hit_flash"]
 
 @onready var _label: Label = $UI/Label
 # Reached by path rather than the Fx global so the placeholder-seeder can compile and attach this

systems/fx/fx.gd

@@ -7,18 +7,10 @@ extends Node
 ## placeholder .tscn are seeded — see tools/seed_fx_placeholders.gd.
 
 const _PATHS: Dictionary = {
-	# Generic hit effects.
 	&"blood_burst": "res://systems/fx/blood_burst.tscn",
 	&"slam_dust": "res://systems/fx/slam_dust.tscn",
 	&"spark": "res://systems/fx/spark.tscn",
 	&"hit_flash": "res://systems/fx/hit_flash.tscn",
-	# Bull ability effects — one-shots fired by spawn(), continuous ones held via attach().
-	&"bull_slam": "res://systems/fx/bull_slam.tscn",
-	&"bull_kick": "res://systems/fx/bull_kick.tscn",
-	&"bull_dash": "res://systems/fx/bull_dash.tscn",
-	&"bull_hoof_dust": "res://systems/fx/bull_hoof_dust.tscn",
-	&"bull_charge_trail": "res://systems/fx/bull_charge_trail.tscn",
-	&"bull_roll_sparks": "res://systems/fx/bull_roll_sparks.tscn",
 }
 
 var _cache: Dictionary = {}
@@ -40,18 +32,6 @@ func spawn(effect: StringName, xform: Transform3D, parent: Node = null) -> Node:
 	return inst
 
 
-# Instance a CONTINUOUS effect as a child of `parent` and hand it back. Unlike spawn(), it neither
-# positions nor auto-frees the effect — the caller keeps the reference to place it and toggle
-# `emitting` (hoof dust that follows the bull, the charge trail). Returns null if unknown/missing.
-func attach(effect: StringName, parent: Node) -> Node:
-	var scene := _scene(effect)
-	if scene == null or parent == null:
-		return null
-	var inst := scene.instantiate()
-	parent.add_child(inst)
-	return inst
-
-
 func _scene(effect: StringName) -> PackedScene:
 	if _cache.has(effect):
 		return _cache[effect]

tests/bear_fx_test.gd

@@ -1,6 +1,6 @@
 extends SceneTree
 ## Bear attack-FX test. The four attack effects (crater, smash debris, left/right claw slash)
-## live in art/fx/bear_fx.glb as meshes that rest at scale 0 at Siim's baked positions. The
+## live in Assets/fx/Bear_FX.glb as meshes that rest at scale 0 at Siim's baked positions. The
 ## GLB carries its own AnimationPlayer whose clips scale one mesh up at its strike frame and
 ## back to 0 (self-hiding) while pinning the others at 0. bear.gd fires the matching clip on
 ## each strike (see _play_fx). This asserts each clip pops its own mesh, self-hides by the end,

tests/fx_gallery_test.gd

@@ -26,16 +26,10 @@ func _run() -> void:
 	root.add_child(host)
 	current_scene = host
 
-	for id: StringName in [&"blood_burst", &"slam_dust", &"spark", &"hit_flash",
-			&"bull_slam", &"bull_kick", &"bull_dash"]:
+	for id: StringName in [&"blood_burst", &"slam_dust", &"spark", &"hit_flash"]:
 		var inst: Node = fx.call("spawn", id, Transform3D.IDENTITY, host)
 		_ok(inst != null and is_instance_valid(inst), "spawns %s" % id)
 
-	# Continuous bull effects are held (attach), not fired-and-forgotten (spawn).
-	for id: StringName in [&"bull_hoof_dust", &"bull_charge_trail", &"bull_roll_sparks"]:
-		var inst: Node = fx.call("attach", id, host)
-		_ok(inst != null and is_instance_valid(inst), "attaches %s" % id)
-
 	var missing: Node = fx.call("spawn", &"does_not_exist", Transform3D.IDENTITY, host)
 	_ok(missing == null, "unknown effect returns null instead of crashing")
 

tests/logic_test.gd

@@ -30,6 +30,7 @@ func _run() -> void:
 	test_kick_spread()
 	test_gait_phase_crossing()
 	test_tail_verlet_constraint()
+	test_run_map()
 
 	print("=" .repeat(60))
 	print("Results: %d passed, %d failed" % [_passed, _failed])
@@ -171,6 +172,60 @@ func test_tail_verlet_constraint() -> void:
 	_assert_in_range(damping_factor, 0.85, 1.0, "tail damping factor is reasonable")
 
 
+# ── Run map (Slay-the-Spire progression) ──────────────────────────────────────
+
+func test_run_map() -> void:
+	print("\n-- test_run_map --")
+	var run: Node = root.get_node_or_null("/root/Run")
+	if run == null:
+		_assert_true(false, "Run autoload should exist")
+		return
+
+	run.start_new_run()
+	_assert_true(run.has_run(), "start_new_run builds a map")
+	_assert_true(run.map.size() >= 2, "map has multiple rows")
+
+	# Final row is a single boss node the map funnels toward.
+	var last: Array = run.map[run.map.size() - 1]
+	_assert_eq(last.size(), 1, "final row is a single boss node")
+	_assert_true(last[0].level.is_boss, "final node is a boss level")
+
+	# Connectivity: every node links forward, and every next-row node has a parent.
+	for r: int in run.map.size() - 1:
+		var nxt: Array = run.map[r + 1]
+		var reached := {}
+		for from_node in run.map[r]:
+			_assert_true(from_node.links.size() >= 1, "row %d node links forward" % r)
+			for c: int in from_node.links:
+				_assert_true(c >= 0 and c < nxt.size(), "link column in range")
+				reached[c] = true
+		for c: int in nxt.size():
+			_assert_true(reached.has(c), "row %d col %d has a parent" % [r + 1, c])
+
+	# From the start gate the whole first row is the frontier.
+	_assert_eq(run.reachable().size(), run.map[0].size(), "start frontier is row 0")
+
+	# Advancing follows the chosen node's links.
+	var first = run.map[0][0]
+	run.select_node(first)
+	run.complete_current_level()
+	_assert_eq(run.player_row, 0, "player advanced to row 0")
+	_assert_true(first.cleared, "cleared node is flagged")
+	_assert_eq(run.reachable().size(), first.links.size(),
+		"frontier follows the chosen node's links")
+
+	# Walking to a boss node latches run completion.
+	var guard := 0
+	while not run.run_complete() and guard < 64:
+		var opts: Array = run.reachable()
+		if opts.is_empty():
+			break
+		run.select_node(opts[0])
+		run.complete_current_level()
+		guard += 1
+	_assert_true(run.run_complete(), "reaching a boss node completes the run")
+
+
 # ── Shared helpers ────────────────────────────────────────────────────────────
 
 func _assert_in_range(val: float, lo: float, hi: float, desc: String) -> void:

ui/hud.gd

@@ -66,10 +66,6 @@ const _BULL_FACE_PAD: float = 1.15    # breathing room around the cluster within
 # records which way it went (read by the gameplay test).
 const _WIN_VIDEO  := "res://videos/bull_win.ogv"       # the bull triumphs
 const _LOSS_VIDEO := "res://videos/matador_win.ogv"    # the matador triumphs
-# Clearing the bear — the run's final boss — replaces the usual bull-win clip with the
-# closing "Thank You For Playing" screen. That clip already bakes its own title text in,
-# so _over_label is left blank for this outcome (see _show_game_over).
-const _THANKYOU_VIDEO := "res://videos/thankyou.ogv"
 
 # Beat between the run ending and the outcome screen. A loss is a short freeze on the
 # dead bull; a win gives the player a longer stretch to strut a victory lap around the
@@ -85,12 +81,6 @@ var _over_label: Label
 var _over_continue: Button
 var _over_again: Button
 
-# Run clock readout — top-left, desktop only (touch's top-left corner is already the
-# mobile HP readout from mobile_hud.gd). Tracks Run.run_elapsed(); hidden until the timer
-# has actually started (the player hasn't entered the arena yet) and while the game-over
-# screen is up.
-var _run_timer_label: Label
-
 
 func _ready() -> void:
 	layer = 11
@@ -102,7 +92,6 @@ func _ready() -> void:
 	_build_ability_bar()
 	_build_health()
 	_build_version_label()
-	_build_run_timer()
 	_build_damage_vignette()
 	_build_game_over()
 	_build_touch_controls()
@@ -217,41 +206,8 @@ func _build_version_label() -> void:
 	add_child(lbl)
 
 
-# Run clock, top-left. Desktop only — touch already owns that corner for the mobile HP
-# readout, and a run timer is a nice-to-have there, not worth the crowding.
-func _build_run_timer() -> void:
-	if Controls.use_touch_ui():
-		return
-	_run_timer_label = Label.new()
-	_run_timer_label.text = _format_time(0.0)
-	_run_timer_label.visible = false
-	_run_timer_label.add_theme_font_override("font", UiFonts.body())
-	_run_timer_label.add_theme_color_override("font_color", _CREAM)
-	_run_timer_label.add_theme_color_override("font_outline_color", Color(0, 0, 0, 0.85))
-	_run_timer_label.add_theme_constant_override("outline_size", 4)
-	_run_timer_label.add_theme_font_size_override("font_size", 20)
-	_run_timer_label.set_anchors_preset(Control.PRESET_TOP_LEFT)
-	_run_timer_label.offset_left = 20.0
-	_run_timer_label.offset_top  = 16.0
-	_run_timer_label.mouse_filter = Control.MOUSE_FILTER_IGNORE
-	add_child(_run_timer_label)
-
-
-# mm:ss.hh — matches how a speedrun-style clock reads at a glance.
-static func _format_time(seconds: float) -> String:
-	var total_cs := int(round(seconds * 100.0))
-	var minutes := total_cs / 6000
-	var secs    := (total_cs / 100) % 60
-	var centis  := total_cs % 100
-	return "%02d:%02d.%02d" % [minutes, secs, centis]
-
-
 func _process(_delta: float) -> void:
 	_update_control_hints()
-	if _run_timer_label != null:
-		_run_timer_label.visible = Run.run_timer_started() and not _game_over
-		if _run_timer_label.visible:
-			_run_timer_label.text = _format_time(Run.run_elapsed())
 	if _player == null:
 		var players := get_tree().get_nodes_in_group(&"player")
 		if not players.is_empty():
@@ -478,10 +434,6 @@ func _on_player_died(cause: String = "") -> void:
 
 
 func _on_all_defeated() -> void:
-	# Freeze the run clock the instant the bear falls — before _show_game_over's
-	# celebratory delay — so the recorded time is the kill moment, not the victory lap.
-	if Run.active_level().id == &"bear":
-		Run.stop_run_timer()
 	_show_game_over(true)
 
 
@@ -498,16 +450,12 @@ func _show_game_over(win: bool, _cause: String = "") -> void:
 
 	await get_tree().create_timer(_WIN_DELAY if win else _LOSS_DELAY, false, false, true).timeout
 
-	var is_final_boss := _result_win and Run.active_level().id == &"bear"
-	# The thank-you clip already bakes in its own title, so this label carries the
-	# winning time instead — the one thing that clip can't show.
-	_over_label.text = ("Your Time: %s" % _format_time(Run.run_elapsed())) if is_final_boss \
-		else ("Bull Won!" if _result_win else "Matadors Won!")
+	_over_label.text = "Bull Won!" if _result_win else "Matadors Won!"
 	# A win advances the run (on to the map); a loss ends it (retry from the top).
 	_over_continue.visible = _result_win
 	_over_again.visible = not _result_win
 
-	var path := _THANKYOU_VIDEO if is_final_boss else (_WIN_VIDEO if _result_win else _LOSS_VIDEO)
+	var path := _WIN_VIDEO if _result_win else _LOSS_VIDEO
 	if ResourceLoader.exists(path):
 		_over_video.stream = load(path)
 		_over_video.play()

videos/thankyou.ogv.uid

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