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
131
132
133
134
135
136

//! System trait for ISSUN
//!
//! Systems orchestrate game logic using Services and managing state.
//! Examples: CombatSystem, TurnManager, QuestOrchestrator

use crate::context::Context;
use async_trait::async_trait;
use std::any::Any;

/// System trait for Application Logic
///
/// Systems handle:
/// - State management (turn count, score, logs)
/// - Orchestration (coordinating multiple services)
/// - Game loop logic
///
/// # Difference from Service
///
/// - **Service**: Pure functions, stateless (damage calculation, pathfinding)
/// - **System**: Stateful, orchestration (turn management, combat flow)
///
/// # Examples
///
/// ```ignore
/// use issun::prelude::*;
///
/// #[derive(System)]
/// #[system(name = "combat_engine")]
/// pub struct CombatSystem {
///     turn_count: u32,
///     log: Vec<String>,
/// }
///
/// impl CombatSystem {
///     pub fn new() -> Self {
///         Self {
///             turn_count: 0,
///             log: Vec::new(),
///         }
///     }
///
///     pub fn process_turn(&mut self) {
///         self.turn_count += 1;
///         self.log.push(format!("Turn {}", self.turn_count));
///     }
/// }
/// ```
#[async_trait]
pub trait System: Send + Sync + 'static {
    /// System name (must be unique)
    fn name(&self) -> &'static str;

    /// Initialize system (called once at startup)
    async fn initialize(&mut self, _ctx: &mut Context) {}

    /// Optional: Shutdown cleanup
    async fn shutdown(&mut self, _ctx: &mut Context) {}

    /// Downcast to Any for type-safe access
    fn as_any(&self) -> &dyn Any;

    /// Downcast to Any for type-safe mutable access
    fn as_any_mut(&mut self) -> &mut dyn Any;
}

/// Example: Turn management system
#[cfg(test)]
mod tests {
    use super::*;

    struct TurnManagerSystem {
        turn_count: u32,
        log: Vec<String>,
    }

    impl TurnManagerSystem {
        fn new() -> Self {
            Self {
                turn_count: 0,
                log: Vec::new(),
            }
        }

        fn next_turn(&mut self) {
            self.turn_count += 1;
            self.log.push(format!("Turn {}", self.turn_count));
        }

        fn get_turn_count(&self) -> u32 {
            self.turn_count
        }
    }

    #[async_trait]
    impl System for TurnManagerSystem {
        fn name(&self) -> &'static str {
            "turn_manager"
        }

        async fn initialize(&mut self, _ctx: &mut Context) {
            self.log.push("Turn manager initialized".to_string());
        }

        fn as_any(&self) -> &dyn Any {
            self
        }

        fn as_any_mut(&mut self) -> &mut dyn Any {
            self
        }
    }

    #[tokio::test]
    async fn test_system_creation() {
        let system = TurnManagerSystem::new();
        assert_eq!(system.name(), "turn_manager");
        assert_eq!(system.get_turn_count(), 0);
    }

    #[tokio::test]
    async fn test_system_turn_management() {
        let mut system = TurnManagerSystem::new();
        system.next_turn();
        system.next_turn();
        assert_eq!(system.get_turn_count(), 2);
        assert_eq!(system.log.len(), 2);
    }

    #[tokio::test]
    async fn test_system_initialize() {
        let mut system = TurnManagerSystem::new();
        let mut ctx = Context::new();
        system.initialize(&mut ctx).await;
        assert!(system.log.contains(&"Turn manager initialized".to_string()));
    }
}