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

//! Research project definitions (ReadOnly asset)

use super::types::*;
use crate::resources::Resource;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Collection of research project definitions (ReadOnly)
///
/// This is an asset loaded at startup and does not change during gameplay.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResearchProjects {
    projects: HashMap<ResearchId, ResearchProject>,
}

impl Resource for ResearchProjects {}

impl ResearchProjects {
    /// Create a new empty projects collection
    pub fn new() -> Self {
        Self {
            projects: HashMap::new(),
        }
    }

    /// Add a research project definition
    pub fn define(&mut self, project: ResearchProject) {
        self.projects.insert(project.id.clone(), project);
    }

    /// Get a project by id
    pub fn get(&self, id: &ResearchId) -> Option<&ResearchProject> {
        self.projects.get(id)
    }

    /// Check if a project exists
    pub fn contains(&self, id: &ResearchId) -> bool {
        self.projects.contains_key(id)
    }

    /// List all projects
    pub fn iter(&self) -> impl Iterator<Item = &ResearchProject> {
        self.projects.values()
    }

    /// Get the number of projects
    pub fn len(&self) -> usize {
        self.projects.len()
    }

    /// Check if the collection is empty
    pub fn is_empty(&self) -> bool {
        self.projects.is_empty()
    }
}

impl Default for ResearchProjects {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_projects_new() {
        let projects = ResearchProjects::new();
        assert!(projects.is_empty());
        assert_eq!(projects.len(), 0);
    }

    #[test]
    fn test_define_and_get() {
        let mut projects = ResearchProjects::new();
        let project = ResearchProject::new("test", "Test Project", "Test description");
        projects.define(project);

        assert_eq!(projects.len(), 1);
        assert!(!projects.is_empty());
        assert!(projects.get(&ResearchId::new("test")).is_some());
        assert_eq!(
            projects.get(&ResearchId::new("test")).unwrap().name,
            "Test Project"
        );
    }

    #[test]
    fn test_contains() {
        let mut projects = ResearchProjects::new();
        projects.define(ResearchProject::new("test", "Test", "Test"));

        assert!(projects.contains(&ResearchId::new("test")));
        assert!(!projects.contains(&ResearchId::new("other")));
    }

    #[test]
    fn test_iter() {
        let mut projects = ResearchProjects::new();
        projects.define(ResearchProject::new("test1", "Test 1", "Test"));
        projects.define(ResearchProject::new("test2", "Test 2", "Test"));

        let count = projects.iter().count();
        assert_eq!(count, 2);
    }
}