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

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

@@ -0,0 +1,137 @@
+//! A seeded random number generator (xorshift64*), plain data so it lives in a hub's state
+//! and carries on after a snapshot. Seed it from something the hub already has: its key, the
+//! clock at spawn, a match's seed.
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Rng {
+    state: u64,
+}
+
+impl Default for Rng {
+    fn default() -> Self {
+        Self::seeded(1)
+    }
+}
+
+impl Rng {
+    /// A generator seeded with `seed`; 0 counts as 1, which xorshift needs.
+    pub fn seeded(seed: u64) -> Self {
+        Self { state: seed.max(1) }
+    }
+
+    /// A seed from text: a key, a name.
+    pub fn seed_from(text: &str) -> u64 {
+        // FNV-1a.
+        text.bytes().fold(0xcbf2_9ce4_8422_2325u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x0000_0100_0000_01b3))
+    }
+
+    pub fn next_u64(&mut self) -> u64 {
+        let mut s = self.state;
+        s ^= s >> 12;
+        s ^= s << 25;
+        s ^= s >> 27;
+        self.state = s;
+        s.wrapping_mul(0x2545_f491_4f6c_dd1d)
+    }
+
+    /// Uniform in `[0, 1)`.
+    pub fn f64(&mut self) -> f64 {
+        (self.next_u64() >> 11) as f64 / (1u64 << 53) as f64
+    }
+
+    /// Uniform in `[0, 1)`, single precision.
+    pub fn f32(&mut self) -> f32 {
+        (self.next_u64() >> 40) as f32 / (1u64 << 24) as f32
+    }
+
+    /// Uniform in `[lo, hi]`, both included: [`Rng::range`].
+    pub fn range_i64(&mut self, lo: i64, hi: i64) -> i64 {
+        self.range(lo, hi)
+    }
+
+    /// Uniform in `[0, n)`; 0 when `n` is 0.
+    pub fn below(&mut self, n: u64) -> u64 {
+        if n == 0 { 0 } else { self.next_u64() % n }
+    }
+
+    /// Uniform in `[lo, hi]`, both included; `lo` when `hi` is not above it.
+    pub fn range(&mut self, lo: i64, hi: i64) -> i64 {
+        if hi <= lo {
+            return lo;
+        }
+        let span = hi.abs_diff(lo).saturating_add(1);
+        lo.wrapping_add(self.below(span) as i64)
+    }
+
+    /// True with probability `p` (clamped to `[0, 1]`).
+    pub fn chance(&mut self, p: f64) -> bool {
+        self.f64() < p.clamp(0.0, 1.0)
+    }
+
+    pub fn pick<'a, T>(&mut self, items: &'a [T]) -> Option<&'a T> {
+        if items.is_empty() { None } else { items.get(self.below(items.len() as u64) as usize) }
+    }
+
+    /// The index of one weight, chosen in proportion to the weights; `None` when they sum to
+    /// nothing.
+    pub fn weighted(&mut self, weights: &[u64]) -> Option<usize> {
+        let total: u64 = weights.iter().fold(0u64, |a, w| a.saturating_add(*w));
+        if total == 0 {
+            return None;
+        }
+        let mut roll = self.below(total);
+        for (i, w) in weights.iter().enumerate() {
+            if roll < *w {
+                return Some(i);
+            }
+            roll -= w;
+        }
+        None
+    }
+
+    /// Shuffles in place (Fisher-Yates).
+    pub fn shuffle<T>(&mut self, items: &mut [T]) {
+        for i in (1..items.len()).rev() {
+            let j = self.below(i as u64 + 1) as usize;
+            items.swap(i, j);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deterministic_and_bounded() {
+        let (mut a, mut b) = (Rng::seeded(42), Rng::seeded(42));
+        for _ in 0..100 {
+            assert_eq!(a.next_u64(), b.next_u64());
+        }
+        for _ in 0..1_000 {
+            assert!((0.0..1.0).contains(&a.f64()));
+            assert!((-5..=5).contains(&a.range(-5, 5)));
+            assert!(a.below(3) < 3);
+        }
+        // The widest span does not overflow.
+        let _ = a.range(i64::MIN, i64::MAX);
+        assert_eq!(a.range(4, 4), 4);
+        assert!(a.pick::<u8>(&[]).is_none());
+        assert_eq!(a.weighted(&[0, 0]), None);
+        assert_eq!(a.weighted(&[0, 5, 0]), Some(1));
+    }
+
+    #[test]
+    fn a_shuffle_keeps_every_item_and_seeds_from_text_are_stable() {
+        let mut items: Vec<u32> = (0..52).collect();
+        Rng::seeded(Rng::seed_from("table-1")).shuffle(&mut items);
+        let mut sorted = items.clone();
+        sorted.sort_unstable();
+        assert_eq!(sorted, (0..52).collect::<Vec<_>>());
+        assert_ne!(items, sorted);
+        assert_eq!(Rng::seed_from("a"), Rng::seed_from("a"));
+        assert_ne!(Rng::seed_from("a"), Rng::seed_from("b"));
+    }
+}

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

@@ -0,0 +1,65 @@
+//! Shard keys: one keyed hub per square of the world, so no one hub holds everyone.
+//!
+//! A shard is `size` by `size` chunks on the x and z axes, and its key is its centre chunk,
+//! `"<x>,<z>"`. Players' clients compute the same keys (the kit clients carry this function),
+//! so a client finds the hub for where it stands without asking anyone. A hub that sees its
+//! neighbours' edges subscribes to [`around`]'s keys.
+
+/// The shard's centre chunk for chunk `(x, z)`. `size` is at least 1.
+pub fn centre(x: i64, z: i64, size: i64) -> (i64, i64) {
+    let size = size.max(1);
+    (x.div_euclid(size) * size + size / 2, z.div_euclid(size) * size + size / 2)
+}
+
+/// The key of the shard that holds chunk `(x, z)`.
+pub fn key(x: i64, z: i64, size: i64) -> String {
+    let (cx, cz) = centre(x, z, size);
+    format!("{cx},{cz}")
+}
+
+/// The centre chunk a key names, or `None` when it is not `"<x>,<z>"`.
+pub fn parse(key: &str) -> Option<(i64, i64)> {
+    let (x, z) = key.split_once(',')?;
+    Some((x.trim().parse().ok()?, z.trim().parse().ok()?))
+}
+
+/// The keys of the shards within `radius` shards of the one holding `(x, z)`, its own first,
+/// then row by row.
+pub fn around(x: i64, z: i64, size: i64, radius: i64) -> Vec<String> {
+    let size = size.max(1);
+    let (cx, cz) = centre(x, z, size);
+    let mut keys = vec![format!("{cx},{cz}")];
+    for dz in -radius..=radius {
+        for dx in -radius..=radius {
+            if (dx, dz) != (0, 0) {
+                keys.push(format!("{},{}", cx + dx * size, cz + dz * size));
+            }
+        }
+    }
+    keys
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_chunk_falls_in_one_shard_named_by_its_centre() {
+        assert_eq!(key(10, -4, 8), "12,-4");
+        assert_eq!(key(8, -8, 8), "12,-4");
+        assert_eq!(key(7, -9, 8), "4,-12");
+        assert_eq!(key(-1, 0, 16), "-8,8");
+        assert_eq!(key(3, 5, 1), "3,5", "size 1 is the chunk itself");
+        assert_eq!(parse("12,-4"), Some((12, -4)));
+        assert_eq!(parse("x"), None);
+    }
+
+    #[test]
+    fn around_starts_with_its_own_shard() {
+        let keys = around(0, 0, 8, 1);
+        assert_eq!(keys.len(), 9);
+        assert_eq!(keys[0], "4,4");
+        assert!(keys.contains(&"-4,-4".to_string()) && keys.contains(&"12,12".to_string()));
+        assert_eq!(around(0, 0, 8, 0), vec!["4,4".to_string()]);
+    }
+}

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

@@ -0,0 +1,71 @@
+//! The deterministic day/night clock: a pure function of wall-clock ms, so
+//! hubs and clients agree without any synchronization message.
+//! A 20-minute day is the
+//! default; games pick their own length.
+
+use serde::{Deserialize, Serialize};
+
+pub const DEFAULT_DAY_LENGTH_MS: u64 = 1_200_000; // 20 minutes
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug)]
+pub struct DayCycle {
+    pub day_length_ms: u64,
+}
+
+impl Default for DayCycle {
+    fn default() -> Self {
+        Self { day_length_ms: DEFAULT_DAY_LENGTH_MS }
+    }
+}
+
+impl DayCycle {
+    pub fn new(day_length_ms: u64) -> Self {
+        Self { day_length_ms: day_length_ms.max(1) }
+    }
+
+    /// Phase in [0, 1): 0 = day start, 0.5 = day/night boundary region.
+    pub fn phase(&self, now_ms: u64) -> f32 {
+        (now_ms % self.day_length_ms) as f32 / self.day_length_ms as f32
+    }
+
+    /// Night when sin(phase*TAU) dips below -0.05.
+    pub fn is_night(&self, now_ms: u64) -> bool {
+        (self.phase(now_ms) * std::f32::consts::TAU).sin() < -0.05
+    }
+
+    /// Sun height in [-1, 1] (drive lighting / spawn weights).
+    pub fn sun(&self, now_ms: u64) -> f32 {
+        (self.phase(now_ms) * std::f32::consts::TAU).sin()
+    }
+
+    /// Day number since epoch (season math, daily resets).
+    pub fn day_index(&self, now_ms: u64) -> u64 {
+        now_ms / self.day_length_ms
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_twenty_minute_day_turns_to_night_and_back() {
+        let cycle = DayCycle::default();
+        // First half of the cycle: sun up (sin > 0).
+        assert!(!cycle.is_night(60_000));
+        assert!(cycle.sun(300_000) > 0.99); // quarter cycle = noon
+        // Second half: night.
+        assert!(cycle.is_night(900_000)); // three-quarter = midnight
+        assert_eq!(cycle.day_index(2_500_000), 2);
+    }
+
+    #[test]
+    fn deterministic_across_instances() {
+        let a = DayCycle::new(600_000);
+        let b = DayCycle::new(600_000);
+        for t in (0..3_000_000).step_by(90_000) {
+            assert_eq!(a.is_night(t), b.is_night(t));
+            assert_eq!(a.phase(t), b.phase(t));
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+//! World simulation a hub runs: [`daycycle`] (a clock everyone agrees on from the time alone),
+//! [`weather`] (seeded fronts), [`nodes`] (resource nodes that deplete and regrow), [`waves`]
+//! (timed spawn waves) and [`zones`] (rule boxes and shrinking circles). Deterministic over
+//! `now_ms` and a seeded [`Rng`](super::Rng).
+
+pub mod daycycle;
+pub mod nodes;
+pub mod waves;
+pub mod weather;
+pub mod zones;

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

@@ -0,0 +1,109 @@
+//! Resource nodes: harvest/deplete/respawn lifecycle (ore veins, berry
+//! bushes, fishing spots). Pure state machine — a hub keeps the pool in
+//! its state.
+
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
+pub enum NodePhase {
+    #[default]
+    Ready,
+    /// Depleted; respawns at the embedded time.
+    Respawning { at_ms: u64 },
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct Node {
+    pub phase: NodePhase,
+    /// Remaining harvests before depletion (0 = infinite until depleted
+    /// explicitly).
+    pub charges: u32,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct NodePool {
+    pub nodes: BTreeMap<String, Node>,
+}
+
+pub struct HarvestOutcome {
+    pub harvested: bool,
+    pub depleted: bool,
+}
+
+impl NodePool {
+    /// Register a node (idempotent; keeps existing state).
+    pub fn ensure(&mut self, id: &str, charges: u32) -> &mut Node {
+        self.nodes.entry(id.to_string()).or_insert(Node { phase: NodePhase::Ready, charges })
+    }
+
+    /// Attempt a harvest. Depletes when charges run out.
+    pub fn harvest(&mut self, id: &str, now_ms: u64, respawn_ms: u64) -> HarvestOutcome {
+        let Some(node) = self.nodes.get_mut(id) else {
+            return HarvestOutcome { harvested: false, depleted: false };
+        };
+        if !matches!(node.phase, NodePhase::Ready) {
+            return HarvestOutcome { harvested: false, depleted: false };
+        }
+        let depleted = if node.charges > 0 {
+            node.charges -= 1;
+            node.charges == 0
+        } else {
+            false
+        };
+        if depleted {
+            node.phase = NodePhase::Respawning { at_ms: now_ms + respawn_ms };
+        }
+        HarvestOutcome { harvested: true, depleted }
+    }
+
+    /// Tick respawns: returns ids that just came back (re-arm charges).
+    pub fn tick(&mut self, now_ms: u64, recharge: u32) -> Vec<String> {
+        let mut respawned = Vec::new();
+        for (id, node) in &mut self.nodes {
+            if let NodePhase::Respawning { at_ms } = node.phase
+                && now_ms >= at_ms
+            {
+                node.phase = NodePhase::Ready;
+                node.charges = recharge;
+                respawned.push(id.clone());
+            }
+        }
+        respawned
+    }
+
+    pub fn is_ready(&self, id: &str) -> bool {
+        matches!(self.nodes.get(id), Some(Node { phase: NodePhase::Ready, .. }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn harvest_deplete_respawn() {
+        let mut pool = NodePool::default();
+        pool.ensure("vein-1", 2);
+        assert!(pool.harvest("vein-1", 1_000, 30_000).harvested);
+        let second = pool.harvest("vein-1", 2_000, 30_000);
+        assert!(second.harvested && second.depleted);
+        // Depleted: further harvests fail; not ready.
+        assert!(!pool.harvest("vein-1", 3_000, 30_000).harvested);
+        assert!(!pool.is_ready("vein-1"));
+        // Respawn on schedule with recharged charges.
+        assert!(pool.tick(31_000, 2).is_empty());
+        assert_eq!(pool.tick(32_000, 2), vec!["vein-1".to_string()]);
+        assert!(pool.harvest("vein-1", 33_000, 30_000).harvested);
+    }
+
+    #[test]
+    fn infinite_nodes_never_self_deplete() {
+        let mut pool = NodePool::default();
+        pool.ensure("well", 0);
+        for t in 0..50 {
+            let outcome = pool.harvest("well", t, 1_000);
+            assert!(outcome.harvested && !outcome.depleted);
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+//! Wave schedules: primitives for timed spawn waves (tower defense, horde
+//! nights): the scheduling core a director hub drives.
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct WaveDef {
+    /// Entries: (unit id, count).
+    pub units: Vec<(String, u32)>,
+    /// Delay after the previous wave clears (or starts, for timed mode).
+    pub delay_ms: u64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub enum WavePhase {
+    /// Before wave `next` starts; starts at the embedded time.
+    Countdown { next: usize, starts_at_ms: u64 },
+    /// Wave `index` is live.
+    Active { index: usize },
+    /// All waves done.
+    Complete,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct WaveSchedule {
+    pub phase: WavePhase,
+}
+
+impl Default for WaveSchedule {
+    fn default() -> Self {
+        Self { phase: WavePhase::Complete }
+    }
+}
+
+pub enum WaveEvent {
+    /// Spawn this wave's units now.
+    Start(usize),
+    Finished,
+}
+
+impl WaveSchedule {
+    /// Arm the schedule from wave 0 with the first delay.
+    pub fn start(waves: &[WaveDef], now_ms: u64) -> Self {
+        match waves.first() {
+            Some(first) => Self { phase: WavePhase::Countdown { next: 0, starts_at_ms: now_ms + first.delay_ms } },
+            None => Self { phase: WavePhase::Complete },
+        }
+    }
+
+    /// Advance. `active_cleared` = the live wave's units are all dead.
+    pub fn step(&mut self, waves: &[WaveDef], now_ms: u64, active_cleared: bool) -> Option<WaveEvent> {
+        match self.phase.clone() {
+            WavePhase::Countdown { next, starts_at_ms } if now_ms >= starts_at_ms => {
+                self.phase = WavePhase::Active { index: next };
+                Some(WaveEvent::Start(next))
+            }
+            WavePhase::Active { index } if active_cleared => {
+                let next = index + 1;
+                match waves.get(next) {
+                    Some(wave) => {
+                        self.phase = WavePhase::Countdown { next, starts_at_ms: now_ms + wave.delay_ms };
+                        None
+                    }
+                    None => {
+                        self.phase = WavePhase::Complete;
+                        Some(WaveEvent::Finished)
+                    }
+                }
+            }
+            _ => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn two_waves() -> Vec<WaveDef> {
+        vec![
+            WaveDef { units: vec![("slime".into(), 3)], delay_ms: 5_000 },
+            WaveDef { units: vec![("skeleton".into(), 2)], delay_ms: 10_000 },
+        ]
+    }
+
+    #[test]
+    fn full_run() {
+        let waves = two_waves();
+        let mut schedule = WaveSchedule::start(&waves, 0);
+        assert!(schedule.step(&waves, 4_999, false).is_none());
+        assert!(matches!(schedule.step(&waves, 5_000, false), Some(WaveEvent::Start(0))));
+        // Wave 0 live until cleared.
+        assert!(schedule.step(&waves, 8_000, false).is_none());
+        assert!(schedule.step(&waves, 9_000, true).is_none()); // countdown to wave 1
+        assert!(matches!(schedule.step(&waves, 19_000, false), Some(WaveEvent::Start(1))));
+        assert!(matches!(schedule.step(&waves, 25_000, true), Some(WaveEvent::Finished)));
+        assert_eq!(schedule.phase, WavePhase::Complete);
+    }
+
+    #[test]
+    fn empty_schedule_completes() {
+        let schedule = WaveSchedule::start(&[], 0);
+        assert_eq!(schedule.phase, WavePhase::Complete);
+    }
+}

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

@@ -0,0 +1,142 @@
+//! Weather fronts: a seeded state machine that walks through weather kinds
+//! with randomized durations, plus broadcast helpers. Clients receive
+//! transitions as type-90 server events (see `EVENT_WEATHER`) and render
+//! locally; late joiners read the current front from the hub.
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use crate::kit::Rng;
+use crate::kit::wire;
+use crate::node::ChunkPos;
+use crate::{Ctx, Result};
+
+/// The platform-reserved server-event type for weather/season transitions.
+pub const EVENT_WEATHER: u16 = 90;
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct WeatherKind {
+    pub id: String,
+    /// Relative pick weight (0 disables).
+    pub weight: u32,
+    pub min_ms: u64,
+    pub max_ms: u64,
+}
+
+pub fn default_kinds() -> Vec<WeatherKind> {
+    vec![
+        WeatherKind { id: "clear".into(), weight: 6, min_ms: 300_000, max_ms: 900_000 },
+        WeatherKind { id: "cloudy".into(), weight: 3, min_ms: 180_000, max_ms: 600_000 },
+        WeatherKind { id: "rain".into(), weight: 2, min_ms: 120_000, max_ms: 480_000 },
+        WeatherKind { id: "storm".into(), weight: 1, min_ms: 60_000, max_ms: 240_000 },
+    ]
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+pub struct WeatherState {
+    pub current: String,
+    pub since_ms: u64,
+    pub until_ms: u64,
+}
+
+pub struct Transition {
+    pub from: String,
+    pub to: String,
+    pub until_ms: u64,
+}
+
+/// Advance the front. Returns the transition when the front changed (emit it
+/// to clients), `None` while the current front holds.
+pub fn step(state: &mut WeatherState, kinds: &[WeatherKind], now_ms: u64, rng: &mut Rng) -> Option<Transition> {
+    if !state.current.is_empty() && now_ms < state.until_ms {
+        return None;
+    }
+    let total: u32 = kinds.iter().map(|k| k.weight).sum();
+    if total == 0 {
+        return None;
+    }
+    // Weighted pick, avoiding an immediate repeat when there's a choice.
+    let mut pick = || {
+        let mut roll = (rng.next_u64() % total as u64) as u32;
+        for kind in kinds {
+            if roll < kind.weight {
+                return kind.clone();
+            }
+            roll -= kind.weight;
+        }
+        kinds[0].clone()
+    };
+    let mut next = pick();
+    if next.id == state.current && kinds.iter().filter(|k| k.weight > 0).count() > 1 {
+        for _ in 0..4 {
+            next = pick();
+            if next.id != state.current {
+                break;
+            }
+        }
+    }
+    let duration = next.min_ms + rng.next_u64() % (next.max_ms.saturating_sub(next.min_ms).max(1));
+    let from = std::mem::replace(&mut state.current, next.id.clone());
+    state.since_ms = now_ms;
+    state.until_ms = now_ms + duration;
+    Some(Transition { from, to: next.id, until_ms: state.until_ms })
+}
+
+/// The client-facing JSON for a front (both the event body and `forecast`).
+pub fn front_json(state: &WeatherState, now_ms: u64) -> Value {
+    json!({
+        "weather": state.current,
+        "sinceMs": state.since_ms,
+        "untilMs": state.until_ms,
+        "remainingMs": state.until_ms.saturating_sub(now_ms),
+    })
+}
+
+/// Sends a transition as a type-90 server event to the players within `distance` chunks of
+/// `at`, from the hub's `actor`.
+pub fn emit_transition(ctx: &Ctx, at: ChunkPos, distance: u8, actor: &[u8; 32], state: &WeatherState, now_ms: u64) -> Result<()> {
+    wire::emit_event(ctx, at, distance, actor, EVENT_WEATHER, &front_json(state, now_ms))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fronts_advance_and_hold() {
+        let kinds = default_kinds();
+        let mut state = WeatherState::default();
+        let mut rng = Rng::seeded(7);
+        let t = step(&mut state, &kinds, 1_000, &mut rng).expect("first step transitions");
+        assert_eq!(t.from, "");
+        assert!(!state.current.is_empty());
+        assert!(state.until_ms > 1_000);
+        // Holds until the front expires.
+        let until = state.until_ms;
+        assert!(step(&mut state, &kinds, until - 1, &mut rng).is_none());
+        let prev = state.current.clone();
+        let t2 = step(&mut state, &kinds, until, &mut rng).expect("expiry transitions");
+        assert_eq!(t2.from, prev);
+        assert_ne!(t2.to, prev, "avoids immediate repeats");
+    }
+
+    #[test]
+    fn deterministic_for_a_seed() {
+        let kinds = default_kinds();
+        let mut a = (WeatherState::default(), Rng::seeded(42));
+        let mut b = (WeatherState::default(), Rng::seeded(42));
+        for t in (0..10_000_000u64).step_by(60_000) {
+            let ta = step(&mut a.0, &kinds, t, &mut a.1).map(|x| x.to);
+            let tb = step(&mut b.0, &kinds, t, &mut b.1).map(|x| x.to);
+            assert_eq!(ta, tb);
+        }
+    }
+
+    #[test]
+    fn front_json_shape() {
+        let state = WeatherState { current: "rain".into(), since_ms: 100, until_ms: 5_100 };
+        let v = front_json(&state, 1_100);
+        assert_eq!(v["weather"], "rain");
+        assert_eq!(v["remainingMs"], 4_000);
+    }
+}