fixes

src/bin/main.rs

@@ -10,7 +10,10 @@ fn main() -> std::result::Result<(), Box<ParseError>> {
     let stream: Stream = demo.get_stream();
     let mut parser = DemoParser::new(stream);
     let (header, state) = parser.parse_demo()?;
-    dbg!(header);
-    dbg!(state);
+    //dbg!(header);
+    //dbg!(state.deaths);
+    //let json = serde_json::to_string(&state.deaths).unwrap_or("err".to_string());
+    //std::thread::sleep(std::time::Duration::from_secs(5));
+    //println!("{}", json);
     Ok(())
 }

src/demo/message/generated.rs

@@ -82,7 +82,7 @@ pub struct EntityMessage {
     pub class_id: u16,
     #[size = 11]
     pub length: u16,
-    #[size = "length * 8"]
+    #[size = "length"]
     pub data: Stream,
 }
 

src/demo/message/usermessage.rs

@@ -1,6 +1,7 @@
 use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
 use enum_primitive_derive::Primitive;
 use num_traits::{FromPrimitive, ToPrimitive};
+use serde::Serialize;
 
 use crate::demo::message::usermessage::UserMessage::SayText2;
 use crate::{ReadResult, Stream};
@@ -87,7 +88,7 @@ impl BitRead<LittleEndian> for UserMessage {
         let mut data = stream.read_bits(length)?;
         let message = match message_type {
             UserMessageType::SayText2 => UserMessage::SayText2(data.read()?),
-            UserMessageType::TextMsg => UserMessage::Text(data.read()?),
+            //UserMessageType::TextMsg => UserMessage::Text(data.read()?),
             UserMessageType::ResetHUD => UserMessage::ResetHUD(data.read()?),
             UserMessageType::Train => UserMessage::Train(data.read()?),
             UserMessageType::VoiceSubtitle => UserMessage::VoiceSubtitle(data.read()?),
@@ -98,7 +99,7 @@ impl BitRead<LittleEndian> for UserMessage {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub enum SayText2Kind {
     ChatAll,
     ChatTeam,

src/demo/packet/consolecmd.rs

@@ -13,7 +13,7 @@ impl BitRead<LittleEndian> for ConsoleCmdPacket {
         let tick = stream.read_int(32)?;
         let len = stream.read_int::<usize>(32)?;
         let mut packet_data = stream.read_bits(len * 8)?;
-        let command = packet_data.read_string(None)?;
+        let command = packet_data.read_string(Some(len))?;
         Ok(ConsoleCmdPacket { tick, command })
     }
 }

src/demo/packet/stringtable.rs

@@ -65,7 +65,7 @@ pub struct ExtraData {
     pub data: Stream,
 }
 
-#[derive(BitRead, Clone)]
+#[derive(BitRead, Clone, Default)]
 #[endianness = "LittleEndian"]
 pub struct StringTableEntry {
     pub text: String,

src/demo/parser/analyser.rs

@@ -1,9 +1,11 @@
+use serde::Serialize;
+
 use crate::demo::gameevent_gen::{GameEvent, PlayerDeathEvent};
 use crate::demo::message::Message;
 use crate::demo::message::usermessage::{SayText2Kind, UserMessage};
 use crate::demo::vector::Vector;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct ChatMassage {
     pub kind: SayText2Kind,
     pub from: String,
@@ -11,7 +13,7 @@ pub struct ChatMassage {
     pub tick: u32,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct UserEntityInfo {
     pub name: String,
     pub user_id: u8,
@@ -19,13 +21,13 @@ pub struct UserEntityInfo {
     pub entity_id: u32,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct UserInfo {
     pub team: String,
     pub entity_info: UserEntityInfo,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Death {
     pub weapon: String,
     pub victim: u8,
@@ -34,26 +36,26 @@ pub struct Death {
     pub tick: u32,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Round {
     winner: String,
     length: f32,
     end_tick: u32,
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Serialize)]
 pub struct World {
     boundary_min: Vector,
     boundary_max: Vector,
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Serialize)]
 pub struct Analyser {
-    chat: Vec<ChatMassage>,
-    users: Vec<UserInfo>,
-    deaths: Vec<Death>,
-    rounds: Vec<Round>,
-    world: World,
+    pub chat: Vec<ChatMassage>,
+    pub users: Vec<UserInfo>,
+    pub deaths: Vec<Death>,
+    pub rounds: Vec<Round>,
+    pub world: World,
 }
 
 impl Analyser {

src/demo/parser/mod.rs

@@ -85,6 +85,7 @@ impl DemoParser {
         }
     }
 
+    #[inline(always)]
     pub fn read<T: Parse>(&mut self) -> Result<T> {
         T::parse(&mut self.stream, &self.state)
     }

src/demo/parser/state.rs

@@ -39,14 +39,9 @@ impl ParserState {
     pub fn handle_packet(&mut self, packet: Packet) -> Vec<Message> {
         match packet {
             Packet::Message(packet) | Packet::Sigon(packet) => {
-                let mut unhandled_messages = Vec::with_capacity(packet.messages.len());
-                for message in packet.messages {
-                    match self.handle_message(message) {
-                        Some(message) => unhandled_messages.push(message),
-                        _ => {}
-                    }
-                }
-                return unhandled_messages;
+                return packet.messages.into_iter()
+                    .filter_map(|message| self.handle_message(message))
+                    .collect();
             }
             Packet::DataTables(packet) => {
                 if self.send_tables.len() > 0 {
@@ -97,6 +92,9 @@ impl ParserState {
         match table {
             Some(table) => {
                 for (index, entry) in entries {
+                    if index as usize > table.entries.len() {
+                        table.entries.resize(index as usize, StringTableEntry::default());
+                    }
                     table.entries.insert(index as usize, entry);
                 }
             }

src/demo/vector.rs

@@ -1,13 +1,26 @@
-use bitstream_reader::BitRead;
+use bitstream_reader::{BitRead, LittleEndian};
+use serde::Serialize;
 
-#[derive(BitRead, Debug, Clone, Copy, Default)]
+use crate::{ReadResult, Stream};
+
+#[derive(Debug, Clone, Copy, Default, Serialize)]
 pub struct Vector {
     pub x: f32,
     pub y: f32,
     pub z: f32,
 }
 
-#[derive(BitRead, Debug, Clone, Copy, Default)]
+impl BitRead<LittleEndian> for Vector {
+    fn read(stream: &mut Stream) -> ReadResult<Self> {
+        Ok(Vector {
+            x: stream.read()?,
+            y: stream.read()?,
+            z: stream.read()?,
+        })
+    }
+}
+
+#[derive(BitRead, Debug, Clone, Copy, Default, Serialize)]
 pub struct VectorXY {
     pub x: f32,
     pub y: f32,