some write progress

src/demo/packet/consolecmd.rs

@@ -1,4 +1,4 @@
-use bitbuffer::{BitRead, LittleEndian};
+use bitbuffer::{BitRead, BitWrite, BitWriteSized, LittleEndian};
 
 use crate::{ReadResult, Stream};
 
@@ -17,3 +17,13 @@ impl BitRead<'_, LittleEndian> for ConsoleCmdPacket {
         Ok(ConsoleCmdPacket { tick, command })
     }
 }
+
+impl BitWrite<LittleEndian> for ConsoleCmdPacket {
+    fn write(&self, stream: &mut bitbuffer::BitWriteStream<LittleEndian>) -> ReadResult<()> {
+        self.tick.write(stream)?;
+        let len = self.command.len() as u32;
+        len.write(stream)?;
+        self.command.write_sized(stream, len as usize)?;
+        Ok(())
+    }
+}

src/demo/packet/datatable.rs

@@ -1,4 +1,4 @@
-use bitbuffer::BitRead;
+use bitbuffer::{BitRead, BitWrite};
 
 use crate::demo::parser::MalformedSendPropDefinitionError;
 use crate::demo::sendprop::{
@@ -11,9 +11,10 @@ use serde::{Deserialize, Serialize};
 use std::cmp::min;
 
 use std::convert::TryFrom;
-use std::rc::Rc;
 
-#[derive(BitRead, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd, Display, FromStr)]
+#[derive(
+    BitRead, BitWrite, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd, Display, FromStr,
+)]
 pub struct ClassId(u16);
 
 impl From<u16> for ClassId {
@@ -28,8 +29,8 @@ impl From<ClassId> for usize {
     }
 }
 
-#[derive(BitRead, PartialEq, Eq, Hash, Debug, Serialize, Deserialize, Clone, Display)]
-pub struct ServerClassName(Rc<String>);
+#[derive(BitRead, BitWrite, PartialEq, Eq, Hash, Debug, Serialize, Deserialize, Clone, Display)]
+pub struct ServerClassName(String);
 
 impl ServerClassName {
     pub fn as_str(&self) -> &str {
@@ -39,11 +40,11 @@ impl ServerClassName {
 
 impl From<String> for ServerClassName {
     fn from(value: String) -> Self {
-        Self(Rc::new(value))
+        Self(value)
     }
 }
 
-#[derive(BitRead, Debug, Clone)]
+#[derive(BitRead, BitWrite, Debug, Clone)]
 pub struct ServerClass {
     pub id: ClassId,
     pub name: ServerClassName,
@@ -52,6 +53,7 @@ pub struct ServerClass {
 
 #[derive(
     BitRead,
+    BitWrite,
     PartialEq,
     Eq,
     Hash,
@@ -64,7 +66,7 @@ pub struct ServerClass {
     Ord,
     Default,
 )]
-pub struct SendTableName(Rc<String>);
+pub struct SendTableName(String);
 
 impl SendTableName {
     pub fn as_str(&self) -> &str {
@@ -74,7 +76,7 @@ impl SendTableName {
 
 impl From<String> for SendTableName {
     fn from(value: String) -> Self {
-        Self(Rc::new(value))
+        Self(value)
     }
 }
 

src/demo/packet/message.rs

@@ -1,11 +1,11 @@
-use bitbuffer::{bit_size_of, BitRead, Endianness, LazyBitRead, LittleEndian};
+use bitbuffer::{bit_size_of, BitRead, BitWrite, Endianness, LazyBitRead, LittleEndian};
 
 use crate::demo::message::{Message, MessageType};
 use crate::demo::vector::Vector;
 use crate::{Parse, ParserState, ReadResult, Result, Stream};
 use std::fmt;
 
-#[derive(Debug, BitRead)]
+#[derive(Debug, BitRead, BitWrite)]
 pub struct MessagePacketMeta {
     pub flags: u32, // TODO
     pub view_angles: ViewAngles,
@@ -20,7 +20,7 @@ pub struct MessagePacket<'a> {
     pub meta: LazyBitRead<'a, MessagePacketMeta, LittleEndian>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct ViewAngles {
     pub origin: (Vector, Vector),
     pub angles: (Vector, Vector),
@@ -29,12 +29,10 @@ pub struct ViewAngles {
 
 impl<E: Endianness> BitRead<'_, E> for ViewAngles {
     fn read(stream: &mut bitbuffer::BitReadStream<E>) -> ReadResult<Self> {
-        let view_origin_1 = Vector::read(stream)?;
-        let view_angle_1 = Vector::read(stream)?;
-        let local_view_angle_1 = Vector::read(stream)?;
-        let origin = (Vector::read(stream)?, view_origin_1);
-        let angles = (Vector::read(stream)?, view_angle_1);
-        let local_angles = (Vector::read(stream)?, local_view_angle_1);
+        let vectors = <[Vector; 6]>::read(stream)?;
+        let origin = (vectors[3], vectors[0]);
+        let angles = (vectors[4], vectors[1]);
+        let local_angles = (vectors[5], vectors[2]);
         Ok(ViewAngles {
             origin,
             angles,
@@ -47,6 +45,67 @@ impl<E: Endianness> BitRead<'_, E> for ViewAngles {
     }
 }
 
+impl<E: Endianness> BitWrite<E> for ViewAngles {
+    fn write(&self, stream: &mut bitbuffer::BitWriteStream<E>) -> ReadResult<()> {
+        [
+            self.origin.1,
+            self.angles.1,
+            self.local_angles.1,
+            self.origin.0,
+            self.angles.0,
+            self.local_angles.0,
+        ]
+        .write(stream)
+    }
+}
+
+#[test]
+fn test_view_angles_roundtrip() {
+    crate::test_roundtrip_encode(ViewAngles {
+        origin: (Vector::default(), Vector::default()),
+        angles: (Vector::default(), Vector::default()),
+        local_angles: (Vector::default(), Vector::default()),
+    });
+    crate::test_roundtrip_encode(ViewAngles {
+        origin: (
+            Vector {
+                x: 1.0,
+                y: 1.0,
+                z: 1.0,
+            },
+            Vector {
+                x: 2.0,
+                y: 2.0,
+                z: 2.0,
+            },
+        ),
+        angles: (
+            Vector {
+                x: 3.0,
+                y: 3.0,
+                z: 3.0,
+            },
+            Vector {
+                x: 4.0,
+                y: 4.0,
+                z: 4.0,
+            },
+        ),
+        local_angles: (
+            Vector {
+                x: 5.0,
+                y: 5.0,
+                z: 5.0,
+            },
+            Vector {
+                x: 6.0,
+                y: 6.0,
+                z: 6.0,
+            },
+        ),
+    });
+}
+
 impl<'a> Parse<'a> for MessagePacket<'a> {
     fn parse(stream: &mut Stream<'a>, _state: &ParserState) -> Result<Self> {
         let tick = stream.read()?;

src/demo/packet/mod.rs

@@ -1,4 +1,4 @@
-use bitbuffer::BitRead;
+use bitbuffer::{BitRead, BitWrite};
 use num_enum::TryFromPrimitive;
 
 use crate::{Parse, ParserState, Result, Stream};
@@ -25,13 +25,13 @@ pub enum Packet<'a> {
     Message(MessagePacket<'a>),
     SyncTick(SyncTickPacket),
     ConsoleCmd(ConsoleCmdPacket),
-    UserCmd(UserCmdPacket),
+    UserCmd(UserCmdPacket<'a>),
     DataTables(DataTablePacket),
     Stop(StopPacket),
     StringTables(StringTablePacket<'a>),
 }
 
-#[derive(BitRead, TryFromPrimitive, Debug, Clone, Copy)]
+#[derive(BitRead, BitWrite, TryFromPrimitive, Debug, Clone, Copy)]
 #[discriminant_bits = 8]
 #[repr(u8)]
 pub enum PacketType {

src/demo/packet/stop.rs

@@ -1,12 +1,4 @@
-use bitbuffer::{BitRead, LittleEndian};
+use bitbuffer::{BitRead, BitWrite};
 
-use crate::{ReadResult, Stream};
-
-#[derive(Debug)]
+#[derive(Debug, BitRead, BitWrite)]
 pub struct StopPacket;
-
-impl BitRead<'_, LittleEndian> for StopPacket {
-    fn read(_stream: &mut Stream) -> ReadResult<Self> {
-        Ok(StopPacket)
-    }
-}

src/demo/packet/stringtable.rs

@@ -1,13 +1,13 @@
 use std::fmt;
 
-use bitbuffer::{BitRead, LittleEndian};
+use bitbuffer::{BitRead, BitWrite, LittleEndian};
 
 use crate::demo::message::stringtable::StringTableMeta;
 use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 use std::borrow::{Borrow, Cow};
 use std::cmp::min;
 
-#[derive(BitRead, Clone, Copy, Debug)]
+#[derive(BitRead, BitWrite, Clone, Copy, Debug)]
 pub struct FixedUserDataSize {
     #[size = 12]
     pub size: u16,
@@ -62,7 +62,7 @@ impl<'a> BitRead<'a, LittleEndian> for StringTable<'a> {
     }
 }
 
-#[derive(BitRead, Clone, Debug)]
+#[derive(BitRead, BitWrite, Clone, Debug)]
 #[endianness = "LittleEndian"]
 pub struct ExtraData<'a> {
     pub byte_len: u16,

src/demo/packet/synctick.rs

@@ -1,6 +1,6 @@
-use bitbuffer::BitRead;
+use bitbuffer::{BitRead, BitWrite};
 
-#[derive(BitRead, Debug)]
+#[derive(BitRead, BitWrite, Debug)]
 pub struct SyncTickPacket {
     pub tick: u32,
 }

src/demo/packet/usercmd.rs

@@ -1,20 +1,12 @@
-use bitbuffer::{BitRead, LittleEndian};
+use crate::Stream;
+use bitbuffer::{BitRead, BitWrite, LittleEndian};
 
-use crate::{ReadResult, Stream};
-
-#[derive(Debug)]
-pub struct UserCmdPacket {
+#[derive(Debug, BitRead, BitWrite)]
+#[endianness = "LittleEndian"]
+pub struct UserCmdPacket<'a> {
     tick: u32,
     sequence_out: u32,
-}
-
-impl BitRead<'_, LittleEndian> for UserCmdPacket {
-    fn read(stream: &mut Stream) -> ReadResult<Self> {
-        let tick = stream.read()?;
-        let sequence_out = stream.read()?;
-        let len: u32 = stream.read()?;
-        stream.skip_bits(len as usize * 8)?;
-        // TODO parse the packet data
-        Ok(UserCmdPacket { tick, sequence_out })
-    }
+    len: u32,
+    #[size = "len.saturating_mul(8)"]
+    data: Stream<'a>,
 }