Struct Tape 

pub struct Tape<I> { /* private fields */ }

A recorded run: one intent per tick, plus the canonical world hash each tick left behind, both in tick order.

A tape is the artifact a bug report carries: the seed, what the player asked for on every tick, and what the world looked like. Serialisable, so it can be written next to the save it came from.

Implementations

impl<I> Tape<I>

pub const fn new(seed: u64) -> Self

An empty tape for a run seeded with seed.

The seed is carried because a tape without it is not replayable: the factory a replay is handed reads seed to rebuild the same starting world.

pub const fn seed(&self) -> u64

The seed the recording run started from.

pub fn ticks(&self) -> u64

How many ticks are recorded. What a replay runs.

pub fn is_empty(&self) -> bool

Whether no tick has been recorded yet.

pub fn intents(&self) -> &[I]

Every recorded intent, in tick order.

pub fn intents_mut(&mut self) -> &mut [I]

Every recorded intent, to edit a tape before replaying it.

Rewriting a tick’s intent while keeping the recorded hashes is how a divergence is bisected: the replay then reports that tick (or says the edit changed nothing), instead of a hunt through a whole session.

pub fn hashes(&self) -> &[u64]

Every recorded hash, in tick order. Shorter than the tape when the intent tail was never hashed.

pub fn intent(&self, tick: u64) -> Option<&I>

The intent of tick, or None past the end.

pub fn hash(&self, tick: u64) -> Option<u64>

The recorded world hash of tick, or None if that tick was not hashed.

pub fn record_intent(&mut self, intent: I) -> u64

Appends one tick’s intent. Returns the tick it landed on.

Call it before the tick runs, so the tape is in the order the game saw.

pub fn record_hash(&mut self, world_hash: u64)

Appends the canonical world hash of the tick just recorded, in tick order: tick n’s hash is the world after tick n ran.

A tape may stop hashing early (an intent-only tail cannot be verified, see verify), but never hashes twice for one tick, and never more hashes than ticks.

Panics

If every recorded intent already has a hash. That is a recording loop hashing twice for one tick, which would misalign every later comparison.

impl<I> Tape<I>

where I: Clone + Send + Sync + 'static,

pub fn replay<F>(&self, setup: F) -> Vec<u64>

where F: FnMut() -> Setup,

Replays the tape into a fresh world and returns the canonical hash of every tick, in tick order.

setup is called once per replay and must rebuild the same starting world every time, so a caller can replay one tape twice and diff the two logs itself, or compare them against a golden list.

pub fn replay_with<F, C>(&self, setup: F, commit: C) -> Vec<u64>

where F: FnMut() -> Setup, C: FnMut(&mut World, &I),

replay, running commit on each tick’s intent after Intent is set and before the tick runs.

This is the hook for a game whose systems read their own action resources:

let commit = |world: &mut World, input: &Press| {
    world.resource_mut::<Keys>().0 = *input;
};
let hashes = tape.replay_with(|| fresh(seed), commit);

pub fn verify<F>(&self, setup: F) -> Result<(), VerifyError>

where F: FnMut() -> Setup,

Replays the tape and compares every tick’s hash against the recording, returning the first tick that differs.

The replay stops at the divergence: a world that already disagrees is not worth stepping further, and a game that would panic on it panics here instead of reporting the tick it went wrong at. Pair this with record_intent and record_hash.

pub fn verify_with<F, C>(&self, setup: F, commit: C) -> Result<(), VerifyError>

where F: FnMut() -> Setup, C: FnMut(&mut World, &I),

verify, running commit on each tick’s intent after Intent is set and before the tick runs.

Trait Implementations

impl<I: Clone> Clone for Tape<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for Tape<I>

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

Formats the value using the given formatter.

impl<'de, I> Deserialize<'de> for Tape<I>

where I: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: Eq> Eq for Tape<I>

impl<I: PartialEq> PartialEq for Tape<I>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<I> Serialize for Tape<I>

where I: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: PartialEq> StructuralPartialEq for Tape<I>