Crate boxcars[][src]


Boxcars is a Rocket League replay parser written in Rust with serde support for serialization oftentimes into JSON. The focus is correctness and performance with boxcar users able to dictate what sections of the replay to parse. For instance, parsing just the header (where tidbits like goals and scores are stored) completes in under 50 microseconds. However, if you want to check against replay corruption and parse the network data, it would cost you 30 milliseconds (~1000x increase). While a 1000x increase in time sounds significant; keep in mind, 30ms is phenomenal compared to current state of the art Rocket League Replay parsers.

extern crate boxcars;
extern crate serde_json;
extern crate failure;

use std::fs::File;
use std::io::{self, Read};

fn run(filename: &str) -> Result<(), ::failure::Error> {
    let mut f = File::open(filename)?;
    let mut buffer = vec![];
    f.read_to_end(&mut buffer)?;
    let replay = boxcars::ParserBuilder::new(&buffer)

    serde_json::to_writer(&mut io::stdout(), &replay)?;





A mapping between an object (that's an attribute)'s index and what its id will be when encoded in the network data


A mapping between an object's name and its index. Largely redundant


Contains useful information when decoding the network stream, which we aren't


Debugging info stored in the replay if debugging is enabled.


Contains the time and any new information that occurred during a frame


Keyframes as defined by the video compression section in the wikipedia article, are the main frames that are derived from in the following frame data. The key frames decoded will match up with the frames decoded from the network data.


The frames decoded from the network data


Information for a new actor that appears in the game


The main entry point to parsing replays in boxcars. Allows one to customize parsing options, such as only parsing the header and forgoing crc (corruption) checks.


The structure that a rocket league replay is parsed into.


An object's current rotation


In Rocket league replays, there are tickmarks that typically represent a significant event in the game (eg. a goal). The tick mark is placed before the event happens so there is a ramp-up time. For instance, a tickmark could be at frame 396 for a goal at frame 441. At 30 fps, this would be 1.5 seconds of ramp up time.


Contains the optional location and rotation of an object when it spawns


Notifies that an actor has had one of their properties updated (most likely their rigid body state (location / rotation) has changed)


An object's current vector



Determines under what circumstances the parser should perform the crc check for replay corruption. Since the crc check is the most time consuming check for parsing (causing microseconds to turn into milliseconds), clients should choose under what circumstances a crc check is performed.


All the interesting data are stored as properties in the header, properties such as:


Determines how the parser should handle the network data, which is the most intensive and volatile section of the replay.