Adjust SB data in WASM to use 1 letter race identifiers, simplify SB data parsing structure.

Author: tec27

broodrep-wasm/examples/index.html

@@ -138,16 +138,16 @@
         color: #666;
       }
 
-      .race-terran {
+      .race-t {
         color: #ff6b6b;
       }
-      .race-protoss {
+      .race-p {
         color: #4ecdc4;
       }
-      .race-zerg {
+      .race-z {
         color: #9b59b6;
       }
-      .race-random {
+      .race-r {
         color: #95a5a6;
       }
 
@@ -263,7 +263,7 @@ <h3>ShieldBattery Data</h3>
       }
 
       function getRaceClass(race) {
-        return `race-${race.toLowerCase()}`
+        return `race-${race}`
       }
 
       function displayReplayInfo(replay) {
@@ -368,10 +368,7 @@ <h3>ShieldBattery Data</h3>
         if (shieldBatteryData) {
           shieldBatterySection.style.display = 'block'
 
-          const raceNames = ['Zerg', 'Terran', 'Protoss']
-          const startingRaces = shieldBatteryData.startingRaces
-            .map(race => raceNames[race] || `Random`)
-            .join(', ')
+          const startingRaces = shieldBatteryData.startingRaces.join(', ')
 
           const activeUserIds = shieldBatteryData.userIds.filter(id => id !== 0)
           const mainPlayers = shieldBatteryData.teamGameMainPlayers

broodrep-wasm/src/lib.rs

@@ -176,12 +176,15 @@ impl From<broodrep::PlayerType> for PlayerType {
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Tsify, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 #[tsify(into_wasm_abi)]
 pub enum Race {
+    #[serde(rename = "z")]
     Zerg,
+    #[serde(rename = "t")]
     Terran,
+    #[serde(rename = "p")]
     Protoss,
+    #[serde(rename = "r")]
     Random,
 }
 
@@ -318,7 +321,7 @@ pub struct ShieldBatteryData {
     pub starcraft_exe_build: u32,
     pub shieldbattery_version: String,
     pub team_game_main_players: [u8; 4],
-    pub starting_races: [u8; 12],
+    pub starting_races: [Race; 12],
     pub game_id: Uuid,
     pub user_ids: [u32; 8],
     pub game_logic_version: Option<u16>,
@@ -327,13 +330,13 @@ pub struct ShieldBatteryData {
 impl From<broodrep::ShieldBatteryData> for ShieldBatteryData {
     fn from(data: broodrep::ShieldBatteryData) -> Self {
         ShieldBatteryData {
-            starcraft_exe_build: data.starcraft_exe_build(),
-            shieldbattery_version: data.shieldbattery_version().to_string(),
-            team_game_main_players: data.team_game_main_players(),
-            starting_races: data.starting_races(),
-            game_id: Uuid::from_u128(data.game_id()),
-            user_ids: data.user_ids(),
-            game_logic_version: data.game_logic_version(),
+            starcraft_exe_build: data.starcraft_exe_build,
+            shieldbattery_version: data.shieldbattery_version.to_string(),
+            team_game_main_players: data.team_game_main_players,
+            starting_races: data.starting_races.map(Into::into),
+            game_id: Uuid::from_u128(data.game_id),
+            user_ids: data.user_ids,
+            game_logic_version: data.game_logic_version,
         }
     }
 }

broodrep/src/lib.rs

@@ -412,7 +412,7 @@ impl<R: Read + Seek> Replay<R> {
                 let network_id = cursor.read_u8()?;
                 cursor.seek(SeekFrom::Current(3))?; // unknown
                 let player_type: PlayerType = cursor.read_u8()?.try_into()?;
-                let race: Race = cursor.read_u8()?.try_into()?;
+                let race: Race = cursor.read_u8()?.into();
                 let team = cursor.read_u8()?;
                 let mut name = vec![0u8; 26];
                 cursor.read_exact(&mut name[..25])?;
@@ -836,15 +836,13 @@ pub enum Race {
     Random = 6,
 }
 
-impl TryFrom<u8> for Race {
-    type Error = BroodrepError;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
+impl From<u8> for Race {
+    fn from(value: u8) -> Self {
         match value {
-            0 => Ok(Race::Zerg),
-            1 => Ok(Race::Terran),
-            2 => Ok(Race::Protoss),
-            _ => Ok(Race::Random),
+            0 => Race::Zerg,
+            1 => Race::Terran,
+            2 => Race::Protoss,
+            _ => Race::Random,
         }
     }
 }
@@ -1078,13 +1076,29 @@ mod tests {
         assert!(data.is_some());
         let data = data.unwrap();
 
-        assert_eq!(data.starcraft_exe_build(), 13515);
-        assert_eq!(data.shieldbattery_version(), "10.1.0");
-        assert_eq!(data.team_game_main_players(), [0, 0, 0, 0]);
-        assert_eq!(data.starting_races(), [2, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0]);
-        assert_eq!(data.game_id(), 56542772156747381282200559102402795521);
-        assert_eq!(data.user_ids(), [101, 112, 1, 113, 0, 0, 0, 0]);
-        assert_eq!(data.game_logic_version(), Some(3));
+        assert_eq!(data.starcraft_exe_build, 13515);
+        assert_eq!(data.shieldbattery_version, "10.1.0");
+        assert_eq!(data.team_game_main_players, [0, 0, 0, 0]);
+        assert_eq!(
+            data.starting_races,
+            [
+                Race::Protoss,
+                Race::Terran,
+                Race::Zerg,
+                Race::Terran,
+                Race::Terran,
+                Race::Zerg,
+                Race::Terran,
+                Race::Terran,
+                Race::Zerg,
+                Race::Zerg,
+                Race::Zerg,
+                Race::Zerg
+            ]
+        );
+        assert_eq!(data.game_id, 56542772156747381282200559102402795521);
+        assert_eq!(data.user_ids, [101, 112, 1, 113, 0, 0, 0, 0]);
+        assert_eq!(data.game_logic_version, Some(3));
     }
 
     #[test]

broodrep/src/shieldbattery.rs

@@ -6,6 +6,8 @@ use std::{
 use byteorder::{LittleEndian as LE, ReadBytesExt as _};
 use thiserror::Error;
 
+use crate::Race;
+
 #[derive(Error, Debug)]
 pub enum ShieldBatteryDataError {
     #[error(transparent)]
@@ -15,83 +17,23 @@ pub enum ShieldBatteryDataError {
 }
 
 #[derive(Debug, Clone)]
-pub enum ShieldBatteryData {
-    Version0(ShieldBatteryDataV0),
-    Version1(ShieldBatteryDataV0, ShieldBatteryDataV1),
-}
-
-#[derive(Debug, Clone)]
-pub struct ShieldBatteryDataV0 {
-    pub starcraft_exe_build: u32,
-    pub shieldbattery_version: String,
-    pub team_game_main_players: [u8; 4],
-    pub starting_races: [u8; 12],
-    pub game_id: u128,
-    pub user_ids: [u32; 8],
-}
-
-#[derive(Debug, Clone)]
-pub struct ShieldBatteryDataV1 {
-    game_logic_version: u16,
-}
-
-impl ShieldBatteryData {
+pub struct ShieldBatteryData {
     /// The build number of the StarCraft executable used to play the game.
-    pub fn starcraft_exe_build(&self) -> u32 {
-        match self {
-            ShieldBatteryData::Version0(data) => data.starcraft_exe_build,
-            ShieldBatteryData::Version1(data, _) => data.starcraft_exe_build,
-        }
-    }
-
+    pub starcraft_exe_build: u32,
     /// The version string of the ShieldBattery client used to play the game.
-    pub fn shieldbattery_version(&self) -> &str {
-        match self {
-            ShieldBatteryData::Version0(data) => &data.shieldbattery_version,
-            ShieldBatteryData::Version1(data, _) => &data.shieldbattery_version,
-        }
-    }
-
+    pub shieldbattery_version: String,
     /// Which players were the "main" players in a team game (e.g. Team Melee).
-    pub fn team_game_main_players(&self) -> [u8; 4] {
-        match self {
-            ShieldBatteryData::Version0(data) => data.team_game_main_players,
-            ShieldBatteryData::Version1(data, _) => data.team_game_main_players,
-        }
-    }
-
+    pub team_game_main_players: [u8; 4],
     /// The starting race for each player in the game.
-    pub fn starting_races(&self) -> [u8; 12] {
-        match self {
-            ShieldBatteryData::Version0(data) => data.starting_races,
-            ShieldBatteryData::Version1(data, _) => data.starting_races,
-        }
-    }
-
+    pub starting_races: [Race; 12],
     /// The game's ID on ShieldBattery (a UUID as a u128).
-    pub fn game_id(&self) -> u128 {
-        match self {
-            ShieldBatteryData::Version0(data) => data.game_id,
-            ShieldBatteryData::Version1(data, _) => data.game_id,
-        }
-    }
-
+    pub game_id: u128,
     /// The ShieldBattery user IDs of the players ingame, in the same order as the players in the
     /// replay header.
-    pub fn user_ids(&self) -> [u32; 8] {
-        match self {
-            ShieldBatteryData::Version0(data) => data.user_ids,
-            ShieldBatteryData::Version1(data, _) => data.user_ids,
-        }
-    }
-
-    /// The version of ShieldBattery game logic modifications used to play the game.
-    pub fn game_logic_version(&self) -> Option<u16> {
-        match self {
-            ShieldBatteryData::Version0(_) => None,
-            ShieldBatteryData::Version1(_, data) => Some(data.game_logic_version),
-        }
-    }
+    pub user_ids: [u32; 8],
+    /// The version of ShieldBattery game logic modifications used to play the game. May not be
+    /// present on older replays.
+    pub game_logic_version: Option<u16>,
 }
 
 pub fn parse_shieldbattery_section(
@@ -109,25 +51,23 @@ pub fn parse_shieldbattery_section(
     data.read_exact(&mut team_game_main_players)?;
     let mut starting_races = [0u8; 12];
     data.read_exact(&mut starting_races)?;
+    let starting_races = starting_races.map(Into::into);
     let game_id = data.read_u128::<LE>()?;
     let mut user_ids = [0u32; 8];
     data.read_u32_into::<LE>(&mut user_ids)?;
 
-    let v0 = ShieldBatteryDataV0 {
+    let mut parsed = ShieldBatteryData {
         starcraft_exe_build,
         shieldbattery_version,
         team_game_main_players,
         starting_races,
         game_id,
         user_ids,
+        game_logic_version: None,
     };
-    if version == 0 {
-        Ok(ShieldBatteryData::Version0(v0))
-    } else
-    /* if version >= 1 */
-    {
-        let game_logic_version = data.read_u16::<LE>()?;
-        let v1 = ShieldBatteryDataV1 { game_logic_version };
-        Ok(ShieldBatteryData::Version1(v0, v1))
+    if version >= 1 {
+        parsed.game_logic_version = Some(data.read_u16::<LE>()?);
     }
+
+    Ok(parsed)
 }