Distinguish between client and server ticks

benches/iai.rs

@@ -12,7 +12,7 @@ impl MessageHandler for AllMessages {
         true
     }
 
-    fn handle_message(&mut self, message: &Message, _tick: u32, _parser_state: &ParserState) {
+    fn handle_message(&mut self, message: &Message, _server_tick: u32, _client_tick: u32, _parser_state: &ParserState) {
         black_box(message);
     }
 

examples/allprops.rs

@@ -42,7 +42,7 @@ impl MessageHandler for PropAnalyzer {
         matches!(message_type, MessageType::PacketEntities)
     }
 
-    fn handle_message(&mut self, message: &Message, _tick: u32, _parser_state: &ParserState) {
+    fn handle_message(&mut self, message: &Message, _server_tick: u32, _client_tick:u32, _parser_state: &ParserState) {
         if let Message::PacketEntities(message) = message {
             for entity in &message.entities {
                 for prop in &entity.props {

src/demo/parser/analyser.rs

@@ -378,16 +378,16 @@ impl MessageHandler for Analyser {
         )
     }
 
-    fn handle_message(&mut self, message: &Message, tick: u32, _parser_state: &ParserState) {
+    fn handle_message(&mut self, message: &Message, server_tick: u32, _client_tick: u32, _parser_state: &ParserState) {
         if self.state.start_tick == 0 {
-            self.state.start_tick = tick;
+            self.state.start_tick = server_tick;
         }
         match message {
             Message::ServerInfo(message) => {
                 self.state.interval_per_tick = message.interval_per_tick
             }
-            Message::GameEvent(message) => self.handle_event(&message.event, tick),
+            Message::GameEvent(message) => self.handle_event(&message.event, server_tick),
-            Message::UserMessage(message) => self.handle_user_message(message, tick),
+            Message::UserMessage(message) => self.handle_user_message(message, server_tick),
             _ => {}
         }
     }

src/demo/parser/gamestateanalyser.rs

@@ -303,7 +303,6 @@ impl GameState {
 #[derive(Default, Debug)]
 pub struct GameStateAnalyser {
     pub state: GameState,
-    tick: u32,
     class_names: Vec<ServerClassName>, // indexed by ClassId
 }
 
@@ -317,7 +316,7 @@ impl MessageHandler for GameStateAnalyser {
         )
     }
 
-    fn handle_message(&mut self, message: &Message, _tick: u32, parser_state: &ParserState) {
+    fn handle_message(&mut self, message: &Message, _server_tick: u32, client_tick: u32, parser_state: &ParserState) {
         match message {
             Message::PacketEntities(message) => {
                 for entity in &message.entities {
@@ -326,7 +325,7 @@ impl MessageHandler for GameStateAnalyser {
             }
             Message::GameEvent(GameEventMessage { event, .. }) => match event {
                 GameEvent::PlayerDeath(death) => {
-                    self.state.kills.push(Kill::new(self.tick, death.as_ref()))
+                    self.state.kills.push(Kill::new(client_tick, death.as_ref()))
                 }
                 GameEvent::RoundStart(_) => {
                     self.state.buildings.clear();
@@ -374,12 +373,11 @@ impl MessageHandler for GameStateAnalyser {
 
     fn handle_packet_meta(
         &mut self,
-        tick: u32,
+        client_tick: u32,
         _meta: &MessagePacketMeta,
         _parser_state: &ParserState,
     ) {
-        self.state.tick = tick;
+        self.state.tick = client_tick;
-        self.tick = tick;
     }
 
     fn into_output(self, _state: &ParserState) -> Self::Output {

src/demo/parser/handler.rs

@@ -16,7 +16,7 @@ pub trait MessageHandler {
 
     fn handle_header(&mut self, _header: &Header) {}
 
-    fn handle_message(&mut self, _message: &Message, _tick: u32, _parser_state: &ParserState) {}
+    fn handle_message(&mut self, _message: &Message, _server_tick: u32, _client_tick: u32, _parser_state: &ParserState) {}
 
     fn handle_string_entry(
         &mut self,
@@ -37,7 +37,7 @@ pub trait MessageHandler {
 
     fn handle_packet_meta(
         &mut self,
-        _tick: u32,
+        _client_tick: u32,
         _meta: &MessagePacketMeta,
         _parser_state: &ParserState,
     ) {
@@ -64,7 +64,7 @@ impl MessageHandler for NullHandler {
 
 #[derive(Clone)]
 pub struct DemoHandler<'a, T: MessageHandler> {
-    pub tick: u32,
+    pub server_tick: u32,
     pub string_table_names: Vec<Cow<'a, str>>,
     analyser: T,
     pub state_handler: ParserState,
@@ -87,7 +87,7 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
         let state_handler = ParserState::new(24, T::does_handle, false);
 
         DemoHandler {
-            tick: 0,
+            server_tick: 0,
             string_table_names: Vec::new(),
             analyser,
             state_handler,
@@ -97,7 +97,7 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
         let state_handler = ParserState::new(24, T::does_handle, true);
 
         DemoHandler {
-            tick: 0,
+            server_tick: 0,
             string_table_names: Vec::new(),
             analyser,
             state_handler,
@@ -124,17 +124,14 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
                     .handle_packet_meta(packet.tick, &packet.meta, &self.state_handler);
                 for message in packet.messages {
                     match message {
-                        Message::NetTick(message) => self.tick = message.tick,
+                        Message::NetTick(message) => self.server_tick = message.tick,
                         Message::CreateStringTable(message) => {
                             self.handle_string_table(message.table)
                         }
                         Message::UpdateStringTable(message) => {
                             self.handle_table_update(message.table_id, message.entries)
                         }
-                        Message::PacketEntities(msg) => {
+                        message => self.handle_message(message, packet.tick),
-                            self.handle_message(Message::PacketEntities(msg))
-                        }
-                        message => self.handle_message(message),
                     }
                 }
             }
@@ -184,13 +181,13 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
             .handle_data_table(send_tables, server_classes)
     }
 
-    pub fn handle_message(&mut self, message: Message<'a>) {
+    pub fn handle_message(&mut self, message: Message<'a>, client_tick: u32) {
         let message_type = message.get_message_type();
         if T::does_handle(message_type) {
             self.analyser
-                .handle_message(&message, self.tick, &self.state_handler);
+                .handle_message(&message, self.server_tick, client_tick, &self.state_handler);
         }
-        self.state_handler.handle_message(message, self.tick);
+        self.state_handler.handle_message(message, self.server_tick);
     }
 
     pub fn into_output(self) -> T::Output {

src/demo/parser/messagetypeanalyser.rs

@@ -16,7 +16,7 @@ impl MessageHandler for MessageTypeAnalyser {
         true
     }
 
-    fn handle_message(&mut self, message: &Message, _tick: u32, _parser_state: &ParserState) {
+    fn handle_message(&mut self, message: &Message, _server_tick: u32, _client_tick: u32, _parser_state: &ParserState) {
         self.packet_types.push(message.get_message_type())
     }
 

src/demo/parser/state.rs

@@ -221,7 +221,7 @@ impl<'a> ParserState {
         )
     }
 
-    pub fn handle_message(&mut self, message: Message, _tick: u32) {
+    pub fn handle_message(&mut self, message: Message, _server_tick: u32) {
         match message {
             Message::ServerInfo(message) => {
                 self.demo_meta.version = message.version;