@crowdedkingdoms/ckx-kit 0.3.0-dev.1 → 0.4.0-dev.1

package/crates/ckx-sdk/src/kit/ai/path.rs

@@ -0,0 +1,214 @@
+//! Budget-capped A* over a pluggable cost provider. Under the platform's fuel
+//! metering A* costs a little more than natively; the budget cap keeps a
+//! pathological query from eating a call's fuel.
+
+/// Walkability/cost source. Implement over your world representation
+/// (obstacle grids, voxel columns, nav data in a hub's state).
+pub trait CostProvider {
+    /// Cost to ENTER (x, z); `None` = blocked. Uniform worlds return Some(1).
+    fn cost(&self, x: i32, z: i32) -> Option<u32>;
+}
+
+/// A grid of booleans (true = blocked) — the simplest provider, also the
+/// test fixture.
+pub struct GridProvider<'a> {
+    pub width: i32,
+    pub height: i32,
+    pub blocked: &'a dyn Fn(i32, i32) -> bool,
+}
+
+impl CostProvider for GridProvider<'_> {
+    fn cost(&self, x: i32, z: i32) -> Option<u32> {
+        if x < 0 || z < 0 || x >= self.width || z >= self.height || (self.blocked)(x, z) { None } else { Some(1) }
+    }
+}
+
+pub struct PathConfig {
+    /// Max nodes expanded before giving up (the fuel guard). ~4x the
+    /// manhattan distance is plenty for sane worlds.
+    pub max_expanded: usize,
+}
+
+impl Default for PathConfig {
+    fn default() -> Self {
+        Self { max_expanded: 4_096 }
+    }
+}
+
+/// 4-connected A*. Returns the path INCLUDING both endpoints, or empty when
+/// unreachable / budget-exhausted / endpoints blocked.
+pub fn a_star(provider: &impl CostProvider, from: (i32, i32), to: (i32, i32), config: &PathConfig) -> Vec<(i32, i32)> {
+    use std::collections::{BTreeMap, BinaryHeap};
+
+    if provider.cost(from.0, from.1).is_none() || provider.cost(to.0, to.1).is_none() {
+        return Vec::new();
+    }
+    if from == to {
+        return vec![from];
+    }
+
+    #[derive(PartialEq, Eq)]
+    struct Entry {
+        f: u32,
+        pos: (i32, i32),
+    }
+    impl Ord for Entry {
+        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            other.f.cmp(&self.f) // min-heap
+        }
+    }
+    impl PartialOrd for Entry {
+        fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+            Some(self.cmp(other))
+        }
+    }
+
+    let h = |p: (i32, i32)| p.0.abs_diff(to.0) + p.1.abs_diff(to.1);
+    let mut open = BinaryHeap::new();
+    let mut g: BTreeMap<(i32, i32), u32> = BTreeMap::new();
+    let mut came: BTreeMap<(i32, i32), (i32, i32)> = BTreeMap::new();
+    open.push(Entry { f: h(from), pos: from });
+    g.insert(from, 0);
+
+    let mut expanded = 0usize;
+    while let Some(Entry { pos, .. }) = open.pop() {
+        expanded += 1;
+        if expanded > config.max_expanded {
+            return Vec::new();
+        }
+        if pos == to {
+            let mut path = vec![to];
+            let mut cur = to;
+            while let Some(&prev) = came.get(&cur) {
+                path.push(prev);
+                cur = prev;
+            }
+            path.reverse();
+            return path;
+        }
+        let g_here = g[&pos];
+        for (dx, dz) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
+            let next = (pos.0 + dx, pos.1 + dz);
+            let Some(step) = provider.cost(next.0, next.1) else { continue };
+            let tentative = g_here.saturating_add(step);
+            if tentative < *g.get(&next).unwrap_or(&u32::MAX) {
+                g.insert(next, tentative);
+                came.insert(next, pos);
+                open.push(Entry { f: tentative + h(next), pos: next });
+            }
+        }
+    }
+    Vec::new()
+}
+
+/// A route: from, then to.
+type Route = ((i32, i32), (i32, i32));
+
+/// A generation-keyed path cache: repeated queries between the same cells
+/// reuse the stored path until the world changes (`invalidate()` on any
+/// voxel/tower edit bumps the generation and lazily discards entries).
+#[derive(Default)]
+pub struct PathCache {
+    generation: u64,
+    entries: std::collections::BTreeMap<Route, (u64, Vec<(i32, i32)>)>,
+}
+
+impl PathCache {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Drop every cached path (world changed).
+    pub fn invalidate(&mut self) {
+        self.generation += 1;
+        // Lazy: stale entries are ignored on read and overwritten on write;
+        // clear outright when the map has grown past a sane bound.
+        if self.entries.len() > 1024 {
+            self.entries.clear();
+        }
+    }
+
+    /// Cached path or compute-and-store via [`a_star`].
+    pub fn get(&mut self, provider: &impl CostProvider, from: (i32, i32), to: (i32, i32), config: &PathConfig) -> Vec<(i32, i32)> {
+        if let Some((generation, path)) = self.entries.get(&(from, to))
+            && *generation == self.generation
+        {
+            return path.clone();
+        }
+        let path = a_star(provider, from, to, config);
+        self.entries.insert((from, to), (self.generation, path.clone()));
+        path
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn field<'a>(blocked: &'a dyn Fn(i32, i32) -> bool) -> GridProvider<'a> {
+        GridProvider { width: 32, height: 32, blocked }
+    }
+
+    #[test]
+    fn straight_line() {
+        let open = |_x: i32, _z: i32| false;
+        let path = a_star(&field(&open), (0, 0), (5, 0), &PathConfig::default());
+        assert_eq!(path.len(), 6);
+        assert_eq!(path[0], (0, 0));
+        assert_eq!(path[5], (5, 0));
+    }
+
+    #[test]
+    fn routes_around_walls() {
+        // Vertical wall at x=5 with a gap at z=30.
+        let wall = |x: i32, z: i32| x == 5 && z != 30;
+        let path = a_star(&field(&wall), (0, 0), (10, 0), &PathConfig::default());
+        assert!(!path.is_empty());
+        assert!(path.contains(&(5, 30)), "must route through the gap");
+        // No step lands on the wall.
+        assert!(path.iter().all(|&(x, z)| !(x == 5 && z != 30)));
+        // Consecutive steps are 4-connected.
+        for pair in path.windows(2) {
+            let d = (pair[0].0 - pair[1].0).abs() + (pair[0].1 - pair[1].1).abs();
+            assert_eq!(d, 1);
+        }
+    }
+
+    #[test]
+    fn unreachable_and_budget() {
+        let sealed = |x: i32, _z: i32| x == 5; // full wall
+        assert!(a_star(&field(&sealed), (0, 0), (10, 0), &PathConfig::default()).is_empty());
+        let open = |_x: i32, _z: i32| false;
+        let tiny = PathConfig { max_expanded: 3 };
+        assert!(a_star(&field(&open), (0, 0), (20, 20), &tiny).is_empty());
+    }
+
+    #[test]
+    fn blocked_endpoints_and_identity() {
+        let wall = |x: i32, z: i32| x == 0 && z == 0;
+        assert!(a_star(&field(&wall), (0, 0), (5, 5), &PathConfig::default()).is_empty());
+        let open = |_x: i32, _z: i32| false;
+        assert_eq!(a_star(&field(&open), (3, 3), (3, 3), &PathConfig::default()), vec![(3, 3)]);
+    }
+
+    #[test]
+    fn cache_reuses_until_invalidated() {
+        use std::cell::Cell;
+        let calls = Cell::new(0u32);
+        let counting = |_x: i32, _z: i32| {
+            calls.set(calls.get() + 1);
+            false
+        };
+        let provider = field(&counting);
+        let mut cache = PathCache::new();
+        let config = PathConfig::default();
+        let first = cache.get(&provider, (0, 0), (5, 0), &config);
+        let after_first = calls.get();
+        let second = cache.get(&provider, (0, 0), (5, 0), &config);
+        assert_eq!(first, second);
+        assert_eq!(calls.get(), after_first, "cache hit does no provider work");
+        cache.invalidate();
+        cache.get(&provider, (0, 0), (5, 0), &config);
+        assert!(calls.get() > after_first, "invalidation recomputes");
+    }
+}

package/crates/ckx-sdk/src/kit/ai/steering.rs

@@ -0,0 +1,137 @@
+//! Steering behaviors: pure functions from positions to a bounded step.
+//! A hub calls one per agent per tick and add the result to the pose.
+
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Vec2 {
+    pub x: f32,
+    pub z: f32,
+}
+
+impl Vec2 {
+    pub fn new(x: f32, z: f32) -> Self {
+        Self { x, z }
+    }
+
+    pub fn len(&self) -> f32 {
+        (self.x * self.x + self.z * self.z).sqrt()
+    }
+
+    pub fn to(self, other: Vec2) -> Vec2 {
+        Vec2::new(other.x - self.x, other.z - self.z)
+    }
+
+    pub fn dist(&self, other: Vec2) -> f32 {
+        self.to(other).len()
+    }
+
+    /// Clamp this displacement to at most `max` length.
+    pub fn clamped(self, max: f32) -> Vec2 {
+        let len = self.len();
+        if len <= max || len == 0.0 { self } else { Vec2::new(self.x / len * max, self.z / len * max) }
+    }
+
+    pub fn yaw(&self) -> f32 {
+        self.x.atan2(self.z)
+    }
+}
+
+/// Step toward `target` at up to `speed*dt`, stopping within `stop_at`.
+pub fn seek(pos: Vec2, target: Vec2, speed: f32, dt: f32, stop_at: f32) -> Vec2 {
+    let delta = pos.to(target);
+    if delta.len() <= stop_at {
+        return Vec2::default();
+    }
+    delta.clamped(speed * dt)
+}
+
+/// Step directly away from `threat`.
+pub fn flee(pos: Vec2, threat: Vec2, speed: f32, dt: f32) -> Vec2 {
+    let away = threat.to(pos);
+    if away.len() == 0.0 {
+        return Vec2::new(speed * dt, 0.0);
+    }
+    away.clamped(speed * dt)
+}
+
+/// Seek that decelerates inside `slow_radius` (smooth stops).
+pub fn arrive(pos: Vec2, target: Vec2, speed: f32, dt: f32, slow_radius: f32) -> Vec2 {
+    let delta = pos.to(target);
+    let dist = delta.len();
+    if dist < 0.05 {
+        return Vec2::default();
+    }
+    let eased = if dist < slow_radius { speed * (dist / slow_radius) } else { speed };
+    delta.clamped(eased.max(0.2) * dt)
+}
+
+/// Push away from any neighbor closer than `min_dist` (crowd separation).
+pub fn separate(pos: Vec2, neighbors: &[Vec2], min_dist: f32, speed: f32, dt: f32) -> Vec2 {
+    let mut push = Vec2::default();
+    for n in neighbors {
+        let away = n.to(pos);
+        let d = away.len();
+        if d > 0.0 && d < min_dist {
+            let w = (min_dist - d) / min_dist;
+            push.x += away.x / d * w;
+            push.z += away.z / d * w;
+        }
+    }
+    push.clamped(speed * dt)
+}
+
+/// Return-home pull when beyond `leash_radius`; `None` inside the leash.
+pub fn leash(pos: Vec2, home: Vec2, leash_radius: f32, speed: f32, dt: f32) -> Option<Vec2> {
+    (pos.dist(home) > leash_radius).then(|| seek(pos, home, speed, dt, 0.5))
+}
+
+/// A wander target picker: a point within `range` of `anchor`, clamped to
+/// `bounds` (half-extent box around origin). Pure — feed it your RNG rolls.
+pub fn wander_target(anchor: Vec2, range: f32, roll_x: f32, roll_z: f32, bounds: f32) -> Vec2 {
+    Vec2::new(
+        (anchor.x + (roll_x - 0.5) * 2.0 * range).clamp(-bounds, bounds),
+        (anchor.z + (roll_z - 0.5) * 2.0 * range).clamp(-bounds, bounds),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn seek_stops_and_clamps() {
+        let step = seek(Vec2::new(0.0, 0.0), Vec2::new(10.0, 0.0), 2.0, 0.25, 1.0);
+        assert!((step.x - 0.5).abs() < 1e-6 && step.z == 0.0);
+        assert_eq!(seek(Vec2::new(9.5, 0.0), Vec2::new(10.0, 0.0), 2.0, 0.25, 1.0), Vec2::default());
+    }
+
+    #[test]
+    fn flee_moves_away() {
+        let step = flee(Vec2::new(1.0, 1.0), Vec2::new(0.0, 0.0), 4.0, 0.25);
+        assert!(step.x > 0.0 && step.z > 0.0);
+        assert!((step.len() - 1.0).abs() < 1e-5);
+    }
+
+    #[test]
+    fn arrive_decelerates() {
+        let far = arrive(Vec2::new(0.0, 0.0), Vec2::new(100.0, 0.0), 4.0, 1.0, 5.0);
+        let near = arrive(Vec2::new(96.0, 0.0), Vec2::new(100.0, 0.0), 4.0, 1.0, 5.0);
+        assert!(near.len() < far.len());
+    }
+
+    #[test]
+    fn separation_and_leash() {
+        let push = separate(Vec2::new(0.0, 0.0), &[Vec2::new(0.5, 0.0)], 2.0, 4.0, 0.25);
+        assert!(push.x < 0.0); // pushed away from the neighbor
+        assert!(leash(Vec2::new(3.0, 0.0), Vec2::default(), 10.0, 2.0, 0.25).is_none());
+        let pull = leash(Vec2::new(30.0, 0.0), Vec2::default(), 10.0, 2.0, 0.25).unwrap();
+        assert!(pull.x < 0.0);
+    }
+
+    #[test]
+    fn wander_stays_in_bounds() {
+        for roll in [0.0f32, 0.5, 1.0] {
+            let t = wander_target(Vec2::new(39.0, -39.0), 12.0, roll, roll, 40.0);
+            assert!(t.x.abs() <= 40.0 && t.z.abs() <= 40.0);
+        }
+    }
+}

package/crates/ckx-sdk/src/kit/ai/turn.rs

@@ -0,0 +1,141 @@
+//! Budgeted heuristic movers for enemy phases in turn-based games:
+//! enumerate reachable cells under a movement budget, score
+//! each candidate with a game-supplied heuristic, pick the best — all capped
+//! by an expansion budget so fuel stays predictable. Depth-1 "minimax" is
+//! the heuristic itself; deeper search is deliberately out of scope v1.
+
+use super::path::CostProvider;
+use std::collections::{BTreeMap, VecDeque};
+
+/// One candidate destination for a turn move.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Candidate {
+    pub x: i32,
+    pub z: i32,
+    /// Movement cost spent to reach it.
+    pub cost: u32,
+}
+
+/// Enumerate the cells reachable from `from` with at most `move_points`
+/// total entry cost (BFS/Dijkstra-lite over the provider, 4-connected),
+/// including standing still. Expansion stops at `max_expanded` cells.
+pub fn reachable(provider: &impl CostProvider, from: (i32, i32), move_points: u32, max_expanded: usize) -> Vec<Candidate> {
+    let mut best_cost: BTreeMap<(i32, i32), u32> = BTreeMap::new();
+    let mut queue: VecDeque<((i32, i32), u32)> = VecDeque::new();
+    best_cost.insert(from, 0);
+    queue.push_back((from, 0));
+    let mut expanded = 0usize;
+
+    while let Some((pos, cost)) = queue.pop_front() {
+        expanded += 1;
+        if expanded > max_expanded {
+            break;
+        }
+        for (dx, dz) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
+            let next = (pos.0 + dx, pos.1 + dz);
+            let Some(step) = provider.cost(next.0, next.1) else { continue };
+            let total = cost.saturating_add(step);
+            if total > move_points {
+                continue;
+            }
+            if total < *best_cost.get(&next).unwrap_or(&u32::MAX) {
+                best_cost.insert(next, total);
+                queue.push_back((next, total));
+            }
+        }
+    }
+    best_cost.into_iter().map(|((x, z), cost)| Candidate { x, z, cost }).collect()
+}
+
+/// The chosen move for a turn.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct TurnMove {
+    pub to: (i32, i32),
+    pub score: f32,
+}
+
+/// Pick the best reachable cell under `move_points` by `score` (higher wins;
+/// ties prefer cheaper movement, then stable coordinate order). Returns
+/// None only when even standing still is impossible (blocked origin).
+pub fn best_move(
+    provider: &impl CostProvider,
+    from: (i32, i32),
+    move_points: u32,
+    max_expanded: usize,
+    mut score: impl FnMut(&Candidate) -> f32,
+) -> Option<TurnMove> {
+    let candidates = reachable(provider, from, move_points, max_expanded);
+    let mut best: Option<(f32, u32, (i32, i32))> = None;
+    for candidate in &candidates {
+        let s = score(candidate);
+        let key = (s, candidate.cost, (candidate.x, candidate.z));
+        let better = match &best {
+            None => true,
+            Some((bs, bc, bp)) => {
+                s > *bs || (s == *bs && candidate.cost < *bc) || (s == *bs && candidate.cost == *bc && (candidate.x, candidate.z) < *bp)
+            }
+        };
+        if better {
+            best = Some((key.0, key.1, key.2));
+        }
+    }
+    best.map(|(s, _, to)| TurnMove { to, score: s })
+}
+
+/// The classic melee-enemy heuristic: get adjacent to the closest target,
+/// preferring cells that minimize distance to ANY target. Returns a score
+/// function for [`best_move`].
+pub fn approach_scorer(targets: Vec<(i32, i32)>) -> impl FnMut(&Candidate) -> f32 {
+    move |candidate: &Candidate| {
+        let d = targets.iter().map(|t| (t.0 - candidate.x).abs() + (t.1 - candidate.z).abs()).min().unwrap_or(0);
+        -(d as f32)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kit::ai::path::GridProvider;
+
+    fn open_field<'a>(blocked: &'a dyn Fn(i32, i32) -> bool) -> GridProvider<'a> {
+        GridProvider { width: 16, height: 16, blocked }
+    }
+
+    #[test]
+    fn reachable_respects_budget_and_walls() {
+        let open = |_x: i32, _z: i32| false;
+        let cells = reachable(&open_field(&open), (8, 8), 2, 10_000);
+        // Manhattan diamond radius 2 = 13 cells (incl. origin).
+        assert_eq!(cells.len(), 13);
+        assert!(cells.iter().any(|c| c.x == 8 && c.z == 8 && c.cost == 0));
+
+        let wall = |x: i32, _z: i32| x == 9; // wall right of origin
+        let cells = reachable(&open_field(&wall), (8, 8), 2, 10_000);
+        assert!(!cells.iter().any(|c| c.x == 9));
+        assert!(!cells.iter().any(|c| c.x == 10), "cannot pass through the wall with 2 mp");
+    }
+
+    #[test]
+    fn best_move_approaches_target() {
+        let open = |_x: i32, _z: i32| false;
+        let provider = open_field(&open);
+        let chosen = best_move(&provider, (2, 2), 3, 10_000, approach_scorer(vec![(10, 2)])).unwrap();
+        assert_eq!(chosen.to, (5, 2), "walks straight toward the target");
+        // Already adjacent: stays adjacent (distance 1 beats distance 0? No —
+        // approach minimizes distance, landing ON the target cell if open).
+        let chosen = best_move(&provider, (9, 2), 1, 10_000, approach_scorer(vec![(10, 2)])).unwrap();
+        assert_eq!(chosen.to, (10, 2));
+    }
+
+    #[test]
+    fn best_move_prefers_cheaper_on_ties_and_survives_blocked_budget() {
+        let open = |_x: i32, _z: i32| false;
+        let provider = open_field(&open);
+        // Constant score: standing still (cost 0) wins the tie.
+        let chosen = best_move(&provider, (4, 4), 3, 10_000, |_| 1.0).unwrap();
+        assert_eq!(chosen.to, (4, 4));
+        // Zero move points: only standing still is reachable.
+        let chosen = best_move(&provider, (4, 4), 0, 10_000, approach_scorer(vec![(9, 9)])).unwrap();
+        assert_eq!(chosen.to, (4, 4));
+    }
+}

package/crates/ckx-sdk/src/kit/mod.rs

@@ -60,8 +60,12 @@ use serde::{Deserialize, Serialize};
 use crate::model::{Model, Published, Schema, Viewer};
 use crate::{Call, Caller, Ctx, Error, Result, decode, encode};
 
+pub mod ai;
+pub mod play;
+pub mod presence;
 pub mod rng;
 pub mod shard;
+pub mod sim;
 pub mod wire;
 
 pub use rng::Rng;
@@ -131,8 +135,19 @@ struct Outgoing<'a, T: ?Sized> {
     body: &'a T,
 }
 
-/// Encodes one kit message from this instance. `body` must serialize as a struct or a map.
+/// The fields a kit message's header owns; a body may not use them (they sit side by side).
+pub const RESERVED_FIELDS: [&str; 4] = ["v", "epoch", "seq", "kind"];
+
+/// Encodes one kit message from this instance. `body` must serialize as a struct or a map, and
+/// none of its fields may be one of [`RESERVED_FIELDS`]: a debug build (`cargo test`) refuses a
+/// body that uses one, which would leave a client two `kind`s to choose from.
 pub fn message<T: Serialize + ?Sized>(ctx: &Ctx, kind: MessageKind, seq: u64, body: &T) -> Result<Vec<u8>> {
+    #[cfg(debug_assertions)]
+    if let Ok(fields) = decode::<BTreeMap<String, serde::de::IgnoredAny>>(&encode(body)?)
+        && let Some(taken) = RESERVED_FIELDS.iter().find(|f| fields.contains_key(**f))
+    {
+        return Err(Error::new(format!("a kit message's body may not have a field `{taken}`: the header owns it")));
+    }
     let header = Header { v: PROTOCOL, epoch: ctx.epoch, seq, kind };
     encode(&Outgoing { header, body })
 }
@@ -237,6 +252,15 @@ pub fn args<T: DeserializeOwned>(call: &Call<'_>) -> Result<T> {
     decode(call.payload).map_err(|Error(e)| error(codes::BAD_REQUEST, format!("`{}`: {e}", call.method)))
 }
 
+/// A call's arguments when it may send none: an empty payload or a nil (what a client sends for
+/// no arguments) is `T::default()`.
+pub fn args_or_default<T: DeserializeOwned + Default>(call: &Call<'_>) -> Result<T> {
+    match call.payload {
+        [] | [0xc0] => Ok(T::default()),
+        _ => args(call),
+    }
+}
+
 // ---- refusals ----
 
 /// The refusal codes kit hubs share. A hub may add its own: lowercase letters, digits and `_`.
@@ -417,6 +441,13 @@ mod tests {
         assert!(message(&ctx(), MessageKind::Event, 1, &vec![1u8]).is_err(), "a body is a struct or a map");
     }
 
+    #[test]
+    fn a_body_may_not_use_a_field_the_header_owns() {
+        let e = message(&ctx(), MessageKind::Event, 1, &serde_json::json!({ "type": "timing", "kind": "lap" })).unwrap_err();
+        assert!(e.0.contains("`kind`"), "{}", e.0);
+        assert!(message(&ctx(), MessageKind::Event, 1, &serde_json::json!({ "type": "timing", "stage": "lap" })).is_ok());
+    }
+
     #[test]
     fn each_topic_counts_its_own_messages_and_a_snapshot_reply_names_the_last() {
         let mut p = Publisher::new();
@@ -480,6 +511,23 @@ mod tests {
         assert!(Receipts::action_id(&encode(&Act { points: 1, action_id: &long }).unwrap()).is_err());
     }
 
+    #[test]
+    fn no_arguments_are_the_defaults_and_bad_ones_are_a_bad_request() {
+        #[derive(Deserialize, Default, Debug, PartialEq)]
+        #[serde(default)]
+        struct Open {
+            seed: Option<u64>,
+        }
+        let call = |payload: &'static [u8]| Call { caller: Caller::Player(1), method: "open", payload };
+        assert_eq!(args_or_default::<Open>(&call(&[])).unwrap(), Open::default());
+        assert_eq!(args_or_default::<Open>(&call(&[0xc0])).unwrap(), Open::default());
+        let given = encode(&serde_json::json!({ "seed": 4 })).unwrap();
+        let c = Call { caller: Caller::Player(1), method: "open", payload: &given };
+        assert_eq!(args_or_default::<Open>(&c).unwrap(), Open { seed: Some(4) });
+        let Error(e) = args_or_default::<Open>(&call(&[0x05])).unwrap_err();
+        assert_eq!(error_code(&e).map(|c| c.0), Some(codes::BAD_REQUEST));
+    }
+
     #[test]
     fn a_collection_snapshot_holds_every_public_view() {
         let schema = Schema::new()