dreamwell-engine 1.0.0

Dreamwell pure-logic engine library — transforms, hierarchy, canon pipeline, spatial math, hashing, tile rules, validation, waymark schema, material/lighting descriptors. No SpacetimeDB dependency.
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use serde::{Deserialize, Serialize};

/// Promotion target — what a particle becomes when promoted to gameplay entity.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PromotionTarget {
    Pickup,
    Hazard,
    Interactable,
    WorldScar,
    PersistentDebris,
    ResourceNode,
    AIStimulus,
}

/// Promotion authority — who decides promotion.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PromotionAuthority {
    ClientSuggestsServerConfirms,
    ServerOnly,
    EventDeterministic,
}

/// Promotion rule — condition for a particle to be promoted.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PromotionRule {
    pub when: String,
    pub min_age: f32,
    pub requires_tags: Vec<String>,
    pub set_tags: Vec<String>,
}

/// Promotion policy for an emitter.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PromotionPolicy {
    pub enabled: bool,
    pub target: PromotionTarget,
    pub rules: Vec<PromotionRule>,
    pub authority: PromotionAuthority,
}

impl Default for PromotionPolicy {
    fn default() -> Self {
        Self {
            enabled: false,
            target: PromotionTarget::Pickup,
            rules: Vec::new(),
            authority: PromotionAuthority::ClientSuggestsServerConfirms,
        }
    }
}

impl PromotionTarget {
    pub const ALL: &[PromotionTarget] = &[
        Self::Pickup,
        Self::Hazard,
        Self::Interactable,
        Self::WorldScar,
        Self::PersistentDebris,
        Self::ResourceNode,
        Self::AIStimulus,
    ];

    pub fn name(&self) -> &'static str {
        match self {
            Self::Pickup => "Pickup",
            Self::Hazard => "Hazard",
            Self::Interactable => "Interactable",
            Self::WorldScar => "World Scar",
            Self::PersistentDebris => "Persistent Debris",
            Self::ResourceNode => "Resource Node",
            Self::AIStimulus => "AI Stimulus",
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn promotion_target_all() {
        assert_eq!(PromotionTarget::ALL.len(), 7);
    }

    #[test]
    fn promotion_policy_default() {
        let p = PromotionPolicy::default();
        assert!(!p.enabled);
    }

    #[test]
    fn promotion_policy_serde() {
        let p = PromotionPolicy {
            enabled: true,
            target: PromotionTarget::Pickup,
            authority: PromotionAuthority::ClientSuggestsServerConfirms,
            rules: vec![PromotionRule {
                when: "resting".into(),
                min_age: 1.5,
                requires_tags: vec!["isDebris".into(), "isStone".into()],
                set_tags: vec!["isPickupable".into(), "signal.promoted".into()],
            }],
        };
        let json = serde_json::to_string(&p).unwrap();
        let restored: PromotionPolicy = serde_json::from_str(&json).unwrap();
        assert_eq!(restored.rules.len(), 1);
    }
}