- Rust 99.8%
- Nix 0.2%
56f0856441
CreateStringTable and TempEntities both read their payload length as a fixed width field on protocol 23 and older and as a var int after that, but the encoders always write the var int. Reencoding an older demo therefore hands the game a length it can't read: string tables come back as "bogus substring index", and any packet carrying temp entities is malformed from there on, taking whatever messages follow it in that packet with it. The threshold and both widths are taken from the read paths a few lines up in these same two files rather than worked out separately, so the two sides can't drift: > 23, with 20 bits for CreateStringTable and 17 for TempEntities. The engine agrees, for what it's worth - netmessages.cpp reads both of these under > PROTOCOL_VERSION_23 at NET_MAX_PAYLOAD_BITS_V23 + 3 and NET_MAX_PAYLOAD_BITS_V23 respectively, and that constant is 17. serverinfo and prefetch already branch on the protocol on both sides, these two were the only ones that didn't. On a protocol 15 demo that was 28909 of 92518 reencoded packets failing to parse back; on test_data/protocol23.dem, 13220 of 43327. Both are zero now, so protocol23.dem can join the reencode round trip test. Protocol 24 output is unchanged, byte for byte. |
||
|---|---|---|
| .forgejo/workflows | ||
| benches | ||
| examples | ||
| fuzz | ||
| nix | ||
| smoker | ||
| src | ||
| test_data | ||
| tests | ||
| .envrc | ||
| .gitignore | ||
| Cargo.lock | ||
| Cargo.toml | ||
| flake.lock | ||
| flake.nix | ||
| pgo_build.sh | ||
| README.md | ||
| rustig.toml | ||
| schema.json | ||
TF Demo Parser
Parsing of tf2 demo files
Building
This project is build using rust and requires cargo and friends, see
the rust website for how to get started.
Once rust is setup building is as simple as
cargo build --release
which will place the binary at target/release/parse_demo
Usage
Basic usage is as simple as parse_demo demofile.dem which will output a
"summary" of the demo file in JSON format.
Passing the detailed_summary argument to the end of parse_demo will output a
table with scoreboard information for all players who were ever on the server
while the demo was being recorded. The player who created the demo will be
highlighted in the output.
Advanced usage
Loop through every packet
use bitbuffer::BitRead;
use main_error::MainError;
use std::fs;
use tf_demo_parser::demo::header::Header;
use tf_demo_parser::demo::parser::{DemoHandler, RawPacketStream};
use tf_demo_parser::Demo;
fn main() -> Result<(), MainError> {
let file = fs::read("demofile.dem")?;
let demo = Demo::new(&file);
let mut handler = DemoHandler::default();
let mut stream = demo.get_stream();
let header = Header::read(&mut stream)?;
handler.handle_header(&header);
let mut packets = RawPacketStream::new(stream);
while let Some(packet) = packets.next(&handler.state_handler)? {
handler.handle_packet(packet).unwrap();
}
assert_eq!(false, packets.incomplete);
Ok(())
}
Handle demo data with a custom analyser
Sometimes it's easier to create a custom Analyser to handle the demo data as
it comes along.
See src/demo/parser/analyser.rs for an example.
Once you have a custom analyser you can use it with:
DemoParser::new_all_with_analyser(demo.get_stream(), CustomAnalyser::new());
let (header, state) = parser.parse()?;