nms-core 0.2.0

Core types, enums, address math, and portal glyph display for No Man's Sky Copilot
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

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use crate::address::GalacticAddress;
use crate::biome::{Biome, BiomeSubType};

/// Unique identifier for a star system.
///
/// The value is the packed 48-bit galactic address with planet index zeroed out
/// (i.e., bits 47-44 cleared). Two systems at the same voxel coordinates but
/// different SSI values get different IDs.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SystemId(pub u64);

impl SystemId {
    /// Create from a `GalacticAddress` by zeroing the planet index bits.
    pub fn from_address(addr: &GalacticAddress) -> Self {
        // Clear the top 4 bits (planet index) of the 48-bit packed value
        let packed = addr.packed() & 0x0FFF_FFFF_FFFF;
        SystemId(packed)
    }
}

/// A star system containing one or more planets.
///
/// The galaxy (reality index) is encoded in the `address` field.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct System {
    pub address: GalacticAddress,
    pub name: Option<String>,
    pub discoverer: Option<String>,
    pub timestamp: Option<DateTime<Utc>>,
    pub planets: Vec<Planet>,
}

impl System {
    pub fn new(
        address: GalacticAddress,
        name: Option<String>,
        discoverer: Option<String>,
        timestamp: Option<DateTime<Utc>>,
        planets: Vec<Planet>,
    ) -> Self {
        Self {
            address,
            name,
            discoverer,
            timestamp,
            planets,
        }
    }

    /// Galaxy index (convenience accessor for `address.reality_index`).
    pub fn reality_index(&self) -> u8 {
        self.address.reality_index
    }
}

/// A planet within a star system.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(
    feature = "archive",
    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
)]
#[non_exhaustive]
pub struct Planet {
    /// Planet index within the system (0-15).
    pub index: u8,
    pub biome: Option<Biome>,
    pub biome_subtype: Option<BiomeSubType>,
    /// Whether the planet has infested (biological horror) variant.
    pub infested: bool,
    pub name: Option<String>,
    /// Procedural generation seed.
    pub seed_hash: Option<u64>,
}

impl Planet {
    pub fn new(
        index: u8,
        biome: Option<Biome>,
        biome_subtype: Option<BiomeSubType>,
        infested: bool,
        name: Option<String>,
        seed_hash: Option<u64>,
    ) -> Self {
        Self {
            index,
            biome,
            biome_subtype,
            infested,
            name,
            seed_hash,
        }
    }
}

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

    #[test]
    fn system_reality_index_from_address() {
        let addr = GalacticAddress::new(0, 0, 0, 0x123, 0, 42);
        let sys = System::new(addr, None, None, None, vec![]);
        assert_eq!(sys.reality_index(), 42);
    }

    #[test]
    fn planet_constructor() {
        let p = Planet::new(3, Some(Biome::Lush), None, false, Some("Eden".into()), None);
        assert_eq!(p.index, 3);
        assert_eq!(p.biome, Some(Biome::Lush));
        assert!(!p.infested);
    }
}