refactoring

kiln-core/src/utils.rs

@@ -0,0 +1,113 @@
+use serde::{Deserialize, Serialize};
+use crate::archetype::Archetype;
+use crate::script::Direction;
+
+/// Which directions a solid may be pushed in.
+///
+/// Only meaningful for `solid` cells (a non-solid cell is passable, so nothing is
+/// ever pushed into it). `Crate` is [`Pushable::Any`]; the directional crates
+/// constrain pushes to one axis.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum Pushable {
+    /// Cannot be pushed.
+    No,
+    /// Pushable in any direction.
+    Any,
+    /// Pushable east/west only.
+    Horizontal,
+    /// Pushable north/south only.
+    Vertical,
+}
+
+impl Pushable {
+    /// Whether a push in `dir` is allowed.
+    pub fn allows(self, dir: Direction) -> bool {
+        match self {
+            Pushable::No => false,
+            Pushable::Any => true,
+            Pushable::Horizontal => matches!(dir, Direction::East | Direction::West),
+            Pushable::Vertical => matches!(dir, Direction::North | Direction::South),
+        }
+    }
+}
+
+/// The behavioral properties of a board cell at runtime.
+///
+/// `Behavior` is a plain data struct returned by [`Archetype::behavior`]. It
+/// contains the properties the engine needs to simulate a cell — currently
+/// solidity, opacity, and pushability. Future properties (shootable, etc.) can
+/// be added here without changing call sites.
+///
+/// For scripted objects, solidity and opacity are stored directly on
+/// [`ObjectDef`] and will eventually be overridable by Rhai scripts at runtime.
+#[derive(Copy, Clone, Debug)]
+pub struct Behavior {
+    /// Whether this cell blocks / participates in movement. A solid cell stops a
+    /// mover (and is the only kind of cell that can later be pushed or receive a
+    /// collision event). This is the inverse of the old `passable` flag.
+    pub solid: bool,
+    /// Whether this cell blocks line of sight (reserved for future rendering).
+    pub opaque: bool,
+    /// Which directions a mover can shove this cell in (only meaningful when `solid`).
+    pub pushable: Pushable,
+}
+
+/// A stable, unique identifier for a board object.
+///
+/// Ids are handed out by [`Board::add_object`] from the per-board
+/// [`Board::next_object_id`] counter (starting at 1) and never reused, so a
+/// reference to an object stays valid even as other objects are added or removed.
+/// This replaces the old "index into `Board::objects`" scheme, which shifted when
+/// objects were reordered/destroyed.
+pub type ObjectId = u32;
+
+/// The single solid occupant of a board cell, returned by [`Board::solid_at`].
+///
+/// At most one solid — the player, a grid [`Archetype`], *or* an [`ObjectDef`] — may
+/// occupy a cell (the invariant enforced at load time), so this represents the one
+/// thing a mover would collide with there.
+pub enum Solid {
+    /// The player occupies the cell. The player is solid (it blocks movers) and
+    /// pushable in any direction (see [`Board::is_pushable`]).
+    Player,
+    /// The cell's grid archetype is itself solid (e.g. [`Archetype::Wall`]).
+    Cell(Archetype),
+    /// A solid [`ObjectId`] occupies the cell.
+    Object(ObjectId),
+}
+
+/// 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
+/// stored on [`Board`]. When the player steps onto a portal's cell, they
+/// should be moved to `target_entry` on the board named by `target_map`.
+///
+/// **Not yet runtime-wired.** Portal navigation (multi-board loading and
+/// switching) is a future feature.
+#[derive(Deserialize, Serialize)]
+pub struct PortalDef {
+    /// Column of this portal on the board (0-indexed).
+    pub x: usize,
+    /// Row of this portal on the board (0-indexed).
+    pub y: usize,
+    /// File name (without extension) of the target board, e.g. `"cave"`.
+    pub target_map: String,
+    /// Named entry point on the target board where the player arrives.
+    pub target_entry: String,
+}
+
+/// The player's current position on the board.
+///
+/// The player is currently a special entity rendered on top of the board
+/// rather than being stored as a board cell. This is expected to change:
+/// the player will eventually become a scripted object that responds to
+/// input events, at which point this struct may be removed or made optional.
+/// See the "player may become an object" notes in `CLAUDE.md` for the design
+/// tensions this implies.
+#[derive(Copy, Clone)]
+pub struct Player {
+    /// Column position (0-indexed, increasing rightward).
+    pub x: i32,
+    /// Row position (0-indexed, increasing downward).
+    pub y: i32,
+}