issun 0.10.0

A mini game engine for logic-focused games - Build games in ISSUN (一寸) of time
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Events for OrganizationSuitePlugin
//!
//! Defines Command (request) and State (result) events for organizational transitions.

use super::types::{FactionId, OrgArchetype, TransitionTrigger};

// ========== Command Events (Requests) ==========

/// Manual transition request (player/AI initiated)
#[derive(Debug, Clone)]
pub struct TransitionRequested {
    pub faction_id: FactionId,
    pub from: OrgArchetype,
    pub to: OrgArchetype,
    pub reason: String,
}

/// Register a faction under Suite management
#[derive(Debug, Clone)]
pub struct FactionRegisterRequested {
    pub faction_id: FactionId,
    pub initial_archetype: OrgArchetype,
}

// ========== State Events (Results) ==========

/// Transition successfully occurred
#[derive(Debug, Clone)]
pub struct TransitionOccurredEvent {
    pub faction_id: FactionId,
    pub from: OrgArchetype,
    pub to: OrgArchetype,
    pub trigger: TransitionTrigger,
    pub timestamp: u64,
}

/// Transition failed
#[derive(Debug, Clone)]
pub struct TransitionFailedEvent {
    pub faction_id: FactionId,
    pub from: OrgArchetype,
    pub to: OrgArchetype,
    pub error: String,
}

/// Faction registered in Suite
#[derive(Debug, Clone)]
pub struct FactionRegisteredEvent {
    pub faction_id: FactionId,
    pub archetype: OrgArchetype,
}

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

    #[test]
    fn test_transition_requested() {
        let event = TransitionRequested {
            faction_id: "rebels".to_string(),
            from: OrgArchetype::Holacracy,
            to: OrgArchetype::Hierarchy,
            reason: "Growth exceeded threshold".to_string(),
        };

        assert_eq!(event.faction_id, "rebels");
        assert_eq!(event.from, OrgArchetype::Holacracy);
        assert_eq!(event.to, OrgArchetype::Hierarchy);
    }

    #[test]
    fn test_faction_register_requested() {
        let event = FactionRegisterRequested {
            faction_id: "empire".to_string(),
            initial_archetype: OrgArchetype::Hierarchy,
        };

        assert_eq!(event.faction_id, "empire");
        assert_eq!(event.initial_archetype, OrgArchetype::Hierarchy);
    }

    #[test]
    fn test_transition_occurred_event() {
        let event = TransitionOccurredEvent {
            faction_id: "corp".to_string(),
            from: OrgArchetype::Holacracy,
            to: OrgArchetype::Hierarchy,
            trigger: TransitionTrigger::Scaling {
                from: OrgArchetype::Holacracy,
                to: OrgArchetype::Hierarchy,
                member_count: 50,
            },
            timestamp: 100,
        };

        assert_eq!(event.faction_id, "corp");
        assert_eq!(event.timestamp, 100);

        match event.trigger {
            TransitionTrigger::Scaling { member_count, .. } => {
                assert_eq!(member_count, 50);
            }
            _ => panic!("Expected Scaling trigger"),
        }
    }

    #[test]
    fn test_transition_failed_event() {
        let event = TransitionFailedEvent {
            faction_id: "test".to_string(),
            from: OrgArchetype::Social,
            to: OrgArchetype::Culture,
            error: "Condition not met".to_string(),
        };

        assert_eq!(event.faction_id, "test");
        assert!(event.error.contains("Condition"));
    }

    #[test]
    fn test_faction_registered_event() {
        let event = FactionRegisteredEvent {
            faction_id: "hackers".to_string(),
            archetype: OrgArchetype::Holacracy,
        };

        assert_eq!(event.faction_id, "hackers");
        assert_eq!(event.archetype, OrgArchetype::Holacracy);
    }
}