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

package/crates/ckx-sdk/src/kit/sim/zones.rs

@@ -0,0 +1,218 @@
+//! Rule zones: static axis-aligned boxes tagged with rule strings ("safe",
+//! "pvp", "build-locked") plus **shrinking circles** — the
+//! battle-royale zone: a phased schedule of (radius, hold, shrink) steps
+//! with warning/shrink/settle events for the type-98 lane.
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Zone {
+    pub id: String,
+    pub rule: String,
+    pub min: (f32, f32, f32),
+    pub max: (f32, f32, f32),
+}
+
+impl Zone {
+    pub fn contains(&self, pos: (f32, f32, f32)) -> bool {
+        pos.0 >= self.min.0
+            && pos.0 <= self.max.0
+            && pos.1 >= self.min.1
+            && pos.1 <= self.max.1
+            && pos.2 >= self.min.2
+            && pos.2 <= self.max.2
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct ZoneSet {
+    pub zones: Vec<Zone>,
+}
+
+impl ZoneSet {
+    /// All zones containing the position.
+    pub fn at(&self, pos: (f32, f32, f32)) -> Vec<&Zone> {
+        self.zones.iter().filter(|z| z.contains(pos)).collect()
+    }
+
+    /// Does any zone with this rule cover the position?
+    pub fn has_rule(&self, pos: (f32, f32, f32), rule: &str) -> bool {
+        self.zones.iter().any(|z| z.rule == rule && z.contains(pos))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Shrinking circles (BR zones)
+// ---------------------------------------------------------------------------
+
+/// One phase of a shrinking-zone schedule.
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq)]
+pub struct ShrinkPhase {
+    /// The radius this phase shrinks TO.
+    pub radius: f32,
+    /// How long the zone HOLDS before shrinking (the warning window).
+    pub hold_ms: u64,
+    /// How long the shrink itself takes (radius interpolates linearly).
+    pub shrink_ms: u64,
+}
+
+/// Announcements a shrinking zone produces as time advances.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub enum ZoneEvent {
+    /// A hold began: the zone will start shrinking to `to_radius` at `at_ms`.
+    Warning { phase: usize, to_radius: f32, shrink_starts_at_ms: u64 },
+    /// The shrink began.
+    Shrinking { phase: usize, to_radius: f32 },
+    /// The phase's target radius was reached.
+    Settled { phase: usize, radius: f32 },
+    /// Every phase is done (the final circle).
+    Final { radius: f32 },
+}
+
+/// A battle-royale circle: fixed center, radius stepping down a schedule.
+/// Pure clock math — feed it `now_ms`, read `radius()` and drain events.
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct ShrinkingZone {
+    pub center: (f32, f32),
+    pub initial_radius: f32,
+    pub phases: Vec<ShrinkPhase>,
+    pub started_at_ms: u64,
+    /// Last phase-progress marker events were emitted for (phase, stage).
+    announced: Vec<(usize, u8)>,
+}
+
+impl ShrinkingZone {
+    pub fn start(center: (f32, f32), initial_radius: f32, phases: Vec<ShrinkPhase>, now_ms: u64) -> Self {
+        Self { center, initial_radius, phases, started_at_ms: now_ms, announced: Vec::new() }
+    }
+
+    /// Phase timeline offsets: each phase = hold then shrink.
+    fn phase_bounds(&self, phase: usize) -> (u64, u64, u64) {
+        let mut offset = 0u64;
+        for p in &self.phases[..phase] {
+            offset += p.hold_ms + p.shrink_ms;
+        }
+        let p = &self.phases[phase];
+        (offset, offset + p.hold_ms, offset + p.hold_ms + p.shrink_ms)
+    }
+
+    /// The circle's radius at `now_ms` (linear interpolation during shrinks).
+    pub fn radius(&self, now_ms: u64) -> f32 {
+        let elapsed = now_ms.saturating_sub(self.started_at_ms);
+        let mut from = self.initial_radius;
+        for (index, phase) in self.phases.iter().enumerate() {
+            let (_, shrink_start, shrink_end) = self.phase_bounds(index);
+            if elapsed < shrink_start {
+                return from;
+            }
+            if elapsed < shrink_end {
+                let t = (elapsed - shrink_start) as f32 / (shrink_end - shrink_start).max(1) as f32;
+                return from + (phase.radius - from) * t;
+            }
+            from = phase.radius;
+        }
+        from
+    }
+
+    /// Is a position inside the live circle?
+    pub fn contains(&self, pos: (f32, f32), now_ms: u64) -> bool {
+        let (dx, dz) = (pos.0 - self.center.0, pos.1 - self.center.1);
+        (dx * dx + dz * dz).sqrt() <= self.radius(now_ms)
+    }
+
+    /// Every phase fully settled?
+    pub fn done(&self, now_ms: u64) -> bool {
+        match self.phases.len() {
+            0 => true,
+            n => now_ms.saturating_sub(self.started_at_ms) >= self.phase_bounds(n - 1).2,
+        }
+    }
+
+    /// Advance the announcer: returns the events newly due at `now_ms`
+    /// (warning at hold start, shrinking at shrink start, settled at end,
+    /// final once after the last phase).
+    pub fn poll(&mut self, now_ms: u64) -> Vec<ZoneEvent> {
+        let elapsed = now_ms.saturating_sub(self.started_at_ms);
+        let mut events = Vec::new();
+        for (index, phase) in self.phases.iter().enumerate() {
+            let (hold_start, shrink_start, shrink_end) = self.phase_bounds(index);
+            let stages: [(u8, u64); 3] = [(0, hold_start), (1, shrink_start), (2, shrink_end)];
+            for (stage, at) in stages {
+                if elapsed >= at && !self.announced.contains(&(index, stage)) {
+                    self.announced.push((index, stage));
+                    events.push(match stage {
+                        0 => ZoneEvent::Warning {
+                            phase: index,
+                            to_radius: phase.radius,
+                            shrink_starts_at_ms: self.started_at_ms + shrink_start,
+                        },
+                        1 => ZoneEvent::Shrinking { phase: index, to_radius: phase.radius },
+                        _ => ZoneEvent::Settled { phase: index, radius: phase.radius },
+                    });
+                }
+            }
+        }
+        if self.done(now_ms) && !self.announced.contains(&(usize::MAX, 3)) {
+            self.announced.push((usize::MAX, 3));
+            events.push(ZoneEvent::Final { radius: self.radius(now_ms) });
+        }
+        events
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shrinking_zone_interpolates_and_announces() {
+        let mut zone = ShrinkingZone::start(
+            (0.0, 0.0),
+            100.0,
+            vec![
+                ShrinkPhase { radius: 50.0, hold_ms: 10_000, shrink_ms: 10_000 },
+                ShrinkPhase { radius: 10.0, hold_ms: 5_000, shrink_ms: 5_000 },
+            ],
+            1_000,
+        );
+        // Hold: full radius; the warning fires immediately.
+        let events = zone.poll(1_000);
+        assert!(matches!(events[0], ZoneEvent::Warning { phase: 0, to_radius, .. } if to_radius == 50.0));
+        assert_eq!(zone.radius(5_000), 100.0);
+        // Mid-shrink: halfway between 100 and 50.
+        let events = zone.poll(16_000);
+        assert!(events.iter().any(|e| matches!(e, ZoneEvent::Shrinking { phase: 0, .. })));
+        assert!((zone.radius(16_000) - 75.0).abs() < 0.01);
+        // Settled at 50, phase 1 warning issued in the same poll window.
+        let events = zone.poll(21_500);
+        assert!(events.iter().any(|e| matches!(e, ZoneEvent::Settled { phase: 0, radius } if *radius == 50.0)));
+        assert!(events.iter().any(|e| matches!(e, ZoneEvent::Warning { phase: 1, .. })));
+        assert_eq!(zone.radius(24_000), 50.0);
+        // Final circle.
+        let events = zone.poll(31_000);
+        assert!(events.iter().any(|e| matches!(e, ZoneEvent::Settled { phase: 1, radius } if *radius == 10.0)));
+        assert!(events.iter().any(|e| matches!(e, ZoneEvent::Final { radius } if *radius == 10.0)));
+        assert!(zone.done(31_000));
+        assert!(zone.poll(40_000).is_empty(), "announce once");
+        // Containment tracks the live radius.
+        assert!(zone.contains((60.0, 0.0), 5_000));
+        assert!(!zone.contains((60.0, 0.0), 31_000));
+    }
+
+    #[test]
+    fn containment_and_rules() {
+        let set = ZoneSet {
+            zones: vec![
+                Zone { id: "spawn".into(), rule: "safe".into(), min: (-10.0, 0.0, -10.0), max: (10.0, 32.0, 10.0) },
+                Zone { id: "arena".into(), rule: "pvp".into(), min: (5.0, 0.0, 5.0), max: (30.0, 32.0, 30.0) },
+            ],
+        };
+        assert!(set.has_rule((0.0, 16.0, 0.0), "safe"));
+        assert!(!set.has_rule((0.0, 16.0, 0.0), "pvp"));
+        // Overlap region carries both rules.
+        assert_eq!(set.at((7.0, 16.0, 7.0)).len(), 2);
+        // Boundaries are inclusive; outside is outside.
+        assert!(set.has_rule((10.0, 32.0, 10.0), "safe"));
+        assert!(set.at((50.0, 16.0, 50.0)).is_empty());
+    }
+}

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

@@ -0,0 +1,266 @@
+//! What kit hubs show players near them through the realtime tier ([`crate::emit`]): server
+//! events, numbered by the registry below, and the state of server-driven actors.
+//!
+//! A server event's payload is `[event type, u16 little endian][JSON]`. The bodies here use
+//! camelCase keys, the shape the kit clients' event parsers read. An app's own events take
+//! numbers from [`APP_EVENTS`] up.
+//!
+//! A server-driven actor's state is [`ActorState`] as MessagePack: the kit clients decode it
+//! into their actor stores like a player's.
+
+use serde::{Deserialize, Serialize};
+
+use crate::emit::{MAX_DISTANCE, MAX_PAYLOAD, Spatial};
+use crate::node::ChunkPos;
+use crate::{Ctx, Error, Result, encode};
+
+/// A mob or a trap hit a player.
+pub const CONTACT_DAMAGE: u16 = 77;
+/// The weather or the time of day turned.
+pub const WEATHER: u16 = 90;
+/// A turn passed to the next player.
+pub const TURN: u16 = 91;
+/// Scores or a result.
+pub const SCORE: u16 = 92;
+/// A match was proposed to the players in it.
+pub const PROPOSAL: u16 = 93;
+/// An ability was cast, or landed.
+pub const ABILITY: u16 = 94;
+/// A movement the warden flagged.
+pub const MOVEMENT_VIOLATION: u16 = 95;
+/// A control point changed hands, or its capture moved.
+pub const CONTROL_POINT: u16 = 96;
+/// A racer started, passed a checkpoint, finished a lap or the race.
+pub const RACE_TIMING: u16 = 97;
+/// A play zone moved or shrank.
+pub const ZONE_CHANGE: u16 = 98;
+/// A wave began or ended, or a boss changed phase.
+pub const ENCOUNTER: u16 = 99;
+/// The contested object (a ball) changed hands, or a goal was scored.
+pub const POSSESSION: u16 = 100;
+/// An emote: a client event players send each other (the kit clients' convention); a hub may
+/// send one too, for a server-driven actor.
+pub const EMOTE: u16 = 101;
+/// The first number an app's own events may use.
+pub const APP_EVENTS: u16 = 1000;
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContactDamage {
+    pub target_uuid: String,
+    pub damage: i64,
+    pub mob_id: String,
+    pub mob_name: String,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct WeatherChange {
+    pub weather: String,
+    pub since_ms: u64,
+    pub until_ms: u64,
+    pub night: bool,
+    pub time_of_day: f64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct TurnChange {
+    /// Whose turn it is now: a player id, or a unit's id.
+    pub actor_id: String,
+    pub round: u32,
+    pub turn_in_round: u32,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Standing {
+    pub actor_id: String,
+    pub score: i64,
+    pub rank: u32,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ScoreUpdate {
+    pub standings: Vec<Standing>,
+    pub winner_id: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ProposalMade {
+    pub proposal_id: String,
+    pub mode: String,
+    pub players: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct AbilityUse {
+    /// `cast` or `impact`.
+    pub kind: String,
+    pub ability_id: String,
+    pub caster_id: String,
+    pub victim_id: Option<String>,
+    pub damage: i64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct MovementViolation {
+    /// `speed`, `teleport` or `bounds`.
+    pub kind: String,
+    pub user_id: String,
+    pub detail: String,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ControlPointChange {
+    pub point_id: String,
+    pub owner: String,
+    pub previous_owner: String,
+    /// Capture progress toward the attacker, 0 to 1.
+    pub progress: f64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct RaceTiming {
+    /// `started`, `checkpoint`, `lap` or `finished`.
+    pub kind: String,
+    pub course_id: String,
+    pub user_id: String,
+    pub checkpoint: u32,
+    pub lap: u32,
+    pub elapsed_ms: u64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ZoneChange {
+    /// `hold`, `shrink` or `closed`.
+    pub kind: String,
+    pub phase: Option<u32>,
+    pub radius_now: f64,
+    pub center_x: f64,
+    pub center_z: f64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct EncounterChange {
+    /// `wave_started`, `wave_cleared`, `boss_phase` or `finished`.
+    pub kind: String,
+    pub encounter_id: String,
+    pub wave: u32,
+    pub phase: u32,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct PossessionChange {
+    /// `claimed`, `passed`, `loose` or `goal`.
+    pub kind: String,
+    pub holder_id: Option<String>,
+    pub team: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Emote {
+    /// The emote's name, as the game knows it: `wave`, `cheer`, ...
+    pub emote: String,
+    /// The actor it is aimed at, if any.
+    pub target_uuid: Option<String>,
+}
+
+/// A server event's payload: its type, then its body as JSON.
+pub fn event_bytes<T: Serialize + ?Sized>(event_type: u16, body: &T) -> Result<Vec<u8>> {
+    let json = serde_json::to_vec(body).map_err(|e| Error::new(format!("an event body encodes as JSON: {e}")))?;
+    let mut out = Vec::with_capacity(2 + json.len());
+    out.extend_from_slice(&event_type.to_le_bytes());
+    out.extend_from_slice(&json);
+    if out.len() > MAX_PAYLOAD {
+        return Err(Error::new(format!("a realtime payload is at most {MAX_PAYLOAD} bytes")));
+    }
+    Ok(out)
+}
+
+/// Sends a server event to the players within `distance` chunks of `at` (at most
+/// [`MAX_DISTANCE`]). `actor` is the event's actor: the one it is about, or the hub's own.
+pub fn emit_event<T: Serialize + ?Sized>(ctx: &Ctx, at: ChunkPos, distance: u8, actor: &[u8; 32], event_type: u16, body: &T) -> Result<()> {
+    let bytes = event_bytes(event_type, body)?;
+    ctx.emit_spatial(at, distance.min(MAX_DISTANCE), actor, Spatial::Event { event_type, state: &bytes[2..] })?;
+    Ok(())
+}
+
+/// A server-driven actor as players near it see it.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct ActorState {
+    /// What it is: `mob`, `npc`, `pet`, `ball`, `ghost`, a game's own word.
+    pub kind: String,
+    /// Its id within the hub that shows it.
+    pub id: u64,
+    /// Where it is, in chunks.
+    pub x: f64,
+    #[serde(default)]
+    pub y: f64,
+    pub z: f64,
+    /// Its health, when it has any.
+    pub hp: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_hp: Option<i64>,
+    /// What it is doing: `idle`, `chase`, `follow`, ...
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mode: Option<String>,
+    /// The player it belongs to (a pet, a summon).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner: Option<u64>,
+    /// Facing, in radians.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub yaw: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+
+impl ActorState {
+    pub fn new(kind: &str, id: u64, x: f64, z: f64) -> Self {
+        Self { kind: kind.to_owned(), id, x, y: 0.0, z, hp: None, max_hp: None, mode: None, owner: None, yaw: None, name: None }
+    }
+
+    /// The chunk it stands in.
+    pub fn chunk(&self) -> ChunkPos {
+        ChunkPos::new(self.x.floor() as i64, self.y.floor() as i64, self.z.floor() as i64)
+    }
+}
+
+/// Shows a server-driven actor to the players within `distance` chunks of where it stands.
+pub fn emit_actor_state(ctx: &Ctx, actor: &[u8; 32], distance: u8, state: &ActorState) -> Result<()> {
+    ctx.emit_actor(actor, state.chunk(), distance.min(MAX_DISTANCE), &encode(state)?)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn an_event_is_its_type_then_json() {
+        let bytes = event_bytes(TURN, &TurnChange { actor_id: "7".into(), round: 2, turn_in_round: 1 }).unwrap();
+        assert_eq!(&bytes[..2], &[91, 0]);
+        let body: serde_json::Value = serde_json::from_slice(&bytes[2..]).unwrap();
+        assert_eq!(body, serde_json::json!({ "actorId": "7", "round": 2, "turnInRound": 1 }));
+        assert!(event_bytes(APP_EVENTS, &"x".repeat(MAX_PAYLOAD)).is_err());
+    }
+
+    #[test]
+    fn an_actor_state_leaves_out_what_it_does_not_have() {
+        let mut s = ActorState::new("mob", 3, 1.5, -2.25);
+        s.hp = Some(40);
+        let back: serde_json::Value = crate::decode(&encode(&s).unwrap()).unwrap();
+        assert_eq!(back, serde_json::json!({ "kind": "mob", "id": 3, "x": 1.5, "y": 0.0, "z": -2.25, "hp": 40 }));
+        assert_eq!(s.chunk(), ChunkPos::new(1, 0, -3));
+    }
+}

package/crates/ckx-sdk/src/lib.rs

@@ -44,10 +44,15 @@
 //! Nodes are unit tested natively with `cargo test`: `testing` runs one against a fake of the
 //! platform (calls, timers, events, snapshots, the node API, a mod's grid). [`limits`] has the
 //! platform's bounds.
+//!
+//! [`kit`] is the game kit's half here: the protocol kit hubs speak to the kit clients
+//! (snapshots and deltas with sequence numbers, retry-safe actions, refusal codes), shard keys,
+//! a seeded random generator, and the realtime event registry.
 
 mod abi;
 pub mod cron;
 pub mod emit;
+pub mod kit;
 pub mod limits;
 pub mod model;
 pub mod node;
@@ -546,20 +551,25 @@ macro_rules! export_spoke {
     };
 }
 
+// Only the module the sandbox loads needs the exports: a native build (a unit test, a crate
+// that includes several nodes' sources) defines none, so nodes link side by side.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __export_node {
     ($node:ty) => {
+        #[cfg(target_arch = "wasm32")]
         #[unsafe(no_mangle)]
         pub extern "C" fn ckx_abi() -> u32 {
             $crate::rt::ABI_VERSION
         }
 
+        #[cfg(target_arch = "wasm32")]
         #[unsafe(no_mangle)]
         pub extern "C" fn ckx_alloc(len: u32) -> u32 {
             $crate::rt::alloc(len)
         }
 
+        #[cfg(target_arch = "wasm32")]
         #[unsafe(no_mangle)]
         pub extern "C" fn ckx_init(
             ctx_ptr: u32,
@@ -574,16 +584,19 @@ macro_rules! __export_node {
             $crate::rt::init::<$node>(ctx_ptr, ctx_len, seed_ptr, seed_len, snap_ptr, snap_len, snap_version, has_snap)
         }
 
+        #[cfg(target_arch = "wasm32")]
         #[unsafe(no_mangle)]
         pub extern "C" fn ckx_handle(caller_kind: u32, caller_id: u64, buf_ptr: u32, method_len: u32, payload_len: u32) -> u64 {
             $crate::rt::handle(caller_kind, caller_id, buf_ptr, method_len, payload_len)
         }
 
+        #[cfg(target_arch = "wasm32")]
         #[unsafe(no_mangle)]
         pub extern "C" fn ckx_persist() -> u64 {
             $crate::rt::persist()
         }
 
+        #[cfg(target_arch = "wasm32")]
         #[unsafe(no_mangle)]
         pub extern "C" fn ckx_evict() {
             $crate::rt::evict()

package/crates/ckx-sdk/src/model.rs

@@ -209,6 +209,11 @@ impl Model {
         self.containers.get(&id)
     }
 
+    /// Every container's id, oldest first.
+    pub fn ids(&self) -> impl Iterator<Item = u64> + '_ {
+        self.containers.keys().copied()
+    }
+
     /// Every container of `type_name`, oldest first.
     pub fn of_type<'a>(&'a self, type_name: &'a str) -> impl Iterator<Item = u64> + 'a {
         self.containers.iter().filter(move |(_, c)| c.type_name == type_name).map(|(id, _)| *id)

package/crates/crowdy-client-sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crowdy-client-sdk"
-version = "0.1.0"
+version = "0.1.0-dev.1"
 edition = "2021"
 description = "Guest SDK for the CLIENT half of a ck-exec mod: browser WASM (ck ABI v0 + the client host calls)."
 license = "MIT OR Apache-2.0"

package/dist/cli/src/new.js

@@ -15,6 +15,15 @@ exports.TEMPLATES = {
     matchmaker: { dir: ['starters', 'matchmaker'], sdk: 'ckx-sdk', about: 'a rating queue that reserves sessions' },
     session: { dir: ['starters', 'session'], sdk: 'ckx-sdk', about: 'one game from lobby to result' },
     'npc-mobs': { dir: ['starters', 'npc-mobs'], sdk: 'ckx-sdk', about: "an area's mobs and NPCs" },
+    leaderboard: { dir: ['starters', 'leaderboard'], sdk: 'ckx-sdk', about: 'a board other hubs submit to, with seasons' },
+    deck: { dir: ['starters', 'deck'], sdk: 'ckx-sdk', about: 'a card table with hands only their player reads' },
+    tactics: { dir: ['starters', 'tactics'], sdk: 'ckx-sdk', about: "a grid battle in phases against the hub's units" },
+    director: { dir: ['starters', 'director'], sdk: 'ckx-sdk', about: 'waves down a lane, towers, a boss with phases' },
+    minigame: { dir: ['starters', 'minigame'], sdk: 'ckx-sdk', about: 'a duel of hidden throws, revealed together' },
+    instance: { dir: ['starters', 'instance'], sdk: 'ckx-sdk', about: "a party's private run: seeded floors, permadeath" },
+    arena: { dir: ['starters', 'arena'], sdk: 'ckx-sdk', about: 'classes and abilities in real time' },
+    racing: { dir: ['starters', 'racing'], sdk: 'ckx-sdk', about: 'races with laps and a ghost, and ball games' },
+    territory: { dir: ['starters', 'territory'], sdk: 'ckx-sdk', about: 'control points, and a shrinking circle' },
 };
 const CRATE_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
 function copyTree(from, to) {

package/kit.pin

@@ -1,9 +1,9 @@
 # The platform toolchain release this kit was copied from (sync-kit.sh in the platform's
 # repository). The paths in `copied` are byte-identical to it: change them there, never here.
-toolchain_version=v1.10.1
-toolchain_commit=277975dcb57b2fc770e67933cd47b0f911bf6b7d
-sdk_commit=4aa2af5aa86c3b1d90ed7eb10f65a0fcd14a1387
-ckx_sdk_version=0.9.0
+toolchain_version=v1.13.0
+toolchain_commit=4e6f1a7c9502d5d7171d75b6063acec97172239e
+sdk_commit=04d42bc77e24b6d84debc71eeee0efc687c0ee9a
+ckx_sdk_version=0.11.0
 crowdy_client_sdk_version=0.1.0
 rust_version=1.97.1
 copied=crates/ckx-sdk/src crates/crowdy-client-sdk/src tools/instrument/Cargo.toml tools/instrument/Cargo.lock tools/instrument/src checks/src/build/exec-source.ts checks/src/build/exec-source.spec.ts checks/src/build/rust-source-guard.ts checks/src/build/rust-source-guard.spec.ts checks/src/build/wasm-inspect.ts checks/src/build/wasm-inspect.spec.ts checks/src/build/client-capabilities.ts checks/src/build/client-capabilities.spec.ts checks/src/test-support/wasm-module.ts checks/compute-toolchain/host-catalog.json starters rust-toolchain.toml vendor.lock

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdedkingdoms/ckx-kit",
-  "version": "0.2.0",
+  "version": "0.4.0-dev.1",
   "description": "Build, check and test Crowded Kingdoms ck-exec mods, hubs and spokes on your machine, as the platform builds them",
   "license": "MIT OR Apache-2.0",
   "homepage": "https://docs.crowdedkingdoms.com/exec/intro",

package/starters/arena/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "arena"
+description = "Starter: a real-time arena where the hub referees every hit: classes with abilities (hit-scan, projectiles, area damage, statuses), respawns, kill credit, and a warden on the positions clients report"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+ckx-sdk = "0.11.0"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"