010dcc3 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

010dcc3 — Peter John 2026-11-02T13:44:15+05:30

T3: plum-game crate + KaM asset decoders

Files changed (5) hide show

plum-game/.gitignore +2 -0
plum-game/Cargo.toml +21 -0
plum-game/src/assets.rs +253 -0
plum-game/src/lib.rs +1 -0
plum-game/tests/assets_test.rs +114 -0

plum-game/.gitignore ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ target/
2	+ dist/

plum-game/Cargo.toml ADDED Viewed

@@ -0,0 +1,21 @@
+[package]
+name = "plum-game"
+version = "0.1.0"
+edition = "2021"
+description = "Native and web host for Plum game programs"
+[dependencies]
+macroquad = { version = "0.4", default-features = false }
+flate2 = "1"
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+wasmtime = "47"
+[dev-dependencies]
+plum-core = { path = "../plum-core" }
+plum-wasm-codegen = { path = "../plum-wasm-codegen" }
+# Stand on its own rather than joining the parent directory's workspace: the
+# Plum compiler workspace must build without pulling in the game host's
+# graphics and runtime dependencies.
+[workspace]

plum-game/src/assets.rs ADDED Viewed

@@ -0,0 +1,253 @@
+//! Decoders for KaM Remake assets: `.rxx` sprite atlases and `.map` terrain
+//! files. Plain Rust with no graphics dependency. Malformed or truncated
+//! input is an `Err`, never a panic.
+//!
+//! The formats follow kam_macroquad's `rxx.rs`, `rules/map_file.rs` and
+//! `kamdat.rs`.
+use flate2::read::ZlibDecoder;
+use std::io::{self, Read};
+use std::path::{Path, PathBuf};
+fn bad(what: impl Into<String>) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, what.into())
+}
+/// Where the game's asset files live.
+pub struct AssetRoot;
+impl AssetRoot {
+    /// The `--assets` argument, else `$PLUM_GAME_ASSETS`, else
+    /// `../kam_macroquad/assets` beside the repository.
+    pub fn resolve(cli: Option<&Path>) -> PathBuf {
+        if let Some(p) = cli {
+            return p.to_path_buf();
+        }
+        if let Some(p) = std::env::var_os("PLUM_GAME_ASSETS") {
+            return PathBuf::from(p);
+        }
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../kam_macroquad/assets")
+    }
+}
+// --- bounds-checked reader ---------------------------------------------------
+struct Reader<'a> {
+    b: &'a [u8],
+    pos: usize,
+}
+impl<'a> Reader<'a> {
+    fn take(&mut self, n: usize) -> Result<&'a [u8], String> {
+        let end = self.pos.checked_add(n).ok_or("length overflow")?;
+        let s = self.b.get(self.pos..end).ok_or_else(|| format!("data ends early at byte {}", self.pos))?;
+        self.pos = end;
+        Ok(s)
+    }
+    fn u8(&mut self) -> Result<u8, String> {
+        Ok(self.take(1)?[0])
+    }
+    fn u16(&mut self) -> Result<u16, String> {
+        let s = self.take(2)?;
+        Ok(u16::from_le_bytes([s[0], s[1]]))
+    }
+    fn i32(&mut self) -> Result<i32, String> {
+        let s = self.take(4)?;
+        Ok(i32::from_le_bytes([s[0], s[1], s[2], s[3]]))
+    }
+    fn u32(&mut self) -> Result<u32, String> {
+        Ok(self.i32()? as u32)
+    }
+}
+// --- .rxx --------------------------------------------------------------------
+pub struct Sprite {
+    pub w: u16,
+    pub h: u16,
+    pub px: i32,
+    pub py: i32,
+    pub rgba: Vec<u8>,
+}
+/// A sprite archive. `sprites` is 1-based: sprite `n` is `sprites[n]`, and
+/// index 0 and unused slots are `None`.
+pub struct Atlas {
+    pub sprites: Vec<Option<Sprite>>,
+}
+impl Atlas {
+    /// Layout: optional `RXX1`/`RXX2` header, then a zlib stream holding a
+    /// u32 count, `count` flag bytes, then per flagged sprite its size
+    /// (u16 w, u16 h), pivot (i32 x, i32 y), w*h RGBA bytes, a has-mask byte
+    /// and an optional w*h team-colour mask (skipped).
+    pub fn parse(bytes: &[u8]) -> io::Result<Atlas> {
+        let off = if bytes.starts_with(b"RXX1") {
+            4 + 32
+        } else if bytes.starts_with(b"RXX2") {
+            let l = bytes.get(4..6).ok_or_else(|| bad("rxx header ends early"))?;
+            6 + u16::from_le_bytes([l[0], l[1]]) as usize
+        } else {
+            0
+        };
+        let body = bytes.get(off..).ok_or_else(|| bad("rxx header ends early"))?;
+        let mut data = Vec::new();
+        ZlibDecoder::new(body).read_to_end(&mut data)?;
+        let mut r = Reader { b: &data, pos: 0 };
+        let count = r.u32().map_err(bad)? as usize;
+        let flags = r.take(count).map_err(bad)?;
+        let mut sprites: Vec<Option<Sprite>> = Vec::with_capacity(count + 1);
+        sprites.push(None);
+        for &flag in flags {
+            if flag != 1 {
+                sprites.push(None);
+                continue;
+            }
+            let w = r.u16().map_err(bad)?;
+            let h = r.u16().map_err(bad)?;
+            let px = r.i32().map_err(bad)?;
+            let py = r.i32().map_err(bad)?;
+            let n = w as usize * h as usize;
+            let rgba = padded(&mut r, n * 4)?;
+            let has_mask = padded(&mut r, 1)?[0];
+            if has_mask != 0 {
+                padded(&mut r, n)?;
+            }
+            sprites.push(Some(Sprite { w, h, px, py, rgba }));
+        }
+        Ok(Atlas { sprites })
+    }
+    /// Mean colour of the non-transparent pixels, alpha 1; zeros for a
+    /// missing sprite or one with no opaque pixel.
+    pub fn avg_color(&self, idx: usize) -> [f32; 4] {
+        let Some(Some(s)) = self.sprites.get(idx) else { return [0.0; 4] };
+        let (mut sum, mut n) = ([0u64; 3], 0u64);
+        for p in s.rgba.chunks_exact(4).filter(|p| p[3] != 0) {
+            for c in 0..3 {
+                sum[c] += p[c] as u64;
+            }
+            n += 1;
+        }
+        if n == 0 {
+            return [0.0; 4];
+        }
+        [0, 1, 2].map(|c| sum[c] as f32 / n as f32 / 255.0).into_iter().chain([1.0]).collect::<Vec<_>>().try_into().unwrap()
+    }
+}
+/// Read `len` bytes. Some archives end a few bytes early, and what is
+/// missing stays zero; a larger shortfall is an error.
+fn padded(r: &mut Reader, len: usize) -> io::Result<Vec<u8>> {
+    let avail = len.min(r.b.len() - r.pos);
+    if len - avail > 1024 {
+        return Err(bad("rxx sprite data ends early"));
+    }
+    let mut v = r.take(avail).map_err(bad)?.to_vec();
+    v.resize(len, 0);
+    Ok(v)
+}
+// --- .map --------------------------------------------------------------------
+/// Terrain grids indexed `y * w + x`, row 0 being the first row in the file.
+pub struct MapData {
+    pub w: i32,
+    pub h: i32,
+    /// Tileset id (the Tileset sprite is id + 1).
+    pub terrain: Vec<u16>,
+    pub rotation: Vec<u8>,
+    pub elevation: Vec<u8>,
+    /// Trees_a sprite index, 0 = none.
+    pub object: Vec<u16>,
+}
+const MAX_MAP_SIZE: i32 = 256;
+const MAPELEM_RECORD: usize = 99;
+/// First Trees sprite of a map element in `mapelem.dat`, 0 when the element
+/// is none/invisible or has no frames.
+fn object_sprite(mapelem: &[u8], obj: u16) -> u16 {
+    if obj >= 254 {
+        return 0;
+    }
+    let o = obj as usize * MAPELEM_RECORD;
+    let Some(rec) = mapelem.get(o..o + MAPELEM_RECORD) else { return 0 };
+    let i16_at = |i: usize| i16::from_le_bytes([rec[i], rec[i + 1]]);
+    let count = i16_at(60).clamp(0, 30) as usize;
+    (0..count).map(|s| i16_at(s * 2)).find(|&v| v > 0).map_or(0, |v| v as u16 + 1)
+}
+impl MapData {
+    /// Parse a map, converting object ids through `mapelem.dat` read from the
+    /// default asset root (see [`AssetRoot::resolve`]).
+    pub fn parse(bytes: &[u8]) -> Result<MapData, String> {
+        let path = AssetRoot::resolve(None).join("data/defines/mapelem.dat");
+        let mapelem = std::fs::read(&path).map_err(|e| format!("{}: {e}", path.display()))?;
+        MapData::parse_with(bytes, &mapelem)
+    }
+    /// Parse a map with the contents of `mapelem.dat` given.
+    pub fn parse_with(bytes: &[u8], mapelem: &[u8]) -> Result<MapData, String> {
+        let mut r = Reader { b: bytes, pos: 0 };
+        let mut w = r.i32()?;
+        let mut game_rev = 0;
+        if w == 0 {
+            // Remake format: UTF-16 revision string like "r12345", data size.
+            let len = r.u16()? as usize;
+            let units: Vec<u16> = (0..len).map(|_| r.u16()).collect::<Result<_, _>>()?;
+            let rev = String::from_utf16_lossy(&units);
+            game_rev = rev.chars().skip(1).collect::<String>().parse::<i32>().map_err(|_| "unexpected game revision in map header")?;
+            r.u32()?;
+            w = r.i32()?;
+        }
+        let h = r.i32()?;
+        if !(1..=MAX_MAP_SIZE).contains(&w) || !(1..=MAX_MAP_SIZE).contains(&h) {
+            return Err(format!("wrong map dimensions [{w}:{h}]"));
+        }
+        let n = (w * h) as usize;
+        let mut m = MapData {
+            w,
+            h,
+            terrain: Vec::with_capacity(n),
+            rotation: Vec::with_capacity(n),
+            elevation: Vec::with_capacity(n),
+            object: Vec::with_capacity(n),
+        };
+        for _ in 0..n {
+            let (terrain, rotation, height, obj);
+            if game_rev == 0 {
+                terrain = r.u8()? as u16;
+                r.take(1)?;
+                height = r.u8()?;
+                rotation = r.u8()?;
+                r.take(1)?;
+                obj = r.u8()? as u16;
+                r.take(17)?;
+            } else {
+                terrain = r.u16()?;
+                rotation = r.u8()?;
+                height = r.u8()?;
+                obj = r.u16()?;
+                r.u8()?; // IsCustom
+                if game_rev > 10968 {
+                    r.u8()?; // overlay
+                }
+                let layers = r.u8()?;
+                if layers > 0 {
+                    r.u8()?; // corner owners
+                    if game_rev > 10745 {
+                        r.u8()?; // blending level
+                    }
+                    r.take(layers as usize * 3)?;
+                }
+            }
+            m.terrain.push(terrain);
+            m.rotation.push(rotation % 4);
+            m.elevation.push(height);
+            m.object.push(object_sprite(mapelem, obj));
+        }
+        Ok(m)
+    }
+}

plum-game/src/lib.rs ADDED Viewed

	@@ -0,0 +1 @@
1	+ pub mod assets;

plum-game/tests/assets_test.rs ADDED Viewed

@@ -0,0 +1,114 @@
+#![allow(non_snake_case)]
+use plum_game::assets::{Atlas, AssetRoot, MapData};
+use std::path::PathBuf;
+fn root() -> Option<PathBuf> {
+    let r = AssetRoot::resolve(None);
+    if r.join("sprites").is_dir() {
+        Some(r)
+    } else {
+        eprintln!("skipping: asset root {} not found", r.display());
+        None
+    }
+}
+fn zlib(data: &[u8]) -> Vec<u8> {
+    use flate2::{write::ZlibEncoder, Compression};
+    use std::io::Write;
+    let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
+    e.write_all(data).unwrap();
+    e.finish().unwrap()
+}
+fn tiny_payload() -> Vec<u8> {
+    let mut p = Vec::new();
+    p.extend(2u32.to_le_bytes());
+    p.extend([0u8, 1]);
+    p.extend(2u16.to_le_bytes());
+    p.extend(1u16.to_le_bytes());
+    p.extend((-3i32).to_le_bytes());
+    p.extend(4i32.to_le_bytes());
+    p.extend([10, 20, 30, 255, 0, 0, 0, 0]);
+    p.push(0);
+    p
+}
+#[test]
+fn rxxHeaderVariants() {
+    let z = zlib(&tiny_payload());
+    let mut rxx1 = b"RXX1".to_vec();
+    rxx1.extend([0u8; 32]);
+    rxx1.extend(&z);
+    let mut rxx2 = b"RXX2".to_vec();
+    rxx2.extend(5u16.to_le_bytes());
+    rxx2.extend([9u8; 5]);
+    rxx2.extend(&z);
+    for bytes in [z.clone(), rxx1, rxx2] {
+        let a = Atlas::parse(&bytes).unwrap();
+        assert_eq!(a.sprites.len(), 3);
+        let s = a.sprites[2].as_ref().unwrap();
+        assert_eq!((s.w, s.h, s.px, s.py), (2, 1, -3, 4));
+        assert_eq!(a.avg_color(2), [10.0 / 255.0, 20.0 / 255.0, 30.0 / 255.0, 1.0]);
+        assert!(a.sprites[1].is_none());
+    }
+}
+#[test]
+fn tilesetSprite1Is32() {
+    let Some(r) = root() else { return };
+    let a = Atlas::parse(&std::fs::read(r.join("sprites/Tileset.rxx")).unwrap()).unwrap();
+    let s = a.sprites[1].as_ref().unwrap();
+    assert_eq!((s.w, s.h), (32, 32));
+}
+#[test]
+fn mapParsesANewBeginning() {
+    let Some(r) = root() else { return };
+    let m = MapData::parse(&std::fs::read(r.join("Maps/A new Beginning/A new Beginning.map")).unwrap()).unwrap();
+    assert!((32..=256).contains(&m.w) && (32..=256).contains(&m.h));
+    let n = (m.w * m.h) as usize;
+    assert_eq!(m.terrain.len(), n);
+    assert_eq!(m.rotation.len(), n);
+    assert_eq!(m.elevation.len(), n);
+    assert_eq!(m.object.len(), n);
+    assert!(m.terrain.iter().all(|&t| t < 512));
+    assert!(m.rotation.iter().all(|&r| r < 4));
+}
+#[test]
+fn mapObjectsAreTreesSpriteIndices() {
+    let Some(r) = root() else { return };
+    let trees = Atlas::parse(&std::fs::read(r.join("sprites/Trees_a.rxx")).unwrap()).unwrap();
+    let m = MapData::parse(&std::fs::read(r.join("Maps/A new Beginning/A new Beginning.map")).unwrap()).unwrap();
+    assert!(m.object.iter().any(|&o| o != 0));
+    assert!(m.object.iter().all(|&o| o == 0 || trees.sprites.get(o as usize).is_some_and(|s| s.is_some())));
+}
+#[test]
+fn truncatedRxxIsError() {
+    let z = zlib(&tiny_payload());
+    for n in [0, 1, 3, z.len() / 2] {
+        assert!(Atlas::parse(&z[..n]).is_err());
+    }
+    assert!(Atlas::parse(b"RXX1").is_err());
+    assert!(Atlas::parse(b"RXX2\xff\xff").is_err());
+    assert!(Atlas::parse(b"RXX2\x05").is_err());
+    // A count larger than the data must not allocate or panic.
+    assert!(Atlas::parse(&zlib(&u32::MAX.to_le_bytes())).is_err());
+}
+#[test]
+fn truncatedMapIsError() {
+    assert!(MapData::parse(&[]).is_err());
+    assert!(MapData::parse(&[1, 0]).is_err());
+    let mut b = Vec::new();
+    b.extend(40i32.to_le_bytes());
+    b.extend(40i32.to_le_bytes());
+    b.extend(vec![0u8; 23 * 10]);
+    assert!(MapData::parse(&b).is_err());
+    let Some(r) = root() else { return };
+    let full = std::fs::read(r.join("Maps/A new Beginning/A new Beginning.map")).unwrap();
+    for n in [0, 4, 8, 100, full.len() / 2] {
+        assert!(MapData::parse(&full[..n]).is_err(), "n={n}");
+    }
+}