Struct GalacticAddress 

pub struct GalacticAddress {
    pub reality_index: u8,
    /* private fields */
}

A packed 48-bit galactic coordinate plus a galaxy (reality) index.

The 48-bit value encodes fields in portal glyph order: P-SSS-YY-ZZZ-XXX where P=PlanetIndex, SSS=SolarSystemIndex, YY=VoxelY, ZZZ=VoxelZ, XXX=VoxelX.

The reality_index identifies the galaxy (0=Euclid, 1=Hilbert, etc.) and is stored separately from the packed value.

Fields

reality_index: u8

Implementations

impl GalacticAddress

pub fn new( voxel_x: i16, voxel_y: i8, voxel_z: i16, solar_system_index: u16, planet_index: u8, reality_index: u8, ) -> Self

Create from individual field values (portal coordinate frame).

pub fn from_packed(packed: u64, reality_index: u8) -> Self

Create from raw packed 48-bit value and reality index.

pub fn packed(&self) -> u64

Return the raw 48-bit packed value.

pub fn planet_index(&self) -> u8

Planet index (4-bit unsigned, 0-15). Bits 47-44.

pub fn solar_system_index(&self) -> u16

Solar system index (12-bit unsigned, 0x000-0xFFE). Bits 43-32.

pub fn voxel_y(&self) -> i8

VoxelY (8-bit signed, -128..127). Bits 31-24.

pub fn voxel_z(&self) -> i16

VoxelZ (12-bit signed, -2048..2047). Bits 23-12.

pub fn voxel_x(&self) -> i16

VoxelX (12-bit signed, -2048..2047). Bits 11-0.

pub fn voxel_position(&self) -> (i16, i8, i16)

Voxel coordinates as (x, y, z) signed integers (center-origin).

pub fn from_signal_booster( s: &str, planet_index: u8, reality_index: u8, ) -> Result<Self, AddressParseError>

Parse signal booster format XXXX:YYYY:ZZZZ:SSSS.

Signal booster uses corner-origin unsigned coordinates. The conversion adds fixed offsets to translate into portal-frame (center-origin) values. Does NOT include planet index or reality index; caller must supply those.

pub fn to_signal_booster(&self) -> String

Format as signal booster string XXXX:YYYY:ZZZZ:SSSS.

Converts portal-frame (center-origin) coordinates back to the corner-origin unsigned format used by the in-game signal booster.

pub fn distance_ly(&self, other: &GalacticAddress) -> f64

Distance in light-years to another address.

Uses Euclidean distance in voxel space multiplied by 400. Only meaningful for addresses in the same galaxy.

pub fn same_region(&self, other: &GalacticAddress) -> bool

Whether two addresses are in the same region (same VoxelX/Y/Z).

pub fn same_system(&self, other: &GalacticAddress) -> bool

Whether two addresses are in the same system (same region + same SSI).

pub fn within(&self, other: &GalacticAddress, ly: f64) -> bool

Whether another address is within N light-years.

pub fn distance_to_core_ly(&self) -> f64

Distance in light-years from this address to the galactic core (0, 0, 0).

Note: comparing addresses across different galaxies (reality_index) is not physically meaningful.

pub fn is_black_hole(&self) -> bool

Whether this address points to a black hole system (SSI 0x079).

pub fn is_atlas_interface(&self) -> bool

Whether this address points to an Atlas Interface system (SSI 0x07A).

pub fn is_purple_system(&self) -> bool

Whether this address is in the purple system SSI range (0x3E8-0x429).

impl GalacticAddress

pub fn to_portal_address(&self) -> PortalAddress

Convert to PortalAddress.

pub fn from_portal_string(s: &str) -> Result<Self, PortalParseError>

Create from a portal address string (hex, emoji, or mixed). Reality index defaults to 0.

Trait Implementations

impl Clone for GalacticAddress

fn clone(&self) -> GalacticAddress

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GalacticAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GalacticAddress

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GalacticAddress

Display as 0x followed by 12 uppercase hex digits.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<GalacticAddress> for PortalAddress

fn from(addr: GalacticAddress) -> Self

Convert galactic address to portal address.

Extracts each nibble from the packed 48-bit value.

impl From<GalacticAddress> for u64

Into raw packed u64 (drops reality_index).

fn from(addr: GalacticAddress) -> u64

Converts to this type from the input type.

impl From<PortalAddress> for GalacticAddress

fn from(pa: PortalAddress) -> Self

Convert portal address to galactic address.

Portal glyph layout: P-SSS-YY-ZZZ-XXX (glyph positions 0-indexed: [0]=P, [1-3]=SSS, [4-5]=YY, [6-8]=ZZZ, [9-11]=XXX). Reality index defaults to 0.

impl From<u64> for GalacticAddress

From raw packed u64 (reality_index defaults to 0).

fn from(packed: u64) -> Self

Converts to this type from the input type.

impl FromStr for GalacticAddress

Parse from 0x/0X prefix + 12 hex digits, or bare 12 hex digits. Reality index defaults to 0.

type Err = AddressParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for GalacticAddress

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for GalacticAddress

fn eq(&self, other: &GalacticAddress) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for GalacticAddress

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for GalacticAddress

impl Eq for GalacticAddress

impl StructuralPartialEq for GalacticAddress