strictly distinguish between server and demo ticks

src/demo/packet/consolecmd.rs

@@ -1,3 +1,4 @@
+use crate::demo::data::DemoTick;
 use crate::{ReadResult, Stream};
 use bitbuffer::{BitRead, BitWrite, LittleEndian};
 use serde::{Deserialize, Serialize};
@@ -5,13 +6,13 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ConsoleCmdPacket {
-    pub tick: u32,
+    pub tick: DemoTick,
     pub command: String,
 }
 
 impl BitRead<'_, LittleEndian> for ConsoleCmdPacket {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
-        let tick = stream.read_int(32)?;
+        let tick = stream.read()?;
         let len = stream.read_int::<usize>(32)?;
         let mut packet_data = stream.read_bits(len * 8)?;
         let command: String = packet_data.read()?;

src/demo/packet/datatable.rs

@@ -1,3 +1,4 @@
+use crate::demo::data::DemoTick;
 use crate::demo::parser::MalformedSendPropDefinitionError;
 use crate::demo::sendprop::{
     RawSendPropDefinition, SendPropDefinition, SendPropFlag, SendPropIdentifier, SendPropType,
@@ -403,7 +404,7 @@ pub struct SendTable {
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DataTablePacket {
-    pub tick: u32,
+    pub tick: DemoTick,
     pub tables: Vec<ParseSendTable>,
     pub server_classes: Vec<ServerClass>,
 }
@@ -460,7 +461,7 @@ fn test_data_table_packet_roundtrip() {
     let state = ParserState::new(24, |_| false, false);
     crate::test_roundtrip_encode(
         DataTablePacket {
-            tick: 123,
+            tick: 123.into(),
             tables: vec![],
             server_classes: vec![],
         },
@@ -545,7 +546,7 @@ fn test_data_table_packet_roundtrip() {
     };
     crate::test_roundtrip_encode(
         DataTablePacket {
-            tick: 1,
+            tick: 1.into(),
             tables: vec![table1, table2],
             server_classes: vec![
                 ServerClass {

src/demo/packet/message.rs

@@ -1,6 +1,7 @@
 use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
 use serde::{Deserialize, Serialize};
 
+use crate::demo::data::DemoTick;
 use crate::demo::message::{Message, MessageType};
 use crate::demo::parser::Encode;
 use crate::demo::vector::Vector;
@@ -21,7 +22,7 @@ pub struct MessagePacketMeta {
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone, Default)]
 #[serde(bound(deserialize = "'a: 'static"))]
 pub struct MessagePacket<'a> {
-    pub tick: u32,
+    pub tick: DemoTick,
     pub messages: Vec<Message<'a>>,
     pub meta: MessagePacketMeta,
 }

src/demo/packet/mod.rs

@@ -9,6 +9,7 @@ use self::stop::StopPacket;
 use self::stringtable::StringTablePacket;
 use self::synctick::SyncTickPacket;
 use self::usercmd::UserCmdPacket;
+use crate::demo::data::DemoTick;
 use crate::demo::parser::Encode;
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "trace")]
@@ -38,7 +39,7 @@ pub enum Packet<'a> {
 }
 
 impl Packet<'_> {
-    pub fn tick(&self) -> u32 {
+    pub fn tick(&self) -> DemoTick {
         match self {
             Packet::Signon(msg) => msg.tick,
             Packet::Message(msg) => msg.tick,
@@ -51,7 +52,7 @@ impl Packet<'_> {
         }
     }
 
-    pub fn set_tick(&mut self, tick: u32) {
+    pub fn set_tick(&mut self, tick: DemoTick) {
         match self {
             Packet::Signon(msg) => msg.tick = tick,
             Packet::Message(msg) => msg.tick = tick,

src/demo/packet/stop.rs

@@ -1,9 +1,23 @@
-use bitbuffer::{BitRead, BitWrite};
+use crate::demo::data::DemoTick;
+use bitbuffer::{BitRead, BitReadStream, BitWrite, BitWriteStream, Endianness};
 use serde::{Deserialize, Serialize};
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitRead, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct StopPacket {
-    #[size = 24]
-    pub tick: u32,
+    pub tick: DemoTick,
+}
+
+impl<'a, E: Endianness> BitRead<'a, E> for StopPacket {
+    fn read(stream: &mut BitReadStream<'a, E>) -> bitbuffer::Result<Self> {
+        Ok(StopPacket {
+            tick: stream.read_int::<u32>(24)?.into(),
+        })
+    }
+}
+
+impl<E: Endianness> BitWrite<E> for StopPacket {
+    fn write(&self, stream: &mut BitWriteStream<E>) -> bitbuffer::Result<()> {
+        stream.write_int::<u32>(self.tick.into(), 24)
+    }
 }

src/demo/packet/stringtable.rs

@@ -2,6 +2,7 @@ use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
+use crate::demo::data::DemoTick;
 use crate::demo::message::stringtable::StringTableMeta;
 use crate::demo::parser::Encode;
 use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
@@ -233,13 +234,13 @@ impl fmt::Debug for StringTableEntry<'_> {
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 #[serde(bound(deserialize = "'a: 'static"))]
 pub struct StringTablePacket<'a> {
-    pub tick: u32,
+    pub tick: DemoTick,
     pub tables: Vec<StringTable<'a>>,
 }
 
 impl<'a> Parse<'a> for StringTablePacket<'a> {
     fn parse(stream: &mut Stream<'a>, _state: &ParserState) -> Result<Self> {
-        let tick = stream.read_int(32)?;
+        let tick = stream.read()?;
         let length: usize = stream.read_int(32)?;
         let mut packet_data = stream.read_bits(length.saturating_mul(8))?;
         let count: usize = packet_data.read_int(8)?;
@@ -274,14 +275,14 @@ fn test_string_table_packet_roundtrip() {
     let state = ParserState::new(24, |_| false, false);
     crate::test_roundtrip_encode(
         StringTablePacket {
-            tick: 1,
+            tick: 1.into(),
             tables: vec![],
         },
         &state,
     );
     crate::test_roundtrip_encode(
         StringTablePacket {
-            tick: 1,
+            tick: 1.into(),
             tables: vec![StringTable {
                 name: "table1".into(),
                 entries: vec![],
@@ -295,7 +296,7 @@ fn test_string_table_packet_roundtrip() {
     );
     crate::test_roundtrip_encode(
         StringTablePacket {
-            tick: 1,
+            tick: 1.into(),
             tables: vec![
                 StringTable {
                     name: "table1".into(),

src/demo/packet/synctick.rs

@@ -1,8 +1,9 @@
+use crate::demo::data::DemoTick;
 use bitbuffer::{BitRead, BitWrite};
 use serde::{Deserialize, Serialize};
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(BitRead, BitWrite, Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SyncTickPacket {
-    pub tick: u32,
+    pub tick: DemoTick,
 }

src/demo/packet/usercmd.rs

@@ -1,10 +1,11 @@
+use crate::demo::data::DemoTick;
 use bitbuffer::{BitRead, BitReadStream, BitWrite, BitWriteStream, LittleEndian};
 use serde::{Deserialize, Serialize};
 
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct UserCmdPacket {
-    pub tick: u32,
+    pub tick: DemoTick,
     pub sequence_out: u32,
     pub cmd: UserCmd,
 }