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
137
138
139
140
141
142
143
144

//! Territory collection (read-only resource)

use super::types::*;
use issun_macros::Resource as DeriveResource;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Collection of all territory definitions (read-only)
///
/// Contains all territory definitions loaded from assets/config.
/// These are immutable during gameplay.
///
/// # Example
///
/// ```ignore
/// use issun::plugin::territory::{Territories, Territory};
///
/// let mut territories = Territories::new();
/// territories.add(Territory::new("nova", "Nova Harbor"));
/// territories.add(Territory::new("rust-city", "Rust City"));
///
/// // Query
/// if let Some(territory) = territories.get(&"nova".into()) {
///     println!("Found: {}", territory.name);
/// }
/// ```
#[derive(Debug, Clone, Serialize, Deserialize, DeriveResource)]
pub struct Territories {
    territories: HashMap<TerritoryId, Territory>,
}

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

    /// Add a territory definition
    pub fn add(&mut self, territory: Territory) {
        self.territories.insert(territory.id.clone(), territory);
    }

    /// Get territory by id
    pub fn get(&self, id: &TerritoryId) -> Option<&Territory> {
        self.territories.get(id)
    }

    /// Check if a territory exists
    pub fn contains(&self, id: &TerritoryId) -> bool {
        self.territories.contains_key(id)
    }

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

    /// Check if empty
    pub fn is_empty(&self) -> bool {
        self.territories.is_empty()
    }

    /// Iterate over all territories
    pub fn iter(&self) -> impl Iterator<Item = &Territory> {
        self.territories.values()
    }

    /// Query territories by predicate
    pub fn query<F>(&self, predicate: F) -> Vec<&Territory>
    where
        F: Fn(&Territory) -> bool,
    {
        self.territories.values().filter(|t| predicate(t)).collect()
    }
}

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

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

    #[test]
    fn test_territories_new() {
        let territories = Territories::new();
        assert_eq!(territories.len(), 0);
        assert!(territories.is_empty());
    }

    #[test]
    fn test_add_and_get() {
        let mut territories = Territories::new();
        let territory = Territory::new("nova", "Nova Harbor");
        territories.add(territory);

        assert_eq!(territories.len(), 1);
        assert!(!territories.is_empty());

        let retrieved = territories.get(&TerritoryId::new("nova"));
        assert!(retrieved.is_some());
        assert_eq!(retrieved.unwrap().name, "Nova Harbor");
    }

    #[test]
    fn test_contains() {
        let mut territories = Territories::new();
        territories.add(Territory::new("nova", "Nova Harbor"));

        assert!(territories.contains(&TerritoryId::new("nova")));
        assert!(!territories.contains(&TerritoryId::new("rust")));
    }

    #[test]
    fn test_iter() {
        let mut territories = Territories::new();
        territories.add(Territory::new("nova", "Nova Harbor"));
        territories.add(Territory::new("rust", "Rust City"));

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

        let names: Vec<_> = territories.iter().map(|t| t.name.as_str()).collect();
        assert!(names.contains(&"Nova Harbor"));
        assert!(names.contains(&"Rust City"));
    }

    #[test]
    fn test_query() {
        let mut territories = Territories::new();
        territories.add(Territory::new("nova", "Nova Harbor"));
        territories.add(Territory::new("rust", "Rust City"));

        // Query by name
        let nova_only = territories.query(|t| t.name == "Nova Harbor");
        assert_eq!(nova_only.len(), 1);
        assert_eq!(nova_only[0].id.as_str(), "nova");
    }
}