Struct Board 

pub struct Board { /* private fields */ }

The entire game state. No engine types, no floats, no hash maps: every tick is a pure function of prior state plus one action per seat, so the same seed and input list replays bit-identically on any platform.

Implementations

impl Board

pub fn spawn_crab( &mut self, x: u8, y: u8, dir: Direction, handed: Handedness, kind: CrabKind, )

Place a crab directly (puzzle setups and tests; spawner tiles handle the normal case). The crab immediately wall-resolves so it never starts a tick facing a wall.

impl Board

pub fn force_lure(&mut self, owner: PlayerId)

Start a lure for owner, as banking a molting crab does.

Same reason as Self::force_tide_event: the dev hook and the tests need one on demand, and waiting for a molt to turn up and be banked is not a thing a screenshot can do.

pub fn force_tide_event(&mut self, event: TideEvent, banker: PlayerId)

Fire a named tide event outright. The roulette is the only caller in play; this exists for the dev hook that has to show one on demand, and for the tests, which cannot wait for a sparkling crab.

impl Board

pub fn step(&self, tile: u16, dir: Direction) -> Option<u16>

The tile one step away in dir, if there is one: across the seam on a wrapping arena, None off the edge otherwise. The public face of Board::neighbor for callers outside the board: the bot plans on the same beach the crabs walk, seam included.

pub fn coords(&self, tile: u16) -> (i32, i32)

Tile index to (x, y), in the i32 the movement arithmetic speaks; Board::coords_u8 is the byte-sized form. Forwards to the grid, which owns the arithmetic.

pub fn index_of(&self, x: u8, y: u8) -> u16

(x, y) back to the tile index, the inverse of Board::coords_u8.

impl Board

pub fn gull_may_stand(&self, x: u8, y: u8) -> bool

Whether a gull can be put down on (x, y): sand, not rock and not kelp, which a gull’s feet cannot reach through. The one rule every placer asks (spawn_gull asserts it) so a level file, a pasted code and the editor’s brush cannot disagree with the sim about where a bird may stand.

pub fn spawn_gull(&mut self, x: u8, y: u8, dir: Direction)

Drop a gull onto the board, walking. Used by level setup and the periodic edge spawner.

impl Board

pub fn state_hash(&self) -> u64

Fingerprint of the complete simulation state, in a fixed field order. Two boards fed the same seed and inputs must agree on this after every tick, on every platform: the determinism contract of spec §7.5.

impl Board

pub fn can_place_signpost(&self, player: PlayerId, x: u8, y: u8) -> bool

Whether a placement at (x, y) would succeed, without mutating. Mirrors Board::place_signpost exactly; the UI uses it for instant denied feedback on a queued (not yet applied) action.

pub fn out_of_signposts(&self, player: PlayerId, x: u8, y: u8) -> bool

Whether a refusal at (x, y) is the inventory talking rather than the tile: the player has spent their posts and this board rejects rather than evicts.

The one branch of Board::can_place_signpost a player can fix by picking up a signpost instead of by aiming somewhere else, and the UI says so differently. Read off the same rule so the two cannot drift: under Evict this is never true, because the placement succeeds and takes the oldest in trade.

pub fn place_signpost( &mut self, player: PlayerId, x: u8, y: u8, dir: Direction, ) -> bool

Spec §3.3: signposts go on empty sand only, not on castles, rocks, spawners, or a tile that already has one. At the cap, the outcome depends on the board’s CapPolicy: evict the player’s oldest (versus) or reject the placement (puzzle inventory).

pub fn signpost_fade(&self, sp: &Signpost) -> f32

Remaining life of a signpost as a 0..=1 fraction (always 1 under puzzle rules, where posts are permanent).

pub fn newest_signpost_of(&self, player: PlayerId) -> Option<(u8, u8, u64)>

Where a player’s most recent signpost stands and when they placed it: (x, y, tick).

This is the anchor for a bot’s cursor (see crate::sim::bot_action): the last tile it reached, so the walk to the next one can be charged for. Reading it from the board keeps the bot a pure function of the state, so every peer of an online match derives the same move for an AI seat.

pub fn signpost_count(&self, player: PlayerId) -> usize

How many signposts player currently has on the board.

pub fn remove_signpost(&mut self, player: PlayerId, x: u8, y: u8) -> bool

Players may only remove their own signposts.

pub fn signpost_at(&self, x: u8, y: u8) -> Option<Signpost>

pub fn signpost_rule(&self) -> (u8, CapPolicy)

The current signpost cap rule, for serialization.

impl Board

pub fn to_snapshot(&self) -> String

The whole board as text.

pub fn parse_snapshot(text: &str) -> Result<Board, String>

Read a snapshot back, or say why it is not one.

Strict where the level format is lenient: a snapshot is written by this build for this build, so a line it cannot read is a corrupt save rather than a hand edit to shrug at.

impl Board

pub fn new(width: u8, height: u8, seed: u64) -> Board

An empty all-sand board with walled borders (spec §3.1; wrap-around edges are a later, flag-gated variant).

pub fn set_wall(&mut self, x: u8, y: u8, dir: Direction, present: bool)

Add or remove the wall on the dir side of tile (x, y). Walls are stored per-edge, so the neighbouring tile sees the same wall and the two tiles cannot disagree (spec §7.3).

pub fn set_tile(&mut self, x: u8, y: u8, kind: TileKind)

pub fn set_castle_raids(&mut self, raids: bool)

Let gulls into the castles, or keep them out. See castle_raids.

pub fn castle_raids(&self) -> bool

pub fn set_signpost_rule(&mut self, cap: u8, policy: CapPolicy)

Change the signpost cap and what happens at it. Versus keeps the default (3, evict-oldest); puzzle mode sets (inventory, reject).

pub fn set_gull_period(&mut self, period: u32)

Auto-spawn a gull every period ticks (0 disables). Doubled during the final-scramble surge of a timed round.

pub fn set_round_length(&mut self, ticks: Option<u32>)

pub fn set_wrap(&mut self, wrap: bool)

Open (or close) the board edges. Opening removes the border walls so creatures walk and fly off one side and re-enter on the opposite one.

pub fn wrap(&self) -> bool

pub fn events_enabled(&self) -> bool

Enable tide events (the sparkling crab’s roulette). Off by default: puzzles and goal-checked challenges stay predictable.

pub fn set_events_enabled(&mut self, enabled: bool)

pub fn last_event(&self) -> Option<(TideEvent, u64)>

The most recent tide event and when it fired.

pub fn golden_banked(&self) -> u32

pub fn set_score(&mut self, player: PlayerId, score: u32)

Preload a score (editor, sandboxes, tests). Not used by live play: scores otherwise change only through banking and gull raids. A seat that does not exist takes no score: the callers that parse untrusted text already refuse it with a message, and this is the backstop.

pub fn tick(&mut self, actions: &[PlayerAction; 6])

Advance one fixed 30 Hz step. Order within a tick is fixed and part of the ruleset: player actions (in the tick’s rotating seat order; on a same-tile conflict, whoever that order reaches first wins), then spawners, then crab movement, then gull movement, then gulls eat, in stable creature order throughout. A signpost placed this tick affects crabs arriving this tick. Once the tide is in (round_over), the sim is frozen and ticks are no-ops: scores locked at the wave (spec §3.6).

pub fn seats_in_play(&self) -> u8

How many seats this board seats: one past the highest castle owner, so a four-castle beach rotates ties among four however wide the arrays.

pub fn round_over(&self) -> bool

The tide has come in: the round is finished and the sim is frozen.

pub fn remaining_ticks(&self) -> Option<u64>

Ticks left before the wave, if a round timer is set.

pub fn in_surge(&self) -> bool

The final scramble: the last 30 s of a timed round, when gulls spawn at double rate.

pub fn tick_idle(&mut self)

Advance one step with no player input.

pub fn width(&self) -> u8

pub fn height(&self) -> u8

pub fn ticks(&self) -> u64

pub fn crabs(&self) -> &[Crab]

pub fn gulls(&self) -> &[Gull]

pub fn gull_period(&self) -> u32

pub fn round_length(&self) -> Option<u32>

pub fn seed(&self) -> u64

The seed this board was constructed with.

pub fn remove_crabs_at(&mut self, x: u8, y: u8)

Remove every crab standing on tile (x, y) (editor use).

pub fn remove_gulls_at(&mut self, x: u8, y: u8)

Remove every gull standing on tile (x, y) (editor use).

pub fn lure(&self) -> Option<(PlayerId, u32)>

Active molting lure, if any: (luring player, ticks left).

pub fn crabs_banked(&self) -> u32

Crabs banked since the start, all players combined.

pub fn swept_home(&self, crab: u32) -> Option<PlayerId>

The seat a crab was banked for by the tide, if it was one of those rather than one that walked home.

The render layer’s question, and the only reason Board keeps the record at all: a crab that vanished off open sand looks eaten from the outside, and half the time a Monopoly fires it is the opposite of eaten.

pub fn crabs_spawned(&self) -> u32

Crabs ever spawned (initial, spawner-emitted, and castle-spilled).

pub fn scores(&self) -> &[u32; 6]

pub fn tile_at(&self, x: u8, y: u8) -> TileKind

pub fn tiles(&self) -> impl Iterator<Item = (u8, u8, TileKind)> + '_

Every tile with its coordinates, in the board’s own row-major order.

pub fn castle_of(&self, player: PlayerId) -> Option<(u8, u8)>

Where a seat’s castle stands, if it has one.

pub fn castle_owners(&self) -> impl Iterator<Item = PlayerId> + '_

The highest seat number with a castle on the board: the seat count a recorded board implies.

pub fn castle_seats(&self) -> u8

How many seats the board has castles for, counted by owner rather than by castle: a beach seats as many players as there are banks to run for. What the map dial measures a handmade beach against.

pub fn first_signpost_of(&self, player: PlayerId) -> Option<(u8, u8)>

The first signpost owned by player in reading order (top-left to bottom-right), as tile coordinates. Drives the “clear one” input.

pub fn coords_u8(&self, tile: u16) -> (u8, u8)

Tile index back to coordinates. Board::coords speaks i32 for the movement arithmetic; this is the public-facing form.

pub fn wall_at(&self, x: u8, y: u8, dir: Direction) -> bool

Trait Implementations

impl Clone for Board

fn clone(&self) -> Board

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Board

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.