state handling

src/bin/main.rs

@@ -5,11 +5,12 @@ use std::fs;
 pub use tf_demo_parser::{Demo, DemoParser, Parse, ParseError, ParserState, Result, Stream};
 
 fn main() -> std::result::Result<(), Box<ParseError>> {
-    let file = fs::read("data/small.dem").expect("Unable to read file");
+    let file = fs::read("data/gully.dem").expect("Unable to read file");
     let demo = Demo::new(file);
     let stream: Stream = demo.get_stream();
     let mut parser = DemoParser::new(stream);
-    let (header, packets) = parser.parse_demo()?;
+    let (header, state) = parser.parse_demo()?;
     dbg!(header);
+    dbg!(state);
     Ok(())
 }

src/demo/message/usermessage.rs

@@ -120,11 +120,11 @@ impl BitRead<LittleEndian> for SayText2Kind {
 
 #[derive(Debug, Clone)]
 pub struct SayText2Message {
-    client: u8,
+    pub client: u8,
-    raw: u8,
+    pub raw: u8,
-    kind: SayText2Kind,
+    pub kind: SayText2Kind,
-    from: String,
+    pub from: String,
-    text: String,
+    pub text: String,
 }
 
 impl BitRead<LittleEndian> for SayText2Message {

src/demo/parser/analyser.rs

@@ -0,0 +1,120 @@
+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)]
+pub struct ChatMassage {
+    pub kind: SayText2Kind,
+    pub from: String,
+    pub text: String,
+    pub tick: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct UserEntityInfo {
+    pub name: String,
+    pub user_id: u8,
+    pub steam_id: String,
+    pub entity_id: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct UserInfo {
+    pub team: String,
+    pub entity_info: UserEntityInfo,
+}
+
+#[derive(Debug, Clone)]
+pub struct Death {
+    pub weapon: String,
+    pub victim: u8,
+    pub assister: Option<u8>,
+    pub killer: u8,
+    pub tick: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct Round {
+    winner: String,
+    length: f32,
+    end_tick: u32,
+}
+
+#[derive(Default, Debug)]
+pub struct World {
+    boundary_min: Vector,
+    boundary_max: Vector,
+}
+
+#[derive(Default, Debug)]
+pub struct Analyser {
+    chat: Vec<ChatMassage>,
+    users: Vec<UserInfo>,
+    deaths: Vec<Death>,
+    rounds: Vec<Round>,
+    world: World,
+}
+
+impl Analyser {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn handle_message(&mut self, message: Message, tick: u32) {
+        match message {
+            Message::GameEvent(message) => self.handle_event(message.event, tick),
+            Message::UserMessage(message) => self.handle_user_message(message, tick),
+            _ => {}
+        }
+    }
+
+    fn handle_user_message(&mut self, message: UserMessage, tick: u32) {
+        match message {
+            UserMessage::SayText2(message) => {
+                match message.kind {
+                    SayText2Kind::NameChange => self.change_name(message.from, message.text),
+                    _ => self.chat.push(ChatMassage {
+                        tick,
+                        text: message.text,
+                        from: message.from,
+                        kind: message.kind,
+                    })
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn change_name(&mut self, from: String, to: String) {
+        for user in &mut self.users {
+            if user.entity_info.name == from {
+                user.entity_info.name = to;
+                return;
+            }
+        }
+    }
+
+    fn handle_event(&mut self, event: GameEvent, tick: u32) {
+        match event {
+            GameEvent::PlayerDeath(event) => self.handle_death(event, tick),
+            _ => {}
+        }
+    }
+
+    fn handle_death(&mut self, death: PlayerDeathEvent, tick: u32) {
+        let assister = if death.assister < (16 * 1024) {
+            Some((death.assister & 255) as u8)
+        } else {
+            None
+        };
+        let death = Death {
+            assister,
+            tick,
+            killer: (death.attacker & 255) as u8,
+            weapon: death.weapon,
+            victim: (death.user_id & 255) as u8,
+        };
+        self.deaths.push(death);
+    }
+}

src/demo/parser/mod.rs

@@ -5,10 +5,12 @@ use bitstream_reader::{BitRead, LittleEndian, ReadError};
 use crate::demo::gamevent::GameEventValue;
 use crate::demo::header::Header;
 use crate::demo::packet::Packet;
+use crate::demo::parser::analyser::Analyser;
 pub use crate::demo::parser::state::ParserState;
 use crate::Stream;
 
 mod state;
+mod analyser;
 
 /// Errors that can occur during parsing
 #[derive(Debug)]
@@ -71,6 +73,7 @@ impl<T: BitRead<LittleEndian>> Parse for T {
 pub struct DemoParser {
     stream: Stream,
     state: ParserState,
+    analyser: Analyser,
 }
 
 impl DemoParser {
@@ -78,6 +81,7 @@ impl DemoParser {
         DemoParser {
             state: ParserState::new(),
             stream,
+            analyser: Analyser::new(),
         }
     }
 
@@ -94,15 +98,18 @@ impl DemoParser {
         Ok(())
     }
 
-    pub fn parse_demo(mut self) -> Result<(Header, ParserState)> {
+    pub fn parse_demo(mut self) -> Result<(Header, Analyser)> {
         let header = self.read::<Header>()?;
         loop {
             let packet = self.read::<Packet>()?;
-            match packet {
+            let messages = match packet {
                 Packet::Stop(_) => break,
                 packet => self.state.handle_packet(packet),
+            };
+            for message in messages {
+                self.analyser.handle_message(message, self.state.tick);
             }
         }
-        Ok((header, self.state))
+        Ok((header, self.analyser))
     }
 }

src/demo/parser/state.rs

@@ -2,11 +2,11 @@ use std::collections::HashMap;
 
 use crate::demo::gameevent_gen::GameEventType;
 use crate::demo::gamevent::GameEventDefinition;
-use crate::demo::message::packetentities::EntityId;
 use crate::demo::message::Message;
+use crate::demo::message::packetentities::EntityId;
 use crate::demo::packet::datatable::{SendTable, ServerClass};
-use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
 use crate::demo::packet::Packet;
+use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
 use crate::demo::sendprop::SendProp;
 use crate::Stream;
 
@@ -36,12 +36,17 @@ impl ParserState {
         ParserState::default()
     }
 
-    pub fn handle_packet(&mut self, packet: Packet) {
+    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 {
-                    self.handle_message(message);
+                    match self.handle_message(message) {
+                        Some(message) => unhandled_messages.push(message),
+                        _ => {}
+                    }
                 }
+                return unhandled_messages;
             }
             Packet::DataTables(packet) => {
                 if self.send_tables.len() > 0 {
@@ -59,9 +64,10 @@ impl ParserState {
             }
             _ => {}
         }
+        Vec::new()
     }
 
-    fn handle_message(&mut self, message: Message) {
+    fn handle_message(&mut self, message: Message) -> Option<Message> {
         match message {
             Message::NetTick(message) => self.tick = message.tick,
             Message::ServerInfo(message) => {
@@ -77,8 +83,9 @@ impl ParserState {
             Message::UpdateStringTable(message) => {
                 self.handle_table_update(message.table_id, message.entries);
             }
-            _ => {}
+            _ => return Some(message)
         }
+        None
     }
 
     fn handle_table(&mut self, table: StringTable) {

src/demo/vector.rs

@@ -1,13 +1,13 @@
 use bitstream_reader::BitRead;
 
-#[derive(BitRead, Debug, Clone, Copy)]
+#[derive(BitRead, Debug, Clone, Copy, Default)]
 pub struct Vector {
     pub x: f32,
     pub y: f32,
     pub z: f32,
 }
 
-#[derive(BitRead, Debug, Clone, Copy)]
+#[derive(BitRead, Debug, Clone, Copy, Default)]
 pub struct VectorXY {
     pub x: f32,
     pub y: f32,