Initial commit

Author: qoh

.gitignore

@@ -0,0 +1,4 @@
+/target
+**/*.rs.bk
+Cargo.lock
+.vscode

Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "brs"
+version = "0.1.0"
+authors = ["ns <[email protected]>"]
+edition = "2018"
+description = "Read and write Brickadia save files."
+keywords = ["brickadia", "parser", "file", "binary"]
+categories = ["encoding"]
+readme = "README.md"
+
+[dependencies]
+byteorder = "1"
+libflate = "0.1"
+uuid = "0.7"
+chrono = "0.4"

README.md

@@ -0,0 +1,87 @@
+[![brs on crates.io][cratesio-image]][cratesio]
+[![brs on docs.rs][docsrs-image]][docsrs]
+
+[cratesio-image]: https://img.shields.io/crates/v/brs.svg
+[cratesio]: https://crates.io/crates/brs
+[docsrs-image]: https://docs.rs/brs/badge.svg
+[docsrs]: https://docs.rs/brs
+
+Interfaces for reading and writing Brickadia save files.
+
+Aims to be able to read all previous versions just like the game,
+but only write the newest version of the format.
+
+# Usage
+
+## Reading
+
+First, create a reader from any
+[`Read`](https://doc.rust-lang.org/std/io/trait.Read.html)
+source, such as a file or buffer.
+
+```rust
+let reader = brs::Reader::new(File::open("village.brs")?)?;
+```
+
+Brickadia save files have information split into sections ordered
+such that one can extract simple information
+without needing to parse the entire file.
+
+This library surfaces this by strictly enforcing the way that data is read
+and made available at the type level; you can't go wrong.
+
+To continue, reading the first header gets you basic information.
+For details on what is available, see
+[`HasHeader1`](https://docs.rs/brs/*/brs/read/trait.HasHeader1.html).
+
+```rust
+use brs::HasHeader1;
+let reader = reader.read_header1();
+println!("Brick count: {}", reader.brick_count());
+println!("Map: {}", reader.map());
+```
+
+The next header contains data less likely to be relevant for simpler
+introspection, but rather things such as tables for loading bricks.
+See [`HasHeader2`](https://docs.rs/brs/*/brs/read/trait.HasHeader2.html).
+
+```rust
+use brs::HasHeader2;
+let reader = reader.read_header2();
+println!("Mods: {:?}", reader.mods());
+println!("Color count: {}", reader.colors().len());
+// Properties from header 1 are still available:
+println!("Description: {}", reader.description();
+```
+
+After both headers have been read, you may now iterate over the bricks.
+See [`Brick`](https://docs.rs/brs/*/brs/struct.Brick.html).
+
+```rust
+for brick in reader.iter_bricks()? {
+    let brick = brick?;
+    println!("{:?}", brick);
+}
+```
+
+You may retain access to the header information while getting the iterator:
+
+```rust
+let (rdr, bricks) = reader.iter_bricks_and_reader()?;
+```
+
+## Writing
+
+Writing save files isn't as fancy, for now you simply just put all the data
+in the [`WriteData`](https://docs.rs/brs/*/brs/struct.WriteData.html) struct and pass it to
+[`write_save`](https://docs.rs/brs/*/brs/fn.write_save.html) along with a
+[`Write`](https://doc.rust-lang.org/std/io/trait.Write.html) destination.
+
+```rust
+let data = brs::WriteData {
+    map: String::from("Plate"),
+    description: String::from("A quaint park full of ducks and turkeys."),
+    // ...
+};
+brs::write_save(&mut File::create("park.brs")?, &data)?;
+```

src/bin/debug.rs

@@ -0,0 +1,19 @@
+use brs::{HasHeader1, HasHeader2};
+use std::env::args;
+use std::fs::File;
+
+fn main() -> std::io::Result<()> {
+    let path = args().nth(1).expect("missing path");
+    let reader = brs::Reader::new(File::open(path)?)?;
+    let reader = reader.read_header1()?;
+    let reader = reader.read_header2()?;
+    dbg!(reader.header1());
+    dbg!(reader.header2());
+    let mut first_brick = None;
+    for brick in reader.iter_bricks()? {
+        let brick = brick?;
+        first_brick.get_or_insert(brick);
+    }
+    dbg!(first_brick);
+    Ok(())
+}

src/bin/rewrite.rs

@@ -0,0 +1,14 @@
+use std::env::args;
+use std::fs::File;
+
+fn main() -> std::io::Result<()> {
+    let path = args().nth(1).expect("missing path");
+    let reader = brs::Reader::new(File::open(&path)?)?;
+    let reader = reader.read_header1()?;
+    let reader = reader.read_header2()?;
+    let data = reader.into_write_data()?;
+    let mut new_path = path.clone();
+    new_path.push_str(".rewrite.brs");
+    brs::write_save(&mut File::create(new_path)?, &data)?;
+    Ok(())
+}

src/bit_reader.rs

@@ -0,0 +1,133 @@
+// Currently panics on EOF.
+// Needs improvement.
+
+use std::io::{self, prelude::*};
+
+pub struct BitReader {
+    buf: Vec<u8>,
+    pos: usize,
+}
+
+impl BitReader {
+    pub fn new(buf: Vec<u8>) -> Self {
+        Self { buf, pos: 0 }
+    }
+
+    // ReadBit
+    #[inline(always)]
+    pub fn read_bit(&mut self) -> bool {
+        let bit = (self.buf[self.pos >> 3] & (1 << (self.pos & 7))) != 0;
+        self.pos += 1;
+        bit
+    }
+
+    // SerializeBits
+    pub fn read_bits(&mut self, dst: &mut [u8], len: usize) {
+        for bit in 0..len {
+            let byte = &mut dst[bit >> 3];
+            let shift = bit & 7;
+            *byte = (*byte & !(1 << shift)) | (u8::from(self.read_bit()) << shift);
+        }
+        self.pos += len;
+    }
+
+    // SerializeInt
+    pub fn read_int(&mut self, max: u32) -> u32 {
+        let mut value = 0;
+        let mut mask = 1;
+
+        while (value + mask) < max && mask != 0 {
+            if self.read_bit() {
+                value |= mask;
+            }
+            mask *= 2;
+        }
+
+        value
+    }
+
+    // SerializeIntPacked
+    pub fn read_int_packed(&mut self) -> u32 {
+        /*
+        let mut src = &self.buf[..];
+        let bit_count_used_in_byte = self.pos & 7;
+        let bit_count_left_in_byte = 8 - (self.pos & 7);
+        let src_mask_byte_0 = ((1 << bit_count_left_in_byte) - 1) as u8;
+        let src_mask_byte_1 = ((1 << bit_count_used_in_byte) - 1) as u8;
+        let next_src_index = (bit_count_used_in_byte != 0) as usize;
+
+        let mut value: u32 = 0;
+
+        let mut it = 0;
+        let mut shift_count = 0;
+
+        while it < 5 {
+            self.pos += 8;
+
+            let byte = ((src[0] >> bit_count_used_in_byte) & src_mask_byte_0)
+                | ((src[next_src_index] & src_mask_byte_1) << (bit_count_left_in_byte & 7));
+            let next_byte_indicator = byte & 1;
+            let byte_as_word = (byte >> 1) as u32;
+            value = (byte_as_word << shift_count) | value;
+            src = &src[1..];
+
+            if next_byte_indicator == 0 {
+                break;
+            }
+
+            it += 1;
+            shift_count += 7;
+        }
+
+        value
+        */
+
+        let mut value = 0;
+
+        for i in 0..5 {
+            let has_next = self.read_bit();
+            let mut part = 0;
+            for bit_shift in 0..7 {
+                part |= (self.read_bit() as u32) << bit_shift;
+            }
+            value |= part << (7 * i);
+            if !has_next {
+                break;
+            }
+        }
+
+        value
+    }
+
+    // EatByteAlign
+    pub fn eat_byte_align(&mut self) {
+        self.pos = (self.pos + 7) & !0x07;
+    }
+
+    // SerializeIntVectorPacked
+    pub fn read_int_vector_packed(&mut self) -> (i32, i32, i32) {
+        (self.rivp_item(), self.rivp_item(), self.rivp_item())
+    }
+
+    #[inline(always)]
+    fn rivp_item(&mut self) -> i32 {
+        let value = self.read_int_packed();
+        (value >> 1) as i32 * if value & 1 != 0 { 1 } else { -1 }
+    }
+
+    // SerializePositiveIntVectorPacked
+    pub fn read_positive_int_vector_packed(&mut self) -> (u32, u32, u32) {
+        (
+            self.read_int_packed(),
+            self.read_int_packed(),
+            self.read_int_packed(),
+        )
+    }
+}
+
+impl Read for BitReader {
+    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
+        self.read_bits(dst, dst.len() * 8);
+        Ok(dst.len())
+    }
+}

src/bit_writer.rs

@@ -0,0 +1,112 @@
+use std::io::{self, prelude::*};
+
+pub struct BitWriter<W: Write> {
+    w: W,
+    cur: u8,
+    bit: u8,
+}
+
+impl<W: Write> BitWriter<W> {
+    pub fn new(w: W) -> Self {
+        Self { w, cur: 0, bit: 0 }
+    }
+
+    pub fn finish(mut self) -> io::Result<W> {
+        self.flush_byte()?;
+        Ok(self.w)
+    }
+
+    #[inline]
+    fn flush_byte(&mut self) -> io::Result<()> {
+        if self.bit > 0 {
+            let src = [self.cur];
+            if self.w.write(&src)? != 1 {
+                return Err(io::Error::from(io::ErrorKind::WriteZero));
+            }
+            self.cur = 0;
+            self.bit = 0;
+        }
+        Ok(())
+    }
+
+    pub fn byte_align(&mut self) -> io::Result<()> {
+        self.flush_byte()
+    }
+
+    #[inline]
+    pub fn write_bit(&mut self, bit: bool) -> io::Result<bool> {
+        self.cur |= (bit as u8) << self.bit;
+        self.bit += 1;
+        if self.bit >= 8 {
+            self.flush_byte()?;
+        }
+        Ok(bit)
+    }
+
+    pub fn write_bits(&mut self, src: &[u8], len: usize) -> io::Result<()> {
+        for bit in 0..len {
+            self.write_bit((src[bit >> 3] & (1 << (bit & 7))) != 0)?;
+        }
+        Ok(())
+    }
+
+    pub fn write_int(&mut self, value: u32, max: u32) -> io::Result<()> {
+        assert!(max >= 2);
+
+        if value >= max {
+            return Err(io::Error::from(io::ErrorKind::InvalidInput));
+        }
+
+        let mut new_value = 0;
+        let mut mask = 1;
+
+        while (new_value + mask) < max && mask != 0 {
+            self.write_bit(value & mask != 0)?;
+            if value & mask != 0 {
+                new_value |= mask;
+            }
+            mask *= 2;
+        }
+
+        Ok(())
+    }
+
+    pub fn write_int_packed(&mut self, mut value: u32) -> io::Result<()> {
+        loop {
+            let src = [(value & 0b111_1111) as u8];
+            value >>= 7;
+            self.write_bit(value != 0)?;
+            self.write_bits(&src, 7)?;
+            if value == 0 {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn write_positive_int_vector_packed(&mut self, v: (u32, u32, u32)) -> io::Result<()> {
+        self.write_int_packed(v.0)?;
+        self.write_int_packed(v.1)?;
+        self.write_int_packed(v.2)
+    }
+
+    pub fn write_int_vector_packed(&mut self, v: (i32, i32, i32)) -> io::Result<()> {
+        fn map(x: i32) -> u32 {
+            ((x.abs() as u32) << 1) | (x.is_positive() as u32)
+        }
+        self.write_int_packed(map(v.0))?;
+        self.write_int_packed(map(v.1))?;
+        self.write_int_packed(map(v.2))
+    }
+}
+
+impl<W: Write> Write for BitWriter<W> {
+    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
+        self.write_bits(src, 8 * src.len())?;
+        Ok(src.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.w.flush()
+    }
+}