Implement replay format detection. Add test data files in LFS.

Author: tec27

.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.bat]
+end_of_line = crlf
+
+[*.rs]
+indent_size = 4

.gitattributes

@@ -0,0 +1,3 @@
+* text=auto eol=lf
+
+*.rep filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1 +1,4 @@
 /target
+
+CLAUDE.local.md
+.claude/settings.local.json

CLAUDE.md

@@ -0,0 +1,36 @@
+# CLAUDE.md
+
+## Project Overview
+
+This is a pure Rust library called `broodrep` for reading StarCraft 1 replay files, supporting all versions. The project uses a Cargo workspace structure with two main components:
+
+- `broodrep/` - The core library crate
+- `broodrep-cli/` - A command-line interface that depends on the library
+
+## Development Commands
+
+### Building
+```bash
+cargo build                    # Build all workspace members
+cargo build -p broodrep       # Build only the library
+cargo build -p broodrep-cli   # Build only the CLI
+```
+
+### Testing
+```bash
+cargo test                     # Run all tests in workspace
+cargo test -p broodrep        # Test only the library
+```
+
+### Running
+```bash
+cargo run -p broodrep-cli      # Run the CLI application
+```
+
+## Architecture
+
+- The project is currently in early development.
+- Uses Rust 2024 edition
+- Is warning-free (and clippy lint free)
+
+The workspace is structured as a typical Rust project where the CLI tool depends on the core library for replay parsing functionality.

Cargo.lock

@@ -0,0 +1,33 @@
+# broodrep
+
+A pure Rust library for reading StarCraft 1 replay files. Supports all versions.
+
+## Development
+
+Test data is stored in Git LFS. If you haven't used Git LFS before run:
+
+```
+git lfs install
+```
+
+## See also
+
+- [broodmap](https://github.com/ShieldBattery/broodmap) - a pure Rust implementation of StarCraft 1 map parsing
+
+## License
+
+Licensed under either of
+
+* Apache License, Version 2.0
+  ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+* MIT license
+  ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+

README.md

@@ -5,3 +5,5 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+byteorder = "1.5"
+thiserror = "2.0"

broodrep/Cargo.toml

@@ -1 +1,119 @@
-// TODO(tec27): build it
+use std::io::{Read, Seek, SeekFrom};
+
+use byteorder::ReadBytesExt as _;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum BroodrepError {
+    #[error(transparent)]
+    IoError(#[from] std::io::Error),
+    #[error("malformed header: {0}")]
+    MalformedHeader(&'static str),
+}
+
+pub struct Replay<R: Read + Seek> {
+    inner: R,
+    format: ReplayFormat,
+}
+
+impl<R: Read + Seek> Replay<R> {
+    pub fn new(mut reader: R) -> Result<Self, BroodrepError> {
+        let format = Self::detect_format(&mut reader)?;
+        Ok(Replay {
+            inner: reader,
+            format,
+        })
+    }
+
+    pub fn into_inner(self) -> R {
+        self.inner
+    }
+
+    pub fn format(&self) -> ReplayFormat {
+        self.format
+    }
+
+    fn detect_format(reader: &mut R) -> Result<ReplayFormat, BroodrepError> {
+        // 1.21+ has `seRS`, before that it's `reRS`
+        reader.seek(SeekFrom::Start(12))?;
+        let mut magic = [0; 4];
+        reader.read(&mut magic)?;
+        if magic == *b"seRS" {
+            return Ok(ReplayFormat::Modern121);
+        }
+        if magic != *b"reRS" {
+            return Err(BroodrepError::MalformedHeader("invalid magic bytes"));
+        }
+
+        // Check compression type, newer compression type indicates 1.18+
+        reader.seek(SeekFrom::Current(12))?; // offset 28
+        let byte = reader.read_u8()?;
+        if byte == 0x78 {
+            Ok(ReplayFormat::Modern)
+        } else {
+            // TODO(tec27): Make sure it's within the valid range
+            Ok(ReplayFormat::Legacy)
+        }
+    }
+}
+
+/// The format version of a replay.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum ReplayFormat {
+    /// The replay was created with a version before 1.18.
+    Legacy,
+    /// The replay was created with a version between 1.18 and 1.21.
+    Modern,
+    /// The replay was created with version 1.21 or later.
+    Modern121,
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    use super::*;
+
+    const NOT_A_REPLAY: &[u8] = include_bytes!("../testdata/not_a_replay.rep");
+    const LEGACY: &[u8] = include_bytes!("../testdata/things.rep");
+    const LEGACY_EMPTY: &[u8] = include_bytes!("../testdata/empty.rep");
+    const SCR_OLD: &[u8] = include_bytes!("../testdata/scr_old.rep");
+    const SCR_121: &[u8] = include_bytes!("../testdata/scr_replay.rep");
+
+    #[test]
+    fn test_replay_format_invalid() {
+        let mut cursor = Cursor::new(NOT_A_REPLAY);
+        assert!(matches!(
+            Replay::new(&mut cursor),
+            Err(BroodrepError::MalformedHeader(_))
+        ));
+    }
+
+    #[test]
+    fn test_replay_format_legacy() {
+        let mut cursor = Cursor::new(LEGACY);
+        let replay = Replay::new(&mut cursor).unwrap();
+        assert_eq!(replay.format, ReplayFormat::Legacy);
+    }
+
+    #[test]
+    fn test_replay_format_legacy_empty() {
+        let mut cursor = Cursor::new(LEGACY_EMPTY);
+        let replay = Replay::new(&mut cursor).unwrap();
+        assert_eq!(replay.format, ReplayFormat::Legacy);
+    }
+
+    #[test]
+    fn test_replay_format_scr_old() {
+        let mut cursor = Cursor::new(SCR_OLD);
+        let replay = Replay::new(&mut cursor).unwrap();
+        assert_eq!(replay.format, ReplayFormat::Modern);
+    }
+
+    #[test]
+    fn test_replay_format_scr_121() {
+        let mut cursor = Cursor::new(SCR_121);
+        let replay = Replay::new(&mut cursor).unwrap();
+        assert_eq!(replay.format, ReplayFormat::Modern121);
+    }
+}

broodrep/src/lib.rs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b243f0e8e850b48e2e70de9ea409f7f1e306e538f242f19c670f77029060efb0
+size 291677

broodrep/testdata/empty.rep

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92df6b4e7b78404a7258a8fc096343058728caee06a7551baf1a141be813264d
+size 38