moirai-for-games 0.1.0

A small deterministic no_std ECS for constrained and headless games
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! Completed replay evidence and partial failure reports.

use alloc::vec::Vec;

use super::config::ReplayConfig;
use super::record::{StepRecord, StepSnapshot};
use super::step::StepIndex;

/// Completed replay evidence for a finite run.
#[derive(Clone, Debug, PartialEq)]
pub struct ReplayReport<S> {
    seed: u64,
    config: ReplayConfig,
    steps: Vec<StepSnapshot<S>>,
}

/// Failed replay step with partial evidence retained.
#[derive(Clone, Debug, PartialEq)]
pub struct ReplayFailure<E, S> {
    step: StepIndex,
    partial_report: ReplayReport<S>,
    source: E,
}

impl<S> ReplayReport<S> {
    pub(crate) fn new(config: ReplayConfig) -> Self {
        Self {
            seed: config.seed(),
            config,
            steps: Vec::new(),
        }
    }

    pub(crate) fn push_record(&mut self, record: StepRecord<S>) {
        self.steps.push(record.into_snapshot());
    }

    /// Seed from the replay config used for this run.
    pub fn seed(&self) -> u64 {
        self.seed
    }

    /// Replay policy that governed capture and step count.
    pub fn config(&self) -> &ReplayConfig {
        &self.config
    }

    /// Captured step records after [`CapturePolicy`](super::config::CapturePolicy) filtering.
    pub fn step_snapshots(&self) -> &[StepSnapshot<S>] {
        &self.steps
    }

    /// Host fixture snapshots across captured replay steps.
    pub fn snapshots(&self) -> impl Iterator<Item = &S> {
        self.steps.iter().map(|step| step.snapshot())
    }
}

impl<E, S> ReplayFailure<E, S> {
    pub(crate) fn new(step: StepIndex, partial_report: ReplayReport<S>, source: E) -> Self {
        Self {
            step,
            partial_report,
            source,
        }
    }

    /// Checked replay step where the run failed.
    pub fn step(&self) -> StepIndex {
        self.step
    }

    /// Step records captured before the failure, if any.
    pub fn partial_report(&self) -> &ReplayReport<S> {
        &self.partial_report
    }

    /// Replay failure source at the failing step.
    pub fn source(&self) -> &E {
        &self.source
    }
}