tf_demo_parser/demo/packet/
message.rs

1use bitbuffer::BitRead;
2#[cfg(feature = "write")]
3use bitbuffer::{BitWrite, BitWriteStream, LittleEndian};
4use serde::{Deserialize, Serialize};
5
6use crate::demo::data::DemoTick;
7use crate::demo::message::{Message, MessageType};
8#[cfg(feature = "write")]
9use crate::demo::parser::Encode;
10use crate::demo::vector::Vector;
11use crate::{Parse, ParserState, Result, Stream};
12#[cfg(feature = "trace")]
13use tracing::{event, span, Level};
14
15#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16#[derive(Debug, BitRead, PartialEq, Serialize, Deserialize, Clone, Default)]
17#[cfg_attr(feature = "write", derive(BitWrite))]
18pub struct MessagePacketMeta {
19    pub flags: u32, // TODO
20    pub view_angles: [ViewAngles; 2],
21    pub sequence_in: u32,
22    pub sequence_out: u32,
23}
24
25#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
26#[derive(Debug, PartialEq, Serialize, Deserialize, Clone, Default)]
27#[serde(bound(deserialize = "'a: 'static"))]
28pub struct MessagePacket<'a> {
29    pub tick: DemoTick,
30    pub messages: Vec<Message<'a>>,
31    pub meta: MessagePacketMeta,
32}
33
34#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
35#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize, BitRead)]
36#[cfg_attr(feature = "write", derive(BitWrite))]
37pub struct ViewAngles {
38    pub origin: Vector,
39    pub angles: Vector,
40    pub local_angles: Vector,
41}
42
43#[test]
44#[cfg(feature = "write")]
45fn test_view_angles_roundtrip() {
46    crate::test_roundtrip_write(ViewAngles::default());
47    crate::test_roundtrip_write(ViewAngles {
48        origin: Vector {
49            x: 1.0,
50            y: 2.0,
51            z: 3.0,
52        },
53        angles: Vector {
54            x: 4.0,
55            y: 5.0,
56            z: 6.0,
57        },
58        local_angles: Vector {
59            x: 7.0,
60            y: 8.0,
61            z: 9.0,
62        },
63    });
64}
65
66impl<'a> Parse<'a> for MessagePacket<'a> {
67    fn parse(stream: &mut Stream<'a>, state: &ParserState) -> Result<Self> {
68        let tick = stream.read()?;
69
70        let meta = stream.read()?;
71
72        let length: u32 = stream.read()?;
73        let mut packet_data = stream.read_bits(length as usize * 8)?;
74
75        let mut messages = Vec::with_capacity(8);
76        while packet_data.bits_left() > 6 {
77            let message_type = MessageType::read(&mut packet_data)?;
78            #[cfg(feature = "trace")]
79            let _span =
80                span!(Level::DEBUG, "reading message", message_type = ?message_type, tick = ?tick)
81                    .entered();
82
83            if state.should_parse_message(message_type) && message_type != MessageType::Empty {
84                #[cfg(feature = "trace")]
85                event!(Level::TRACE, "parsing message");
86                messages.push(Message::from_type(message_type, &mut packet_data, state)?);
87            } else {
88                #[cfg(feature = "trace")]
89                event!(Level::TRACE, "skipping message");
90                Message::skip_type(message_type, &mut packet_data, state)?;
91            }
92        }
93
94        let packet = MessagePacket {
95            tick,
96            messages,
97            meta,
98        };
99        Ok(packet)
100    }
101}
102
103#[cfg(feature = "write")]
104impl Encode for MessagePacket<'_> {
105    fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
106        self.tick.write(stream)?;
107        self.meta.write(stream)?;
108        stream.reserve_byte_length(32, |stream| {
109            for message in self.messages.iter() {
110                message.get_message_type().write(stream)?;
111                message.encode(stream, state)?;
112            }
113
114            Ok(())
115        })
116    }
117}
tf_demo_parser/demo/packet/message.rs

tf_demo_parser/demo/packet/
message.rs
