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

//! System for macroeconomy plugin

use super::config::MacroeconomyConfig;
use super::resources::EconomicMetrics;
use super::service::MacroeconomyService;
use super::state::MacroeconomyState;
use issun_core::mechanics::macroeconomy::prelude::*;
use issun_core::mechanics::{EventEmitter, Mechanic};

/// Type alias for the default macroeconomy mechanic
pub type DefaultMacroeconomy = MacroeconomyMechanic<SimpleEconomicPolicy>;

/// System for running macroeconomy mechanic
#[derive(Debug, Clone, Copy)]
pub struct MacroeconomySystem;

impl MacroeconomySystem {
    /// Check if macroeconomy should update this tick
    pub fn should_update(current_tick: u64, config: &MacroeconomyConfig) -> bool {
        if config.update_interval == 0 {
            return true; // Update every tick
        }
        current_tick.is_multiple_of(config.update_interval)
    }

    /// Update economic indicators
    pub fn update_indicators<
        E: EventEmitter<issun_core::mechanics::macroeconomy::EconomicEvent>,
    >(
        config: &MacroeconomyConfig,
        state: &mut MacroeconomyState,
        metrics: &EconomicMetrics,
        emitter: &mut E,
    ) {
        let service = MacroeconomyService;
        let snapshot = service.create_snapshot(metrics);

        // Run the mechanic
        DefaultMacroeconomy::step(&config.parameters, &mut state.indicators, snapshot, emitter);
    }
}

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

    #[test]
    fn test_should_update_every_tick() {
        let mut config = MacroeconomyConfig::default();
        config.update_interval = 0;

        assert!(MacroeconomySystem::should_update(0, &config));
        assert!(MacroeconomySystem::should_update(1, &config));
        assert!(MacroeconomySystem::should_update(100, &config));
    }

    #[test]
    fn test_should_update_interval() {
        let mut config = MacroeconomyConfig::default();
        config.update_interval = 10;

        assert!(MacroeconomySystem::should_update(0, &config));
        assert!(!MacroeconomySystem::should_update(1, &config));
        assert!(!MacroeconomySystem::should_update(9, &config));
        assert!(MacroeconomySystem::should_update(10, &config));
        assert!(MacroeconomySystem::should_update(20, &config));
    }

    #[test]
    fn test_update_indicators() {
        let config = MacroeconomyConfig::default();
        let mut state = MacroeconomyState::default();
        let mut metrics = EconomicMetrics::default();
        metrics.current_tick = 100;

        struct TestEmitter {
            events: Vec<issun_core::mechanics::macroeconomy::EconomicEvent>,
        }
        impl EventEmitter<issun_core::mechanics::macroeconomy::EconomicEvent> for TestEmitter {
            fn emit(&mut self, event: issun_core::mechanics::macroeconomy::EconomicEvent) {
                self.events.push(event);
            }
        }

        let mut emitter = TestEmitter { events: vec![] };

        MacroeconomySystem::update_indicators(&config, &mut state, &metrics, &mut emitter);

        // State should be updated
        assert_eq!(state.indicators.last_update, 100);
    }
}