Break: make winner_team_number optional

rustfmt.toml

@@ -8,3 +8,4 @@ reorder_impl_items = true
 unstable_features = true
 use_field_init_shorthand = true
 version = "Two"
+struct_lit_width = 35

src/error.rs

@@ -6,10 +6,10 @@ pub enum Error {
     ZipError(#[from] zip::result::ZipError),
 
     #[error("Protocol Buffers error")]
-    DecodeFailed(#[from] prost::DecodeError),
+    ProtobufError(#[from] prost::DecodeError),
 
     #[error("Pickle error")]
-    UnpickleFailed(#[from] serde_pickle::Error),
+    PickleError(#[from] serde_pickle::Error),
 
     #[error("I/O error")]
     IoError(#[from] std::io::Error),
@@ -19,7 +19,7 @@ pub enum Error {
 
     #[cfg(feature = "meta")]
     #[error("JSON error")]
-    JsonDecodeFailed(#[from] serde_json::Error),
+    JsonError(#[from] serde_json::Error),
 
     #[error("invalid magic: {0:#X}, expected: {1:#X}")]
     InvalidMagic(u32, u32),

src/models/battle_results.rs

@@ -1,5 +1,5 @@
 use prost::bytes::Buf;
-use prost::Message;
+use prost::{Enumeration, Message};
 use serde::Serialize;
 
 use crate::result::Result;
@@ -22,8 +22,8 @@ pub struct BattleResults {
     #[prost(int64, tag = "2")]
     pub timestamp: i64,
 
-    #[prost(enumeration = "TeamNumber", tag = "3")]
-    pub winner_team_number: i32,
+    #[prost(enumeration = "TeamNumber", optional, tag = "3")]
+    pub winner_team_number: Option<i32>,
 
     /// Replay's author results.
     #[prost(message, required, tag = "8")]
@@ -78,9 +78,7 @@ pub struct PlayerInfo {
     pub avatar: Avatar,
 }
 
-#[derive(
-    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, prost::Enumeration, Serialize,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Enumeration, Serialize)]
 #[repr(i32)]
 pub enum TeamNumber {
     One = 1,

src/models/data.rs

@@ -3,8 +3,8 @@
 pub mod entity_method;
 pub mod packet;
 pub mod payload;
-pub mod replay_header;
-pub mod summary;
+pub mod type_0;
+pub mod update_arena;
 
 use std::io::Read;
 
@@ -12,11 +12,7 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use serde::de::DeserializeOwned;
 use serde::Serialize;
 
-pub use self::entity_method::*;
-pub use self::summary::*;
 use crate::models::data::packet::Packet;
-use crate::models::data::payload::Payload;
-use crate::models::data::replay_header::ReplayHeader;
 use crate::result::Result;
 use crate::Error;
 
@@ -26,9 +22,7 @@ pub struct Data {
     /// For example: `9.8.5_apple`.
     pub client_version: String,
 
-    pub replay_header: Option<ReplayHeader>,
-
-    pub other_packets: Vec<Packet>,
+    pub packets: Vec<Packet>,
 }
 
 impl Data {
@@ -39,36 +33,19 @@ impl Data {
         reader.read_u64::<LittleEndian>()?;
 
         // Some sort of client hash, e.g.: `6CF2A9EFA5C52D6F6CE43A6D4A699C05`:
-        read_bytes(&mut reader)?;
+        read_length_delimited(&mut reader)?;
 
         let client_version = read_string(&mut reader)?;
 
         // Some extra byte, no idea:
         reader.read_u8()?;
 
-        let mut this = Self::new(client_version);
-
-        loop {
-            let Some(packet) = Packet::from_reader(&mut reader)? else { break };
-            match packet.payload {
-                Payload::ReplayHeader(header) => {
-                    this.replay_header = Some(*header);
-                }
-                _ => {
-                    this.other_packets.push(packet);
-                }
-            }
+        let mut packets = Vec::new();
+        while let Some(packet) = Packet::from_reader(&mut reader)? {
+            packets.push(packet);
         }
 
-        Ok(this)
-    }
-
-    pub const fn new(client_version: String) -> Self {
-        Self {
-            client_version,
-            replay_header: None,
-            other_packets: Vec::new(),
-        }
+        Ok(Self { client_version, packets })
     }
 }
 
@@ -82,7 +59,7 @@ fn assert_magic<T: Into<u32> + PartialEq>(actual: T, expected: T) -> Result {
 }
 
 #[inline]
-fn read_bytes(reader: &mut impl Read) -> Result<Vec<u8>> {
+fn read_length_delimited(reader: &mut impl Read) -> Result<Vec<u8>> {
     let length = reader.read_u8()? as usize;
     let mut buffer = Vec::new();
     buffer.resize(length, 0);
@@ -92,7 +69,7 @@ fn read_bytes(reader: &mut impl Read) -> Result<Vec<u8>> {
 
 #[inline]
 fn read_string(reader: &mut impl Read) -> Result<String> {
-    Ok(String::from_utf8(read_bytes(reader)?)?)
+    Ok(String::from_utf8(read_length_delimited(reader)?)?)
 }
 
 #[inline]
@@ -102,3 +79,19 @@ fn read_pickled<T: DeserializeOwned>(reader: &mut impl Read, length: usize) -> R
     reader.read_exact(&mut buffer)?;
     Ok(serde_pickle::from_slice(&buffer, Default::default())?)
 }
+
+/// Read 2-byte length surrounded by the magical `0xFF` and `0x00`,
+/// unless it's a simple 1-byte length.
+///
+/// P.S. Okay, Wargaming, I've no idea what you smoke, but I want some!
+#[inline]
+fn read_quirky_length(reader: &mut impl Read) -> Result<usize> {
+    match reader.read_u8()? {
+        0xFF => {
+            let length = reader.read_u16::<LittleEndian>()?;
+            assert_magic(reader.read_u8()?, 0x00)?;
+            Ok(length as usize)
+        }
+        length => Ok(length as usize),
+    }
+}

src/models/data/entity_method.rs

@@ -1,16 +1,26 @@
 use byteorder::{LittleEndian, ReadBytesExt};
+use prost::encoding::decode_varint;
+use prost::Message;
 use serde::Serialize;
 use serde_with::serde_as;
 
+use crate::models::data::read_quirky_length;
+use crate::models::data::update_arena::UpdateArena;
 use crate::result::Result;
 
 #[serde_as]
 #[derive(Debug, Serialize)]
 pub enum EntityMethod {
-    /// TODO: team composition.
-    Subtype2F,
+    Subtype2F {
+        field_number: u64,
+        sub_type_2f: UpdateArena,
 
-    /// Default variant when subtype is not known.
+        /// Original payload for investigation.
+        #[serde_as(as = "serde_with::hex::Hex")]
+        payload: Vec<u8>,
+    },
+
+    /// Default variant when subtype is not known by the parser.
     Unknown {
         sub_type: u32,
 
@@ -28,7 +38,18 @@ impl EntityMethod {
         let sub_type = reader.read_u32::<LittleEndian>()?;
 
         let this = match sub_type {
-            0x2F => Self::Subtype2F,
+            0x2F => {
+                let _inner_length = reader.read_u32::<LittleEndian>()?;
+
+                let field_number = decode_varint(&mut reader)?;
+                let message_length = read_quirky_length(&mut reader)?;
+                Self::Subtype2F {
+                    field_number,
+                    sub_type_2f: UpdateArena::decode(&reader[..message_length])?,
+                    payload,
+                }
+            }
+
             _ => Self::Unknown { sub_type, payload },
         };
         Ok(this)

src/models/data/payload.rs

@@ -4,17 +4,25 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use serde::Serialize;
 use serde_with::serde_as;
 
-use crate::models::data::replay_header::ReplayHeader;
-use crate::models::data::{assert_magic, read_pickled, read_string, EntityMethod};
+use crate::models::data::entity_method::EntityMethod;
+use crate::models::data::type_0::Type0;
+use crate::models::data::{read_pickled, read_quirky_length, read_string};
 use crate::result::Result;
 
 #[serde_as]
 #[derive(Debug, Serialize)]
 pub enum Payload {
-    ReplayHeader(Box<ReplayHeader>),
+    /// Looks like some sort of replay summary.
+    Type0 {
+        author_nickname: String,
+        arena_unique_id: u64,
+        arena_type_id: u32,
+        type_0: Box<Type0>,
+    },
+
     EntityMethod(EntityMethod),
 
-    /// Default payload when type is not known.
+    /// Default payload when type is not known by the parser.
     Unknown {
         type_: u32,
 
@@ -34,26 +42,21 @@ impl Payload {
                 let author_nickname = read_string(&mut reader)?;
                 let arena_unique_id = reader.read_u64::<LittleEndian>()?;
                 let arena_type_id = reader.read_u32::<LittleEndian>()?;
-                let summary = {
-                    assert_magic(reader.read_u8()?, 0xFF)?;
-                    let pickled_length = reader.read_u16::<LittleEndian>()?;
-                    assert_magic(reader.read_u8()?, 0x00)?;
-                    read_pickled(&mut reader, pickled_length as usize)?
+                let type_0 = {
+                    let pickled_length = read_quirky_length(&mut reader)?;
+                    read_pickled(&mut reader, pickled_length)?
                 };
-                Self::ReplayHeader(Box::new(ReplayHeader {
-                    summary,
+                Self::Type0 {
+                    type_0,
                     author_nickname,
                     arena_unique_id,
                     arena_type_id,
-                }))
+                }
             }
 
             8 => Self::EntityMethod(EntityMethod::new(payload)?),
 
-            _ => Self::Unknown {
-                raw: payload,
-                type_,
-            },
+            _ => Self::Unknown { raw: payload, type_ },
         };
         Ok(this)
     }

src/models/data/replay_header.rs

@@ -1,11 +0,0 @@
-use serde::Serialize;
-
-use crate::models::data::Summary;
-
-#[derive(Debug, Serialize)]
-pub struct ReplayHeader {
-    pub summary: Summary,
-    pub author_nickname: String,
-    pub arena_unique_id: u64,
-    pub arena_type_id: u32,
-}

src/models/data/type_0.rs

@@ -2,8 +2,9 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
+/// Looks like some sort of replay summary.
 #[derive(Debug, Serialize, Deserialize)]
-pub struct Summary {
+pub struct Type0 {
     #[serde(rename(deserialize = "playersBattleCategoriesIds"))]
     pub players_battle_categories_ids: HashMap<u32, (u8, u32)>,
 
@@ -23,7 +24,7 @@ pub struct Summary {
     pub camouflage_slot: u8,
 
     #[serde(rename(deserialize = "avgMmr"))]
-    pub average_mmr: Vec<f64>,
+    pub average_mmr: Vec<Option<f64>>,
 
     #[serde(rename(deserialize = "playerWaitTimes"))]
     pub player_wait_times: HashMap<u32, f64>,

src/models/data/update_arena.rs

@@ -0,0 +1,33 @@
+use prost::Message;
+use serde::Serialize;
+
+/// Subtype `0x2F`.
+#[derive(Message, Serialize)]
+pub struct UpdateArena {
+    #[prost(message, tag = "1")]
+    pub players: Option<Players>,
+}
+
+#[derive(Message, Serialize)]
+pub struct Players {
+    #[prost(message, repeated, tag = "1")]
+    pub players: Vec<Player>,
+}
+
+#[derive(Message, Serialize)]
+pub struct Player {
+    #[prost(string, required, tag = "3")]
+    pub nickname: String,
+
+    #[prost(uint32, required, tag = "4")]
+    pub team_number: u32,
+
+    #[prost(uint32, required, tag = "7")]
+    pub account_id: u32,
+
+    #[prost(string, optional, tag = "8")]
+    pub clan_tag: Option<String>,
+
+    #[prost(uint32, optional, tag = "11")]
+    pub platoon_number: Option<u32>,
+}

tests/battle_results.rs

@@ -11,7 +11,7 @@ fn player_results_ok() -> Result<()> {
     assert_eq!(battle_results_dat.arena_unique_id, 1661909200500084);
     let battle_results: BattleResults = battle_results_dat.try_into()?;
 
-    assert_eq!(battle_results.winner_team_number, 2);
+    assert_eq!(battle_results.winner_team_number, Some(2));
 
     assert_eq!(battle_results.author.team_number, 2);
     assert_eq!(battle_results.author.credits_earned, 59518);
@@ -117,3 +117,11 @@ fn victory_points_ok() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn draw_ok() -> Result<()> {
+    let battle_results = Replay::open(File::open("tests/replays/20230503_0027__helaas_pindakaas_A140_ASTRON_REX_105_2319058483532631656.wotbreplay")?)?
+        .read_battle_results()?;
+    assert_eq!(battle_results.winner_team_number, None);
+    Ok(())
+}

tests/data.rs

@@ -1,30 +1,59 @@
 use std::fs::File;
 
 use anyhow::Result;
+use wotbreplay_parser::models::data::entity_method::EntityMethod;
+use wotbreplay_parser::models::data::payload::Payload;
 use wotbreplay_parser::replay::Replay;
 
 #[test]
-fn data_ok() -> Result<()> {
+fn parse_ok() -> Result<()> {
     let mut replay = Replay::open(File::open(
         "tests/replays/20230429_0126__helaas_pindakaas_A140_ASTRON_REX_105_16114615898101270.wotbreplay",
     )?)?;
     let data = replay.read_data()?;
 
     assert_eq!(data.client_version, "9.8.5_apple");
-    assert_eq!(data.other_packets.len(), 60138);
+    assert_eq!(data.packets.len(), 60139);
 
-    let header = data.replay_header.unwrap();
-    assert_eq!(header.author_nickname, "helaas_pindakaas");
-    assert_eq!(header.arena_unique_id, 16114615898101270);
-    assert_eq!(header.arena_type_id, 43);
-    assert_eq!(header.summary.battle_level, 9);
-    assert_eq!(header.summary.battle_category_id, 13);
-    assert!(header.summary.is_mouse_enabled);
-    assert_eq!(header.summary.matchmaker_type, 2);
-    assert_eq!(header.summary.camouflage_slot, 1);
-    assert_eq!(header.summary.average_mmr, [59.29457753400008, 99.34182121604681]);
+    Ok(())
+}
+
+#[test]
+fn type0_ok() -> Result<()> {
+    let mut replay = Replay::open(File::open(
+        "tests/replays/20230429_0126__helaas_pindakaas_A140_ASTRON_REX_105_16114615898101270.wotbreplay",
+    )?)?;
+    let data = replay.read_data()?;
+
+    let (author_nickname, arena_unique_id, arena_type_id, type_0) = data
+        .packets
+        .iter()
+        .filter_map(|packet| {
+            if let Payload::Type0 {
+                author_nickname,
+                arena_unique_id,
+                arena_type_id,
+                type_0,
+            } = &packet.payload
+            {
+                Some((author_nickname, arena_unique_id, arena_type_id, type_0))
+            } else {
+                None
+            }
+        })
+        .next()
+        .unwrap();
+    assert_eq!(author_nickname, "helaas_pindakaas");
+    assert_eq!(*arena_unique_id, 16114615898101270);
+    assert_eq!(*arena_type_id, 43);
+    assert_eq!(type_0.battle_level, 9);
+    assert_eq!(type_0.battle_category_id, 13);
+    assert!(type_0.is_mouse_enabled);
+    assert_eq!(type_0.matchmaker_type, 2);
+    assert_eq!(type_0.camouflage_slot, 1);
+    assert_eq!(type_0.average_mmr, [Some(59.29457753400008), Some(99.34182121604681)]);
     assert_eq!(
-        header.summary.account_database_ids,
+        type_0.account_database_ids,
         [
             517033644, 537867068, 597583401, 601893865, 576810156, 531053956, 599580824, 558025185,
             526927603, 594778041, 505587490, 597422303, 531923111, 587617355
@@ -33,3 +62,32 @@ fn data_ok() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn subtype_2f_players_ok() -> Result<()> {
+    let mut replay = Replay::open(File::open(
+        "tests/replays/20230429_0126__helaas_pindakaas_A140_ASTRON_REX_105_16114615898101270.wotbreplay",
+    )?)?;
+    let data = replay.read_data()?;
+
+    let players = data
+        .packets
+        .iter()
+        .filter_map(|packet| match &packet.payload {
+            Payload::EntityMethod(EntityMethod::Subtype2F { sub_type_2f, .. }) => {
+                sub_type_2f.players.as_ref()
+            }
+            _ => None,
+        })
+        .next()
+        .unwrap();
+
+    assert_eq!(players.players.len(), 14);
+    assert_eq!(players.players[1].team_number, 1);
+    assert_eq!(players.players[1].nickname, "Igrok_WoT_blitz");
+    assert_eq!(players.players[1].account_id, 597583401);
+    assert_eq!(players.players[1].platoon_number, None);
+    assert_eq!(players.players[1].clan_tag, Some("F_ANG".to_string()));
+
+    Ok(())
+}