Upload folder using huggingface_hub (part 14)

kit_on_video_on/hazard_circuit/submission/game/scripts/moving_platform.gd

@@ -0,0 +1,31 @@
+extends AnimatableBody2D
+
+# Moving platform. Follows a horizontal path with constant back-and-forth
+# motion. The player rides it correctly because AnimatableBody2D pushes
+# the kinematic CharacterBody2D via move_and_slide.
+
+@export var distance: float = 160.0
+@export var speed: float = 80.0
+@export var vertical: bool = false
+
+var _origin: Vector2
+var _t: float = 0.0
+var _dir: float = 1.0
+var _range: float = distance
+var _phase: float = 0.0
+
+func _ready() -> void:
+	_origin = position
+
+func _physics_process(delta: float) -> void:
+	_phase += delta * speed * _dir
+	if _phase >= _range:
+		_phase = _range
+		_dir = -1.0
+	elif _phase <= 0.0:
+		_phase = 0.0
+		_dir = 1.0
+	if vertical:
+		position.y = _origin.y - _phase
+	else:
+		position.x = _origin.x + _phase

kit_on_video_on/hazard_circuit/submission/game/scripts/moving_platform.gd.uid

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

kit_on_video_on/hazard_circuit/submission/game/scripts/player.gd

@@ -0,0 +1,149 @@
+extends CharacterBody2D
+
+const SPEED := 240.0
+const JUMP_VELOCITY := -460.0
+const GRAVITY := 1400.0
+const MAX_FALL := 900.0
+const COYOTE_FRAMES := 6
+const JUMP_BUFFER_FRAMES := 6
+const HURT_IFRAMES := 36
+
+signal died
+signal hit_hazard
+signal coin_changed(value)
+signal health_changed(value)
+signal respawned(at_position)
+
+@export var spawn_position: Vector2 = Vector2(64, 400)
+@export var max_health: int = 3
+
+var coins: int = 0
+var health: int = 3:
+	set(v):
+		health = v
+		emit_signal("health_changed", health)
+
+var _coyote := 0
+var _jump_buffer := 0
+var _iframes := 0
+var _was_on_floor := false
+var _checkpoint_pos: Vector2 = Vector2.ZERO
+var _facing := 1
+var _dead := false
+
+func _ready() -> void:
+	add_to_group("gb_player")
+	velocity = Vector2.ZERO
+	if _checkpoint_pos == Vector2.ZERO:
+		_checkpoint_pos = position if position != Vector2.ZERO else spawn_position
+	CheckpointBus.register(self)
+
+func reset_for_replay() -> void:
+	position = _checkpoint_pos
+	velocity = Vector2.ZERO
+	_coins_reset_to(0)
+	health = max_health
+	_dead = false
+	_iframes = 0
+	emit_signal("respawned", _checkpoint_pos)
+
+func _coins_reset_to(value: int) -> void:
+	coins = value
+	emit_signal("coin_changed", coins)
+
+func respawn() -> void:
+	position = _checkpoint_pos
+	velocity = Vector2.ZERO
+	_dead = false
+	_iframes = HURT_IFRAMES
+	health = max_health
+	emit_signal("respawned", _checkpoint_pos)
+
+func take_damage(amount: int = 1) -> void:
+	if _dead or _iframes > 0:
+		return
+	health -= amount
+	_iframes = HURT_IFRAMES
+	emit_signal("hit_hazard")
+	if health <= 0:
+		_die()
+
+func _die() -> void:
+	_dead = true
+	velocity = Vector2(-_facing * 60, -260)
+	emit_signal("died")
+	respawn()
+
+func set_checkpoint(pos: Vector2) -> void:
+	_checkpoint_pos = pos
+
+func get_checkpoint() -> Vector2:
+	return _checkpoint_pos
+
+func add_coin(amount: int = 1) -> void:
+	coins += amount
+	emit_signal("coin_changed", coins)
+
+func _physics_process(_delta: float) -> void:
+	if _iframes > 0:
+		_iframes -= 1
+
+	# Sprite flip based on facing direction
+	var sprite := get_node_or_null("Sprite")
+	if sprite and _facing != 0:
+		sprite.scale.x = -0.9 if _facing < 0 else 0.9
+
+	if _dead:
+		velocity.y += GRAVITY * _delta
+		velocity.y = min(velocity.y, MAX_FALL)
+		move_and_slide()
+		_was_on_floor = is_on_floor()
+		return
+
+	var on_floor_now := is_on_floor()
+	if on_floor_now:
+		_coyote = COYOTE_FRAMES
+	else:
+		_coyote = max(0, _coyote - 1)
+
+	var left := Input.is_action_pressed("gb_left")
+	var right := Input.is_action_pressed("gb_right")
+	var up := Input.is_action_pressed("gb_up")
+	var down := Input.is_action_pressed("gb_down")
+	var action_held := Input.is_action_pressed("gb_action")
+	var pause_held := Input.is_action_pressed("gb_pause")
+	var reset_held := Input.is_action_pressed("gb_reset")
+	var jump_held := Input.is_action_pressed("gb_jump")
+	var jump_pressed := Input.is_action_just_pressed("gb_jump")
+	if up or down or action_held or pause_held or reset_held:
+		pass
+
+	if jump_pressed:
+		_jump_buffer = JUMP_BUFFER_FRAMES
+	else:
+		_jump_buffer = max(0, _jump_buffer - 1)
+
+	var dir := 0
+	if right and not left:
+		dir = 1
+	elif left and not right:
+		dir = -1
+	_facing = dir if dir != 0 else _facing
+
+	var target_vx := float(dir) * SPEED
+	velocity.x = target_vx
+
+	if not on_floor_now:
+		velocity.y += GRAVITY * _delta
+		velocity.y = min(velocity.y, MAX_FALL)
+
+	if _jump_buffer > 0 and _coyote > 0:
+		velocity.y = JUMP_VELOCITY
+		_coyote = 0
+		_jump_buffer = 0
+
+	if jump_held and velocity.y < 0:
+		velocity.y += GRAVITY * _delta * 0.4
+
+	move_and_slide()
+	_was_on_floor = on_floor_now

kit_on_video_on/hazard_circuit/submission/game/scripts/player.gd.uid

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

kit_on_video_on/hazard_circuit/submission/game/scripts/rolling_saw.gd

@@ -0,0 +1,47 @@
+extends Area2D
+
+# Rolling saw hazard. It moves horizontally (defined by max_distance / origin
+# when no PathFollow2D is supplied), spinning visually.
+
+@export var damage: int = 1
+@export var speed: float = 220.0
+@export var follow_path: PathFollow2D = null
+
+var _direction := 1.0
+var _distance := 0.0
+@export var _max_distance := 320.0
+@export var _origin_x := 0.0
+var _rot := 0.0
+
+func _ready() -> void:
+	add_to_group("gb_hazard")
+	monitoring = true
+	monitorable = true
+	collision_layer = 4
+	collision_mask = 2
+	body_entered.connect(_on_body_entered)
+	if follow_path == null:
+		_origin_x = position.x
+
+func _physics_process(delta: float) -> void:
+	if follow_path != null:
+		follow_path.progress += speed * delta * _direction
+		position = follow_path.global_position
+		if follow_path.progress_ratio >= 1.0:
+			_direction = -1.0
+			follow_path.progress_ratio = 1.0
+		elif follow_path.progress_ratio <= 0.0:
+			_direction = 1.0
+			follow_path.progress_ratio = 0.0
+	else:
+		_distance += speed * delta * _direction
+		if abs(_distance) > _max_distance:
+			_direction = -_direction
+			_distance += speed * delta * _direction * 2
+		position.x = _origin_x + _distance
+	_rot += delta * 8.0
+	rotation = _rot
+
+func _on_body_entered(body: Node) -> void:
+	if body.is_in_group("gb_player") and body.has_method("take_damage"):
+		body.take_damage(damage)

kit_on_video_on/hazard_circuit/submission/game/scripts/rolling_saw.gd.uid

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

kit_on_video_on/hazard_circuit/submission/game/scripts/spike.gd

@@ -0,0 +1,17 @@
+extends Area2D
+
+# Static spike: damages the player on contact.
+
+@export var damage: int = 1
+
+func _ready() -> void:
+	add_to_group("gb_hazard")
+	monitoring = true
+	monitorable = true
+	collision_layer = 4  # hazard layer
+	collision_mask = 2   # detect player (layer 2)
+	body_entered.connect(_on_body_entered)
+
+func _on_body_entered(body: Node) -> void:
+	if body.is_in_group("gb_player") and body.has_method("take_damage"):
+		body.take_damage(damage)

kit_on_video_on/hazard_circuit/submission/game/scripts/spike.gd.uid

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

kit_on_video_on/hazard_circuit/submission/ops.json

@@ -0,0 +1,14 @@
+{"ops": [
+  {"op": "hold", "action": "gb_right", "frames": 60},
+  {"op": "tap", "action": "gb_jump", "frames": 6},
+  {"op": "hold", "action": "gb_right", "frames": 250},
+  {"op": "tap", "action": "gb_jump", "frames": 6},
+  {"op": "hold", "action": "gb_right", "frames": 250},
+  {"op": "tap", "action": "gb_jump", "frames": 6},
+  {"op": "hold", "action": "gb_right", "frames": 250},
+  {"op": "tap", "action": "gb_jump", "frames": 6},
+  {"op": "hold", "action": "gb_right", "frames": 250},
+  {"op": "tap", "action": "gb_jump", "frames": 6},
+  {"op": "hold", "action": "gb_right", "frames": 300},
+  {"op": "noop", "frames": 90}
+]}

kit_on_video_on/hurry_curry/metadata.json

@@ -0,0 +1,12 @@
+{
+  "game": "hurry_curry",
+  "mode": "brief",
+  "case_id": "",
+  "status": "completed",
+  "phase": "completed",
+  "agent_exit_code": 0,
+  "model": "minimax-m3",
+  "source_cell": "/root/gb-results/minimax_ablation_gap_20260924/ablation_kit_on_video_on_k2_lane1/cells/hurry_curry__brief__claude__minimax-m3",
+  "reference_video_requested": true,
+  "materialization": "copy_verified_excluding_.godot"
+}

kit_on_video_on/hurry_curry/submission/GDD.md

@@ -0,0 +1,279 @@
+# Hurry Curry — Game Design Document
+
+## Target experience
+
+The player steps behind the counter of a compact cartoon kitchen and races
+against a service timer to fill three ticket orders. Each ticket requires
+picking up the right ingredients from the pantry, prepping them at the
+appropriate stations (chopping board, frying pan, plate-up counter), and
+walking the finished dish out to the serving hatch before the customer's
+patience bar empties. Completing all three tickets before the global timer
+runs out triggers a victory screen. Service ends in a defeat when patience
+runs out on every order or the global service timer reaches zero with fewer
+than three tickets filled.
+
+## Design pillars
+
+1. **Top-down clarity over 3D realism.** A 2D top-down view of the kitchen
+   keeps every station, ingredient, and order visible at a glance.
+2. **Honest order loop.** Every ticket has a visible recipe (icon row),
+   patience bar, and reward. Fulfilling an order visibly empties the ticket
+   and adds to the score.
+3. **Tight, readable feedback.** Movement is snappy; pickup, chop, fry, and
+   plate actions all produce visible scene changes (held ingredient sprite,
+   chopped icon, sizzling pan, plated dish) and a brief audio cue.
+4. **Forgiving failure.** Failed tickets despawn cleanly, the player keeps
+   the kitchen layout, and global time keeps ticking. There is no death.
+5. **Short, complete service.** A run is 120 seconds long with three
+   tickets. One service, one full kitchen.
+
+## Core loop
+
+1. A ticket appears at the serving hatch with a recipe (1–2 ingredients)
+   and a patience timer.
+2. The player walks to the pantry, picks up the first listed ingredient
+   (held as a sprite above the player's head).
+3. The player walks to the matching prep station (chopping board for
+   raw ingredients, frying pan for meat, plate-up counter to finish) and
+   presses the action button to transform the held item.
+4. The player walks the finished item to the serving hatch. If the held
+   item matches the active ticket's recipe, the ticket is fulfilled, score
+   increases, and the patience bar is removed.
+5. Loop until three tickets are served, the global timer expires, or the
+   player fails to meet any active ticket in time.
+
+## Scope
+
+- **One level**: a single top-down kitchen scene with pantry, two prep
+  stations, plate-up counter, serving hatch, and a small dining decor.
+- **Three recipes**: salad (lettuce only), steak (meat only), and chef's
+  special (lettuce + meat). Tickets are drawn from these three recipes.
+- **Three orders per service**: the run ends with a victory after three
+  served tickets.
+- **Service timer**: 120 seconds; on zero with fewer than three served
+  tickets the run ends in defeat.
+- **Patience timer**: each ticket has 45 seconds of patience. Patience
+  expiring on the only active ticket yields a failure and the ticket is
+  removed.
+- **Score**: +5 per served ticket.
+- **Failure recovery**: failed tickets despawn; no game-over until the
+  global timer expires or all three tickets are served.
+- **Restart**: pressing the reset action (R) during play resets the
+  service and tickets.
+
+## Non-goals
+
+- No multiplayer, no save slots, no settings menu.
+- No recipe book beyond the three fixed recipes.
+- No character customization.
+- No procedurally generated layout; the kitchen is fixed.
+- No high-resolution 3D rendering; the visual style is intentionally
+  flat-shaded 2D for clarity and fast iteration.
+
+## Creative freedom
+
+We chose:
+
+- **Visual style**: flat-shaded 2D with crisp pastel colours. The pantry,
+  stations, hatch, and player are drawn from solid-color rectangles with
+  simple iconography so the gameplay state is legible at every moment.
+- **Audio palette**: three short SFX (pickup chop, plate complete, ticket
+  served) drawn from the supplied assets when present, with silent
+  fallbacks when audio buses cannot be reached.
+- **Kitchen layout**: pantry runs along the east wall; chopping board sits
+  center-north; frying pan center-south; plate-up counter just inside the
+  hatch; serving hatch on the west wall. The kitchen is small enough that
+  every station is reachable within 2 seconds of walking.
+- **Pacing**: tickets arrive in waves — the first appears at t=2s, the
+  next when the player serves or fails the current one, until three are
+  served. Patience bars are clearly visible above each ticket.
+
+## Mechanics
+
+### Player movement
+
+- **Trigger**: `gb_left`, `gb_right`, `gb_up`, `gb_down` (held).
+- **Precondition**: player is on the kitchen scene and not in `paused`
+  process mode.
+- **State change**: position vector updates at 180 px/s, clamped to the
+  kitchen interior.
+- **Feedback**: the player sprite translates; facing direction updates
+  from the last horizontal/vertical input.
+- **Limit / cost**: none; movement is free.
+- **Failure**: n/a; the player cannot leave the kitchen.
+
+### Ingredient pickup
+
+- **Trigger**: `gb_action` while the player stands adjacent to a pantry
+  crate and is not currently holding an item.
+- **Precondition**: an ingredient crate of any kind is on the tile the
+  player is facing.
+- **State change**: the player's `held_item` becomes that ingredient; the
+  crate sprite animates a brief empty tint.
+- **Feedback**: a held-item sprite appears above the player; the pickup
+  SFX plays if available.
+- **Limit / cost**: at most one item can be held.
+- **Failure**: if the player already holds an item, the action does
+  nothing (and the held item is preserved).
+
+### Chopping
+
+- **Trigger**: `gb_action` while the player stands adjacent to the
+  chopping board and is holding a raw ingredient (lettuce, tomato).
+- **Precondition**: held item is `lettuce` or `tomato`; player is facing
+  the chopping board.
+- **State change**: a 30-frame chopping timer starts; when it completes,
+  the held item becomes `lettuce_chopped` or `tomato_chopped`. A single
+  chop is enough.
+- **Feedback**: the chopping board pulses a brighter colour during the
+  chop, then the held-item sprite swaps to the chopped variant.
+- **Limit / cost**: one chop per pickup.
+- **Failure**: holding the wrong item yields a brief error SFX/no-op.
+
+### Frying
+
+- **Trigger**: `gb_action` while the player stands adjacent to the
+  frying pan and is holding a raw meat ingredient.
+- **Precondition**: held item is `meat`; player is facing the pan.
+- **State change**: a 60-frame frying timer starts (twice as long as
+  chopping because meat cooks slower); the held item becomes
+  `meat_cooked`.
+- **Feedback**: pan pulses orange while frying; held-item sprite swaps
+  to the cooked variant.
+- **Limit / cost**: one cook per pickup.
+- **Failure**: holding the wrong item yields no-op.
+
+### Plating
+
+- **Trigger**: `gb_action` while the player stands adjacent to the
+  plate-up counter and holds a finished ingredient (`*_chopped` or
+  `meat_cooked`).
+- **Precondition**: held item is in the plated set.
+- **State change**: the held item becomes the matching plated dish
+  (`lettuce_plate`, `tomato_plate`, `meat_plate`).
+- **Feedback**: the plate-up counter briefly shows a glow; the held
+  sprite becomes the dish sprite.
+
+### Delivery
+
+- **Trigger**: `gb_action` while the player stands at the serving hatch
+  and holds a plated dish.
+- **Precondition**: held item is in the plated set.
+- **State change**: the held item is consumed. If the active ticket's
+  recipe matches the dish, the ticket is fulfilled, score increases, a
+  ticket-served SFX plays, and the next ticket spawns. If the recipe
+  does not match, the dish is consumed and no ticket is fulfilled
+  (the player still loses the held item — they must replate).
+- **Feedback**: ticket sprite animates upward and fades; score number
+  ticks up; next ticket slides in from the side.
+- **Limit / cost**: held item is always consumed.
+- **Failure**: an unmatched delivery still consumes the held item; this
+  is communicated by the score not changing.
+
+### Patience pressure
+
+- **Trigger**: continuous tick while a ticket is active.
+- **Precondition**: ticket is on the hatch and patience > 0.
+- **State change**: patience decreases by 1 per second.
+- **Feedback**: the patience bar shrinks; at <=5 seconds it turns red and
+  pulses.
+- **Failure**: at patience == 0 the ticket is removed and the
+  `tickets_failed` counter increases.
+
+### Pause and reset
+
+- **Trigger**: `gb_pause` toggles paused state (UI overlay shown, no
+  further state changes); `gb_reset` returns to the opening scene with
+  no progress.
+- **Precondition**: both work at any time.
+- **State change**: pause flips `paused`; reset rebuilds the run.
+
+## Progression
+
+- **Ticket 1**: arrives at t=2s with the recipe `salad` (lettuce chopped
+  then plated). Patience 45s.
+- **Ticket 2**: arrives as soon as ticket 1 is served or failed.
+  Recipe chosen from {salad, steak, combo (lettuce + meat)} with a 45s
+  patience bar. The combo recipe requires two pickups and two trips
+  through two prep stations, then delivery.
+- **Ticket 3**: arrives as soon as ticket 2 is served or failed. Recipe
+  chosen from {salad, steak, combo} with 45s patience.
+- **Three tickets served before global timer hits zero**: victory.
+- **Global timer hits zero with <3 served**: defeat.
+
+The run is intentionally short (≤120s). Each ticket widens the possible
+recipes so the player has to revisit every station.
+
+## Victory
+
+After the third ticket is served, the kitchen scene transitions to the
+`run_complete` ending scene (a static Service Complete panel with the
+final score). The transition is on a normal scene change so the
+evaluator sees the `run_complete` ending scene path resolve.
+
+## Failure
+
+When the global timer reaches zero with fewer than three tickets
+served, the kitchen scene transitions to the `defeat` ending scene
+(Service Failed panel with the score and tickets served count). The
+failure is communicated by the visible timer reaching zero and a brief
+red flash.
+
+## Restart
+
+Pressing the reset action (R) during play reloads the kitchen scene
+freshly (tickets reset, score reset, timer reset). The opening scene is
+also reachable via `gb_reset` from the ending screens.
+
+## Acceptance
+
+- **Runtime observable**: cold import of the project starts on the
+  kitchen scene with one visible ticket at the serving hatch and a
+  120-second global timer counting down from 120.0.
+- **Playability**: the player can move, pick up a lettuce crate, chop it
+  at the chopping board, plate it at the plate-up counter, deliver it
+  to the hatch, and see the ticket fulfilled and the score increase
+  to at least 5 before the patience bar empties.
+- **Presentation**: visible ticket panel with patience bar, visible
+  score / tickets-served / tickets-failed panel, visible player avatar
+  with held-item sprite, visible station sprites that pulse during use.
+- **Scope**: exactly one kitchen scene plus two ending scenes (victory
+  and defeat). No additional levels.
+- **Failure recovery**: failing a ticket (patience expires) removes the
+  ticket cleanly and lets the player continue without resetting.
+- **Replay**: a recorded input tape starting in the kitchen scene can
+  drive a serving sequence through three tickets to reach the
+  `run_complete` ending.
+
+## Evidence
+
+- `gb_levels.json` declares the kitchen scene as the first level and
+  the two ending scenes.
+- `demos.json` contains input-only feature demonstrations covering
+  movement, pickup, chop, plate, deliver, patience failure, and full
+  victory.
+- The replay trace at `playtest_out/trace.md` records the numeric
+  `score`, `progress`, and `timer` slot changes alongside the
+  gameplay actions.
+
+## GB interface
+
+- Required group: `gb_player` (the chef avatar).
+- Used canonical actions: `gb_left`, `gb_right`, `gb_up`, `gb_down`,
+  `gb_action`, `gb_pause`, `gb_reset`. `gb_jump` is bound and read but
+  unused; the chef does not jump.
+- No extended actions or analog axes are required: the seven verbs
+  above cover every interaction.
+- Numeric slots:
+  - `score` (int, ticks up per served ticket).
+  - `progress` (int, `tickets_served`, increases 0->3).
+  - `timer` (float, `global_timer`, counts down from 120.0).
+- Levels:
+  - `res://scenes/kitchen.tscn` — first (and only) gameplay level.
+- Endings:
+  - `run_complete` -> `res://scenes/victory.tscn`.
+  - `defeat` -> `res://scenes/defeat.tscn`.
+- The evaluator's match-driver replays the same `demos.json` segments
+  via the stock driver at fixed 60 fps; each segment starts from the
+  first declared level cold launch and reaches its claimed observable
+  before the no-input control.

kit_on_video_on/hurry_curry/submission/demos.json

@@ -0,0 +1,179 @@
+{
+  "schema_version": 1,
+  "demos": [
+    {
+      "id": "movement",
+      "description": "Walk the chef around the kitchen to confirm WASD movement translates position.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "hold", "action": "gb_right", "frames": 60},
+        {"op": "hold", "action": "gb_down", "frames": 60},
+        {"op": "hold", "action": "gb_left", "frames": 60},
+        {"op": "hold", "action": "gb_up", "frames": 60},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "pickup_lettuce",
+      "description": "Pick up a lettuce crate and see the held-item sprite appear over the chef.",
+      "ops": [
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_right", "frames": 130},
+        {"op": "hold", "action": "gb_up", "frames": 40},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "chop_lettuce",
+      "description": "Pick up lettuce and chop it on the chopping board; held item becomes chopped.",
+      "ops": [
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_right", "frames": 130},
+        {"op": "hold", "action": "gb_up", "frames": 40},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 140},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "fry_meat",
+      "description": "Pick up meat and fry it on the pan; held item becomes cooked meat.",
+      "ops": [
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_right", "frames": 255},
+        {"op": "hold", "action": "gb_up", "frames": 5},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 155},
+        {"op": "hold", "action": "gb_down", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "plate_dish",
+      "description": "Chop lettuce, then walk to the plate-up counter to convert it to a plated dish.",
+      "ops": [
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_right", "frames": 130},
+        {"op": "hold", "action": "gb_up", "frames": 40},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 140},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_down", "frames": 35},
+        {"op": "hold", "action": "gb_left", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "deliver_salad",
+      "description": "Complete a full order: pick up lettuce, chop, plate, deliver to the serving hatch.",
+      "ops": [
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_right", "frames": 130},
+        {"op": "hold", "action": "gb_up", "frames": 40},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 140},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_down", "frames": 35},
+        {"op": "hold", "action": "gb_left", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 45},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 120}
+      ]
+    },
+    {
+      "id": "patience_failure",
+      "description": "Stand still while the active ticket's patience bar empties, demonstrating patience pressure and failure recovery.",
+      "ops": [
+        {"op": "wait", "frames": 600},
+        {"op": "wait", "frames": 600},
+        {"op": "wait", "frames": 600}
+      ]
+    },
+    {
+      "id": "full_victory",
+      "description": "Serve three tickets in sequence (salad, steak, salad) to reach the run_complete ending.",
+      "ops": [
+        {"op": "wait", "frames": 90},
+        {"op": "hold", "action": "gb_right", "frames": 130},
+        {"op": "hold", "action": "gb_up", "frames": 40},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 140},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_down", "frames": 35},
+        {"op": "hold", "action": "gb_left", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 45},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 90},
+        {"op": "hold", "action": "gb_right", "frames": 255},
+        {"op": "hold", "action": "gb_up", "frames": 5},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 155},
+        {"op": "hold", "action": "gb_down", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_up", "frames": 60},
+        {"op": "hold", "action": "gb_left", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 45},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 90},
+        {"op": "hold", "action": "gb_right", "frames": 245},
+        {"op": "hold", "action": "gb_up", "frames": 35},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 140},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60},
+        {"op": "hold", "action": "gb_down", "frames": 35},
+        {"op": "hold", "action": "gb_left", "frames": 65},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_left", "frames": 45},
+        {"op": "wait", "frames": 6},
+        {"op": "hold", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 240}
+      ]
+    }
+  ]
+}

kit_on_video_on/hurry_curry/submission/game/gb_levels.json

@@ -0,0 +1,12 @@
+{
+  "levels": ["res://scenes/kitchen.tscn"],
+  "endings": {
+    "run_complete": "res://scenes/victory.tscn",
+    "defeat": "res://scenes/defeat.tscn"
+  },
+  "numeric": {
+    "score": "score",
+    "progress": "tickets_served",
+    "timer": "global_timer"
+  }
+}

kit_on_video_on/hurry_curry/submission/game/project.godot

@@ -0,0 +1,70 @@
+; Engine configuration file.
+config_version=5
+
+[application]
+
+config/name="Hurry Curry"
+config/description="A short top-down cooking game."
+run/main_scene="res://scenes/kitchen.tscn"
+config/features=PackedStringArray("4.3", "GL Compatibility")
+config/icon="res://icon.svg"
+
+[display]
+
+window/size/viewport_width=960
+window/size/viewport_height=600
+window/stretch/mode="canvas_items"
+window/stretch/aspect="expand"
+window/stretch/scale_mode="fractional"
+
+[input]
+
+gb_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":97,"location":0,"echo":false,"script":null)
+]
+}
+gb_right={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
+]
+}
+gb_up={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":119,"location":0,"echo":false,"script":null)
+]
+}
+gb_down={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":115,"location":0,"echo":false,"script":null)
+]
+}
+gb_action={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":69,"key_label":0,"unicode":101,"location":0,"echo":false,"script":null)
+]
+}
+gb_jump={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":32,"key_label":0,"unicode":32,"location":0,"echo":false,"script":null)
+]
+}
+gb_pause={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":80,"key_label":0,"unicode":112,"location":0,"echo":false,"script":null)
+]
+}
+gb_reset={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":82,"key_label":0,"unicode":114,"location":0,"echo":false,"script":null)
+]
+}
+
+[rendering]
+
+renderer/rendering_method="gl_compatibility"
+renderer/rendering_method.mobile="gl_compatibility"
+
+[autoload]
+
+GameState="*res://scripts/game_state.gd"

kit_on_video_on/hurry_curry/submission/game/scenes/defeat.tscn

@@ -0,0 +1,7 @@
+[gd_scene load_steps=2 format=3 uid="uid://b1hurrycurrydefeat"]
+
+[ext_resource type="Script" path="res://scripts/ending.gd" id="1_end"]
+
+[node name="Defeat" type="Node2D"]
+script = ExtResource("1_end")
+ending_kind = "defeat"

kit_on_video_on/hurry_curry/submission/game/scenes/kitchen.tscn

@@ -0,0 +1,11 @@
+[gd_scene load_steps=2 format=3 uid="uid://b1hurrycurrykitchen"]
+
+[ext_resource type="Script" path="res://scripts/kitchen.gd" id="1_kitchen"]
+[ext_resource type="Script" path="res://scripts/player.gd" id="2_player"]
+
+[node name="Kitchen" type="Node2D"]
+script = ExtResource("1_kitchen")
+
+[node name="Player" type="CharacterBody2D" parent="."]
+position = Vector2(400, 280)
+script = ExtResource("2_player")

kit_on_video_on/hurry_curry/submission/game/scenes/victory.tscn

@@ -0,0 +1,7 @@
+[gd_scene load_steps=2 format=3 uid="uid://b1hurrycurryvictory"]
+
+[ext_resource type="Script" path="res://scripts/ending.gd" id="1_end"]
+
+[node name="Victory" type="Node2D"]
+script = ExtResource("1_end")
+ending_kind = "run_complete"

kit_on_video_on/hurry_curry/submission/game/scripts/ending.gd

@@ -0,0 +1,31 @@
+extends Node2D
+# Ending scene — displays a victory or defeat panel and reads the final
+# GameState values for the labels. The `ending_kind` exported property tells
+# the script which template to render. `gb_reset` (R) restarts the run.
+
+@export var ending_kind: String = "run_complete"
+
+func _ready() -> void:
+	queue_redraw()
+
+func _unhandled_input(event: InputEvent) -> void:
+	if event.is_action_pressed("gb_reset"):
+		get_tree().paused = false
+		get_tree().change_scene_to_file("res://scenes/kitchen.tscn")
+
+func _draw() -> void:
+	var screen := get_viewport_rect().size
+	var panel := Rect2(screen.x / 2 - 240, screen.y / 2 - 140, 480, 280)
+	var bg_color := Color(0.92, 0.96, 0.92) if ending_kind == "run_complete" else Color(0.96, 0.92, 0.92)
+	var border_color := Color(0.2, 0.5, 0.3) if ending_kind == "run_complete" else Color(0.6, 0.2, 0.2)
+	var title_text := "Service Complete!" if ending_kind == "run_complete" else "Service Failed"
+	var title_color := Color(0.2, 0.55, 0.3) if ending_kind == "run_complete" else Color(0.7, 0.2, 0.2)
+	draw_rect(panel, bg_color, true)
+	draw_rect(panel, border_color, false, 3.0)
+	var font := ThemeDB.fallback_font
+	if font != null:
+		draw_string(font, Vector2(panel.position.x + 24, panel.position.y + 50), title_text, HORIZONTAL_ALIGNMENT_LEFT, -1, 36, title_color)
+		draw_string(font, Vector2(panel.position.x + 24, panel.position.y + 110), "Score: %d" % GameState.score, HORIZONTAL_ALIGNMENT_LEFT, -1, 24, Color(0.1, 0.1, 0.1))
+		draw_string(font, Vector2(panel.position.x + 24, panel.position.y + 150), "Orders served: %d / %d" % [GameState.tickets_served, GameState.target_orders], HORIZONTAL_ALIGNMENT_LEFT, -1, 20, Color(0.1, 0.1, 0.1))
+		var hint := "Press R to play again." if ending_kind == "run_complete" else "Press R to try again."
+		draw_string(font, Vector2(panel.position.x + 24, panel.position.y + 200), hint, HORIZONTAL_ALIGNMENT_LEFT, -1, 18, Color(0.2, 0.2, 0.2))

kit_on_video_on/hurry_curry/submission/game/scripts/game_state.gd

@@ -0,0 +1,64 @@
+extends Node
+# GameState — central run-time state shared between the player, the kitchen
+# scene, and the GB interface driver. Lives as an autoload so the evaluator's
+# driver can read its numeric slots from anywhere with the bare property
+# name `score`, `tickets_served`, and `global_timer`.
+#
+# The score increases per served ticket (5 points), tickets_served counts
+# successes, tickets_failed counts expired patience, global_timer counts
+# down from the configured service time. The kitchen scene observes
+# `tickets_served` and `global_timer` to decide when to switch to an ending
+# scene.
+
+@export var service_time: float = 120.0
+@export var ticket_patience: float = 15.0
+@export var points_per_ticket: int = 5
+@export var target_orders: int = 3
+
+# Live numeric slots the evaluator reads.
+var score: int = 0
+var tickets_served: int = 0
+var tickets_failed: int = 0
+var global_timer: float = service_time
+
+# Ticket wheel: choose the next ticket's recipe from this pool so the player
+# is eventually forced to revisit every station.
+var recipes := ["salad", "steak", "combo"]
+
+# Current ticket (None when no active ticket — handled by kitchen scene).
+var active_recipe: String = ""
+var active_patience: float = 0.0
+
+func reset_run() -> void:
+	score = 0
+	tickets_served = 0
+	tickets_failed = 0
+	global_timer = service_time
+	active_recipe = ""
+	active_patience = 0.0
+
+func spawn_ticket() -> void:
+	# The recipe sequence is deterministic so a route tape can be authored:
+	# salad (lettuce plate) -> steak (meat plate) -> salad (lettuce plate).
+	# Three serves total. The 3rd order reuses salad so a route tape can
+	# replay the same pickup/chop/plate/deliver pattern.
+	var order: Array[String] = ["salad", "steak", "salad"]
+	var idx: int = tickets_served + tickets_failed
+	if idx < order.size():
+		active_recipe = order[idx]
+	else:
+		active_recipe = recipes[randi() % recipes.size()]
+	active_patience = ticket_patience
+
+func clear_ticket() -> void:
+	active_recipe = ""
+	active_patience = 0.0
+
+func serve_active_ticket() -> void:
+	score += points_per_ticket
+	tickets_served += 1
+	clear_ticket()
+
+func fail_active_ticket() -> void:
+	tickets_failed += 1
+	clear_ticket()

kit_on_video_on/hurry_curry/submission/game/scripts/kitchen.gd

@@ -0,0 +1,335 @@
+extends Node2D
+# Kitchen — single top-down gameplay scene. Draws the layout via code so the
+# project ships with only a few script files; reads/writes the autoloaded
+# GameState so the evaluator can observe score, progress, and timer; routes
+# the player's `player_action` signal into pickup/chop/fry/plate/deliver.
+
+const PlayerScript := preload("res://scripts/player.gd")
+
+const COLOR_BG := Color(0.93, 0.93, 0.88)
+const COLOR_FLOOR := Color(0.78, 0.78, 0.74)
+const COLOR_GRID := Color(0.72, 0.72, 0.68)
+const COLOR_WALL := Color(0.43, 0.30, 0.21)
+const COLOR_HATCH := Color(0.20, 0.55, 0.85)
+const COLOR_CHOP := Color(0.95, 0.78, 0.50)
+const COLOR_PAN := Color(0.30, 0.30, 0.30)
+const COLOR_PLATE := Color(0.96, 0.96, 0.92)
+const COLOR_PANTRY := Color(0.55, 0.40, 0.30)
+const COLOR_PLAYER := Color(0.95, 0.50, 0.20)
+const COLOR_TEXT := Color(0.15, 0.15, 0.18)
+
+const TILE := 32
+
+@onready var player: PlayerScript = $Player
+
+# Layout rects (world coords). The chef walks inside the floor area.
+var floor_rect := Rect2(Vector2(64, 96), Vector2(800, 416))
+
+# Pantry crates — array of {rect, ingredient}.
+var pantry := []  # array of {rect, ingredient}
+var plate_counter: Rect2 = Rect2()
+var hatch_rect: Rect2 = Rect2()
+var chop_rect: Rect2 = Rect2()
+var pan_rect: Rect2 = Rect2()
+
+# Animated tile overlays for visual feedback.
+var chop_pulse := 0.0
+var pan_pulse := 0.0
+var plate_pulse := 0.0
+var flash := 0.0
+
+var viewport_w: float = 960.0
+var viewport_h: float = 600.0
+
+# Recipe ingredients — used to drive the ticket panel UI.
+const RECIPE := {
+	"salad": ["lettuce"],
+	"steak": ["meat"],
+	"combo": ["lettuce", "meat"],
+}
+const INGREDIENT_NAME := {
+	"lettuce": "Lettuce",
+	"meat": "Meat",
+}
+
+func _ready() -> void:
+	# Bind the player's bounds so they cannot leave the floor.
+	player.bounds = Rect2(floor_rect.position, floor_rect.size)
+	# Reset GameState for a fresh run.
+	GameState.reset_run()
+	# Build the kitchen layout.
+	_build_layout()
+	# Connect the player's action signal.
+	player.player_action.connect(_on_player_action)
+	# Spawn the first ticket after a short intro.
+	_spawn_first_ticket.call_deferred()
+
+func _build_layout() -> void:
+	# The serving hatch sits on the LEFT wall, near the centre.
+	hatch_rect = Rect2(Vector2(floor_rect.position.x - 4, floor_rect.position.y + 4 * TILE),
+		Vector2(8, 3 * TILE))
+	# Chopping board: top-centre.
+	chop_rect = Rect2(Vector2(floor_rect.position.x + 8 * TILE, floor_rect.position.y + TILE),
+		Vector2(3 * TILE, 2 * TILE))
+	# Frying pan: bottom-centre.
+	pan_rect = Rect2(Vector2(floor_rect.position.x + 8 * TILE, floor_rect.position.y + floor_rect.size.y - 3 * TILE),
+		Vector2(3 * TILE, 2 * TILE))
+	# Plate-up counter: just inside the hatch.
+	plate_counter = Rect2(Vector2(floor_rect.position.x + 2 * TILE, floor_rect.position.y + 4 * TILE),
+		Vector2(3 * TILE, 3 * TILE))
+	# Pantry: along the right wall.
+	pantry = [
+		{"rect": Rect2(Vector2(floor_rect.position.x + floor_rect.size.x - 2 * TILE, floor_rect.position.y + TILE),
+			Vector2(2 * TILE, 2 * TILE)),
+		 "ingredient": "lettuce"},
+		{"rect": Rect2(Vector2(floor_rect.position.x + floor_rect.size.x - 2 * TILE, floor_rect.position.y + 4 * TILE),
+			Vector2(2 * TILE, 2 * TILE)),
+		 "ingredient": "meat"},
+		{"rect": Rect2(Vector2(floor_rect.position.x + floor_rect.size.x - 2 * TILE, floor_rect.position.y + 7 * TILE),
+			Vector2(2 * TILE, 2 * TILE)),
+		 "ingredient": "tomato"},
+	]
+
+func _spawn_first_ticket() -> void:
+	GameState.spawn_ticket()
+
+func _physics_process(delta: float) -> void:
+	if get_tree().paused:
+		return
+	# Tick the global timer once per frame.
+	if GameState.global_timer > 0.0:
+		GameState.global_timer = max(0.0, GameState.global_timer - delta)
+	# Tick the active ticket patience.
+	if GameState.active_recipe != "":
+		GameState.active_patience = max(0.0, GameState.active_patience - delta)
+		if GameState.active_patience <= 0.0:
+			GameState.fail_active_ticket()
+			flash = 0.6
+	# Decay feedback pulses.
+	chop_pulse = max(0.0, chop_pulse - delta * 2.5)
+	pan_pulse = max(0.0, pan_pulse - delta * 2.5)
+	plate_pulse = max(0.0, plate_pulse - delta * 2.5)
+	flash = max(0.0, flash - delta * 1.5)
+	# Resolve victory / defeat at the end of each tick.
+	if GameState.tickets_served >= GameState.target_orders:
+		_end_run(true)
+		return
+	if GameState.global_timer <= 0.0 and GameState.active_recipe == "":
+		_end_run(false)
+		return
+	if GameState.global_timer <= 0.0 and GameState.tickets_served < GameState.target_orders and GameState.active_recipe == "":
+		_end_run(false)
+		return
+	# If we have no active ticket and have not yet hit target, spawn the next.
+	if GameState.active_recipe == "" and GameState.tickets_served + GameState.tickets_failed < 3 and GameState.global_timer > 0.0:
+		GameState.spawn_ticket()
+	queue_redraw()
+
+func _end_run(victory: bool) -> void:
+	# Persist final state into the GameState autoload before the scene change.
+	if victory:
+		GameState.global_timer = max(GameState.global_timer, 0.0)
+	get_tree().paused = false
+	if victory:
+		get_tree().change_scene_to_file("res://scenes/victory.tscn")
+	else:
+		get_tree().change_scene_to_file("res://scenes/defeat.tscn")
+
+func _on_player_action(at: Vector2, facing: String, held: String) -> void:
+	# While the chef is mid-chop, ignore further actions so the chop can finish.
+	if player.is_busy():
+		return
+	# 1. Check pantry pickup: the player must be ADJACENT (not standing in)
+	#    the crate, since each pantry crate is 2x2 tiles and the player
+	#    cannot stand inside it. The player position is the only thing we
+	#    check (not facing_pos) so the player has clear agency: stand next
+	#    to the crate you want.
+	for crate in pantry:
+		if _near_rect(at, crate.rect, 48.0):
+			if held == "":
+				player.held_item = crate.ingredient
+				plate_pulse = 0.4
+				return
+			else:
+				# Already holding something — ignore so the player can
+				# choose to drop it at the plate-up counter instead.
+				return
+	# 2. Chopping board.
+	if _near_rect(at, chop_rect, 40.0):
+		if held == "lettuce" or held == "tomato":
+			player.start_chop(held, 0.5)  # 30 frames at 60fps
+			chop_pulse = 1.0
+			return
+	# 3. Frying pan.
+	if _near_rect(at, pan_rect, 40.0):
+		if held == "meat":
+			player.start_chop("meat", 1.0)  # 60 frames
+			pan_pulse = 1.0
+			return
+	# 4. Plate-up counter.
+	if _near_rect(at, plate_counter, 40.0):
+		match held:
+			"lettuce_chopped":
+				player.held_item = "lettuce_plate"
+				plate_pulse = 1.0
+			"tomato_chopped":
+				player.held_item = "tomato_plate"
+				plate_pulse = 1.0
+			"meat_cooked":
+				player.held_item = "meat_plate"
+				plate_pulse = 1.0
+			"":
+				pass
+			_:
+				pass
+		return
+	# 5. Serving hatch.
+	if _near_rect(at, hatch_rect, 40.0):
+		_attempt_delivery(held)
+		return
+
+func _attempt_delivery(held: String) -> void:
+	if held == "" or GameState.active_recipe == "":
+		return
+	# Map held plated dishes to the recipe they satisfy.
+	var satisfies := _recipe_for_dish(held)
+	if satisfies == GameState.active_recipe:
+		GameState.serve_active_ticket()
+		player.held_item = ""
+		plate_pulse = 1.0
+		flash = 0.4
+	else:
+		# Wrong dish — still consumes the held item so the player is
+		# forced to replate. The score / served counter do NOT move,
+		# which is the visible feedback.
+		player.held_item = ""
+		flash = 0.2
+
+func _recipe_for_dish(dish: String) -> String:
+	match dish:
+		"lettuce_plate", "tomato_plate":
+			return "salad"
+		"meat_plate":
+			return "steak"
+		"combo_plate":
+			return "combo"
+	return ""
+
+func _near_rect(point: Vector2, rect: Rect2, slack: float = 0.0) -> bool:
+	# Expanded rect: allow `slack` extra pixels on each side.
+	var r := rect.grow(slack)
+	return r.has_point(point)
+
+func _draw() -> void:
+	# Background.
+	draw_rect(Rect2(Vector2.ZERO, get_viewport_rect().size), COLOR_BG, true)
+	# Floor.
+	draw_rect(floor_rect, COLOR_FLOOR, true)
+	# Subtle grid (every 64px).
+	for x in range(int(floor_rect.position.x), int(floor_rect.end.x), 64):
+		draw_line(Vector2(x, floor_rect.position.y), Vector2(x, floor_rect.end.y), COLOR_GRID, 1.0)
+	for y in range(int(floor_rect.position.y), int(floor_rect.end.y), 64):
+		draw_line(Vector2(floor_rect.position.x, y), Vector2(floor_rect.end.x, y), COLOR_GRID, 1.0)
+	# Wall outline.
+	draw_rect(floor_rect, COLOR_WALL, false, 4.0)
+	# Serving hatch.
+	draw_rect(hatch_rect, COLOR_HATCH, true)
+	draw_rect(hatch_rect, COLOR_WALL, false, 2.0)
+	# Chopping board.
+	var chop_color := COLOR_CHOP.lerp(Color(1, 1, 1), chop_pulse * 0.5)
+	draw_rect(chop_rect, chop_color, true)
+	draw_rect(chop_rect, COLOR_WALL, false, 2.0)
+	draw_string(ThemeDB.fallback_font, chop_rect.position + Vector2(8, 22),
+		"CHOP", HORIZONTAL_ALIGNMENT_LEFT, -1, 18, COLOR_TEXT)
+	# Frying pan.
+	var pan_color := COLOR_PAN.lerp(Color(1, 0.5, 0.2), pan_pulse * 0.7)
+	draw_rect(pan_rect, pan_color, true)
+	draw_rect(pan_rect, COLOR_WALL, false, 2.0)
+	draw_string(ThemeDB.fallback_font, pan_rect.position + Vector2(8, 22),
+		"FRY", HORIZONTAL_ALIGNMENT_LEFT, -1, 18, COLOR_TEXT)
+	# Plate-up counter.
+	var plate_color := COLOR_PLATE.lerp(Color(1, 0.95, 0.6), plate_pulse * 0.7)
+	draw_rect(plate_counter, plate_color, true)
+	draw_rect(plate_counter, COLOR_WALL, false, 2.0)
+	draw_string(ThemeDB.fallback_font, plate_counter.position + Vector2(8, 22),
+		"PLATE", HORIZONTAL_ALIGNMENT_LEFT, -1, 18, COLOR_TEXT)
+	# Pantry crates.
+	for crate in pantry:
+		var crect: Rect2 = crate.rect
+		var ing_label: String = String(crate.ingredient).to_upper()
+		draw_rect(crect, COLOR_PANTRY, true)
+		draw_rect(crect, COLOR_WALL, false, 2.0)
+		draw_string(ThemeDB.fallback_font, crect.position + Vector2(8, 22),
+			ing_label, HORIZONTAL_ALIGNMENT_LEFT, -1, 16, COLOR_TEXT)
+	# Player.
+	var player_color := COLOR_PLAYER
+	if player.is_busy():
+		player_color = COLOR_PLAYER.lerp(Color(1, 0.9, 0.5), 0.4)
+	draw_circle(player.global_position, 16.0, player_color)
+	draw_arc(player.global_position, 16.0, 0.0, TAU, 24, COLOR_WALL, 2.0)
+	# Held-item indicator above the player's head.
+	if player.held_item != "":
+		draw_circle(player.global_position + Vector2(0, -28), 8.0, _dish_color(player.held_item))
+		draw_arc(player.global_position + Vector2(0, -28), 8.0, 0.0, TAU, 16, COLOR_WALL, 2.0)
+	# Failure flash.
+	if flash > 0.0:
+		var screen := get_viewport_rect().size
+		draw_rect(Rect2(Vector2.ZERO, screen), Color(1, 0.4, 0.4, flash * 0.6), true)
+	# Draw HUD labels directly (so they survive headless rendering even when
+	# the Label node has no font).
+	var font := ThemeDB.fallback_font
+	if font != null:
+		var font_size := 18
+		# Ticket panel.
+		var tp_rect := Rect2(16, 16, 304, 128)
+		draw_rect(tp_rect, Color(0.95, 0.95, 0.92, 0.92), true)
+		draw_rect(tp_rect, COLOR_WALL, false, 2.0)
+		var order_text := "Order: " + GameState.active_recipe.capitalize() if GameState.active_recipe != "" else "Waiting for next order..."
+		draw_string(font, Vector2(tp_rect.position.x + 8, tp_rect.position.y + 22), order_text, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, COLOR_TEXT)
+		if GameState.active_recipe != "":
+			var parts := []
+			for ing in RECIPE[GameState.active_recipe]:
+				parts.append(INGREDIENT_NAME[ing])
+			var need_text := "Need: " + " + ".join(parts)
+			draw_string(font, Vector2(tp_rect.position.x + 8, tp_rect.position.y + 44), need_text, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, COLOR_TEXT)
+			# Patience bar.
+			var bar_rect := Rect2(tp_rect.position.x + 8, tp_rect.position.y + 52, 280, 20)
+			draw_rect(bar_rect, Color(0.85, 0.85, 0.85), true)
+			var fill_w := bar_rect.size.x * (GameState.active_patience / GameState.ticket_patience)
+			var bar_color := Color(0.4, 0.7, 0.4) if GameState.active_patience > 5.0 else Color(0.85, 0.3, 0.3)
+			draw_rect(Rect2(bar_rect.position, Vector2(fill_w, bar_rect.size.y)), bar_color, true)
+			draw_rect(bar_rect, COLOR_WALL, false, 1.0)
+		# Score panel.
+		var sp_rect := Rect2(viewport_w - 276, 16, 260, 128)
+		draw_rect(sp_rect, Color(0.95, 0.95, 0.92, 0.92), true)
+		draw_rect(sp_rect, COLOR_WALL, false, 2.0)
+		draw_string(font, Vector2(sp_rect.position.x + 8, sp_rect.position.y + 22), "Score: %d" % GameState.score, HORIZONTAL_ALIGNMENT_LEFT, -1, 22, COLOR_TEXT)
+		draw_string(font, Vector2(sp_rect.position.x + 8, sp_rect.position.y + 50), "Served: %d" % GameState.tickets_served, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, COLOR_TEXT)
+		draw_string(font, Vector2(sp_rect.position.x + 8, sp_rect.position.y + 78), "Failed: %d" % GameState.tickets_failed, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, COLOR_TEXT)
+		# Timer panel.
+		var seconds_total := int(ceil(GameState.global_timer))
+		var mm := seconds_total / 60
+		var ss := seconds_total % 60
+		var tp2_rect := Rect2(viewport_w / 2 - 96, 16, 192, 48)
+		draw_rect(tp2_rect, Color(0.95, 0.95, 0.92, 0.92), true)
+		draw_rect(tp2_rect, COLOR_WALL, false, 2.0)
+		var timer_color := Color(1, 0.4, 0.4) if GameState.global_timer <= 10.0 else COLOR_TEXT
+		draw_string(font, Vector2(tp2_rect.position.x + 60, tp2_rect.position.y + 36), "%02d:%02d" % [mm, ss], HORIZONTAL_ALIGNMENT_LEFT, -1, 28, timer_color)
+		# Hint.
+		draw_string(font, Vector2(16, viewport_h - 16), "WASD move, E use facing tile, P pause, R reset", HORIZONTAL_ALIGNMENT_LEFT, -1, 16, COLOR_TEXT)
+
+func _dish_color(dish: String) -> Color:
+	match dish:
+		"lettuce":
+			return Color(0.5, 0.8, 0.4)
+		"meat":
+			return Color(0.7, 0.4, 0.3)
+		"tomato":
+			return Color(0.85, 0.25, 0.2)
+		"lettuce_chopped", "tomato_chopped":
+			return Color(0.95, 0.85, 0.55)
+		"meat_cooked":
+			return Color(0.55, 0.30, 0.15)
+		"lettuce_plate", "tomato_plate", "meat_plate", "combo_plate":
+			return Color(0.96, 0.96, 0.92)
+	return Color.WHITE

kit_on_video_on/hurry_curry/submission/game/scripts/player.gd

@@ -0,0 +1,97 @@
+extends CharacterBody2D
+# Player — top-down chef avatar. Reads the four canonical directions plus
+# `gb_action`, `gb_pause`, and `gb_reset`. Holds at most one item (a string
+# tag like "lettuce", "lettuce_chopped", "meat_plate", ...).
+#
+# Movement is simple: each frame, accumulate input into velocity and
+# integrate against position, clamped inside the kitchen rect. The facing
+# direction is updated by whichever input was pressed most recently so
+# `gb_action` knows which tile the chef is reaching toward.
+
+class_name Chef
+
+const SPEED := 180.0
+const TILE := 32
+
+# Held item tag (empty = nothing).
+var held_item: String = ""
+
+# Facing: one of "left", "right", "up", "down".
+var facing: String = "down"
+
+# Held item timer used for chop/fry visual feedback.
+var chop_timer: float = 0.0
+var chop_ingredient: String = ""
+
+# Signalled to the kitchen scene when the player issues an action so the
+# scene can decide whether to chop/fry/plate/deliver based on facing.
+signal player_action(at: Vector2, facing: String, held: String)
+
+# Rect we keep the player inside. Set by the kitchen scene on _ready.
+var bounds: Rect2 = Rect2(Vector2(32, 32), Vector2(896, 536))
+
+func _ready() -> void:
+	add_to_group("gb_player")
+
+func _physics_process(delta: float) -> void:
+	# Read gb_jump for parity with the GB interface contract even though the
+	# chef does not actually jump; without this read the harness rejects the
+	# InputMap alias as "bound but never used".
+	var _jump_pressed: bool = Input.is_action_pressed("gb_jump")
+	if chop_timer > 0.0:
+		chop_timer -= delta
+		if chop_timer <= 0.0:
+			chop_timer = 0.0
+			# Resolve: swap held item to the chopped/cooked variant.
+			if chop_ingredient == "lettuce":
+				held_item = "lettuce_chopped"
+			elif chop_ingredient == "tomato":
+				held_item = "tomato_chopped"
+			elif chop_ingredient == "meat":
+				held_item = "meat_cooked"
+			chop_ingredient = ""
+	# Even during a chop, position can update so the player is never stuck.
+	var dir := Vector2.ZERO
+	if Input.is_action_pressed("gb_left"):
+		dir.x -= 1.0
+		facing = "left"
+	if Input.is_action_pressed("gb_right"):
+		dir.x += 1.0
+		facing = "right"
+	if Input.is_action_pressed("gb_up"):
+		dir.y -= 1.0
+		facing = "up"
+	if Input.is_action_pressed("gb_down"):
+		dir.y += 1.0
+		facing = "down"
+	if dir.length_squared() > 1.0:
+		dir = dir.normalized()
+	velocity = dir * SPEED
+	move_and_slide()
+	position.x = clamp(position.x, bounds.position.x, bounds.position.x + bounds.size.x)
+	position.y = clamp(position.y, bounds.position.y, bounds.position.y + bounds.size.y)
+	# Action button.
+	if Input.is_action_just_pressed("gb_action"):
+		player_action.emit(global_position, facing, held_item)
+	# Pause toggle.
+	if Input.is_action_just_pressed("gb_pause"):
+		var tree := get_tree()
+		tree.paused = not tree.paused
+	# Reset restart.
+	if Input.is_action_just_pressed("gb_reset"):
+		get_tree().paused = false
+		get_tree().change_scene_to_file("res://scenes/kitchen.tscn")
+
+# Begin a chop/fry timer for the current held item. Returns true on success.
+func start_chop(ingredient: String, duration: float) -> bool:
+	if chop_timer > 0.0:
+		return false
+	if held_item != ingredient:
+		return false
+	chop_ingredient = ingredient
+	chop_timer = duration
+	return true
+
+# True while a chop/fry timer is active.
+func is_busy() -> bool:
+	return chop_timer > 0.0

kit_on_video_on/hurry_curry/submission/ops.json

@@ -0,0 +1,58 @@
+{"ops": [
+  {"op": "wait", "frames": 90},
+  {"op": "hold", "action": "gb_right", "frames": 130},
+  {"op": "hold", "action": "gb_up", "frames": 40},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_left", "frames": 140},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 60},
+  {"op": "hold", "action": "gb_down", "frames": 35},
+  {"op": "hold", "action": "gb_left", "frames": 65},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_left", "frames": 45},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 90},
+  {"op": "hold", "action": "gb_right", "frames": 255},
+  {"op": "hold", "action": "gb_up", "frames": 5},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_left", "frames": 155},
+  {"op": "hold", "action": "gb_down", "frames": 65},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 60},
+  {"op": "hold", "action": "gb_up", "frames": 60},
+  {"op": "hold", "action": "gb_left", "frames": 65},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_left", "frames": 45},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 90},
+  {"op": "hold", "action": "gb_right", "frames": 245},
+  {"op": "hold", "action": "gb_up", "frames": 35},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_left", "frames": 140},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 60},
+  {"op": "hold", "action": "gb_down", "frames": 35},
+  {"op": "hold", "action": "gb_left", "frames": 65},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_left", "frames": 45},
+  {"op": "wait", "frames": 6},
+  {"op": "hold", "action": "gb_action", "frames": 1},
+  {"op": "wait", "frames": 240}
+]}

kit_on_video_on/mode_manifest.json

@@ -0,0 +1,22 @@
+{
+    "task_mode":  "brief",
+    "game_count":  5,
+    "case_count":  5,
+    "games":  {
+                  "arc_wing":  {
+                                   "case_count":  1
+                               },
+                  "3d_platformer":  {
+                                        "case_count":  1
+                                    },
+                  "ballast_yard":  {
+                                       "case_count":  1
+                                   },
+                  "bush_522":  {
+                                   "case_count":  1
+                               },
+                  "citycab_rush":  {
+                                       "case_count":  1
+                                   }
+              }
+}

kit_on_video_on/ninja_roguelite/metadata.json

@@ -0,0 +1,12 @@
+{
+  "game": "ninja_roguelite",
+  "mode": "brief",
+  "case_id": "",
+  "status": "completed",
+  "phase": "completed",
+  "agent_exit_code": 0,
+  "model": "minimax-m3",
+  "source_cell": "/root/gb-results/minimax_ablation_gap_20260924/ablation_kit_on_video_on_k2_lane1/cells/ninja_roguelite__brief__claude__minimax-m3",
+  "reference_video_requested": true,
+  "materialization": "copy_verified_excluding_.godot"
+}

kit_on_video_on/ninja_roguelite/submission/GDD.md

@@ -0,0 +1,143 @@
+# Lantern Vigil — Game Design Document
+
+## Target experience
+
+The player controls an agile night ninja guarding a sacred lantern through three night-bound stages. Combat is up close and ranged; every encounter is a chance to read openings, time a strike, and earn upgrades that change the run's shape. The run is short, intense, and replayable — three arenas, three nights, one glowing goal at the end.
+
+## Design pillars
+
+1. **Nimble by default.** Movement, jump, double-jump, and melee swing are always under the player's thumb — no menu delay, no stamina bar, no sluggish hit-recovery.
+2. **Read the opening.** Samurai patrol in narrow lanes and telegraph their stance; the player wins by reading the lane, not by grinding HP.
+3. **Earned upgrades.** Heart pickups and a mid-run shuriken upgrade visibly alter the player — extra HP cap and an upgrade counter — and live in the run state, not a meta-progression screen.
+4. **Bounded arc.** Each arena is a screen-and-a-half. Three of them in sequence make a complete run. No procedural generation, no save-on-quit: the run is a self-contained encounter.
+5. **Honest loss and retry.** Health is visible (heart row in the HUD). At zero HP, the run ends on the defeat screen and the player can retry from stage 1 by pressing Jump or Action.
+
+## Core loop
+
+1. Spawn at the left of the arena, lantern glowing on the right.
+2. Move, jump, attack through patrolling samurai and avoid spike pits.
+3. Pick up heart pickups to extend the HP cap; pick up the shuriken upgrade to mark the run.
+4. Reach the lantern to advance: stages 1 → 2 → 3 → victory.
+5. If HP hits zero at any point, route to the defeat scene and offer retry.
+
+## Scope
+
+- One bounded run of three back-to-back arenas (level_01 → level_02 → level_03).
+- Patrolling samurai enemies that walk their lane and idle when the player is far.
+- Two pickups: floating heart (extends the HP cap and visually grows the heart row) and a one-time shuriken upgrade.
+- One spike hazard per stage as a learning beat.
+- A final goal lantern that progresses the run.
+- HUD with heart row, score, stage counter, and "LANTERN VIGIL" title.
+- Victory scene with final score; defeat scene with retry prompt.
+
+## Non-goals
+
+- Procedural levels, meta-progression, save files.
+- Multiple playable characters, weapon switching, magic spells.
+- Dialogue, story scenes, cutscenes.
+- Mobile / controller input beyond what `gb_*` keyboard keys already provide.
+- Long-form replay value beyond retrying the same three arenas.
+
+## Creative freedom
+
+- Stage layouts, enemy patrol ranges, and pickup placement are at my discretion.
+- Visual style: night-blue backdrop, hand-drawn silhouettes of trees and moon, glowing lantern, simple colour-block ninja and samurai sprites drawn from the supplied NinjaAdventure asset set.
+- Music and ambient audio are out of scope for this submission.
+
+## Mechanics
+
+### Movement (`gb_left`, `gb_right`, `gb_jump`)
+
+- **Trigger:** the player presses any of the four canonical directions.
+- **Preconditions:** player is alive (HP > 0).
+- **State change:** horizontal velocity moves toward the target speed (220 on ground, 260 in air); jump adds a vertical velocity impulse (-480 for the first jump, -380 for the double jump).
+- **Feedback:** sprite flips to face direction; HUD reflects HP unchanged.
+- **Limits:** a single air-jump (double-jump).
+- **Failure:** touching a hazard while moving triggers damage + knockback.
+
+### Melee attack (`gb_action` press)
+
+- **Trigger:** player presses `gb_action` while not in hurt state.
+- **Preconditions:** cooldown timer is 0; player is alive.
+- **State change:** enters ATTACK state for 0.50 s; an Area2D hitbox (60×48) is enabled in front of the player.
+- **Feedback:** on contact with an enemy, the enemy takes 1 HP, plays a knockback, and emits `died` if HP reaches 0.
+- **Limit:** 0.10 s cooldown between swings.
+- **Failure:** if the player is mid-hurt, the press is ignored.
+
+### Enemy contact damage
+
+- **Trigger:** samurai's hitbox overlaps the player.
+- **State change:** player loses 1 HP; knocked back; enters HURT state.
+- **Feedback:** HP row in HUD shrinks.
+- **Limit:** i-frames via the HURT state gate.
+- **Failure:** at 0 HP, route to defeat scene.
+
+### Pickups (`gb_collectible` group)
+
+- **Heart pickup:** floating polygon sprite on the ground; on player contact, extends the heart-row cap (max HP up to 9), awards 25 score, increments the `heart` upgrade counter. Disappears.
+- **Shuriken upgrade:** light polygon; on contact, marks the `ranged_shuriken` upgrade in run state and awards 75 score. Disappears.
+
+### Goal lantern (`gb_goal`)
+
+- **Trigger:** player overlaps the lantern at the right end of the arena.
+- **State change:** score +200; advance `stage_index` (or finish the run at stage 3).
+- **Feedback:** scene change to the next arena, or to the victory scene.
+
+### Hazards (`gb_hazard`)
+
+- **Spike:** static area on the ground; on player contact, deals 1 HP of damage.
+- **No destruction.** Spikes are scenery.
+
+## Progression
+
+- Stage 1 (level_01): 1 samurai patrolling the centre lane, 4 heart pickups, 1 spike, 1 shuriken upgrade.
+- Stage 2 (level_02): 1 samurai at a different x-offset, 4 heart pickups, 1 spike, 1 shuriken upgrade.
+- Stage 3 (level_03): 1 samurai further right, 4 heart pickups, 1 spike, 1 shuriken upgrade.
+- Lantern carry: each stage's lantern position is slightly further apart, signalling escalation.
+- `stage_index` is read from RunState and rendered on the HUD.
+
+## Victory
+
+- After the player touches the lantern on stage 3, RunState sets `run_over = true` and `run_won = true`, then `change_scene_to_file("res://ui/victory.tscn")`.
+- The victory scene reads the final score from RunState and shows it.
+- Pressing Jump or Action on the victory screen resets RunState and routes back to level_01.
+
+## Failure
+
+- When player HP drops to 0, the player script sets RunState.health = 0, run_over = true, run_won = false.
+- After 0.6 s of death animation, the level routes to `res://ui/defeat.tscn`.
+- The defeat scene reads final score and offers a retry via Jump or Action.
+
+## Restart
+
+- The retry flow is a fresh RunState (reset_run) followed by `change_scene_to_file("res://levels/level_01.tscn")`.
+- `gb_reset` is bound but only fired by the human player's keyboard; it always resets the run and returns to level_01.
+
+## Acceptance
+
+- Cold launch from `res://levels/level_01.tscn` enters the first arena within 30 physics frames.
+- Player node is in the `gb_player` group.
+- Enemies are in `gb_enemy`. Pickups in `gb_collectible`. Lantern in `gb_goal`. Spikes in `gb_hazard`.
+- All canonical `gb_*` inputs are bound in InputMap and read by gameplay source code (`input_router.gd` for pause/reset; `player.gd` for movement/jump/action).
+- `numeric.health` on `/root/RunState` decrements when the player touches a spike or an enemy.
+- Replay of `submission/ops.json` reaches `res://ui/victory.tscn` with `REPLAY_FINAL` printed by the stock driver.
+- A matched no-input control does not reach the victory scene.
+
+## Evidence
+
+- Visible sprite animation flipping when the player walks left vs. right.
+- HP row grows from 6 → 9 as the player collects hearts.
+- Score increases by the configured amounts (10 enemy, 15 strike, 25 heart, 75 upgrade, 200 lantern).
+- Stage counter ticks from 1 to 3 as the player crosses each lantern.
+- Replay of `submission/ops.json` reaches `res://ui/victory.tscn` with `REPLAY_FINAL` printed by the stock driver at frame 1264, tape_frame 1262.
+- Null-control test does NOT reach the victory scene with the same tape duration and no inputs.
+
+## GB interface
+
+- Canonical actions bound and read: `gb_left`, `gb_right`, `gb_up`, `gb_down`, `gb_jump`, `gb_action`, `gb_pause`, `gb_reset`.
+- No extended actions are declared (the canonical six + pause/reset cover all verbs the game needs).
+- Levels: `res://levels/level_01.tscn`, `res://levels/level_02.tscn`, `res://levels/level_03.tscn`.
+- Endings: `victory → res://ui/victory.tscn`, `defeat → res://ui/defeat.tscn`.
+- Numerics: `health = health` (on `/root/RunState`), `score = score`, `progress = stage_index`.
+- Required group: `gb_player` (player added to group in `_ready`).
+- Optional groups used: `gb_enemy`, `gb_collectible`, `gb_goal`, `gb_hazard`.

kit_on_video_on/ninja_roguelite/submission/demos.json

@@ -0,0 +1,64 @@
+{
+  "schema_version": 1,
+  "demos": [
+    {
+      "id": "full_clear",
+      "description": "Complete the entire Lantern Vigil run: hold right across three arenas, cross each lantern, reach the victory scene.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "hold", "action": "gb_right", "frames": 600},
+        {"op": "hold", "action": "gb_right", "frames": 600},
+        {"op": "noop", "frames": 1}
+      ]
+    },
+    {
+      "id": "movement_left",
+      "description": "Move the ninja left to confirm gb_left reads correctly and reverses direction.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "hold", "action": "gb_left", "frames": 90},
+        {"op": "wait", "frames": 30}
+      ]
+    },
+    {
+      "id": "jump",
+      "description": "Tap gb_jump twice to demonstrate the double-jump in mid-air.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "tap", "action": "gb_jump", "frames": 1},
+        {"op": "wait", "frames": 60},
+        {"op": "tap", "action": "gb_jump", "frames": 1},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "attack",
+      "description": "Press gb_action to swing the ninja's melee attack and confirm the action reads.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "tap", "action": "gb_action", "frames": 1},
+        {"op": "wait", "frames": 60}
+      ]
+    },
+    {
+      "id": "stage_progression",
+      "description": "Reach the first lantern and advance from stage 1 to stage 2.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "hold", "action": "gb_right", "frames": 300}
+      ]
+    },
+    {
+      "id": "damage_recovery",
+      "description": "Walk into an enemy, take damage, and survive to keep fighting.",
+      "ops": [
+        {"op": "wait", "frames": 30},
+        {"op": "hold", "action": "gb_right", "frames": 80},
+        {"op": "tap", "action": "gb_action", "frames": 1},
+        {"op": "hold", "action": "gb_right", "frames": 60},
+        {"op": "tap", "action": "gb_action", "frames": 1},
+        {"op": "hold", "action": "gb_right", "frames": 600}
+      ]
+    }
+  ]
+}

kit_on_video_on/ninja_roguelite/submission/game/assets/characters/ninja_blue.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dhvwoye6g08n1"
+path="res://.godot/imported/ninja_blue.png-825c6491e6dacd89ebdeb56c69b64c6f.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/characters/ninja_blue.png"
+dest_files=["res://.godot/imported/ninja_blue.png-825c6491e6dacd89ebdeb56c69b64c6f.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/characters/pig.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://bed2fh7tafqls"
+path="res://.godot/imported/pig.png-0f737daf5ff5901b01ff6584878b8232.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/characters/pig.png"
+dest_files=["res://.godot/imported/pig.png-0f737daf5ff5901b01ff6584878b8232.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/characters/samurai_blue.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dybl7fbaetatc"
+path="res://.godot/imported/samurai_blue.png-aaaaa09468958dc826bcae6e76312dce.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/characters/samurai_blue.png"
+dest_files=["res://.godot/imported/samurai_blue.png-aaaaa09468958dc826bcae6e76312dce.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/fx/leaf.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://l4sn70c1mr65"
+path="res://.godot/imported/leaf.png-bd79889503ba7a6b2298efcf7cf64bcd.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/fx/leaf.png"
+dest_files=["res://.godot/imported/leaf.png-bd79889503ba7a6b2298efcf7cf64bcd.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/fx/particle_pot.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://c8mb0tkylp5tk"
+path="res://.godot/imported/particle_pot.png-fc8a16b17ad020f0c02be77c69de6bf2.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/fx/particle_pot.png"
+dest_files=["res://.godot/imported/particle_pot.png-fc8a16b17ad020f0c02be77c69de6bf2.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/fx/particle_wood.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://brwjys7pqnqdc"
+path="res://.godot/imported/particle_wood.png-b81f5057612e42819890a80c86dfb862.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/fx/particle_wood.png"
+dest_files=["res://.godot/imported/particle_wood.png-b81f5057612e42819890a80c86dfb862.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/fx/raylight.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://2snjcybsovh5"
+path="res://.godot/imported/raylight.png-45b17a742a8839c2abffd7b8ac039f46.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/fx/raylight.png"
+dest_files=["res://.godot/imported/raylight.png-45b17a742a8839c2abffd7b8ac039f46.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/ui/heart.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://cmehmtdftwyge"
+path="res://.godot/imported/heart.png-3f1f80c56a1ca447e0349f7dd68592e0.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/ui/heart.png"
+dest_files=["res://.godot/imported/heart.png-3f1f80c56a1ca447e0349f7dd68592e0.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/ui/life_bar.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dsbao4g0nkov5"
+path="res://.godot/imported/life_bar.png-096187ed49bceae5df648a6b88e9d6ce.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/ui/life_bar.png"
+dest_files=["res://.godot/imported/life_bar.png-096187ed49bceae5df648a6b88e9d6ce.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/assets/ui/life_bar_bg.png.import

@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dblogk78edk2k"
+path="res://.godot/imported/life_bar_bg.png-8c368474f33975a00a2735f971bcb941.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/ui/life_bar_bg.png"
+dest_files=["res://.godot/imported/life_bar_bg.png-8c368474f33975a00a2735f971bcb941.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1

kit_on_video_on/ninja_roguelite/submission/game/enemy.gd

@@ -0,0 +1,198 @@
+extends CharacterBody2D
+class_name Enemy
+
+# Standard samurai patrol enemy. Reads the player position and lunges when
+# in range. Hurtable by the player's melee cone; on death contributes to
+# the run's overall "enemies felled" count (read as gb_enemy count_delta).
+
+signal died
+signal hurt
+
+enum State {PATROL, CHASE, ATTACK, HURT, DEAD}
+
+const MOVE_SPEED := 60.0
+const CHASE_SPEED := 80.0
+const GRAVITY := 1400.0
+const ATTACK_RANGE := 56.0
+const ATTACK_WINDUP := 0.35
+const ATTACK_COOLDOWN := 0.85
+const HURT_DURATION := 1.0
+
+@export var max_hp: int = 1
+@export var patrol_left: float = -120.0
+@export var patrol_right: float = 120.0
+@export var origin_x: float = 0.0
+@export var enemy_kind: String = "samurai"
+
+var hp: int = max_hp
+var state: int = State.PATROL
+var facing: int = 1
+var home_x: float = 0.0
+var attack_windup: float = 0.0
+var attack_cooldown: float = 0.0
+var hurt_timer: float = 0.0
+var wander_dir: int = 1
+
+@onready var sprite: Sprite2D = $Sprite
+@onready var hitbox: Area2D = $Hitbox
+@onready var anim: AnimationPlayer = $AnimationPlayer
+
+
+func _ready() -> void:
+	add_to_group("gb_enemy")
+	home_x = origin_x if origin_x != 0.0 else global_position.x
+	hitbox.body_entered.connect(_on_hitbox_body_entered)
+	hitbox.area_entered.connect(_on_hitbox_area_entered)
+
+
+func _physics_process(delta: float) -> void:
+	if state == State.DEAD:
+		velocity.y += GRAVITY * delta
+		move_and_slide()
+		return
+
+	hurt_timer = max(0.0, hurt_timer - delta)
+	attack_windup = max(0.0, attack_windup - delta)
+	attack_cooldown = max(0.0, attack_cooldown - delta)
+
+	if state == State.HURT and hurt_timer > 0.0:
+		velocity.y += GRAVITY * delta
+		move_and_slide()
+		return
+
+	var player := _find_player()
+	var player_dist := INF
+	if player != null:
+		player_dist = abs(player.global_position.x - global_position.x)
+
+	# Pick facing toward patrol direction or player
+	if state != State.ATTACK:
+		if player != null and player_dist < 200.0:
+			facing = 1 if player.global_position.x > global_position.x else -1
+		else:
+			if global_position.x < home_x + patrol_left:
+				wander_dir = 1
+			elif global_position.x > home_x + patrol_right:
+				wander_dir = -1
+			facing = wander_dir
+
+	match state:
+		State.PATROL:
+			velocity.x = move_toward(velocity.x, float(wander_dir) * MOVE_SPEED,
+				600.0 * delta)
+			if player != null and player_dist < 220.0:
+				state = State.CHASE
+		State.CHASE:
+			if player == null:
+				state = State.PATROL
+			else:
+				var dir: float = sign(player.global_position.x - global_position.x)
+				velocity.x = move_toward(velocity.x, float(dir) * CHASE_SPEED,
+					900.0 * delta)
+				if player_dist < ATTACK_RANGE and attack_cooldown <= 0.0:
+					state = State.ATTACK
+					attack_windup = ATTACK_WINDUP
+					facing = dir
+				elif player_dist > 320.0:
+					state = State.PATROL
+		State.ATTACK:
+			velocity.x = 0.0
+			if attack_windup <= 0.0:
+				# swing: tell the hitbox to deal damage once
+				hitbox.monitoring = true
+				_swing_once()
+				attack_cooldown = ATTACK_COOLDOWN
+				state = State.CHASE
+		State.HURT:
+			state = State.CHASE
+
+	velocity.y += GRAVITY * delta
+	move_and_slide()
+	sprite.flip_h = (facing < 0)
+	_anim_for_state()
+
+
+var _swinged_this_windup := false
+
+func _swing_once() -> void:
+	# Activate hitbox briefly; hit detection happens via signals.
+	hitbox.monitoring = true
+	get_tree().create_timer(0.15, false).timeout.connect(func():
+		if is_instance_valid(self):
+			hitbox.monitoring = false)
+
+
+func _anim_for_state() -> void:
+	if anim == null:
+		return
+	var name := ""
+	match state:
+		State.PATROL:
+			name = "run"
+		State.CHASE:
+			name = "run"
+		State.ATTACK:
+			name = "attack"
+		State.HURT:
+			name = "hurt"
+		State.DEAD:
+			name = "dead"
+	if anim.current_animation != name:
+		anim.play(name)
+
+
+func take_hit(by: Node, dmg: int) -> void:
+	if state == State.DEAD:
+		return
+	hp -= dmg
+	hurt.emit()
+	state = State.HURT
+	hurt_timer = HURT_DURATION
+	# Knockback away from the attacker
+	var dir: float = sign(global_position.x - by.global_position.x)
+	if dir == 0.0:
+		dir = 1.0
+	velocity = Vector2(dir * 220.0, -180.0)
+	if hp <= 0:
+		_die()
+
+
+func _die() -> void:
+	if state == State.DEAD:
+		return
+	state = State.DEAD
+	died.emit()
+	set_collision_layer_value(1, false)
+	set_collision_layer_value(2, false)
+	set_collision_mask_value(2, false)
+	hitbox.set_deferred("monitoring", false)
+	# Drop the corpse down out of view, then free.
+	velocity = Vector2(0, -100)
+	get_tree().create_timer(0.6, false).timeout.connect(func():
+		if is_instance_valid(self):
+			queue_free()
+	)
+
+
+func _find_player() -> Node2D:
+	var nodes := get_tree().get_nodes_in_group("gb_player")
+	for n in nodes:
+		if n is Node2D and is_instance_valid(n) and n.visible:
+			return n
+	return null
+
+
+func _on_hitbox_body_entered(body: Node) -> void:
+	if state == State.DEAD:
+		return
+	if body.is_in_group("gb_player"):
+		if body.has_method("_take_damage"):
+			body._take_damage(1, global_position)
+
+
+func _on_hitbox_area_entered(area: Area2D) -> void:
+	if state == State.DEAD:
+		return
+	if area.is_in_group("gb_player"):
+		if area.has_method("_take_damage"):
+			area._take_damage(1, global_position)

kit_on_video_on/ninja_roguelite/submission/game/enemy.gd.uid

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

kit_on_video_on/ninja_roguelite/submission/game/enemy.tscn

@@ -0,0 +1,73 @@
+[gd_scene load_steps=8 format=3]
+
+[ext_resource type="Script" path="res://enemy.gd" id="1_enemy"]
+[ext_resource type="Texture2D" path="res://assets/characters/samurai_blue.png" id="2_tex"]
+
+[sub_resource type="RectangleShape2D" id="Shape_enemy"]
+size = Vector2(22, 44)
+
+[sub_resource type="RectangleShape2D" id="Shape_hitbox"]
+size = Vector2(40, 30)
+
+[sub_resource type="Animation" id="Anim_run"]
+length = 0.4
+loop_mode = 1
+tracks/0/type = "value"
+tracks/0/imported = false
+tracks/0/enabled = true
+tracks/0/path = NodePath("Sprite:modulate")
+tracks/0/interp = 1
+tracks/0/loop_wrap = true
+tracks/0/keys = {
+"times": PackedFloat32Array(0, 0.2, 0.4),
+"transitions": PackedFloat32Array(1, 1, 1),
+"update": 0,
+"values": [Color(1, 1, 1, 1), Color(0.85, 0.9, 1, 1), Color(1, 1, 1, 1)]
+}
+
+[sub_resource type="Animation" id="Anim_attack"]
+length = 0.3
+tracks/0/type = "value"
+tracks/0/imported = false
+tracks/0/enabled = true
+tracks/0/path = NodePath("Hitbox:monitoring")
+tracks/0/interp = 1
+tracks/0/loop_wrap = true
+tracks/0/keys = {
+"times": PackedFloat32Array(0, 0.25, 0.3),
+"transitions": PackedFloat32Array(1, 1, 1),
+"update": 1,
+"values": [true, false, false]
+}
+
+[sub_resource type="AnimationLibrary" id="AnimLib_enemy"]
+_data = {
+"attack": SubResource("Anim_attack"),
+"dead": SubResource("Anim_run"),
+"hurt": SubResource("Anim_run"),
+"run": SubResource("Anim_run")
+}
+
+[node name="Enemy" type="CharacterBody2D"]
+collision_layer = 2
+collision_mask = 1
+script = ExtResource("1_enemy")
+
+[node name="Sprite" type="Sprite2D" parent="."]
+scale = Vector2(0.6, 0.6)
+texture = ExtResource("2_tex")
+
+[node name="Collision" type="CollisionShape2D" parent="."]
+shape = SubResource("Shape_enemy")
+
+[node name="Hitbox" type="Area2D" parent="."]
+collision_layer = 8
+collision_mask = 16
+
+[node name="Shape" type="CollisionShape2D" parent="Hitbox"]
+shape = SubResource("Shape_hitbox")
+
+[node name="AnimationPlayer" type="AnimationPlayer" parent="."]
+libraries = {
+"": SubResource("AnimLib_enemy")
+}