flatten sendtables in parserstate only when entities are handled

src/demo/packet/datatable.rs

@@ -65,7 +65,7 @@ impl From<String> for SendTableName {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ParseSendTable {
     pub name: SendTableName,
     pub props: Vec<Rc<SendPropDefinition>>,
@@ -207,7 +207,7 @@ pub struct SendTable {
 #[derive(Debug)]
 pub struct DataTablePacket {
     pub tick: u32,
-    pub tables: Vec<SendTable>,
+    pub tables: Vec<ParseSendTable>,
     pub server_classes: Vec<ServerClass>,
 }
 
@@ -217,30 +217,14 @@ impl Parse for DataTablePacket {
         let len = stream.read_int::<usize>(32)?;
         let mut packet_data = stream.read_bits(len * 8)?;
 
-        let mut parse_tables = Vec::new();
+        let mut tables = Vec::new();
         let mut table_index = 0;
         while packet_data.read_bool()? {
             let table = ParseSendTable::parse(&mut packet_data, state, table_index)?;
             table_index += 1;
-            parse_tables.push(table);
+            tables.push(table);
         }
 
-        let flat_props: Vec<_> = parse_tables
-            .iter()
-            .map(|table| table.flatten_props(&parse_tables))
-            .collect();
-
-        let tables = parse_tables
-            .into_iter()
-            .zip(flat_props.into_iter())
-            .map(|(parse_table, flat)| SendTable {
-                name: parse_table.name,
-                props: parse_table.props,
-                needs_decoder: parse_table.needs_decoder,
-                flattened_props: flat,
-            })
-            .collect();
-
         let server_class_count = packet_data.read_int(16)?;
         let server_classes = packet_data.read_sized(server_class_count)?;
 

src/demo/parser/handler.rs

@@ -1,5 +1,5 @@
 use crate::demo::message::{Message, MessageType};
-use crate::demo::packet::datatable::{SendTable, ServerClass};
+use crate::demo::packet::datatable::{ParseSendTable, SendTable, ServerClass};
 use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
 use crate::demo::packet::Packet;
 use crate::demo::parser::analyser::Analyser;
@@ -15,7 +15,7 @@ pub trait MessageHandler {
 
     fn handle_string_entry(&mut self, table: &String, index: usize, entries: &StringTableEntry) {}
 
-    fn handle_data_tables(&mut self, tables: &[SendTable]) {}
+    fn handle_data_tables(&mut self, tables: &[ParseSendTable]) {}
 
     fn get_output(self, state: ParserState) -> Self::Output;
 }
@@ -99,7 +99,11 @@ impl<T: MessageHandler> DemoHandler<T> {
         }
     }
 
-    fn handle_data_table(&mut self, send_tables: Vec<SendTable>, server_classes: Vec<ServerClass>) {
+    fn handle_data_table(
+        &mut self,
+        send_tables: Vec<ParseSendTable>,
+        server_classes: Vec<ServerClass>,
+    ) {
         self.analyser.handle_data_tables(&send_tables);
         self.state_handler
             .handle_data_table(send_tables, server_classes);

src/demo/parser/state.rs

@@ -5,7 +5,9 @@ use crate::demo::message::gameevent::GameEventTypeId;
 use crate::demo::message::packetentities::{EntityId, PacketEntitiesMessage, PVS};
 use crate::demo::message::stringtable::StringTableMeta;
 use crate::demo::message::{Message, MessageType};
-use crate::demo::packet::datatable::{ClassId, SendTable, SendTableName, ServerClass};
+use crate::demo::packet::datatable::{
+    ClassId, ParseSendTable, SendTable, SendTableName, ServerClass,
+};
 use crate::demo::packet::stringtable::StringTableEntry;
 use crate::demo::parser::analyser::Analyser;
 use crate::demo::parser::handler::MessageHandler;
@@ -93,9 +95,26 @@ impl ParserState {
 
     pub fn handle_data_table(
         &mut self,
-        send_tables: Vec<SendTable>,
+        parse_tables: Vec<ParseSendTable>,
         server_classes: Vec<ServerClass>,
     ) {
+        if self.handle_entities {
+            let flat_props: Vec<_> = parse_tables
+                .iter()
+                .map(|table| table.flatten_props(&parse_tables))
+                .collect();
+
+            let send_tables: Vec<_> = parse_tables
+                .into_iter()
+                .zip(flat_props.into_iter())
+                .map(|(parse_table, flat)| SendTable {
+                    name: parse_table.name,
+                    props: parse_table.props,
+                    needs_decoder: parse_table.needs_decoder,
+                    flattened_props: flat,
+                })
+                .collect();
+
             let mut send_tables: HashMap<SendTableName, SendTable> = send_tables
                 .into_iter()
                 .map(|table| (table.name.clone(), table))
@@ -116,6 +135,7 @@ impl ParserState {
                 }
             }
         }
+    }
 
     pub fn handle_string_table_meta(&mut self, table: StringTableMeta) {
         self.string_tables.push(table);

tests/sendprops.rs

@@ -30,15 +30,8 @@ impl MessageHandler for SendPropAnalyser {
         false
     }
 
-    fn handle_data_tables(&mut self, tables: &[SendTable]) {
-        self.tables = tables
-            .iter()
-            .map(|v| ParseSendTable {
-                name: v.name.clone(),
-                props: v.props.clone(),
-                needs_decoder: v.needs_decoder,
-            })
-            .collect()
+    fn handle_data_tables(&mut self, tables: &[ParseSendTable]) {
+        self.tables = tables.to_vec()
     }
 
     fn get_output(self, state: ParserState) -> Self::Output {