From d4b92788384e25569e98dd599b07e0aff50ead81 Mon Sep 17 00:00:00 2001 From: Ross Andrews Date: Sun, 21 Jun 2026 18:27:45 -0500 Subject: [PATCH] spinners and gems --- CLAUDE.md | 4 +- kiln-core/CLAUDE.md | 25 +-- kiln-core/src/action.rs | 13 ++ kiln-core/src/archetype.rs | 29 ++++ kiln-core/src/board.rs | 251 +++++++++++++++++++++++++++-- kiln-core/src/builtin_scripts.rs | 17 ++ kiln-core/src/game.rs | 184 +++++++++++++++++++-- kiln-core/src/map_file.rs | 3 + kiln-core/src/object_def.rs | 6 + kiln-core/src/script.rs | 80 ++++++++- kiln-core/src/scripts/gem.rhai | 9 ++ kiln-core/src/scripts/spinner.rhai | 8 +- kiln-core/src/utils.rs | 22 +++ kiln-tui/CLAUDE.md | 4 +- kiln-tui/src/editor_menu.rs | 8 + kiln-tui/src/status.rs | 13 +- maps/start.toml | 6 +- 17 files changed, 626 insertions(+), 56 deletions(-) create mode 100644 kiln-core/src/scripts/gem.rhai diff --git a/CLAUDE.md b/CLAUDE.md index ec9303c..d9c5eea 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -128,9 +128,9 @@ content = """ "1" = { kind = "portal", name = "east_door", target_map = "room2", target_entry = "west_door" } ``` -Palette `kind` values: the meta-kinds `empty` / `floor` / `object` / `portal` / `player`, or any **archetype name** directly (`wall`, `crate`, `hcrate`, `vcrate`, `pusher_north|south|east|west`, `spinner_cw|spinner_ccw`). For archetype/floor/object kinds, `tile`/`fg`/`bg` are optional and fall back to that kind's default glyph. An unknown `kind` becomes a visible `ErrorBlock` (logged). A floor entry uses `generator` for a procedural texture or `tile`/`fg`/`bg` for a fixed glyph. +Palette `kind` values: the meta-kinds `empty` / `floor` / `object` / `portal` / `player`, or any **archetype name** directly (`wall`, `crate`, `hcrate`, `vcrate`, `pusher_north|south|east|west`, `spinner_cw|spinner_ccw`, `gem`). For archetype/floor/object kinds, `tile`/`fg`/`bg` are optional and fall back to that kind's default glyph. An unknown `kind` becomes a visible `ErrorBlock` (logged). A floor entry uses `generator` for a procedural texture or `tile`/`fg`/`bg` for a fixed glyph. -Colors are `"#RRGGBB"` hex strings. The player is placed by a `kind = "player"` char, which must appear **exactly once** across all layers (missing → `(0,0)` + error; multiple → first + error); that cell is transparent. `tile` accepts a single-character string (`tile = " "`) or an integer (`tile = 35`). Each layer's `content` multi-line string has its leading newline trimmed by TOML and must match `width × height` (the only hard error); the `fill`/`sparse` forms are always exactly sized. An unknown `kind` produces an `ErrorBlock` and a logged warning. An object is spawned once per occurrence of its char (uppercase by convention) in reading order. **Loading is best-effort and nonfatal** (only a layer grid-dimension mismatch is a hard error): each problem is recorded on `Board` (see `is_valid()` / `load_errors()`). The **player wins its cell**: it silently clears solid terrain under it (on any layer) and drops any conflicting solid object. Script source lives in the world-level `[scripts]` table; objects reference a script by `script_name`. Scripts may define optional `init()`, `tick(dt)`, and `bump(id)` functions; they **read** the world through `Board.*` (e.g. `Board.player_x`), check `blocked(dir) -> bool`, `can_push(x, y, dir) -> bool`, `can_shift(x, y, dir) -> bool`, and `passable(x, y) -> bool`, inspect/empty their pending actions via `Queue.length()`/`Queue.clear()`, and **write** via host functions `move(dir)`, `set_tile(n)`, `log(s)`, `say(s)`, `scroll(lines)`, `push(x, y, dir)` (shove a chain at arbitrary coords), and `swap([[src_x, src_y, dst_x, dst_y], …])` (move several solids simultaneously). Writes don't take effect immediately: each is queued and **at most one `move` resolves per 250 ms** per object. When two objects move into the same cell, **lowest id wins** and the bumped object receives `bump(id)`. +Colors are `"#RRGGBB"` hex strings. The player is placed by a `kind = "player"` char, which must appear **exactly once** across all layers (missing → `(0,0)` + error; multiple → first + error); that cell is transparent. `tile` accepts a single-character string (`tile = " "`) or an integer (`tile = 35`). Each layer's `content` multi-line string has its leading newline trimmed by TOML and must match `width × height` (the only hard error); the `fill`/`sparse` forms are always exactly sized. An unknown `kind` produces an `ErrorBlock` and a logged warning. An object is spawned once per occurrence of its char (uppercase by convention) in reading order. **Loading is best-effort and nonfatal** (only a layer grid-dimension mismatch is a hard error): each problem is recorded on `Board` (see `is_valid()` / `load_errors()`). The **player wins its cell**: it silently clears solid terrain under it (on any layer) and drops any conflicting solid object. Script source lives in the world-level `[scripts]` table; objects reference a script by `script_name`. Scripts may define optional `init()`, `tick(dt)`, `bump(id)`, and `grab()` functions; they **read** the world through `Board.*` (e.g. `Board.player_x`), check `blocked(dir) -> bool`, `can_push(x, y, dir) -> bool`, `can_shift(x, y, dir) -> bool`, and `passable(x, y) -> bool`, inspect/empty their pending actions via `Queue.length()`/`Queue.clear()`, and **write** via host functions `move(dir)`, `set_tile(n)`, `log(s)`, `say(s)`, `scroll(lines)`, `push(x, y, dir)` (shove a chain at arbitrary coords), `swap([[src_x, src_y, dst_x, dst_y], …])` (move several solids simultaneously), `add_gems(n)` (change the player's gem count), and `die()` (remove the calling object). Writes don't take effect immediately: each is queued and **at most one `move` resolves per 250 ms** per object. When two objects move into the same cell, **lowest id wins** and the bumped object receives `bump(id)`. **Script state across board transitions**: Rhai `Scope` local variables reset when the `ScriptHost` is rebuilt on board entry. Board-side state (object positions, tags, glyph) is preserved because all boards are held as `Rc>` in `World::boards`. Scripts that need to persist information across transitions should encode it in board data (e.g. `set_tag(Me.id, "visited", true)`). diff --git a/kiln-core/CLAUDE.md b/kiln-core/CLAUDE.md index 61a7363..77e98d8 100644 --- a/kiln-core/CLAUDE.md +++ b/kiln-core/CLAUDE.md @@ -18,22 +18,22 @@ The core types that were formerly monolithic in `game.rs` are now split into foc - `NAMED_COLORS: [(&str, Rgba8); 16]` — the 16 EGA/VGA palette colors as `(name, color)` pairs in palette order (`Black`, `Blue`, …, `White`). The **single source of truth**: `script::register_global_constants` builds the Rhai `Black`/`Blue`/… `"#RRGGBB"` constants from it, and kiln-ui's glyph picker builds its named-swatch strips from it, so the two never drift. **`kiln-core/src/archetype.rs`** — element taxonomy: -- `Archetype` (`Copy`, `PartialEq`, `Hash`) — enum of named element types: `Empty`, `Wall`, `Crate`, `HCrate`, `VCrate`, `Pusher(Direction)`, `Spinner(SpinDirection)`, `ErrorBlock`. Each variant provides `behavior()`, `name()` (used in map files), and `default_glyph()`. `Crate` pushable any direction (CP437 ■, char 254); `HCrate`/`VCrate` pushable east/west (↔, char 29) / north/south (↕, char 18) only. `Pusher(dir)` (`pusher_north|south|east|west`) is a **map-file keyword only**: at load it expands into a scripted object (see [`builtin_scripts`]), never a terrain cell. `Spinner(SpinDirection)` (`SpinDirection::{Clockwise,CounterClockwise}`; keywords `spinner_cw|spinner_ccw`) is the same kind of script-backed keyword: it expands into a `spinner.rhai` object that rotates its 8 neighbours each 0.5 s and animates its glyph (default glyph is the first frame, `/` CW / `\` CCW, gray on black). `ErrorBlock` is a sentinel for unknown archetype names (yellow `?` on red). `TryFrom<&str>` parses by name; unrecognized names return `Err` (the map loader substitutes `ErrorBlock`). +- `Archetype` (`Copy`, `PartialEq`, `Hash`) — enum of named element types: `Empty`, `Wall`, `Crate`, `HCrate`, `VCrate`, `Pusher(Direction)`, `Spinner(SpinDirection)`, `Gem`, `ErrorBlock`. Each variant provides `behavior()`, `name()` (used in map files), and `default_glyph()`. `Crate` pushable any direction (CP437 ■, char 254); `HCrate`/`VCrate` pushable east/west (↔, char 29) / north/south (↕, char 18) only. `Pusher(dir)` (`pusher_north|south|east|west`) is a **map-file keyword only**: at load it expands into a scripted object (see [`builtin_scripts`]), never a terrain cell. `Spinner(SpinDirection)` (`SpinDirection::{Clockwise,CounterClockwise}`; keywords `spinner_cw|spinner_ccw`) is the same kind of script-backed keyword: it expands into a `spinner.rhai` object that rotates its 8 neighbours each 0.5 s and animates its glyph (default glyph is the first frame, `/` CW / `\` CCW, gray on black). `Gem` (keyword `gem`) is also a script-backed keyword: solid + non-opaque + pushable + **grab** (the only archetype with `grab: true`), it expands into a `gem.rhai` object (default glyph blue ♦, CP437 tile 4) whose `grab()` hook adds a gem to the player and `die()`s. `ErrorBlock` is a sentinel for unknown archetype names (yellow `?` on red). `TryFrom<&str>` parses by name; unrecognized names return `Err` (the map loader substitutes `ErrorBlock`). **`kiln-core/src/builtin_scripts.rs`** — archetypes that are really scripted objects (`pub(crate)`): -- `archetype_script(arch) -> Option<&'static str>` — the dispatch (one arm per script-backed archetype) returning the embedded Rhai source (`include_str!`); currently `Pusher(_) -> scripts/pusher.rhai` and `Spinner(_) -> scripts/spinner.rhai`. Such an archetype loads as a plain terrain cell (`layer::resolve_entry`); `Board::expand_builtin_archetypes` (called from `TryFrom` at load and again before a playtest) is the **single** place that turns it into an `ObjectDef` carrying that source in `builtin_script` plus a `BUILTIN_` tag. The spinner reads its `BUILTIN_spinner_cw`/`_ccw` tag for spin direction (defaulting clockwise) and stores per-instance animation frame state in the board `Registry`. +- `archetype_script(arch) -> Option<&'static str>` — the dispatch (one arm per script-backed archetype) returning the embedded Rhai source (`include_str!`); currently `Pusher(_) -> scripts/pusher.rhai`, `Spinner(_) -> scripts/spinner.rhai`, and `Gem -> scripts/gem.rhai` (just `fn grab() { add_gems(1); die(); }`). Such an archetype loads as a plain terrain cell (`layer::resolve_entry`); `Board::expand_builtin_archetypes` (called from `TryFrom` at load and again before a playtest) is the **single** place that turns it into an `ObjectDef` carrying that source in `builtin_script` plus a `BUILTIN_` tag. The spinner reads its `BUILTIN_spinner_cw`/`_ccw` tag for spin direction (defaulting clockwise) and stores per-instance animation frame state in the board `Registry`. - `BUILTIN_TAG_PREFIX` (`"BUILTIN_"`), `builtin_tag(arch) -> String`, `archetype_from_builtin_tag(tag) -> Option` — the tag convention. The script reads its tag for per-instance params (the pusher reads it for its direction, since `Me` isn't visible inside Rhai helper functions); `map_file::save` uses it to collapse the object back into its archetype keyword so maps round-trip. `scripts/pusher.rhai` self-propels via `move(dir)` (which already shoves chains via `step_object`/`push`), pacing itself with `delay` to the old ~0.5 s cadence. **`kiln-core/src/utils.rs`** — shared primitive types (`pub(crate)`): - `Pushable` (`No`/`Any`/`Horizontal`/`Vertical`) — which directions a solid may be pushed. `allows(dir) -> bool`. -- `Behavior` — plain data struct from `Archetype::behavior()`: `solid: bool`, `opaque: bool`, `pushable: Pushable`. +- `Behavior` — plain data struct from `Archetype::behavior()`: `solid: bool`, `opaque: bool`, `pushable: Pushable`, `grab: bool` (walking into a `solid + grab` thing isn't blocked — the player moves onto it and its `grab()` hook fires; only `Gem` sets it). - `ObjectId = u32` — stable identifier for board objects. - `Solid` — the single solid occupant of a cell, returned by `Board::solid_at`: `Player`, `Cell(Archetype)`, or `Object(ObjectId)`. - `Player { x: i32, y: i32 }` — current player position. - `PortalDef { x, y, target_map, target_entry }` — parsed from map files, not yet runtime-wired. **`kiln-core/src/object_def.rs`** — scripted objects (`pub(crate)`): -- `ObjectDef` — a scripted tile: `x`, `y`, `z: usize` (layer index, drives draw order), `glyph: Glyph`, `solid: bool` (default `true`), `opaque: bool` (default `true`), `pushable: bool` (default `false`), `script_name: Option`, `builtin_script: Option<&'static str>` (embedded source set when a script-backed archetype like a pusher is expanded at load; takes precedence over `script_name`; not serialized — see [`builtin_scripts`]), `tags: HashSet`, `name: Option`. The optional `name` is validated for board-wide uniqueness at load time; the first claimant keeps the name and any later duplicate has its name cleared to `None` (nonfatal). `ObjectDef::new(x, y)` constructs with defaults (`z = 0`). `ObjectDef::default_glyph()` returns tile 63 (`?`) yellow on black. +- `ObjectDef` — a scripted tile: `x`, `y`, `z: usize` (layer index, drives draw order), `glyph: Glyph`, `solid: bool` (default `true`), `opaque: bool` (default `true`), `pushable: bool` (default `false`), `grab: bool` (default `false`; set when a grab archetype like a gem is expanded — walking onto it fires `grab()`), `script_name: Option`, `builtin_script: Option<&'static str>` (embedded source set when a script-backed archetype like a pusher is expanded at load; takes precedence over `script_name`; not serialized — see [`builtin_scripts`]), `tags: HashSet`, `name: Option`. The optional `name` is validated for board-wide uniqueness at load time; the first claimant keeps the name and any later duplicate has its name cleared to `None` (nonfatal). `ObjectDef::new(x, y)` constructs with defaults (`z = 0`). `ObjectDef::default_glyph()` returns tile 63 (`?`) yellow on black. **`kiln-core/src/layer.rs`** — palette layers (the map-file/draw-stack unit): - `Layer { cells: Vec<(Glyph, Archetype)> }` (`pub(crate)`) — one row-major draw layer. A cell whose `glyph.tile == 0` (`Glyph::transparent()`) draws nothing, so the layer beneath shows through; solidity comes from the archetype, independent of transparency. @@ -48,12 +48,13 @@ The core types that were formerly monolithic in `game.rs` are now split into foc - `solid_at(x, y) -> Option` — the cell's single solid occupant (player checked first, then objects, then a solid terrain archetype on *any* layer via `solid_cell_layer`). - `is_passable(x, y)` — convenience inverse of `solid_at`. - `can_push(x, y, dir) -> bool` — read-only: does the chain of pushable solids end in open space? -- `can_shift(x, y, dir) -> bool` — read-only, one cell ahead only: `(x, y)` holds a pushable *and* the next cell is empty or another pushable (does **not** require the chain to end in open space, unlike `can_push`). The right gate for a simultaneous shift/rotation via `apply_swap`. +- `can_shift(x, y, dir) -> bool` — read-only, one cell ahead only: `(x, y)` holds a pushable *and* the next cell is empty or another pushable (does **not** require the chain to end in open space, unlike `can_push`). The right gate for a simultaneous shift/rotation via `apply_swap`. Shifting onto the **player** counts only when the source is a `grab` thing (it gets grabbed, the player isn't moved); any other solid treats the player as a blocker. - `push(x, y, dir)` — mutating: shoves the chain one step, leaving a transparent cell behind (so a lower floor layer is revealed). A pushed solid moves within its own layer (found via `solid_cell_layer`). -- `add_object(obj) -> ObjectId`, `remove_object(id) -> Option`, `object_ids_at(x, y)`, `solid_object_id_at(x, y)` — object add/remove + queries. (`remove_object` only edits the `objects` map; a live `ScriptHost` keeps a stale `ObjectRuntime` whose later host-fn calls resolve to a missing id and no-op — benign.) -- `apply_swap(pairs: &[(i32,i32,i32,i32)]) -> Vec` — applies a batch of one-way solid moves **simultaneously** (reads every source's solid occupant — player/object/terrain — into a private `SolidSnapshot` before writing any destination, so cycles and two-cell swaps resolve). A source with no solid moves an "empty", removing the destination's solid (terrain cleared; a displaced object despawned via `remove_object`). The **player is never destroyed** — a write that would overwrite it without relocating it is skipped + logged. Out-of-bounds entries are skipped + logged. Backs the script `swap()` fn. +- `add_object(obj) -> ObjectId`, `remove_object(id) -> Option`, `object_ids_at(x, y)`, `solid_object_id_at(x, y)` — object add/remove + queries. +- `grab_object_at(x, y) -> Option` (a solid `grab` object on the cell — the player-walks-onto-it case) and `pushed_grab_into_player(x, y, dir) -> Option` (walk the pushable chain from `(x,y)`; if a chain cell is a `grab` object whose forward neighbour is the player, return it — the grab-thing-shoved-into-the-player case). `GameState` uses both to decide when to fire `grab()` instead of pushing/sliding the player. (`remove_object` only edits the `objects` map; a live `ScriptHost` keeps a stale `ObjectRuntime` whose later host-fn calls resolve to a missing id and no-op — benign.) +- `apply_swap(pairs: &[(i32,i32,i32,i32)]) -> (Vec, Vec)` — applies a batch of one-way solid moves **simultaneously** (reads every source's solid occupant — player/object/terrain — into a private `SolidSnapshot` before writing any destination, so cycles and two-cell swaps resolve). A source with no solid moves an "empty", removing the destination's solid (terrain cleared; a displaced object despawned via `remove_object`). The **player is never destroyed** — a write that would overwrite it without relocating it is skipped + logged. A **grab** object whose destination is the player isn't written onto it — it is left in place and its id is returned (the second tuple element) so `GameState` fires its `grab()` hook (collected into the same `grabs` list as the push path). Because a grabbed object stays put (and its `grab()` may not despawn it), a final **overlap sweep** over the swapped cells keeps one solid per cell — preferring a grabbed object so its `grab()` can still fire — and deletes the rest (never the player), logging an error per deletion. Out-of-bounds entries are skipped + logged. Backs the script `swap()` fn. - `place_archetype(x, y, arch, glyph)` — editor stamp primitive (used by kiln-tui's drawing tools). Keyed only on the archetype, leaving any floor untouched: a non-`Empty` (solid) arch removes a solid object in the cell then writes `(glyph, arch)` into the existing terrain layer (`terrain_layer_at`, the single non-`Empty` cell) or else the top layer; `Empty` erases — removes every object plus the terrain cell (→ transparent `Empty`). Note it writes **terrain** even for script-backed archetypes (pushers/spinners), so the editor stamps an inert cell — see `expand_builtin_archetypes`. -- `expand_builtin_archetypes()` — the **single** expansion point: replaces every script-backed terrain cell (e.g. `Spinner`/`Pusher`, those with an `archetype_script`) with the scripted object it expands to (embedded script + `BUILTIN_*` tag + behavior, copying the cell's glyph so palette overrides survive). Idempotent (cells already loaded as objects are skipped). Called by `TryFrom for Board` after cross-layer validation (so disk loads get working machines) and again by the editor's `playtest()` on the `World::deep_clone` (so editor-stamped machines, which `place_archetype` writes as inert terrain, also run — the playtest skips the reload path). Because it runs after explicit-object placement, builtin objects get ids after hand-placed ones (still layer-then-reading order among themselves). +- `expand_builtin_archetypes()` — the **single** expansion point: replaces every script-backed terrain cell (e.g. `Spinner`/`Pusher`/`Gem`, those with an `archetype_script`) with the scripted object it expands to (embedded script + `BUILTIN_*` tag + behavior, copying the cell's glyph so palette overrides survive). The object's `pushable`/`grab` flags are taken from the archetype's `Behavior` (so a gem becomes pushable + grabbable; pushers/spinners stay unpushable). Idempotent (cells already loaded as objects are skipped). Called by `TryFrom for Board` after cross-layer validation (so disk loads get working machines) and again by the editor's `playtest()` on the `World::deep_clone` (so editor-stamped machines, which `place_archetype` writes as inert terrain, also run — the playtest skips the reload path). Because it runs after explicit-object placement, builtin objects get ids after hand-placed ones (still layer-then-reading order among themselves). - `in_bounds((i32, i32))` — bounds-checks a possibly-negative coord. - `is_valid()` / `load_errors()` / `report_error(msg)` — nonfatal load-error surface. @@ -61,12 +62,12 @@ The core types that were formerly monolithic in `game.rs` are now split into foc - `SpeechBubble { object_id, text, remaining }` — an active speech bubble created by a script's `say(s)` call. `remaining` counts down in `GameState::tick`; when it reaches zero the bubble is removed. At most one bubble per object (a new `say()` replaces the old one). - `SAY_DURATION: f64` — how long a bubble lives (3.0 seconds). - `Scroll { source: ObjectId, lines: Vec }` — an active scroll overlay opened by a script's `scroll(lines)` call. Lives on `GameState::active_scroll: Option`; front-ends pause ticks while it's `Some` and close it via `close_scroll(choice)`. `ScrollLine` is re-exported from `action.rs` through `game.rs` so front-ends import both from `kiln_core::game`. -- `GameState` — owns `world: World` (all boards as `Rc>` + world scripts) and `current_board_name: String` (key of the active board). `pub log: Vec`, `scripts: ScriptHost`, `pub speech_bubbles: Vec`, `pub active_scroll: Option`, `pub player_health: u32` (starts 5) and `pub player_gems: u32` (starts 0) — game-global player stats that persist across board transitions (display-only for now, no runtime mutation path). Front-ends reach the active board through `board() -> Ref` / `board_mut() -> RefMut` (both look up `world.boards[current_board_name]`). `current_board_name() -> &str` returns the active key. **`from_world(world: World) -> Self`** is the primary constructor: clones the start board's `Rc>` for the `ScriptHost`, compiles scripts from `world.scripts`. `new(board)` and `with_scripts(board, scripts)` are `#[cfg(test)]`-only sugar that build a minimal single-board `World`. `try_move(dir)` moves the player (pushing if possible) and fires `bump(-1)` on any solid object walked into. `run_init()` runs object `init()` hooks once at startup. `tick(dt)` advances cooldowns, expires speech bubbles, and runs `tick(dt)` hooks every frame. Both end by calling `resolve()`, which drains the board queue and applies each `Action` (`Log` → `log`, `SetTile` → source glyph, `Move(dir)` → `step_object`, `Say` → `speech_bubbles`, `Scroll` → `active_scroll`). Resolution is two-phase: mutate the board collecting `(bumped, bumper)` pairs, drop the borrow, then fire `run_bump` for each pair. `drain_errors()` moves script errors into `log`. `close_scroll(choice)` clears `active_scroll` and optionally fires `run_send(source, choice, None)` to dispatch the player's selection back to the object. +- `GameState` — owns `world: World` (all boards as `Rc>` + world scripts) and `current_board_name: String` (key of the active board). `pub log: Vec`, `scripts: ScriptHost`, `pub speech_bubbles: Vec`, `pub active_scroll: Option`, `pub player_health: u32` (starts 5) and `pub player_gems: u32` (starts 0) — game-global player stats that persist across board transitions. `player_gems` is changed at runtime by the `add_gems(n)` script fn (e.g. grabbing a gem); `player_health` is still display-only. Front-ends reach the active board through `board() -> Ref` / `board_mut() -> RefMut` (both look up `world.boards[current_board_name]`). `current_board_name() -> &str` returns the active key. **`from_world(world: World) -> Self`** is the primary constructor: clones the start board's `Rc>` for the `ScriptHost`, compiles scripts from `world.scripts`. `new(board)` and `with_scripts(board, scripts)` are `#[cfg(test)]`-only sugar that build a minimal single-board `World`. `try_move(dir)` moves the player (pushing if possible) and fires `bump(-1)` on any solid object walked into; walking onto a `grab` thing (via `Board::grab_object_at`) instead moves onto it and fires `grab()` + an immediate `resolve()` so its `die()`/`add_gems()` apply before the call returns (no player+object overlap). `run_init()` runs object `init()` hooks once at startup. `tick(dt)` advances cooldowns, expires speech bubbles, and runs `tick(dt)` hooks every frame. Both end by calling `resolve()`, which drains the board queue and applies each `Action` (`Log` → `log`, `SetTile` → source glyph, `Move(dir)` → `step_object`, `Say` → `speech_bubbles`, `Scroll` → `active_scroll`, `AddGems(n)` → `player_gems`, `Die` → `remove_object(source)`). `step_object` and `Action::Push` route a grab-thing-shoved-into-the-player (via `Board::pushed_grab_into_player`) into a deferred `grab()` instead of sliding the player, collected and fired in phase B alongside `bump`s. Resolution is two-phase: mutate the board collecting `(bumped, bumper)` pairs, drop the borrow, then fire `run_bump` for each pair. `drain_errors()` moves script errors into `log`. `close_scroll(choice)` clears `active_scroll` and optionally fires `run_send(source, choice, None)` to dispatch the player's selection back to the object. **`kiln-core/src/action.rs`** — the `Action` enum and its Rhai-facing conversion: - `MOVE_COST: f64` — how long a move occupies an object before it can act again (0.25 s). - `ScrollLine` (`pub`) — one line of content in a `Scroll` action: `Text(String)` (plain, word-wrapped) or `Choice { choice, display }` (selectable; `choice` is sent back to the source object when the player picks it). -- `Action` (`pub(crate)`) — deferred mutation emitted by a script and applied by `GameState` after promotion onto the board queue: `Move(Direction)`, `SetTile(u32)`, `Log(LogLine)`, `SetTag { target, tag, present }`, `Say(String)`, `Delay(f64)` (never reaches the board queue — consumed by `ScriptHost::drain` to pace the object), `SetColor { fg, bg }`, `Send { target, fn_name, arg }`, `Scroll(Vec)`, `Teleport { x, y }`, `Push { x, y, dir }` (shove a chain at arbitrary coords; zero time cost), `Swap(Vec<(i32,i32,i32,i32)>)` (batch of simultaneous one-way solid moves; zero time cost). +- `Action` (`pub(crate)`) — deferred mutation emitted by a script and applied by `GameState` after promotion onto the board queue: `Move(Direction)`, `SetTile(u32)`, `Log(LogLine)`, `SetTag { target, tag, present }`, `Say(String)`, `Delay(f64)` (never reaches the board queue — consumed by `ScriptHost::drain` to pace the object), `SetColor { fg, bg }`, `Send { target, fn_name, arg }`, `Scroll(Vec)`, `Teleport { x, y }`, `Push { x, y, dir }` (shove a chain at arbitrary coords; zero time cost), `Swap(Vec<(i32,i32,i32,i32)>)` (batch of simultaneous one-way solid moves; zero time cost), `AddGems(i64)` (change `GameState::player_gems`, clamped at 0; zero cost), `Die` (remove the source object; zero cost). - `action_to_map(action) -> rhai::Map` — converts an `Action` to a Rhai map for `Queue.peek()` / `Queue.pop()`. The map always has a `"type"` key; other keys carry the payload. `Scroll`/`Swap` emit `type` only (their payloads are not inspectable via the map API). `Log` is flattened to its first span's text. **`kiln-core/src/floor.rs`** — procedural floor generators: @@ -78,9 +79,9 @@ The core types that were formerly monolithic in `game.rs` are now split into foc **`kiln-core/src/script.rs`** — Rhai scripting runtime: - `ScriptHost` — owns the Rhai `Engine`, the compiled scripts referenced by a board's objects, a per-object persistent `Scope` + output queue + ready timer, and the shared board queue. Built with `ScriptHost::new(&Rc>, &HashMap)`: the first arg is a shared ref to the active board (used by read-API closures), the second is the world-level script pool. Each object resolves to a `(key, source)` compiled once per key: a named script keys by its pool name; an object's embedded `builtin_script` keys by its source text (so identical built-ins, e.g. all pushers, share one AST). Reports compile/unknown-script failures onto the error sink; runs nothing. -- Lifecycle hooks per object: `init()` (zero-arg), `tick(dt)` (elapsed seconds as `f64`), and `bump(id)` (the bumper's `ObjectId`, or `-1` for the player), all optional — detected via `AST::iter_functions()` by name and arity. Driven by `run_init()` / `run_tick(dt)` / `run_bump(object_id, bumper)`; runtime errors go to the error sink (drained to the log), not fatal. +- Lifecycle hooks per object: `init()` (zero-arg), `tick(dt)` (elapsed seconds as `f64`), `bump(id)` (the bumper's `ObjectId`, or `-1` for the player), and `grab()` (zero-arg; fired when the player walks onto / pushes a `grab` thing into themselves), all optional — detected via `AST::iter_functions()` by name and arity. Driven by `run_init()` / `run_tick(dt)` / `run_bump(object_id, bumper)` / `run_grab(object_id)`; runtime errors go to the error sink (drained to the log), not fatal. - **Reads (direct):** read getters (`player_x`, `player_y`, `width`, `height`) are registered on `Rc>` (the `BoardRef` alias, exposed to Rhai under the type name `Board`) — getters only, so read-only by construction. A clone of the handle is pushed into each scope as the constant `Board`. `blocked(dir) -> bool` is also a read fn: true if the caller's target cell is off-board, already solid, or the destination of a pending move on the board queue (an object never sees its *own* move, which is pumped only after its script returns). `can_push(x, y, dir) -> bool` is a read fn mirroring `Board::can_push`: true if `(x, y)` holds a pushable whose chain can be shoved in `dir` (false off-board). `can_shift(x, y, dir) -> bool` mirrors `Board::can_shift`: like `can_push` but only checks the single cell ahead (pushable source + an empty-or-pushable next cell), the right gate for a simultaneous shift/rotation via `swap`. `passable(x, y) -> bool` mirrors `Board::is_passable`: true if `(x, y)` is on-board and holds no solid (off-board → false), letting a script tell a hole apart from a blocked solid (which `can_shift`/`can_push` alone cannot). `has_tag(s) -> bool` and `get_tags() -> Array` read the calling object's tag set; `objects_with_tag(s) -> Array` returns all object ids carrying that tag. `my_name() -> String` returns the calling object's name (or `""` if unnamed); `object_id_for_name(s) -> i64` looks up an object by name and returns its id, or `0` if not found. Each getter briefly borrows the shared `Board`. -- **Actions & rate limiting (two-tier queues):** host fns `move(dir)`, `set_tile(n)`, `log(s)`, `say(s)`, `scroll(lines)`, `push(x, y, dir)`, `swap(pairs)` append an `Action` (`Move`/`SetTile`/`Log`/`Say`/`Scroll`/`Push`/`Swap`; `MOVE_COST = 0.25` s for `Move`, else 0 — `push`/`swap` add no delay) to the *issuing object's* output queue (routed by the per-call tag via a `HashMap`). `scroll(lines)` takes a Rhai array where each element is a string (text line) or a two-element array `[choice_key, display_text]` (selectable choice). `push(x, y, dir)` shoves the pushable chain at arbitrary coords `(x, y)`. `swap(pairs)` takes an array of four-int `[src_x, src_y, dst_x, dst_y]` arrays (a malformed entry is skipped + logged) and moves all the named solids simultaneously (see `Board::apply_swap`). `ScriptHost::pump(i)` promotes ready actions onto the shared **board queue** (`Vec`): the leading run of zero-cost actions plus at most one timed action, which arms that object's **ready timer** and ends the pump. While a ready timer is `> 0` nothing is pulled (this caps object speed); `advance_timers(dt)` counts them down each frame. `GameState` drains the board queue with `take_board_queue()` and applies it after the batch — so scripts mutate without a `&mut GameState` borrow. Errors (compile/runtime) bypass the queues via the error sink (`take_errors()`). +- **Actions & rate limiting (two-tier queues):** host fns `move(dir)`, `set_tile(n)`, `log(s)`, `say(s)`, `scroll(lines)`, `push(x, y, dir)`, `swap(pairs)`, `add_gems(n)` (adjust the player's gem count), `die()` (remove the calling object) append an `Action` (`Move`/`SetTile`/`Log`/`Say`/`Scroll`/`Push`/`Swap`; `MOVE_COST = 0.25` s for `Move`, else 0 — `push`/`swap` add no delay) to the *issuing object's* output queue (routed by the per-call tag via a `HashMap`). `scroll(lines)` takes a Rhai array where each element is a string (text line) or a two-element array `[choice_key, display_text]` (selectable choice). `push(x, y, dir)` shoves the pushable chain at arbitrary coords `(x, y)`. `swap(pairs)` takes an array of four-int `[src_x, src_y, dst_x, dst_y]` arrays (a malformed entry is skipped + logged) and moves all the named solids simultaneously (see `Board::apply_swap`). `ScriptHost::pump(i)` promotes ready actions onto the shared **board queue** (`Vec`): the leading run of zero-cost actions plus at most one timed action, which arms that object's **ready timer** and ends the pump. While a ready timer is `> 0` nothing is pulled (this caps object speed); `advance_timers(dt)` counts them down each frame. `GameState` drains the board queue with `take_board_queue()` and applies it after the batch — so scripts mutate without a `&mut GameState` borrow. Errors (compile/runtime) bypass the queues via the error sink (`take_errors()`). - The `Queue` object (a handle to the calling object's output queue) is pushed into each scope; scripts call `Queue.length()`, `Queue.clear()`, `Queue.peek()` (front action as a Rhai map, or `()` if empty), and `Queue.pop()` (same, removes the front). Safe to mutate from script because the host only touches output queues between calls (during `pump`). - **Sender identity:** `source` (which object issued an action) rides the per-call **tag** — `run` calls `call_fn_with_options(...with_tag(object_id)...)` and the host fns read it via `NativeCallContext::tag()` (decoded back to an `ObjectId` by `source_of`). Scripts write `move(North)` without naming themselves; `North`/`South`/`East`/`West` are `Direction` constants in scope, and `impl From for (i32,i32)` gives the delta. - `GameState` (hence the `Engine`/`Scope`) is single-threaded / not `Send`; fine for kiln-tui. diff --git a/kiln-core/src/action.rs b/kiln-core/src/action.rs index f845aa4..243ab0f 100644 --- a/kiln-core/src/action.rs +++ b/kiln-core/src/action.rs @@ -75,6 +75,12 @@ pub(crate) enum Action { /// write-all, so cycles/swaps work). Each tuple is `(src_x, src_y, dst_x, /// dst_y)`. Zero time cost. Swap(Vec<(i32, i32, i32, i32)>), + /// Add `n` to the player's gem count (negative subtracts; the count is + /// clamped at 0). Zero time cost. Applied to `GameState::player_gems`. + AddGems(i64), + /// Remove the source object from the board. Zero time cost. Used by grab + /// things (e.g. gems) to despawn themselves from their `grab()` hook. + Die, } // ── Direction helper ────────────────────────────────────────────────────────── @@ -180,6 +186,13 @@ pub(crate) fn action_to_map(action: &Action) -> rhai::Map { Action::Swap(_) => { m.insert("type".into(), ds("Swap")); } + Action::AddGems(n) => { + m.insert("type".into(), ds("AddGems")); + m.insert("n".into(), Dynamic::from(*n)); + } + Action::Die => { + m.insert("type".into(), ds("Die")); + } } m } diff --git a/kiln-core/src/archetype.rs b/kiln-core/src/archetype.rs index c8e3ecf..4c14fc0 100644 --- a/kiln-core/src/archetype.rs +++ b/kiln-core/src/archetype.rs @@ -45,6 +45,13 @@ pub enum Archetype { /// direction, rotates the 8 neighbouring cells one step each 0.5 s, and animates /// its own glyph through a spinning line `/ ─ \ │` (slash-swapped for counter-clockwise). Spinner(SpinDirection), + /// A collectible gem — solid, non-opaque, pushable, and **grab**bable. Like + /// [`Pusher`](Archetype::Pusher)/[`Spinner`](Archetype::Spinner) this is a + /// map-file *keyword* only: at load it expands into a scripted [`ObjectDef`] + /// carrying the embedded `gem.rhai` (see [`crate::builtin_scripts`]). Walking + /// onto a gem (or pushing one into the player) fires its `grab()` hook, which + /// increments the player's gem count and removes the gem. Glyph: blue ♦. + Gem, /// Sentinel for map files that reference an unknown archetype name. /// Renders as a yellow `?` on red to make the error visible in-game. ErrorBlock, @@ -69,41 +76,56 @@ impl Archetype { solid: false, opaque: false, pushable: Pushable::No, + grab: false, }, Archetype::Wall => Behavior { solid: true, opaque: true, pushable: Pushable::No, + grab: false, }, Archetype::Crate => Behavior { solid: true, opaque: true, pushable: Pushable::Any, + grab: false, }, Archetype::HCrate => Behavior { solid: true, opaque: true, pushable: Pushable::Horizontal, + grab: false, }, Archetype::VCrate => Behavior { solid: true, opaque: true, pushable: Pushable::Vertical, + grab: false, }, Archetype::Pusher(_) => Behavior { solid: true, opaque: true, pushable: Pushable::No, + grab: false, }, Archetype::Spinner(_) => Behavior { solid: true, opaque: true, pushable: Pushable::No, + grab: false, + }, + // A gem doesn't block sight, is shovable, and is grabbed on contact. + Archetype::Gem => Behavior { + solid: true, + opaque: false, + pushable: Pushable::Any, + grab: true, }, Archetype::ErrorBlock => Behavior { solid: true, opaque: true, pushable: Pushable::No, + grab: false, }, } } @@ -122,6 +144,7 @@ impl Archetype { Archetype::Pusher(Direction::West) => "pusher_west", Archetype::Spinner(SpinDirection::Clockwise) => "spinner_cw", Archetype::Spinner(SpinDirection::CounterClockwise) => "spinner_ccw", + Archetype::Gem => "gem", Archetype::ErrorBlock => "error_block", } } @@ -183,6 +206,11 @@ impl Archetype { bg: Rgba8 { r: 0, g: 0, b: 0, a: 255 }, } } + Archetype::Gem => Glyph { + tile: 4, // CP437 ♦ (diamond) + fg: Rgba8 { r: 0x50, g: 0x50, b: 0xFF, a: 255 }, // blue on black + bg: Rgba8 { r: 0, g: 0, b: 0, a: 255 }, + }, // Visually distinct so malformed map files are immediately obvious. Archetype::ErrorBlock => Glyph { tile: 63, @@ -215,6 +243,7 @@ impl TryFrom<&str> for Archetype { "pusher_west" => Ok(Archetype::Pusher(Direction::West)), "spinner_cw" => Ok(Archetype::Spinner(SpinDirection::Clockwise)), "spinner_ccw" => Ok(Archetype::Spinner(SpinDirection::CounterClockwise)), + "gem" => Ok(Archetype::Gem), _ => Err(format!("unknown archetype: {name}")), } } diff --git a/kiln-core/src/board.rs b/kiln-core/src/board.rs index 134b2d3..1932144 100644 --- a/kiln-core/src/board.rs +++ b/kiln-core/src/board.rs @@ -6,6 +6,7 @@ use crate::object_def::ObjectDef; use crate::utils::Direction; use crate::utils::{ObjectId, Player, PortalDef, RegistryValue, Solid}; use std::collections::{BTreeMap, HashMap, HashSet}; +use crate::builtin_scripts::archetype_script_key; /// A captured solid occupant of a cell, used by [`Board::apply_swap`] to read /// every source cell before writing any destination (so cyclic moves work). @@ -234,6 +235,38 @@ impl Board { self.solid_at(x, y).is_none() } + /// Returns `true` if the mover as `(x1, y1)` can enter `(x2, y2)` — i.e. it would not + /// break the rules of "one solid per cell, except for player + grab". + /// + /// Convenience inverse of [`solid_at`](Board::solid_at). + /// Panics if `x` or `y` are out of bounds. + pub fn is_combinable(&self, x1: usize, y1: usize, x2: usize, y2: usize) -> bool { + // Are either out of bounds? + if !self.in_bounds((x1 as i32, y1 as i32)) || !self.in_bounds((x2 as i32, y2 as i32)) { + return false + } + + // Grab the solids + let solid1 = self.solid_at(x1, y1); + let solid2 = self.solid_at(x2, y2); + + // Is one cell empty? + if solid1.is_none() || solid2.is_none() { return true } + + // They're both present, unwrap them: + let solid1 = solid1.unwrap(); + let solid2 = solid2.unwrap(); + + // This is probably disallowed then, but let's check for a player coexisting with a grab: + if solid1.player() && solid2.grab(self) || + solid2.player() && solid1.grab(self) { + return true + } + + // Nope, two solids that can't coexist: + false + } + /// Whether the cell's single solid occupant (if any) can be pushed in `dir`. /// /// Non-solid things are never pushable: `pushable` only matters for solids. @@ -287,6 +320,12 @@ impl Board { /// [`apply_swap`](Board::apply_swap)), where a destination is occupied by /// another pushable that is itself moving the same frame. Returns `false` if /// `(x, y)` holds no pushable, or the cell ahead runs off the board. + /// + /// Shifting onto the **player** is allowed only when the source is a + /// [`grab`](crate::object_def::ObjectDef::grab) thing: it isn't shoving the + /// player aside (a shift can't relocate the player, and `apply_swap` would + /// refuse to overwrite it), it's being grabbed — the player stays put and the + /// thing despawns. Any other solid treats the player as a blocker. pub fn can_shift(&self, x: usize, y: usize, dir: Direction) -> bool { // The source must hold a solid pushable in `dir`. if !self.is_pushable(x, y, dir) { @@ -298,6 +337,11 @@ impl Board { return false; // nothing to shift into off the board } let (nx, ny) = (next.0 as usize, next.1 as usize); + // Shifting onto the player is only legitimate for a grab thing (it gets + // grabbed, the player isn't moved); otherwise the player is a blocker. + if matches!(self.solid_at(nx, ny), Some(Solid::Player)) { + return self.grab_object_at(x, y).is_some(); + } // The cell ahead is acceptable if it is empty or another pushable solid. self.is_passable(nx, ny) || self.is_pushable(nx, ny, dir) } @@ -370,6 +414,50 @@ impl Board { }) } + /// Returns the [`ObjectId`] of a solid, **grab**bable object at `(x, y)`, if any. + /// + /// Used by [`GameState::try_move`](crate::game::GameState::try_move) to detect + /// the player walking onto a grab thing (e.g. a gem): the move isn't blocked, + /// the object's `grab()` hook fires instead. + pub fn grab_object_at(&self, x: usize, y: usize) -> Option { + self.objects.iter().find_map(|(&id, o)| { + if o.x == x && o.y == y && o.solid && o.grab { + Some(id) + } else { + None + } + }) + } + + /// Returns the [`ObjectId`] of a **grab** object that a push at `(x, y)` in + /// `dir` would shove into the player, if any. + /// + /// Walks the pushable chain from `(x, y)`; if a chain cell holds a grab object + /// whose immediate forward neighbour is the player, that object is returned. + /// This is the "grab thing pushed into the player" case: rather than sliding + /// the player along, the caller grabs the thing (see + /// [`GameState`](crate::game::GameState)). Returns `None` for an ordinary push. + pub fn pushed_grab_into_player(&self, x: usize, y: usize, dir: Direction) -> Option { + let (dx, dy): (i32, i32) = dir.into(); + let (mut cx, mut cy) = (x, y); + // Advance through the contiguous run of pushable solids. + while self.is_pushable(cx, cy, dir) { + let next = (cx as i32 + dx, cy as i32 + dy); + if !self.in_bounds(next) { + return None; + } + let (nx, ny) = (next.0 as usize, next.1 as usize); + // If the next cell is the player and this cell is a grab object, the + // push would drive that grab thing into the player: grab it instead. + if matches!(self.solid_at(nx, ny), Some(Solid::Player)) { + return self.grab_object_at(cx, cy); + } + cx = nx; + cy = ny; + } + None + } + /// Inserts `object`, assigning it the next free [`ObjectId`], and returns that id. /// /// Ids start at 1 and increase monotonically; an id is never reused, so it @@ -467,8 +555,13 @@ impl Board { obj.glyph = glyph; obj.solid = b.solid; obj.opaque = b.opaque; - obj.pushable = false; + // Carry the archetype's pushability/grab onto the object (pushers and + // spinners are Pushable::No, so they stay unpushable; gems are pushable + // and grabbable). + obj.pushable = b.pushable != crate::utils::Pushable::No; + obj.grab = b.grab; obj.builtin_script = archetype_script(arch); + obj.script_name = archetype_script_key(arch).map(|s| s.to_owned()); obj.tags.insert(builtin_tag(arch)); self.add_object(obj); } @@ -489,8 +582,21 @@ impl Board { /// [`remove_object`](Board::remove_object)). The **player is never destroyed** — /// a write that would overwrite the player without relocating it is skipped and /// logged (the player wins its cell, per the one-solid-per-cell invariant). - pub fn apply_swap(&mut self, pairs: &[(i32, i32, i32, i32)]) -> Vec { + /// + /// **Grab:** a [`grab`](crate::object_def::ObjectDef::grab) object whose + /// destination is the player isn't written onto the player — it is left where it + /// is and its id is returned in the second tuple element so the caller can fire + /// its `grab()` hook (it gets grabbed, the player isn't moved). Because a + /// grabbed object stays put (and its `grab()` may not despawn it), it can end up + /// sharing a cell with a solid that moved in; a final sweep over the swapped + /// cells resolves any such **overlap** — it keeps one solid (preferring a + /// grabbed object so its `grab()` can still fire), deletes the rest (never the + /// player), and logs an error per deletion. + pub fn apply_swap(&mut self, pairs: &[(i32, i32, i32, i32)]) -> (Vec, Vec) { let mut errors = Vec::new(); + // Grab objects whose destination was the player: left in place here, their + // grab() hooks fired by the caller (GameState). + let mut grabbed: Vec = Vec::new(); // 1. Validate: keep only entries whose source and destination are in bounds. let mut valid: Vec<((i32, i32), (i32, i32))> = Vec::new(); @@ -572,6 +678,16 @@ impl Board { // The player wins its cell: never overwrite player_final with anything // other than the player itself. if (cx, cy) == player_final && !matches!(snap, SolidSnapshot::Player) { + // A grab object shoved onto the player is grabbed, not blocked: leave + // it where it is (don't install onto the player) and report it so the + // caller fires its grab() hook. The overlap sweep below cleans up if + // its source cell is now also someone else's destination. + if let SolidSnapshot::Object(id) = snap + && self.objects.get(id).is_some_and(|o| o.grab) + { + grabbed.push(*id); + continue; + } errors.push(LogLine::error(format!( "swap: cannot overwrite the player at ({cx},{cy})" ))); @@ -595,7 +711,52 @@ impl Board { } } - errors + // 5. Overlap sweep: a grabbed object left in place (above) may now share a + // cell with a solid that moved in. For any swapped cell holding more than + // one solid, keep a single occupant — a grabbed object if present (so its + // grab() can still fire), otherwise whatever remains — and delete the rest + // (never the player). Logs an error per deletion. + for &(cx, cy) in &affected { + let (ux, uy) = (cx as usize, cy as usize); + let player_here = self.player.x == cx && self.player.y == cy; + // Solid objects on this cell, with grabbed ones first so we keep one. + let mut objs: Vec = self + .objects + .iter() + .filter(|(_, o)| o.x == ux && o.y == uy && o.solid) + .map(|(&id, _)| id) + .collect(); + objs.sort_by_key(|id| !grabbed.contains(id)); + let has_terrain = self.solid_cell_layer(ux, uy).is_some(); + + // How many solids share the cell (player + solid objects + solid terrain). + let total = player_here as usize + objs.len() + has_terrain as usize; + if total <= 1 { + continue; + } + errors.push(LogLine::error(format!( + "swap: {total} solids overlap at ({cx},{cy}); deleting extras" + ))); + + // Pick the survivor (priority: player > grabbed/first object > terrain) + // and delete every other solid. The player is only ever a survivor, so + // it is never deleted. `keep_obj` is the object we keep, if any. + let keep_obj = (!player_here).then(|| objs.first().copied()).flatten(); + for id in &objs { + if Some(*id) != keep_obj { + self.remove_object(*id); + } + } + // Clear terrain unless it's the sole survivor (no player, no kept object). + if has_terrain + && (player_here || keep_obj.is_some()) + && let Some(z) = self.solid_cell_layer(ux, uy) + { + *self.get_mut(z, ux, uy) = (Glyph::transparent(), Archetype::Empty); + } + } + + (errors, grabbed) } /// Reads the solid occupant of `(x, y)` into a [`SolidSnapshot`] (for @@ -740,6 +901,27 @@ pub(crate) mod tests { assert!(!board.is_passable(2, 0)); } + #[test] + fn grab_helpers_detect_a_gem() { + // A grabbable gem object at (1,0); the player at (2,0). + let mut gem = ObjectDef::new(1, 0); + gem.grab = true; + gem.pushable = true; + let board = open_board(3, 1, (2, 0), vec![gem]); + + // grab_object_at finds the gem on its own cell, nowhere else. + assert_eq!(board.grab_object_at(1, 0), Some(1)); + assert_eq!(board.grab_object_at(0, 0), None); + + // Pushing the gem east shoves it into the player → reported as a grab. + assert_eq!( + board.pushed_grab_into_player(1, 0, Direction::East), + Some(1) + ); + // Pushing it west (away from the player) is an ordinary push. + assert_eq!(board.pushed_grab_into_player(1, 0, Direction::West), None); + } + #[test] fn non_solid_object_does_not_block() { let mut obj = ObjectDef::new(1, 0); @@ -816,6 +998,22 @@ pub(crate) mod tests { assert!(!board.can_shift(1, 0, Direction::East)); } + #[test] + fn can_shift_into_player_only_for_a_grab_thing() { + // A grab gem at (0,0) may shift east onto the player at (1,0): it gets + // grabbed rather than blocked. + let mut gem = ObjectDef::new(0, 0); + gem.grab = true; + gem.pushable = true; + let board = open_board(2, 1, (1, 0), vec![gem]); + assert!(board.can_shift(0, 0, Direction::East)); + + // A plain crate may not shift onto the player — the player blocks it. + let mut board = open_board(2, 1, (1, 0), vec![]); + crate_at(&mut board, 0, 0); + assert!(!board.can_shift(0, 0, Direction::East)); + } + #[test] fn push_into_player_pushes_player() { // Crate shoved east into the player slides the player along into open space. @@ -992,7 +1190,7 @@ pub(crate) mod tests { let mut board = open_board(3, 1, (1, 0), vec![]); crate_at(&mut board, 0, 0); wall_at(&mut board, 2, 0); - let errs = board.apply_swap(&[(0, 0, 2, 0), (2, 0, 0, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 2, 0), (2, 0, 0, 0)]); assert!(errs.is_empty()); assert_eq!(board.get(0, 0, 0).1, Archetype::Wall); assert_eq!(board.get(0, 2, 0).1, Archetype::Crate); @@ -1006,7 +1204,7 @@ pub(crate) mod tests { // a = (0,0) empty, b = (1,0) crate, c = (2,0) wall. crate_at(&mut board, 1, 0); wall_at(&mut board, 2, 0); - let errs = board.apply_swap(&[(0, 0, 1, 0), (1, 0, 2, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 1, 0), (1, 0, 2, 0)]); assert!(errs.is_empty()); assert_eq!(board.get(0, 0, 0).1, Archetype::Empty); assert_eq!(board.get(0, 1, 0).1, Archetype::Empty); @@ -1017,7 +1215,7 @@ pub(crate) mod tests { fn apply_swap_empty_onto_object_removes_it() { // Moving an empty source onto an object despawns the object. let mut board = open_board(3, 1, (2, 0), vec![ObjectDef::new(1, 0)]); - let errs = board.apply_swap(&[(0, 0, 1, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 1, 0)]); assert!(errs.is_empty()); assert!(board.solid_object_id_at(1, 0).is_none()); assert!(board.objects.is_empty()); @@ -1029,7 +1227,7 @@ pub(crate) mod tests { let mut board = open_board(3, 1, (2, 0), vec![]); crate_at(&mut board, 0, 0); wall_at(&mut board, 1, 0); - let errs = board.apply_swap(&[(0, 0, 1, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 1, 0)]); assert!(errs.is_empty()); assert_eq!(board.get(0, 0, 0).1, Archetype::Empty); assert_eq!(board.get(0, 1, 0).1, Archetype::Crate); @@ -1039,7 +1237,7 @@ pub(crate) mod tests { fn apply_swap_moves_object_and_player() { // An object and the player relocate (swap places) in one batch. let mut board = open_board(3, 1, (0, 0), vec![ObjectDef::new(2, 0)]); - let errs = board.apply_swap(&[(0, 0, 2, 0), (2, 0, 0, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 2, 0), (2, 0, 0, 0)]); assert!(errs.is_empty()); assert_eq!((board.player.x, board.player.y), (2, 0)); assert_eq!((board.objects[&1].x, board.objects[&1].y), (0, 0)); @@ -1049,7 +1247,7 @@ pub(crate) mod tests { fn apply_swap_out_of_bounds_skips_and_logs() { let mut board = open_board(3, 1, (2, 0), vec![]); crate_at(&mut board, 0, 0); - let errs = board.apply_swap(&[(0, 0, 9, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 9, 0)]); assert_eq!(errs.len(), 1); assert_eq!(board.get(0, 0, 0).1, Archetype::Crate); // unchanged } @@ -1059,9 +1257,42 @@ pub(crate) mod tests { // A crate moved onto the (non-relocating) player is rejected and logged. let mut board = open_board(3, 1, (1, 0), vec![]); crate_at(&mut board, 0, 0); - let errs = board.apply_swap(&[(0, 0, 1, 0)]); + let (errs, _) = board.apply_swap(&[(0, 0, 1, 0)]); assert_eq!(errs.len(), 1); assert_eq!((board.player.x, board.player.y), (1, 0)); // player kept its cell assert_eq!(board.get(0, 0, 0).1, Archetype::Empty); // source still vacated } + + #[test] + fn apply_swap_grab_onto_player_is_reported_not_moved() { + // A grab gem swapped onto the player is reported (for its grab() hook) and + // left at its source rather than overwriting / sliding the player. + let mut gem = ObjectDef::new(0, 0); + gem.grab = true; + gem.pushable = true; + let mut board = open_board(2, 1, (1, 0), vec![gem]); + let (errs, grabbed) = board.apply_swap(&[(0, 0, 1, 0)]); + assert!(errs.is_empty()); + assert_eq!(grabbed, vec![1]); + assert_eq!((board.player.x, board.player.y), (1, 0)); // player kept its cell + assert_eq!((board.objects[&1].x, board.objects[&1].y), (0, 0)); // gem stayed + } + + #[test] + fn apply_swap_overlap_after_grab_deletes_the_other_solid() { + // gem (0,0)→player (1,0) [grabbed, stays at (0,0)] while a crate (2,0)→(0,0) + // moves into the gem's cell. The sweep keeps the grabbed gem and deletes the + // crate, logging the overlap. + let mut gem = ObjectDef::new(0, 0); + gem.grab = true; + gem.pushable = true; + let mut board = open_board(3, 1, (1, 0), vec![gem]); + crate_at(&mut board, 2, 0); + let (errs, grabbed) = board.apply_swap(&[(0, 0, 1, 0), (2, 0, 0, 0)]); + assert_eq!(grabbed, vec![1]); + assert_eq!(errs.len(), 1); // the overlap was logged + assert_eq!((board.objects[&1].x, board.objects[&1].y), (0, 0)); // gem kept + assert_eq!(board.get(0, 0, 0).1, Archetype::Empty); // crate deleted + assert_eq!((board.player.x, board.player.y), (1, 0)); // player untouched + } } diff --git a/kiln-core/src/builtin_scripts.rs b/kiln-core/src/builtin_scripts.rs index cb43977..882f8f9 100644 --- a/kiln-core/src/builtin_scripts.rs +++ b/kiln-core/src/builtin_scripts.rs @@ -26,6 +26,10 @@ const PUSHER: &str = include_str!("scripts/pusher.rhai"); /// direction comes from the object's tag, so all spinners share one compiled AST. const SPINNER: &str = include_str!("scripts/spinner.rhai"); +/// The gem behavior, embedded into the binary: a `grab()` hook that adds a gem to +/// the player and removes the object. +const GEM: &str = include_str!("scripts/gem.rhai"); + /// The tag identifying an object as the expanded form of `arch`, e.g. /// `"BUILTIN_pusher_east"`. pub(crate) fn builtin_tag(arch: Archetype) -> String { @@ -46,6 +50,19 @@ pub(crate) fn archetype_script(arch: Archetype) -> Option<&'static str> { match arch { Archetype::Pusher(_) => Some(PUSHER), Archetype::Spinner(_) => Some(SPINNER), + Archetype::Gem => Some(GEM), + _ => None, + } +} + +/// Returns the embedded script implementing `arch` as an object, or `None` if the +/// archetype is a plain terrain cell. The one place script-backed archetypes are +/// declared. +pub(crate) fn archetype_script_key(arch: Archetype) -> Option<&'static str> { + match arch { + Archetype::Pusher(_) => Some("BUILTIN_pusher"), + Archetype::Spinner(_) => Some("BUILTIN_spinner"), + Archetype::Gem => Some("BUILTIN_gem"), _ => None, } } diff --git a/kiln-core/src/game.rs b/kiln-core/src/game.rs index 17ba2e1..54e4f6e 100644 --- a/kiln-core/src/game.rs +++ b/kiln-core/src/game.rs @@ -210,6 +210,12 @@ impl GameState { // below also borrows `self`. let mut logs: Vec = Vec::new(); let mut bumps: Vec<(ObjectId, i64)> = Vec::new(); + // Grab hooks to fire (player walked into / pushed a grab thing); fired after + // the board borrow drops, like bumps. + let mut grabs: Vec = Vec::new(); + // Net change to the player's gem count from AddGems actions; applied to + // `self` after the board borrow drops. + let mut gem_delta: i64 = 0; let mut sends: Vec<(ObjectId, String, Option)> = Vec::new(); let mut new_bubbles: Vec = Vec::new(); // Collected outside the board borrow so we can assign to self.active_scroll. @@ -219,9 +225,13 @@ impl GameState { for ba in actions { match ba.action { Action::Move(dir) => { - if let Some(bumped) = step_object(&mut board, ba.source, dir) { + let outcome = step_object(&mut board, ba.source, dir); + if let Some(bumped) = outcome.bumped { bumps.push((bumped, ba.source as i64)); } + if let Some(grabbed) = outcome.grabbed { + grabs.push(grabbed); + } } Action::SetTile(tile) => { if let Some(obj) = board.objects.get_mut(&ba.source) { @@ -299,15 +309,32 @@ impl GameState { } // push() self-checks can_push, so an in-bounds guard is all we add. Action::Push { x, y, dir } => { - if board.in_bounds((x, y)) { - board.push(x as usize, y as usize, dir); - } else { + if !board.in_bounds((x, y)) { logs.push(LogLine::error(format!("push({x},{y}): out of bounds"))); + } else if let Some(grabbed) = + board.pushed_grab_into_player(x as usize, y as usize, dir) + { + // A grab thing shoved into the player is grabbed, not pushed. + grabs.push(grabbed); + } else { + board.push(x as usize, y as usize, dir); } } // apply_swap reads all sources then writes all destinations, so a // whole batch of moves resolves simultaneously (cycles included). - Action::Swap(pairs) => logs.extend(board.apply_swap(&pairs)), + // A grab thing swapped onto the player is reported back for its + // grab() hook (fired in phase B with the other grabs). + Action::Swap(pairs) => { + let (errs, grabbed) = board.apply_swap(&pairs); + logs.extend(errs); + grabs.extend(grabbed); + } + // Accumulated and applied to `self.player_gems` after the borrow drops. + Action::AddGems(n) => gem_delta += n, + // A grab thing despawns itself from its grab() hook. + Action::Die => { + board.remove_object(ba.source); + } } } } @@ -321,9 +348,18 @@ impl GameState { if let Some(scroll) = new_scroll { self.active_scroll = Some(scroll); } + // Apply the net gem change (clamped at 0, since the count is unsigned). + if gem_delta != 0 { + self.player_gems = (self.player_gems as i64 + gem_delta).max(0) as u32; + } for (bumped, bumper) in bumps { self.scripts.run_bump(bumped, bumper); } + // Fire grab() hooks (player walked into / pushed a grab thing). The hook + // typically adds a stat and calls die(); those actions resolve next pass. + for grabbed in grabs { + self.scripts.run_grab(grabbed); + } for (target, fn_name, arg) in sends { self.scripts.run_send(target, &fn_name, arg); } @@ -403,6 +439,7 @@ impl GameState { /// object's `bump(-1)` hook fires (whether or not the player ends up moving). pub fn try_move(&mut self, dir: Direction) { let bumped; + let grabbed; let portal_target; { let (dx, dy): (i32, i32) = dir.into(); @@ -412,13 +449,21 @@ impl GameState { return; } let (nx, ny) = (target.0 as usize, target.1 as usize); - // A solid object in the way is bumped by the player (id -1). + // Walking onto a grab thing (e.g. a gem) is never blocked: the player + // moves onto it and its grab() hook fires (the thing despawns itself). + grabbed = board.grab_object_at(nx, ny); + // A solid object in the way is bumped by the player (id -1) — but a + // grab thing fires grab() instead of bump(), so don't also bump it. bumped = match board.solid_at(nx, ny) { - Some(Solid::Object(_)) => board.solid_object_id_at(nx, ny), + Some(Solid::Object(_)) if grabbed.is_none() => board.solid_object_id_at(nx, ny), _ => None, }; - if board.is_passable(nx, ny) || board.can_push(nx, ny, dir) { - board.push(nx, ny, dir); // shoves a crate/object out of the way; no-op otherwise + if grabbed.is_some() || board.is_passable(nx, ny) || board.can_push(nx, ny, dir) { + // Don't push a grab thing aside — walk onto it. Otherwise shove any + // pushable chain out of the way (no-op when there's nothing to push). + if grabbed.is_none() { + board.push(nx, ny, dir); + } board.player.x = nx as i32; board.player.y = ny as i32; // Check for a portal at the new position; clone strings to release the borrow. @@ -436,6 +481,12 @@ impl GameState { self.enter_board(&target_map, &target_entry); return; } + // Fire the grab hook and resolve it immediately so the grabbed thing's + // die()/add_gems() apply now — no player+object overlap survives this call. + if let Some(id) = grabbed { + self.scripts.run_grab(id); + self.resolve(); + } if let Some(idx) = bumped { self.scripts.run_bump(idx, -1); self.drain_errors(); @@ -443,22 +494,46 @@ impl GameState { } } -/// Moves object `id` one cell in `dir` on `board`, returning the [`ObjectId`] of a -/// solid object it bumped (its target cell was occupied by that object), if any. +/// The side effects of a [`step_object`] call that the caller resolves after the +/// board borrow drops: a `bump`ed object and/or a `grab`bed object. +#[derive(Default)] +struct StepOutcome { + /// A solid object the mover collided with (target cell was occupied by it). + bumped: Option, + /// A grab object the move shoved into the player (its `grab()` hook should fire). + grabbed: Option, +} + +/// Moves object `id` one cell in `dir` on `board`, returning the objects it bumped +/// and/or grabbed (see [`StepOutcome`]). /// /// The move itself proceeds only if the target is in bounds and either passable or a /// pushable solid the object can shove out of the way (see [`Board::can_push`]). The /// bump is recorded whenever a solid object occupies the target — whether it gets /// pushed aside or blocks the move — since something tried to move into it. Walls and /// crates carry no script, so only solid objects yield a bump. -fn step_object(board: &mut Board, id: ObjectId, dir: Direction) -> Option { +/// +/// If the push would shove a **grab** thing into the player (see +/// [`Board::pushed_grab_into_player`]), the push is skipped and the grab thing is +/// reported instead of sliding the player along. +fn step_object(board: &mut Board, id: ObjectId, dir: Direction) -> StepOutcome { let (dx, dy): (i32, i32) = dir.into(); - let (ox, oy) = board.objects.get(&id).map(|o| (o.x, o.y))?; + let Some((ox, oy)) = board.objects.get(&id).map(|o| (o.x, o.y)) else { + return StepOutcome::default(); + }; let target = (ox as i32 + dx, oy as i32 + dy); if !board.in_bounds(target) { - return None; + return StepOutcome::default(); } let (nx, ny) = (target.0 as usize, target.1 as usize); + // A push that would drive a grab thing into the player grabs it instead of + // sliding the player; skip the move entirely (the grab thing despawns itself). + if let Some(grabbed) = board.pushed_grab_into_player(nx, ny, dir) { + return StepOutcome { + bumped: None, + grabbed: Some(grabbed), + }; + } // Capture the bumped object before any push relocates it (its id is stable). let bumped = match board.solid_at(nx, ny) { Some(Solid::Object(_)) => board.solid_object_id_at(nx, ny), @@ -470,18 +545,95 @@ fn step_object(board: &mut Board, id: ObjectId, dir: Direction) -> Option GameState { let mut obj = ObjectDef::new(0, 0); diff --git a/kiln-core/src/map_file.rs b/kiln-core/src/map_file.rs index 74e9150..377dbaf 100644 --- a/kiln-core/src/map_file.rs +++ b/kiln-core/src/map_file.rs @@ -237,6 +237,9 @@ impl TryFrom for Board { solid: t.solid, opaque: t.opaque, pushable: t.pushable, + // Hand-placed objects are never grab targets; only expanded + // grab archetypes (e.g. gems) set this (see expand_builtin_archetypes). + grab: false, script_name: t.script_name, // Script-backed archetypes are expanded after the board is built // (see `expand_builtin_archetypes` below), not via templates. diff --git a/kiln-core/src/object_def.rs b/kiln-core/src/object_def.rs index 4891c1a..5eb6591 100644 --- a/kiln-core/src/object_def.rs +++ b/kiln-core/src/object_def.rs @@ -49,6 +49,11 @@ pub struct ObjectDef { /// Whether the object can be shoved by a mover. Unused for now (no push /// mechanic yet); defaults to `false`. pub pushable: bool, + /// Whether walking into this object **grabs** it: the player moves onto the + /// cell and the object's `grab()` hook fires (the object is expected to + /// remove itself via `die()`). Set when a grab archetype (e.g. a gem) is + /// expanded into an object. Defaults to `false`. + pub grab: bool, /// Name of the Rhai script in [`Board::scripts`] that drives this object. /// `None` means this object has no script yet. pub script_name: Option, @@ -93,6 +98,7 @@ impl ObjectDef { solid: true, opaque: true, pushable: false, + grab: false, script_name: None, builtin_script: None, tags: HashSet::new(), diff --git a/kiln-core/src/script.rs b/kiln-core/src/script.rs index 458b58f..d6e3710 100644 --- a/kiln-core/src/script.rs +++ b/kiln-core/src/script.rs @@ -8,6 +8,8 @@ //! - `tick(dt)` — run every frame with the elapsed seconds (see [`ScriptHost::run_tick`]). //! - `bump(id)` — run when another mover steps into this object's cell, with the //! bumper's object index (`-1` for the player); see [`ScriptHost::run_bump`]. +//! - `grab()` — run when the player walks onto (or pushes into themselves) a +//! `grab` object; see [`ScriptHost::run_grab`]. Typically adds a stat + `die()`s. //! //! ## Script constants //! @@ -55,7 +57,7 @@ //! `move(dir)`, `delay(secs)`, `now()`, `set_tile(n)`, `log(msg)`, `say(msg)`, //! `set_fg(fg)`, `set_bg(bg)`, `set_color(fg, bg)`, `set_tag(target, tag, present)`, //! `send(target_id, fn_name [, arg])`, `teleport(x, y)`, `push(x, y, dir)`, -//! `swap([[src_x, src_y, dst_x, dst_y], …])` +//! `swap([[src_x, src_y, dst_x, dst_y], …])`, `add_gems(n)`, `die()` //! //! ## Queue API //! @@ -106,6 +108,7 @@ struct CompiledScript { has_init: bool, has_tick: bool, has_bump: bool, + has_grab: bool, } /// The runtime state of one scripted object. @@ -122,11 +125,7 @@ struct ObjectRuntime { /// built-in (so identical built-ins share one compiled AST), or the world-pool /// name for a named script. `None` if the object has no script. fn script_key(obj: &ObjectDef) -> Option { - if let Some(src) = obj.builtin_script { - Some(src.to_string()) - } else { - obj.script_name.clone() - } + obj.script_name.clone() } // ── Rhai types exposed to scripts ──────────────────────────────────────────── @@ -266,6 +265,7 @@ impl ScriptHost { has_init: defines("init", 0), has_tick: defines("tick", 1), has_bump: defines("bump", 1), + has_grab: defines("grab", 0), ast, }, ); @@ -356,6 +356,48 @@ impl ScriptHost { self.drain(i, 0.0); } + /// Calls `grab()` on the object with [`ObjectId`] `object_id`, if it defines the + /// hook, then drains its queue with `dt = 0`. + /// + /// Fired when the player walks onto a grab object or a grab object is pushed + /// into the player (see [`GameState`](crate::game::GameState)). The hook + /// typically increments a player stat and removes the object via `die()`. + pub fn run_grab(&mut self, object_id: ObjectId) { + let Some(i) = self.objects.iter().position(|o| o.object_id == object_id) else { + return; + }; + { + let Self { + engine, + scripts, + objects, + errors, + .. + } = self; + let obj = &mut objects[i]; + let Some(compiled) = scripts.get(&obj.script_key) else { + return; + }; + if !compiled.has_grab { + return; + } + let options = CallFnOptions::default().with_tag(object_id as i64); + if let Err(err) = engine.call_fn_with_options::<()>( + options, + &mut obj.scope, + &compiled.ast, + "grab", + (), + ) { + errors.borrow_mut().push(LogLine::error(format!( + "script '{}' grab error: {err}", + obj.script_key + ))); + } + } + self.drain(i, 0.0); + } + /// Calls the named function on the object with [`ObjectId`] `target_id`. /// /// If `arg` is `Some` and the function accepts one parameter, the arg is passed. @@ -689,8 +731,9 @@ fn register_read_api( }); // can_shift(x, y, dir) — like can_push but inspects only the cell ahead: (x, y) - // holds a pushable and the next cell is empty or another pushable. False - // off-board. The right gate for a simultaneous shift/rotation via swap(). + // holds a pushable and the next cell is empty or another pushable. Shifting + // onto the player counts only when the source is a grab thing (it gets + // grabbed). False off-board. The right gate for a shift/rotation via swap(). let b = board.clone(); engine.register_fn("can_shift", move |x: i64, y: i64, dir: Direction| -> bool { let board = b.borrow(); @@ -706,6 +749,15 @@ fn register_read_api( board.in_bounds((x as i32, y as i32)) && board.is_passable(x as usize, y as usize) }); + // combinable(x1, y1, x2, y2) — true if the solids at (x1, y1) and (x2, y2) can coexist in a cell + // (meaning, either one contains no solid, or one contains a grab solid and the other contains the + // player). Off-board is not combinable with anything. + let b = board.clone(); + engine.register_fn("combinable", move |x1: i64, y1: i64, x2: i64, y2: i64| -> bool { + let board = b.borrow(); + board.is_combinable(x1 as usize, y1 as usize, x2 as usize, y2 as usize) + }); + // Board.tagged(tag) -> Array[ObjectInfo] let b = board.clone(); engine.register_fn( @@ -841,6 +893,18 @@ fn register_write_api(engine: &mut Engine, queues: &QueueMap) { emit(&q, source_of(&ctx), Action::SetTile(tile as u32)); }); + // add_gems(n): change the player's gem count (negative subtracts; clamped at 0). + let q = queues.clone(); + engine.register_fn("add_gems", move |ctx: NativeCallContext, n: i64| { + emit(&q, source_of(&ctx), Action::AddGems(n)); + }); + + // die(): remove the calling object from the board. + let q = queues.clone(); + engine.register_fn("die", move |ctx: NativeCallContext| { + emit(&q, source_of(&ctx), Action::Die); + }); + let q = queues.clone(); engine.register_fn( "log", diff --git a/kiln-core/src/scripts/gem.rhai b/kiln-core/src/scripts/gem.rhai new file mode 100644 index 0000000..f10dc1a --- /dev/null +++ b/kiln-core/src/scripts/gem.rhai @@ -0,0 +1,9 @@ +// Built-in script for the `gem` archetype (see kiln-core/src/builtin_scripts.rs). +// +// A gem is a grabbable collectible: walking onto it (or pushing it into the +// player) fires this `grab()` hook instead of blocking. We bump the player's gem +// count and remove ourselves from the board. +fn grab() { + add_gems(1); + die(); +} diff --git a/kiln-core/src/scripts/spinner.rhai b/kiln-core/src/scripts/spinner.rhai index 358e514..4983218 100644 --- a/kiln-core/src/scripts/spinner.rhai +++ b/kiln-core/src/scripts/spinner.rhai @@ -68,9 +68,15 @@ fn tick(dt) { let changed = false; for i in 0..8 { let n = (i + step) % 8; + let pn = (i + step - 1) % 8; let dx = ox + ring[n][0]; let dy = oy + ring[n][1]; - if moves[i] && !passable(dx, dy) && !moves[n] { + let sx = ox + ring[pn][0]; + let sy = oy + ring[pn][1]; + + let blocked = !passable(dx, dy) && !combinable(sx, sy, dx, dy); + + if moves[i] && blocked && !moves[n] { moves[i] = false; changed = true; } diff --git a/kiln-core/src/utils.rs b/kiln-core/src/utils.rs index 3a1385b..72f454c 100644 --- a/kiln-core/src/utils.rs +++ b/kiln-core/src/utils.rs @@ -2,6 +2,7 @@ use crate::archetype::Archetype; use crate::glyph::Glyph; use color::Rgba8; use rhai::Dynamic; +use crate::Board; /// Which directions a solid may be pushed in. /// @@ -51,6 +52,11 @@ pub struct Behavior { pub opaque: bool, /// Which directions a mover can shove this cell in (only meaningful when `solid`). pub pushable: Pushable, + /// Whether walking into this solid **grabs** it instead of being blocked: the + /// player passes onto the cell and the thing's `grab()` script hook fires (and + /// the thing is expected to remove itself via `die()`). Only meaningful when + /// `solid`. The same grab fires if the thing is pushed into the player. + pub grab: bool, } /// A stable, unique identifier for a board object. @@ -77,6 +83,22 @@ pub enum Solid { Object(ObjectId), } +impl Solid { + pub fn player(&self) -> bool { + matches!(self, Solid::Player) + } + + pub fn grab(&self, board: &Board) -> bool { + match self { + Solid::Player => false, + Solid::Cell(arch) => arch.behavior().grab, + Solid::Object(id) => { + board.objects.get(id).map_or(false, |obj| obj.grab) + } + } + } +} + /// A portal that teleports the player to a named entry point on another board. /// /// Portals are loaded from `[[portals]]` entries in `.toml` map files and diff --git a/kiln-tui/CLAUDE.md b/kiln-tui/CLAUDE.md index 1005dfd..44c2227 100644 --- a/kiln-tui/CLAUDE.md +++ b/kiln-tui/CLAUDE.md @@ -22,7 +22,7 @@ Renders the board as text: each `Glyph.tile` index is reinterpreted as a charact **`kiln-tui/src/editor.rs`** — world editor mode: - `EditorState` — a non-ticking editing session over a freshly reloaded `World`: `world`, `board_name` (board being edited), `menu: Vec` (sidebar menu stack, for breadcrumb + escape-to-parent), `dialog: Option>`, `code_editor: Option` (the open script editor; replaces the board view), `glyph_dialog: Option>` (the open glyph picker overlay), a blinking `cursor`, the **drawing tool** (`current_archetype` + `current_glyph` — the thing stamped on `space`, defaulting to a wall — and `draw_mode`, the toggle that re-stamps on every cursor move), `sidebar_width` (mouse-resizable), blink state, `last_board_area` (written at draw, read for right-click hit-testing), editor-side `log`, and `pending_playtest: Option` (a playtest game parked for the run loop to swap into `Mode::Play`). -- `MenuLevel` (`Main`/`World`/`Floor`/`Terrain`/`Machines`/`Pushers`) — a sidebar menu level; `title()` (breadcrumb segment) and `entries() -> Vec` (the level's lines). A `MenuEntry` is a key-activated `Item` (`[k] Label` + a boxed `FnOnce(&mut EditorState)` action), a `CurrentValue` (a boxed `Fn(&EditorState) -> String` shown indented beneath an item, e.g. the world name), or a `Blank`/`Separator` spacer. An item's action **opens a dialog** (`World`/scripts/boards), **pushes a child level** (`Main` → `World`/`Floor`/`Terrain`/`Machines`; `Machines` → `Pushers`), **sets the drawing tool** (`Terrain`/`Pushers` → `set_current(arch)`, plus `Machines` → `[s]` CW / `[c]` CCW spinner), or **launches a playtest** (`Main` → `[p] Play board` → `playtest()`). The menu is a static letter-keyed stack — picking from a list is always a dialog, so arrow keys never conflict with the board cursor. +- `MenuLevel` (`Main`/`World`/`Floor`/`Terrain`/`Machines`/`Pushers`/`Items`) — a sidebar menu level; (`Main` → `[i] Items` → `[g] ♦ Gem`, which `set_current(Archetype::Gem)`); `title()` (breadcrumb segment) and `entries() -> Vec` (the level's lines). A `MenuEntry` is a key-activated `Item` (`[k] Label` + a boxed `FnOnce(&mut EditorState)` action), a `CurrentValue` (a boxed `Fn(&EditorState) -> String` shown indented beneath an item, e.g. the world name), or a `Blank`/`Separator` spacer. An item's action **opens a dialog** (`World`/scripts/boards), **pushes a child level** (`Main` → `World`/`Floor`/`Terrain`/`Machines`; `Machines` → `Pushers`), **sets the drawing tool** (`Terrain`/`Pushers` → `set_current(arch)`, plus `Machines` → `[s]` CW / `[c]` CCW spinner), or **launches a playtest** (`Main` → `[p] Play board` → `playtest()`). The menu is a static letter-keyed stack — picking from a list is always a dialog, so arrow keys never conflict with the board cursor. - Methods: `breadcrumb()`, `current_menu()`, `menu_escape(ui)` (pop a level, or at the root open the overlay `editor_menu_items()`), `menu_key(c)` (dispatch a letter → the matched `entries()` item's action via `MenuLevel::perform_key`), `playtest()` (deep-clones the world, sets its start to the edited board, **expands script-backed archetypes** in every board via `Board::expand_builtin_archetypes` so editor-stamped spinners/pushers run, builds a `GameState` + runs `init()`, and parks it in `pending_playtest` for the run loop), and the `open_{name,entry,scripts,boards}_dialog` builders (name → text dialog writing `world.name`; entry → list dialog writing `world.start`; boards → select-only; scripts → **opens the script in `code_editor`**). `open_script_editor(name)` builds a `CodeEditor` from `world.scripts[name]`; `close_script_editor()` saves its text back into `world.scripts` (in-memory, like the other dialogs). - Drawing: `set_current(arch)` sets `current_archetype` and resets `current_glyph` to its default; `open_glyph_picker()` seeds a `GlyphDialog` from `current_glyph` and writes the chosen glyph back (bound to **`g`**); `place_current()` stamps the current archetype+glyph at the cursor via `Board::place_archetype`; `toggle_draw_mode()` flips `draw_mode`. `place_current` is bound to **`space`** and `toggle_draw_mode` to **`tab`** in `handle_editor_input`; `move_cursor`/`set_cursor_at_screen` also call `place_current` when `draw_mode` is on and the cursor enters a new cell. The sidebar's bottom **drawing-controls footer** (`draw_footer_lines`) shows the archetype name, `[g] Glyph` + a live colored preview, `[spc] Place`, and `[tab] Draw mode (on/off)`. - `editor_menu_items()` — the overlay editor menu (`[p]` play, `[q]` quit, `[esc]` resume), opened at the root of the menu tree. `handle_dialog_input(event, ed)` — forwards to the open dialog and, on `Submit`/`Cancel`, `take`s it out and calls `finish(.., ed)`. `handle_glyph_dialog_input(event, ed)` — the same pattern for the open `glyph_dialog`. `handle_code_editor_input(event, ed)` — forwards to the open code editor and, on `Exit` (Esc), calls `close_script_editor()`. `draw_editor(frame, ed, ui)` / `editor_layout(..)` — the **code editor (when open) else** the board (with blinking cursor + coord readout) in the left area, a resizable right-hand sidebar (breadcrumb title + the menu choices, each with its optional current-value line), and the optional full-width log panel. @@ -61,7 +61,7 @@ Renders the board as text: each `Glyph.tile` index is reinterpreted as a charact - `board_screen_pos(area, board, bx, by) -> Option<(u16, u16)>` — converts a board cell coordinate to terminal screen coordinates, returning `None` if off-screen. Used by bubble placement. **`kiln-tui/src/status.rs`** — play-mode status sidebar widget: -- `StatusSidebarWidget` — a `ratatui::widgets::Widget` built with `new(health, gems)` that draws the player's stats in a bordered `Block` titled `Status`: a `Health:` label above a row of `MAX_HEARTS` (5) `♥` glyphs (first `health` bright red, rest dark red) and a `Gems: ♦ N` line (gem glyph blue). Purely presentational — reads the values handed in, never mutates game state. Drawn by `draw_play` when `ui.show_status` is set; `i` toggles it. +- `StatusSidebarWidget` — a `ratatui::widgets::Widget` built with `new(health, gems)` that draws the player's stats in a bordered `Block` titled `Status`: a `Health:` label above a row of `MAX_HEARTS` (5) `♥` glyphs (first `health` bright red, rest dark red) and a `Gems: ♦ N` line. The gem indicator is rendered from `kiln_core::Archetype::Gem.default_glyph()` (char via `cp437::tile_to_char`, color via `rgba8_to_color`) so it matches gems on the board — not a hardcoded glyph/color. Purely presentational — reads the values handed in, never mutates game state. Drawn by `draw_play` when `ui.show_status` is set; `Tab` toggles it. **`kiln-tui/src/log.rs`** — log panel widget: - `LogState { open, height, scroll }` — panel visibility, height in rows, and scroll offset. `toggle()`, `scroll_by(delta, log_len)`, `resize(target, total)`. diff --git a/kiln-tui/src/editor_menu.rs b/kiln-tui/src/editor_menu.rs index efc2050..615af32 100644 --- a/kiln-tui/src/editor_menu.rs +++ b/kiln-tui/src/editor_menu.rs @@ -26,6 +26,8 @@ pub(crate) enum MenuLevel { Machines, /// Various directions of pushers Pushers, + /// Collectible items the player picks up (e.g. gems) + Items, } impl MenuLevel { @@ -38,6 +40,7 @@ impl MenuLevel { MenuLevel::Terrain => "Terrain", MenuLevel::Machines => "Machines", MenuLevel::Pushers => "Pushers", + MenuLevel::Items => "Items", } } @@ -54,6 +57,7 @@ impl MenuLevel { MenuEntry::item('f', "Floor", |ed| ed.menu.push(MenuLevel::Floor)), MenuEntry::item('t', "Terrain", |ed| ed.menu.push(MenuLevel::Terrain)), MenuEntry::item('m', "Machines", |ed| ed.menu.push(MenuLevel::Machines)), + MenuEntry::item('i', "Items", |ed| ed.menu.push(MenuLevel::Items)), ], MenuLevel::World => vec![ MenuEntry::item('n', "Name", |ed| ed.open_name_dialog()), @@ -96,6 +100,10 @@ impl MenuLevel { ed.set_current(Archetype::Pusher(Direction::West)) }), ], + MenuLevel::Items => vec![MenuEntry::item('t', "♦ Gem", |ed| { + // gem and glyph start with the same letter + ed.set_current(Archetype::Gem) + })], } } diff --git a/kiln-tui/src/status.rs b/kiln-tui/src/status.rs index 3fcd432..2e1f2aa 100644 --- a/kiln-tui/src/status.rs +++ b/kiln-tui/src/status.rs @@ -5,6 +5,9 @@ //! presentational: it reads `health`/`gems` values handed in at construction and //! never mutates game state. +use crate::utils::rgba8_to_color; +use kiln_core::Archetype; +use kiln_core::cp437::tile_to_char; use ratatui::buffer::Buffer; use ratatui::layout::Rect; use ratatui::style::{Color, Style}; @@ -18,8 +21,6 @@ const MAX_HEARTS: u32 = 5; const HEART_FULL: Color = Color::Rgb(255, 0, 0); /// A depleted heart: dark red. const HEART_EMPTY: Color = Color::Rgb(90, 0, 0); -/// The gem glyph color: blue. -const GEM: Color = Color::Rgb(80, 80, 255); /// A ratatui widget that renders the play-mode status sidebar. /// @@ -51,13 +52,19 @@ impl Widget for StatusSidebarWidget { }) .collect(); + // Draw the gem indicator from the gem archetype's default glyph, so the + // sidebar matches what gems look like on the board (no hardcoded ♦/color). + let gem_glyph = Archetype::Gem.default_glyph(); + let gem_char = tile_to_char(gem_glyph.tile).to_string(); + let gem_style = Style::default().fg(rgba8_to_color(gem_glyph.fg)); + let lines = vec![ Line::from("Health:"), Line::from(hearts), Line::from(""), Line::from(vec![ Span::raw("Gems: "), - Span::styled("♦", Style::default().fg(GEM)), + Span::styled(gem_char, gem_style), Span::raw(format!(" {}", self.gems)), ]), ]; diff --git a/maps/start.toml b/maps/start.toml index 28cb682..6f56325 100644 --- a/maps/start.toml +++ b/maps/start.toml @@ -225,8 +225,8 @@ content = """ # | # # # # V oo G - @ # -# # -# # +# /# # +# t # # # # >| # # # @@ -252,6 +252,8 @@ content = """ "V" = { kind = "object", tile = 1, fg = "#33aa33", bg = "#000000", script_name = "mover" } "M" = { kind = "object", tile = 15, fg = "#ffdd88", bg = "#000000", solid = true, name = "muffin", script_name = "muffin" } "B" = { kind = "object", tile = 240, fg = "#cc9944", bg = "#000000", solid = true, name = "noticeboard", script_name = "noticeboard" } +"/" = { kind = "spinner_cw" } +"t" = { kind = "gem" } # Layer 2: a purely decorative, non-solid object drawn *above* the solid crate # beneath it — only possible because draw order follows layer order.