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

//! Research system configuration (ReadOnly)

use crate::resources::Resource;
use serde::{Deserialize, Serialize};

/// Progress model for research projects
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum ProgressModel {
    /// Fixed progress per turn (e.g., 0.1 per turn = 10 turns)
    #[default]
    TurnBased,

    /// Real-time progress (requires GameTimer plugin)
    TimeBased,

    /// Manual progress updates via events
    Manual,
}

/// Configuration for research system (ReadOnly)
///
/// This is a config/asset loaded at startup and does not change during gameplay.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResearchConfig {
    /// Allow multiple projects to be researched simultaneously
    pub allow_parallel_research: bool,

    /// Maximum number of parallel research slots
    pub max_parallel_slots: usize,

    /// Progress model (turn-based, time-based, manual)
    pub progress_model: ProgressModel,

    /// Auto-advance progress each turn/tick
    pub auto_advance: bool,

    /// Base progress per turn (when auto_advance = true)
    pub base_progress_per_turn: f32,
}

impl Resource for ResearchConfig {}

impl Default for ResearchConfig {
    fn default() -> Self {
        Self {
            allow_parallel_research: false,
            max_parallel_slots: 1,
            progress_model: ProgressModel::TurnBased,
            auto_advance: true,
            base_progress_per_turn: 0.1, // 10 turns by default
        }
    }
}

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

    #[test]
    fn test_default_config() {
        let config = ResearchConfig::default();
        assert!(!config.allow_parallel_research);
        assert_eq!(config.max_parallel_slots, 1);
        assert_eq!(config.progress_model, ProgressModel::TurnBased);
        assert!(config.auto_advance);
        assert_eq!(config.base_progress_per_turn, 0.1);
    }

    #[test]
    fn test_progress_model_default() {
        assert_eq!(ProgressModel::default(), ProgressModel::TurnBased);
    }
}