distributed 2.2.1

CQRS/ES framework for Rust using Plain Old Rust Structs — append-only events, replay, snapshots, outbox, service bus, and pluggable infrastructure
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

use distributed::{sourced, Entity};

#[derive(Default, Clone)]
pub struct Explosion {
    pub entity: Entity,
    pub bomb_id: String,
    pub owner: String,
    pub center: (i32, i32),
    pub blast_radius: u8,
    pub rings: Vec<Vec<(i32, i32)>>,
    pub current_ring: usize,
    pub active: bool,
}

#[sourced(entity)]
impl Explosion {
    #[event("started")]
    pub fn start(
        &mut self,
        id: String,
        bomb_id: String,
        owner: String,
        center: (i32, i32),
        blast_radius: u8,
        rings: Vec<Vec<(i32, i32)>>,
    ) {
        self.entity.set_id(&id);
        self.bomb_id = bomb_id;
        self.owner = owner;
        self.center = center;
        self.blast_radius = blast_radius;
        self.rings = rings;
        self.current_ring = 0;
        self.active = true;
    }

    #[event("expanded", when = self.active && !self.is_fully_expanded())]
    pub fn expand(&mut self) {
        self.current_ring += 1;
    }

    #[event("dissipated", when = self.active)]
    pub fn dissipate(&mut self) {
        self.active = false;
    }

    pub fn is_fully_expanded(&self) -> bool {
        self.rings.is_empty() || self.current_ring >= self.rings.len() - 1
    }

    pub fn newly_reached_cells(&self) -> &[(i32, i32)] {
        if self.current_ring < self.rings.len() {
            &self.rings[self.current_ring]
        } else {
            &[]
        }
    }

    pub fn all_active_cells(&self) -> Vec<(i32, i32)> {
        let end = (self.current_ring + 1).min(self.rings.len());
        self.rings[..end]
            .iter()
            .flat_map(|r| r.iter().copied())
            .collect()
    }
}