source2-demo 0.5.0

Dota 2 / Deadlock / CS2 replay parser written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use super::write_var_u32_to_buf;
use crate::proto::EDemoCommands;
use crate::stream::msg::MessageWriter;
use std::io::{self, Write};

/// Writes a demo command message and returns the number of bytes emitted.
pub fn write_demo_message<W: Write + ?Sized>(
    writer: &mut W,
    msg_type: EDemoCommands,
    tick: u32,
    payload: &[u8],
) -> io::Result<usize> {
    writer.write_message(msg_type, tick, payload)
}

/// Writes a demo command message, optionally Snappy-compressing the payload.
pub fn write_demo_message_with_compression<W: Write + ?Sized>(
    writer: &mut W,
    msg_type: EDemoCommands,
    tick: u32,
    payload: &[u8],
    compressed: bool,
) -> io::Result<usize> {
    writer.write_message_with_compression(msg_type, tick, payload, compressed)
}

impl<W: Write + ?Sized> MessageWriter for W {
    fn write_message(
        &mut self,
        msg_type: EDemoCommands,
        tick: u32,
        payload: &[u8],
    ) -> io::Result<usize> {
        self.write_message_with_compression(msg_type, tick, payload, false)
    }

    fn write_message_with_compression(
        &mut self,
        msg_type: EDemoCommands,
        tick: u32,
        payload: &[u8],
        compressed: bool,
    ) -> io::Result<usize> {
        let compressed_payload;
        let payload = if compressed {
            compressed_payload = snap::raw::Encoder::new()
                .compress_vec(payload)
                .map_err(io::Error::other)?;
            compressed_payload.as_slice()
        } else {
            payload
        };
        let cmd = if compressed {
            msg_type as i32 | EDemoCommands::DemIsCompressed as i32
        } else {
            msg_type as i32
        };
        let mut header = Vec::with_capacity(20);
        write_var_u32_to_buf(&mut header, cmd as u64);
        write_var_u32_to_buf(&mut header, tick as u64);
        write_var_u32_to_buf(&mut header, payload.len() as u64);
        self.write_all(&header)?;
        self.write_all(payload)?;
        Ok(header.len() + payload.len())
    }
}