handle older prefetch messages

src/demo/message/generated.rs

@@ -112,13 +112,6 @@ pub struct EntityMessage<'a> {
     pub data: Stream<'a>,
 }
 
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(BitRead, BitWrite, Debug, PartialEq, Serialize, Deserialize, Clone)]
-pub struct PreFetchMessage {
-    #[size = 14]
-    pub index: u16,
-}
-
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(BitRead, BitWrite, Debug, PartialEq, Serialize, Deserialize, Clone)]
 #[endianness = "LittleEndian"]

src/demo/message/mod.rs

@@ -9,6 +9,7 @@ use crate::demo::message::stringtable::*;
 use crate::demo::message::tempentities::*;
 use crate::demo::message::usermessage::*;
 use crate::demo::message::voice::*;
+use crate::demo::message::prefetch::*;
 use crate::demo::parser::{Encode, ParseBitSkip};
 use crate::{Parse, ParserState, Result, Stream};
 use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
@@ -25,6 +26,7 @@ pub mod stringtable;
 pub mod tempentities;
 pub mod usermessage;
 pub mod voice;
+pub mod prefetch;
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema_repr))]
 #[derive(

src/demo/message/prefetch.rs

@@ -0,0 +1,45 @@
+use bitbuffer::{BitWriteStream, LittleEndian};
+use serde::{Deserialize, Serialize};
+use crate::{Parse, ParserState, Stream, Result};
+use crate::demo::parser::{Encode, ParseBitSkip};
+
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+pub struct PreFetchMessage {
+    pub index: u16,
+}
+
+impl PreFetchMessage {
+    fn bit_size(protocol_version: u32) -> usize {
+        if protocol_version > 22 {
+            14
+        } else {
+            13
+        }
+    }
+}
+
+impl<'a> Parse<'a> for PreFetchMessage {
+    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
+        let size = Self::bit_size(state.protocol_version);
+        Ok(PreFetchMessage {
+            index: stream.read_sized(size)?,
+        })
+    }
+}
+
+impl Encode for PreFetchMessage {
+    fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
+        let size = Self::bit_size(state.protocol_version);
+        stream.write_int(self.index, size)?;
+        Ok(())
+    }
+}
+
+impl<'a> ParseBitSkip<'a> for PreFetchMessage {
+    fn parse_skip(stream: &mut Stream<'a>, state: &ParserState) -> Result<()> {
+        let size = Self::bit_size(state.protocol_version);
+        stream.skip_bits(size)?;
+        Ok(())
+    }
+}

src/demo/parser/mod.rs

@@ -89,6 +89,7 @@ impl<'a, A: MessageHandler> DemoParser<'a, A> {
 
     pub fn parse(self) -> Result<(Header, A::Output)> {
         let (header, mut ticker) = self.ticker()?;
+        dbg!(&header);
         while ticker.tick()? {
             // noop
         }