more state updates

src/demo/packet/datatable.rs

@@ -5,24 +5,24 @@ use crate::{Parse, ParseError, ParserState, Result, Stream};
 
 #[derive(BitRead, Debug)]
 pub struct ServerClass {
-    id: u16,
-    name: String,
-    data_table: String,
+    pub id: u16,
+    pub name: String,
+    pub data_table: String,
 }
 
 #[derive(Debug)]
 pub struct SendTable {
-    name: String,
-    props: Vec<SendPropDefinition>,
-    needs_decoder: bool,
-    flattened_props: Option<Vec<SendPropDefinition>>,
+    pub name: String,
+    pub props: Vec<SendPropDefinition>,
+    pub needs_decoder: bool,
+    pub flattened_props: Option<Vec<SendPropDefinition>>,
 }
 
 #[derive(Debug)]
 pub struct DataTablePacket {
-    tick: u32,
-    tables: Vec<SendTable>,
-    server_classes: Vec<ServerClass>,
+    pub tick: u32,
+    pub tables: Vec<SendTable>,
+    pub server_classes: Vec<ServerClass>,
 }
 
 impl Parse for DataTablePacket {

src/demo/packet/stringtable.rs

@@ -87,8 +87,8 @@ impl fmt::Debug for StringTableEntry {
 
 #[derive(Debug)]
 pub struct StringTablePacket {
-    tick: u32,
-    tables: Vec<StringTable>,
+    pub tick: u32,
+    pub tables: Vec<StringTable>,
 }
 
 impl Parse for StringTablePacket {

src/demo/packet/synctick.rs

@@ -2,5 +2,5 @@ use bitstream_reader::BitRead;
 
 #[derive(BitRead, Debug)]
 pub struct SyncTickPacket {
-    tick: u32,
+    pub tick: u32,
 }

src/demo/parser/state.rs

@@ -6,13 +6,13 @@ use crate::demo::message::Message;
 use crate::demo::message::packetentities::EntityId;
 use crate::demo::packet::datatable::{SendTable, ServerClass};
 use crate::demo::packet::Packet;
-use crate::demo::packet::stringtable::StringTable;
+use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
 use crate::demo::sendprop::SendProp;
 use crate::Stream;
 
 #[derive(Default, Debug)]
 pub struct ParserState {
-    pub version: u32,
+    pub version: u16,
     pub static_baselines: HashMap<u32, StaticBaseline>,
     pub event_definitions: HashMap<GameEventType, GameEventDefinition>,
     pub string_tables: Vec<StringTable>,
@@ -21,6 +21,7 @@ pub struct ParserState {
     pub server_classes: Vec<ServerClass>,
     pub instance_baselines: [HashMap<EntityId, Vec<SendProp>>; 2],
     pub tick: u32,
+    pub game: String,
 }
 
 #[derive(Debug)]
@@ -42,16 +43,57 @@ impl ParserState {
                     self.handle_message(message);
                 }
             }
+            Packet::DataTables(packet) => {
+                if self.send_tables.len() > 0 {
+                    unreachable!("overwriting tables");
+                }
+                for table in packet.tables {
+                    self.send_tables.insert(table.name.clone(), table);
+                }
+                self.server_classes = packet.server_classes;
+            }
+            Packet::StringTables(packet) => {
+                for table in packet.tables {
+                    self.handle_table(table);
+                }
+            }
             _ => {}
         }
     }
 
     fn handle_message(&mut self, message: Message) {
         match message {
+            Message::NetTick(message) => self.tick = message.tick,
+            Message::ServerInfo(message) => {
+                self.version = message.version;
+                self.game = message.game;
+            }
             Message::GameEventList(message) => {
                 self.event_definitions = message.event_list;
             }
+            Message::CreateStringTable(message) => {
+                self.handle_table(message.table);
+            }
+            Message::UpdateStringTable(message) => {
+                self.handle_table_update(message.table_id, message.entries);
+            }
             _ => {}
         }
     }
+
+    fn handle_table(&mut self, table: StringTable) {
+        self.string_tables.push(table);
+    }
+
+    fn handle_table_update(&mut self, table_id: u8, entries: HashMap<u16, StringTableEntry>) {
+        let mut table = self.string_tables.get_mut(table_id as usize);
+        match table {
+            Some(table) => {
+                for (index, entry) in entries {
+                    table.entries.insert(index as usize, entry);
+                }
+            }
+            _ => unreachable!("trying to update non existing table"),
+        }
+    }
 }