Change Team from enum to struct

Author: object-Object

src/logic/vm/instructions.rs

@@ -414,7 +414,7 @@ impl Print {
             }
             LValue::String(string) => Cow::Borrowed(string),
             LValue::Content(content) => Cow::Borrowed(content.name()),
-            LValue::Team(team) => Cow::from(team.as_ref()),
+            LValue::Team(team) => Cow::from(team.name()),
             LValue::Building(position) => vm
                 .building(*position)
                 .map(|b| Cow::Borrowed(b.block.name.as_str()))
@@ -613,8 +613,8 @@ impl SimpleInstruction for Sensor {
                 },
 
                 LValue::Team(team) => match sensor {
-                    Name => LString::Static(team.into()).into(),
-                    Id => team.id().into(),
+                    Name => LString::Static(team.name()).into(),
+                    Id => team.0.into(),
                     Color => team.color().into(),
                     _ => LValue::Null,
                 },
@@ -626,7 +626,7 @@ impl SimpleInstruction for Sensor {
                         Y => building.position.y.into(),
                         Color => colors::TEAM_SHARDED.into(),
                         Dead => false.into(),
-                        Team => crate::types::Team::Sharded.id().into(),
+                        Team => crate::types::Team::SHARDED.0.into(),
                         Efficiency => 1.into(),
                         Timescale => 1.into(),
                         Range => building.block.range.into(),
@@ -853,7 +853,7 @@ impl SimpleInstruction for Lookup {
                 .map(|v| Content::Unit(v))
                 .into(),
 
-            ContentType::Team => id.try_into().ok().map(Team::from_id).into(),
+            ContentType::Team => id.try_into().ok().map(Team).into(),
 
             _ => LValue::Null,
         };

src/logic/vm/mod.rs

@@ -2475,11 +2475,8 @@ mod tests {
         // teams
 
         assert_eq!(variables["team1"].get(&state), LValue::Null);
-        assert_eq!(variables["team2"].get(&state), LValue::Team(Team::Derelict));
-        assert_eq!(
-            variables["team3"].get(&state),
-            LValue::Team(Team::Unknown(255))
-        );
+        assert_eq!(variables["team2"].get(&state), LValue::Team(Team::DERELICT));
+        assert_eq!(variables["team3"].get(&state), LValue::Team(Team(255)));
         assert_eq!(variables["team4"].get(&state), LValue::Null);
     }
 

src/logic/vm/variables.rs

@@ -79,7 +79,11 @@ impl LVar {
             "@unitCount": constant(content::units::FROM_LOGIC_ID.len()),
         };
 
-        globals.extend(Team::base_teams().map(|t| named_constant(t, t)));
+        globals.extend(
+            Team::BASE_TEAMS
+                .iter()
+                .map(|&t| named_constant(t.name(), t)),
+        );
 
         globals.extend(
             content::items::VALUES

src/types/enums.rs

@@ -3,7 +3,9 @@
 use std::hash::Hash;
 
 use binrw::prelude::*;
+use lazy_static::lazy_static;
 use strum_macros::{AsRefStr, IntoStaticStr, VariantArray};
+use velcro::vec;
 
 use super::colors;
 
@@ -118,74 +120,60 @@ pub enum LAccess {
     Color,
 }
 
+lazy_static! {
+    static ref TEAM_NAMES: Vec<&'static str> = vec![
+        "derelict",
+        "sharded",
+        "crux",
+        "malis",
+        "green",
+        "blue",
+        "neoplastic",
+        ..(Team::BASE_TEAMS.len()..256).map(|i| -> &'static str { format!("team#{i}").leak() }),
+    ];
+}
+
+const TEAM_COLORS: &[f64] = &[
+    colors::TEAM_DERELICT_F64,
+    colors::TEAM_SHARDED_F64,
+    colors::TEAM_CRUX_F64,
+    colors::TEAM_MALIS_F64,
+    colors::TEAM_GREEN_F64,
+    colors::TEAM_BLUE_F64,
+    colors::TEAM_NEOPLASTIC_F64,
+    // TODO: unnamed teams
+];
+
 #[binrw]
 #[brw(big)]
-#[derive(
-    Debug, Clone, Copy, PartialEq, Eq, Hash, AsRefStr, IntoStaticStr, strum_macros::Display,
-)]
-#[strum(serialize_all = "camelCase")]
-pub enum Team {
-    #[brw(magic = 0u8)]
-    Derelict,
-    #[brw(magic = 1u8)]
-    Sharded,
-    #[brw(magic = 2u8)]
-    Crux,
-    #[brw(magic = 3u8)]
-    Malis,
-    #[brw(magic = 4u8)]
-    Green,
-    #[brw(magic = 5u8)]
-    Blue,
-    #[brw(magic = 6u8)]
-    Neoplastic,
-    #[strum(to_string = "team#{0}")]
-    Unknown(u8),
-}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Team(pub u8);
 
 impl Team {
-    pub fn base_teams() -> impl Iterator<Item = Self> {
-        (0u8..=6u8).map(Self::from_id)
-    }
+    pub const DERELICT: Self = Self(0);
+    pub const SHARDED: Self = Self(1);
+    pub const CRUX: Self = Self(2);
+    pub const MALIS: Self = Self(3);
+    pub const GREEN: Self = Self(4);
+    pub const BLUE: Self = Self(5);
+    pub const NEOPLASTIC: Self = Self(6);
 
-    pub fn from_id(id: u8) -> Self {
-        match id {
-            0 => Self::Derelict,
-            1 => Self::Sharded,
-            2 => Self::Crux,
-            3 => Self::Malis,
-            4 => Self::Green,
-            5 => Self::Blue,
-            6 => Self::Neoplastic,
-            _ => Self::Unknown(id),
-        }
-    }
+    pub const BASE_TEAMS: &[Self] = &[
+        Self::DERELICT,
+        Self::SHARDED,
+        Self::CRUX,
+        Self::MALIS,
+        Self::GREEN,
+        Self::BLUE,
+        Self::NEOPLASTIC,
+    ];
 
-    pub fn id(&self) -> u8 {
-        match self {
-            Self::Derelict => 0,
-            Self::Sharded => 1,
-            Self::Crux => 2,
-            Self::Malis => 3,
-            Self::Green => 4,
-            Self::Blue => 5,
-            Self::Neoplastic => 6,
-            Self::Unknown(id) => *id,
-        }
+    pub fn name(&self) -> &'static str {
+        TEAM_NAMES[self.0 as usize]
     }
 
     pub fn color(&self) -> f64 {
-        match self {
-            Self::Derelict => colors::TEAM_DERELICT_F64,
-            Self::Sharded => colors::TEAM_SHARDED_F64,
-            Self::Crux => colors::TEAM_CRUX_F64,
-            Self::Malis => colors::TEAM_MALIS_F64,
-            Self::Green => colors::TEAM_GREEN_F64,
-            Self::Blue => colors::TEAM_BLUE_F64,
-            Self::Neoplastic => colors::TEAM_NEOPLASTIC_F64,
-            // TODO: implement
-            Self::Unknown(_) => 0.,
-        }
+        TEAM_COLORS.get(self.0 as usize).copied().unwrap_or(0.)
     }
 }