d5a9f81 | plum | pyrossh

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

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

d5a9f81 — Peter John 2026-11-02T14:42:36+05:30

Game host: generic texture/file/circle API, remove KaM decoders and viewer

Generated files not shown: plum-game/Cargo.lock

Files changed (20) hide show

plum-cli/src/game.rs +37 -41
plum-cli/src/main.rs +2 -6
plum-cli/tests/game_web_test.rs +4 -18
plum-game/Cargo.toml +0 -1
plum-game/kam/Main.plum +0 -269
plum-game/src/api.rs +98 -102
plum-game/src/assets.rs +0 -253
plum-game/src/lib.rs +0 -1
plum-game/src/main.rs +9 -4
plum-game/src/mq.rs +61 -74
plum-game/src/native.rs +42 -24
plum-game/src/recorder.rs +34 -57
plum-game/src/web.rs +57 -51
plum-game/tests/assets_test.rs +0 -114
plum-game/tests/fixtures/assets_fixture.plum +30 -0
plum-game/tests/fixtures/host_fixture.plum +1 -0
plum-game/tests/host_test.rs +85 -62
plum-game/web/bridge_check.mjs +4 -0
plum-game/web/plum_bridge.js +32 -19
plum-std/Game.plum +20 -20

plum-cli/src/game.rs CHANGED Viewed

@@ -6,14 +6,6 @@ use std::process::Command;
 use anyhow::{bail, Context, Result};
-/// The six KaM sprite archives every web build bundles.
-const SPRITES: [&str; 6] = [
-    "GUI_a", "GUIMain", "Houses_a", "Tileset", "Trees_a", "Units_a",
-];
-/// Needed to turn map object ids into sprite indices.
-const MAPELEM: &str = "data/defines/mapelem.dat";
 /// The repository root, fixed when plum-cli is compiled.
 fn repoRoot() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -26,22 +18,26 @@ fn gameManifest() -> PathBuf {
     repoRoot().join("plum-game/Cargo.toml")
 }
+/// The asset root: `--assets`, else `assets` beside the source file.
-fn assetRoot(cli: Option<PathBuf>) -> PathBuf {
+fn assetRoot(file: &Path, cli: Option<PathBuf>) -> PathBuf {
+    cli.unwrap_or_else(|| {
+        file.parent()
-    cli.or_else(|| std::env::var_os("PLUM_GAME_ASSETS").map(PathBuf::from))
+            .filter(|p| !p.as_os_str().is_empty())
-        .unwrap_or_else(|| repoRoot().join("../kam_macroquad/assets"))
+            .unwrap_or(Path::new("."))
+            .join("assets")
+    })
 }
 pub fn cmdGame(
     file: PathBuf,
     web: bool,
     output: Option<PathBuf>,
-    preload: Vec<String>,
     assets: Option<PathBuf>,
     lib_path: Option<PathBuf>,
 ) -> Result<()> {
     let lib_path = lib_path.unwrap_or_else(repoRoot);
     let wasm = crate::compileToWasm(&file, &lib_path)?;
-    let assets = assetRoot(assets);
+    let assets = assetRoot(&file, assets);
     if web {
         let dist = output.unwrap_or_else(|| {
             file.parent()
@@ -49,7 +45,7 @@ pub fn cmdGame(
                 .unwrap_or(Path::new("."))
                 .join("dist")
         });
-        return writeWeb(&wasm, &dist, &preload, &assets);
+        return writeWeb(&wasm, &dist, &assets);
     }
     runNative(&wasm, &assets)
 }
@@ -127,35 +123,35 @@ fn buildHostWasm() -> Result<PathBuf> {
     Ok(target.join("wasm32-unknown-unknown/release/plum-game.wasm"))
 }
+/// Every file under `dir` (dotfiles skipped), as `/`-separated paths relative to it, sorted.
+fn listFiles(dir: &Path) -> Result<Vec<String>> {
+    fn walk(dir: &Path, prefix: &str, out: &mut Vec<String>) -> Result<()> {
+        for entry in fs::read_dir(dir).with_context(|| format!("failed to read {}", dir.display()))? {
+            let entry = entry?;
+            let name = format!("{prefix}{}", entry.file_name().to_string_lossy());
+            if entry.file_name().to_string_lossy().starts_with('.') {
+                continue;
+            }
+            if entry.file_type()?.is_dir() {
+                walk(&entry.path(), &format!("{name}/"), out)?;
+            } else {
+                out.push(name);
+            }
+        }
+        Ok(())
+    }
+    let mut out = Vec::new();
+    walk(dir, "", &mut out)?;
+    out.sort();
+    Ok(out)
+}
-fn writeWeb(wasm: &[u8], dist: &Path, preload: &[String], assets: &Path) -> Result<()> {
+fn writeWeb(wasm: &[u8], dist: &Path, assets: &Path) -> Result<()> {
     let hostWasm = buildHostWasm()?;
     let bundle = jsBundle()?;
-    // Defaults that are missing from the asset root are skipped with a
+    // The whole asset directory (if there is one) is bundled and preloaded.
-    // warning; files asked for with --preload must exist.
-    let mut files: Vec<String> = Vec::new();
+    let files = if assets.is_dir() { listFiles(assets)? } else { Vec::new() };
-    for rel in SPRITES
-        .iter()
-        .map(|s| format!("sprites/{s}.rxx"))
-        .chain([MAPELEM.to_string()])
-    {
-        if assets.join(&rel).is_file() {
-            files.push(rel);
-        } else {
-            eprintln!(
-                "warning: {} not found, not bundled",
-                assets.join(&rel).display()
-            );
-        }
-    }
-    for rel in preload {
-        if !assets.join(rel).is_file() {
-            bail!("--preload {rel}: {} not found", assets.join(rel).display());
-        }
-        if !files.contains(rel) {
-            files.push(rel.clone());
-        }
-    }
     fs::create_dir_all(dist)?;
     let web = repoRoot().join("plum-game/web");
@@ -167,7 +163,7 @@ fn writeWeb(wasm: &[u8], dist: &Path, preload: &[String], assets: &Path) -> Resu
     fs::copy(&hostWasm, dist.join("plum-game.wasm"))
         .with_context(|| format!("failed to copy {}", hostWasm.display()))?;
     fs::write(dist.join("plum.wasm"), wasm)?;
-    fs::write(dist.join("preload.txt"), files.join("\n") + "\n")?;
+    fs::write(dist.join("preload.txt"), files.iter().map(|f| format!("{f}\n")).collect::<String>())?;
     for rel in &files {
         let to = dist.join("assets").join(rel);
         fs::create_dir_all(to.parent().expect("asset has a parent"))?;

plum-cli/src/main.rs CHANGED Viewed

@@ -86,10 +86,7 @@ enum Command {
         /// Output directory for --web (default: `dist` beside the source file)
         #[arg(short, long)]
         output: Option<std::path::PathBuf>,
-        /// Asset file (relative to the asset root) to bundle with --web; repeatable
+        /// Asset root (default: `assets` beside the source file); --web bundles all of it
-        #[arg(long)]
-        preload: Vec<String>,
-        /// Asset root (default: $PLUM_GAME_ASSETS, else ../kam_macroquad/assets beside the repo)
         #[arg(long)]
         assets: Option<std::path::PathBuf>,
         /// Root directory `import <path>` is resolved against (default: the repository root)
@@ -133,10 +130,9 @@ fn run() -> Result<()> {
             file,
             web,
             output,
-            preload,
             assets,
             lib_path,
-        } => game::cmdGame(file, web, output, preload, assets, lib_path),
+        } => game::cmdGame(file, web, output, assets, lib_path),
         Command::Editor { editor, insiders } => editor::install(editor, insiders),
     }
 }

plum-cli/tests/game_web_test.rs CHANGED Viewed

@@ -20,16 +20,9 @@ fn webBuildWritesTheDist() {
     let assets = scratch.join("assets");
     let dist = scratch.join("dist");
     // Stand-in asset files: the build copies them without reading them.
-    let sprites = [
-        "GUI_a", "GUIMain", "Houses_a", "Tileset", "Trees_a", "Units_a",
-    ];
-    std::fs::create_dir_all(assets.join("sprites")).unwrap();
+    std::fs::create_dir_all(assets.join("sub")).unwrap();
-    std::fs::create_dir_all(assets.join("data/defines")).unwrap();
-    for s in sprites {
-        std::fs::write(assets.join(format!("sprites/{s}.rxx")), b"x").unwrap();
-    }
-    std::fs::write(assets.join("data/defines/mapelem.dat"), b"x").unwrap();
-    std::fs::write(assets.join("extra.map"), b"x").unwrap();
+    std::fs::write(assets.join("a.png"), b"x").unwrap();
+    std::fs::write(assets.join("sub/b.txt"), b"x").unwrap();
     let out = Command::new(plumBin())
         .current_dir(root)
@@ -42,7 +35,6 @@ fn webBuildWritesTheDist() {
         .arg(&dist)
         .arg("--assets")
         .arg(&assets)
-        .args(["--preload", "extra.map"])
         .output()
         .expect("failed to run plum");
     let all = format!(
@@ -64,13 +56,7 @@ fn webBuildWritesTheDist() {
     }
     let preload = std::fs::read_to_string(dist.join("preload.txt")).unwrap();
     let lines: Vec<&str> = preload.lines().collect();
-    for s in sprites {
-        assert!(
-            lines.contains(&format!("sprites/{s}.rxx").as_str()),
-            "{s} not preloaded"
-        );
-    }
-    assert!(lines.contains(&"extra.map"));
+    assert_eq!(lines, ["a.png", "sub/b.txt"]);
     for l in &lines {
         assert!(
             dist.join("assets").join(l).is_file(),

plum-game/Cargo.toml CHANGED Viewed

@@ -6,7 +6,6 @@ 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"

plum-game/kam/Main.plum DELETED Viewed

@@ -1,269 +0,0 @@
-# A Knights and Merchants map viewer: terrain tiles and map objects drawn through
-# the game host, a camera that pans (arrows / WASD) and zooms about the mouse
-# (wheel), and a minimap in the bottom-right corner that centres the camera on click.
-module main
-import std/Str
-import std/Int
-import std/Float
-import std/Bool
-import std/Array
-import std/Grid
-import std/Vec2
-import std/Color
-import std/Game
-primitive View =
-  TileSize = 32.0       # world units per tile
-  MinScale = 0.25
-  MaxScale = 4.0
-  PanSpeed = 600.0      # screen pixels per second
-  MiniSize = 160.0      # minimap's longest side in screen pixels
-  MiniMargin = 8.0
-  MapPath = "Maps/A new Beginning/A new Beginning.map"
-# The inclusive tile columns and rows to draw.
-struct TileRange(x0: Int, y0: Int, x1: Int, y1: Int)
-# The minimap's placement on screen: top-left corner and pixels per tile.
-struct MiniRect(x: Float, y: Float, cell: Float)
-# World point (x, y) sits at the screen's top-left; one world unit is `scale` pixels.
-record Camera(x: Float, y: Float, scale: Float) =
-  fun screenToWorld(self, p: Vec2) -> Vec2 =
-    Vec2(x: self.x + p.x / self.scale, y: self.y + p.y / self.scale)
-  fun worldToScreen(self, p: Vec2) -> Vec2 =
-    Vec2(x: {p.x - self.x} * self.scale, y: {p.y - self.y} * self.scale)
-  # Keeps the view inside a `w` x `h` world on a `sw` x `sh` screen; an axis the
-  # world doesn't fill is centred.
-  fun clampTo(self, w: Float, h: Float, sw: Float, sh: Float) =
-    vw := sw / self.scale
-    vh := sh / self.scale
-    if vw >= w
-      self.x = {w - vw} / 2.0
-    else
-      self.x = self.x.max(0.0).min(w - vw)
-    if vh >= h
-      self.y = {h - vh} / 2.0
-    else
-      self.y = self.y.max(0.0).min(h - vh)
-  # Multiplies the zoom by `factor` (scale stays within MinScale..MaxScale) keeping the
-  # world point under `screen` fixed.
-  fun zoomAt(self, screen: Vec2, factor: Float) =
-    anchor := self.screenToWorld(screen)
-    self.scale = {self.scale * factor}.max(View.MinScale).min(View.MaxScale)
-    self.x = anchor.x - screen.x / self.scale
-    self.y = anchor.y - screen.y / self.scale
-  # Moves the view so world point `p` is at the screen's centre.
-  fun centerOn(self, p: Vec2, sw: Float, sh: Float) =
-    self.x = p.x - sw / self.scale / 2.0
-    self.y = p.y - sh / self.scale / 2.0
-  # Tiles touching the screen, including partial ones, clamped to a `mapW` x `mapH` map.
-  fun visibleTiles(self, mapW: Int, mapH: Int, sw: Float, sh: Float) -> TileRange =
-    left := self.x.max(0.0)
-    top := self.y.max(0.0)
-    right := {self.x + sw / self.scale}.max(0.0)
-    bottom := {self.y + sh / self.scale}.max(0.0)
-    TileRange(
-      x0: Int(left / View.TileSize).min(mapW - 1),
-      y0: Int(top / View.TileSize).min(mapH - 1),
-      x1: Int(right / View.TileSize).min(mapW - 1),
-      y1: Int(bottom / View.TileSize).min(mapH - 1))
-fun miniRect(sw: Float, sh: Float, mapW: Int, mapH: Int) -> MiniRect =
-  longest := Float(mapW.max(mapH))
-  cell := View.MiniSize / longest
-  MiniRect(
-    x: sw - View.MiniMargin - cell * Float(mapW),
-    y: sh - View.MiniMargin - cell * Float(mapH),
-    cell: cell)
-# World point under screen point `p` of the minimap, or null when `p` is outside it.
-fun miniToWorld(m: MiniRect, mapW: Int, mapH: Int, p: Vec2) -> Vec2? =
-  tx := {p.x - m.x} / m.cell
-  ty := {p.y - m.y} / m.cell
-  if tx < 0.0 || ty < 0.0 || tx >= Float(mapW) || ty >= Float(mapH)
-    return null
-  Vec2(x: tx * View.TileSize, y: ty * View.TileSize)
-record Viewer(
-  cam: Camera,
-  ok: Bool,
-  mapW: Int,
-  mapH: Int,
-  tileset: Int,
-  trees: Int,
-  terrain: Grid[Int],
-  rotation: Grid[Int],
-  objects: Grid[Int],
-  mini: Grid[Color])
-# The minimap's colour storage: one cell per tile, sized up front (Array.push returns a new array).
-fun miniColors(w: Int, h: Int) -> Grid[Color] =
-  Grid.filled(w, h, Color.Black)
-export fun init() -> Viewer =
-  tileset := atlasLoad("Tileset")
-  trees := atlasLoad("Trees_a")
-  m := mapLoad(View.MapPath)
-  cam := Camera(x: 0.0, y: 0.0, scale: 1.0)
-  if tileset < 0 || trees < 0 || m < 0
-    return Viewer(
-      cam: cam, ok: false, mapW: 1, mapH: 1, tileset: tileset, trees: trees,
-      terrain: Grid.filled(1, 1, 0), rotation: Grid.filled(1, 1, 0),
-      objects: Grid.filled(1, 1, 0), mini: miniColors(1, 1))
-  w := mapWidth(m)
-  h := mapHeight(m)
-  terrain := Grid.filled(w, h, 0)
-  rotation := Grid.filled(w, h, 0)
-  objects := Grid.filled(w, h, 0)
-  mini := miniColors(w, h)
-  for y := range h
-    for x := range w
-      t := mapTerrain(m, x, y)
-      terrain.set(x, y, t)
-      rotation.set(x, y, mapRotation(m, x, y))
-      objects.set(x, y, mapObject(m, x, y))
-      mini.set(x, y, spriteColor(tileset, t + 1))
-  Viewer(
-    cam: cam, ok: true, mapW: w, mapH: h, tileset: tileset, trees: trees,
-    terrain: terrain, rotation: rotation, objects: objects, mini: mini)
-fun worldW(v: Viewer) -> Float =
-  Float(v.mapW) * View.TileSize
-fun worldH(v: Viewer) -> Float =
-  Float(v.mapH) * View.TileSize
-export fun update(v: Viewer, dt: Float) =
-  if !v.ok
-    return
-  sw := screenWidth()
-  sh := screenHeight()
-  step := View.PanSpeed * dt / v.cam.scale
-  if isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
-    v.cam.x = v.cam.x - step
-  if isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
-    v.cam.x = v.cam.x + step
-  if isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
-    v.cam.y = v.cam.y - step
-  if isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
-    v.cam.y = v.cam.y + step
-  wheel := mouseWheel()
-  if wheel != 0.0
-    v.cam.zoomAt(mousePos(), Float(1.1).pow(wheel))
-  if isMouseDown(Mouse.Left)
-    target := miniToWorld(miniRect(sw, sh, v.mapW, v.mapH), v.mapW, v.mapH, mousePos())
-    if t := target
-      v.cam.centerOn(t, sw, sh)
-  v.cam.clampTo(worldW(v), worldH(v), sw, sh)
-export fun draw(v: Viewer) =
-  clear(Color.Black)
-  sw := screenWidth()
-  sh := screenHeight()
-  if !v.ok
-    drawText("assets not found", 20.0, 40.0, 24.0, Color.White)
-    return
-  setCamera(v.cam.x, v.cam.y, v.cam.scale)
-  r := v.cam.visibleTiles(v.mapW, v.mapH, sw, sh)
-  for y := range r.y1 - r.y0 + 1
-    for x := range r.x1 - r.x0 + 1
-      tx := r.x0 + x
-      ty := r.y0 + y
-      drawTile(v.tileset, v.terrain.get(tx, ty) + 1, Float(tx) * View.TileSize,
-        Float(ty) * View.TileSize, View.TileSize, v.rotation.get(tx, ty), Color.White)
-  for y := range r.y1 - r.y0 + 1
-    for x := range r.x1 - r.x0 + 1
-      tx := r.x0 + x
-      ty := r.y0 + y
-      o := v.objects.get(tx, ty)
-      if o != 0
-        drawSprite(v.trees, o, Float(tx) * View.TileSize, Float(ty) * View.TileSize,
-          false, Color.White)
-  resetCamera()
-  drawMinimap(v, sw, sh)
-  drawText("FPS {Int(1.0 / frameTime().max(0.0001))}", 8.0, 20.0, 20.0, Color.Yellow)
-fun drawMinimap(v: Viewer, sw: Float, sh: Float) =
-  m := miniRect(sw, sh, v.mapW, v.mapH)
-  for y := range v.mapH
-    for x := range v.mapW
-      drawRect(m.x + Float(x) * m.cell, m.y + Float(y) * m.cell, m.cell, m.cell,
-        v.mini.get(x, y))
-  vx := m.x + v.cam.x * m.cell / View.TileSize
-  vy := m.y + v.cam.y * m.cell / View.TileSize
-  vw := sw / v.cam.scale * m.cell / View.TileSize
-  vh := sh / v.cam.scale * m.cell / View.TileSize
-  drawLine(vx, vy, vx + vw, vy, 1.0, Color.White)
-  drawLine(vx + vw, vy, vx + vw, vy + vh, 1.0, Color.White)
-  drawLine(vx + vw, vy + vh, vx, vy + vh, 1.0, Color.White)
-  drawLine(vx, vy + vh, vx, vy, 1.0, Color.White)
-test "screenToWorld and worldToScreen are inverses"
-  c := Camera(x: 100.0, y: 50.0, scale: 2.0)
-  assert c.screenToWorld(Vec2(x: 20.0, y: 10.0)) == Vec2(x: 110.0, y: 55.0)
-  assert c.worldToScreen(Vec2(x: 110.0, y: 55.0)) == Vec2(x: 20.0, y: 10.0)
-test "zoomAt keeps the world point under the mouse fixed and clamps the scale"
-  c := Camera(x: 100.0, y: 50.0, scale: 2.0)
-  m := Vec2(x: 300.0, y: 200.0)
-  before := c.screenToWorld(m)
-  c.zoomAt(m, 1.5)
-  assert c.scale == 3.0
-  assert c.screenToWorld(m).distance(before) < 0.000001
-  c.zoomAt(m, 100.0)
-  assert c.scale == 4.0
-  c.zoomAt(m, 0.0001)
-  assert c.scale == 0.25
-test "visibleTiles covers the partial tile and clamps to the map"
-  c := Camera(x: 0.0, y: 0.0, scale: 1.0)
-  r := c.visibleTiles(64, 64, 800.0, 600.0)
-  assert r.x0 == 0
-  assert r.y0 == 0
-  assert r.x1 == 25
-  assert r.y1 == 18
-  small := c.visibleTiles(10, 8, 800.0, 600.0)
-  assert small.x1 == 9
-  assert small.y1 == 7
-  far := Camera(x: 3000.0, y: 3000.0, scale: 1.0).visibleTiles(64, 64, 800.0, 600.0)
-  assert far.x1 == 63
-  assert far.y1 == 63
-test "clampTo keeps the view in the map and centres a small map"
-  c := Camera(x: -50.0, y: 5000.0, scale: 1.0)
-  c.clampTo(2048.0, 2048.0, 800.0, 600.0)
-  assert c.x == 0.0
-  assert c.y == 1448.0
-  c.x = 5000.0
-  c.clampTo(2048.0, 2048.0, 800.0, 600.0)
-  assert c.x == 1248.0
-  s := Camera(x: 99.0, y: 99.0, scale: 1.0)
-  s.clampTo(320.0, 240.0, 800.0, 600.0)
-  assert s.x == -240.0
-  assert s.y == -180.0
-test "a minimap click centres the camera"
-  m := miniRect(800.0, 600.0, 64, 64)
-  assert m.cell == 2.5
-  assert m.x == 632.0
-  assert m.y == 432.0
-  w := miniToWorld(m, 64, 64, Vec2(x: 632.0 + 25.0, y: 432.0 + 50.0)) ?: Vec2.Zero
-  assert w == Vec2(x: 320.0, y: 640.0)
-  assert miniToWorld(m, 64, 64, Vec2(x: 10.0, y: 10.0)) == null
-  c := Camera(x: 0.0, y: 0.0, scale: 2.0)
-  c.centerOn(w, 800.0, 600.0)
-  assert c.screenToWorld(Vec2(x: 400.0, y: 300.0)) == w
-test "minimap colours are sized w*h up front"
-  g := miniColors(4, 3)
-  assert g.w * g.h == 12
-  g.set(3, 2, Color.White)
-  assert g.get(3, 2) == Color.White
-  assert g.get(0, 0) == Color.Black

plum-game/src/api.rs CHANGED Viewed

@@ -3,9 +3,9 @@
 //! `i32`, `Str` is `&str`, a `Color` is `[f32; 4]`, a `Vec2` is `(f32, f32)`).
 //! `Int` handles are indexes into host vectors, `-1` on failure.
-use crate::assets::{Atlas, AssetRoot, MapData};
+use macroquad::texture::Image;
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::{Component, Path, PathBuf};
 pub type Color = [f32; 4];
@@ -16,23 +16,35 @@ pub trait Backend: 'static {
     fn clear(&mut self, c: Color);
     fn draw_rect(&mut self, x: f32, y: f32, w: f32, h: f32, c: Color);
+    fn draw_circle(&mut self, x: f32, y: f32, r: f32, c: Color);
     fn draw_line(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, thickness: f32, c: Color);
     fn draw_text(&mut self, s: &str, x: f32, y: f32, size: f32, c: Color);
     fn set_camera(&mut self, x: f32, y: f32, scale: f32);
     fn reset_camera(&mut self);
-    fn atlas_load(&mut self, name: &str) -> i32;
+    fn texture_load(&mut self, path: &str) -> i32;
+    fn texture_width(&mut self, t: i32) -> i32;
-    fn sprite_count(&mut self, atlas: i32) -> i32;
+    fn texture_height(&mut self, t: i32) -> i32;
-    fn sprite_w(&mut self, atlas: i32, idx: i32) -> i32;
-    fn sprite_h(&mut self, atlas: i32, idx: i32) -> i32;
-    fn sprite_pivot_x(&mut self, atlas: i32, idx: i32) -> i32;
+    fn texture_set_smooth(&mut self, t: i32, smooth: bool);
-    fn sprite_pivot_y(&mut self, atlas: i32, idx: i32) -> i32;
-    fn sprite_color(&mut self, atlas: i32, idx: i32) -> Color;
-    fn draw_sprite(&mut self, atlas: i32, idx: i32, x: f32, y: f32, flip_x: bool, tint: Color);
+    fn draw_texture(&mut self, t: i32, x: f32, y: f32, tint: Color);
+    /// Draws the source rect `(sx, sy, sw, sh)` (texture pixels) into the dest
+    /// rect `(x, y, w, h)`, rotated `rotation` radians clockwise about the dest
+    /// centre.
     #[allow(clippy::too_many_arguments)]
+    fn draw_texture_ex(
+        &mut self,
+        t: i32,
+        src: [f32; 4],
+        dest: [f32; 4],
+        rotation: f32,
+        flip_x: bool,
+        tint: Color,
+    );
+    fn file_exists(&mut self, path: &str) -> bool;
+    /// The whole file, empty when it is missing.
-    fn draw_tile(&mut self, atlas: i32, idx: i32, x: f32, y: f32, size: f32, quarter_turns: i32, tint: Color);
+    fn file_load(&mut self, path: &str) -> Vec<u8>;
     fn is_key_down(&mut self, k: i32) -> bool;
     fn is_key_pressed(&mut self, k: i32) -> bool;
@@ -40,20 +52,13 @@ pub trait Backend: 'static {
     fn is_mouse_down(&mut self, b: i32) -> bool;
     fn is_mouse_pressed(&mut self, b: i32) -> bool;
     fn mouse_wheel(&mut self) -> f32;
-    fn map_load(&mut self, path: &str) -> i32;
-    fn map_width(&mut self, m: i32) -> i32;
-    fn map_height(&mut self, m: i32) -> i32;
-    fn map_terrain(&mut self, m: i32, x: i32, y: i32) -> i32;
-    fn map_rotation(&mut self, m: i32, x: i32, y: i32) -> i32;
-    fn map_elevation(&mut self, m: i32, x: i32, y: i32) -> i32;
-    fn map_object(&mut self, m: i32, x: i32, y: i32) -> i32;
 }
-/// Radians clockwise for `quarter_turns` quarter turns; `drawTile` rotates
+/// Whether `path` stays inside the asset root: relative, no `..`.
-/// about the tile's centre by this angle.
-pub fn quarter_turns_radians(quarter_turns: i32) -> f32 {
+pub fn path_in_root(path: &str) -> bool {
+    !path.is_empty()
+        && !path.contains('\\')
-    quarter_turns.rem_euclid(4) as f32 * std::f32::consts::FRAC_PI_2
+        && Path::new(path).components().all(|c| matches!(c, Component::Normal(_) | Component::CurDir))
 }
 /// Where an [`AssetStore`] reads its files from.
@@ -65,28 +70,26 @@ enum Source {
     Files(HashMap<String, Vec<u8>>),
 }
-const MAPELEM: &str = "data/defines/mapelem.dat";
+struct Tex {
+    image: Image,
+    smooth: bool,
+}
-/// Atlases and maps loaded from an asset root, addressed by handle. Shared by
+/// Files and decoded textures from an asset root, addressed by handle. Shared
-/// every backend so handle numbering and lookups behave the same everywhere.
+/// by every backend so handle numbering and lookups behave the same everywhere.
 pub struct AssetStore {
     source: Source,
-    /// `mapelem.dat`, read on the first map load so files can be preloaded
-    /// after construction.
-    mapelem: Option<Vec<u8>>,
-    pub atlases: Vec<Atlas>,
+    textures: Vec<Tex>,
-    pub maps: Vec<MapData>,
 }
 impl AssetStore {
-    pub fn new(root: Option<PathBuf>) -> Self {
+    pub fn new(root: PathBuf) -> Self {
-        let root = AssetRoot::resolve(root.as_deref());
-        AssetStore { source: Source::Dir(root), mapelem: None, atlases: Vec::new(), maps: Vec::new() }
+        AssetStore { source: Source::Dir(root), textures: Vec::new() }
     }
     /// A store that serves only files added with [`AssetStore::insert`].
     pub fn preloaded() -> Self {
-        AssetStore { source: Source::Files(HashMap::new()), mapelem: None, atlases: Vec::new(), maps: Vec::new() }
+        AssetStore { source: Source::Files(HashMap::new()), textures: Vec::new() }
     }
     /// Registers a file under its asset-root-relative path. No effect on a
@@ -97,89 +100,69 @@ impl AssetStore {
         }
     }
-    fn read(&self, path: &str) -> Option<Vec<u8>> {
+    pub fn read(&self, path: &str) -> Option<Vec<u8>> {
+        if !path_in_root(path) {
+            return None;
+        }
         match &self.source {
             Source::Dir(root) => std::fs::read(root.join(path)).ok(),
-            Source::Files(files) => files.get(path).cloned(),
+            Source::Files(files) => files.get(path.trim_start_matches("./")).cloned(),
         }
     }
-    pub fn atlas_load(&mut self, name: &str) -> i32 {
+    pub fn file_exists(&self, path: &str) -> bool {
-        let Some(bytes) = self.read(&format!("sprites/{name}.rxx")) else { return -1 };
-        match Atlas::parse(&bytes) {
-            Ok(a) => {
-                self.atlases.push(a);
+        if !path_in_root(path) {
-                self.atlases.len() as i32 - 1
-            }
-            Err(_) => -1,
+            return false;
         }
+        match &self.source {
+            Source::Dir(root) => root.join(path).is_file(),
+            Source::Files(files) => files.contains_key(path.trim_start_matches("./")),
+        }
+    }
+    pub fn file_load(&self, path: &str) -> Vec<u8> {
+        self.read(path).unwrap_or_default()
     }
-    pub fn map_load(&mut self, path: &str) -> i32 {
+    pub fn texture_load(&mut self, path: &str) -> i32 {
         let Some(bytes) = self.read(path) else { return -1 };
-        if self.mapelem.is_none() {
-            self.mapelem = Some(self.read(MAPELEM).unwrap_or_default());
-        }
-        match MapData::parse_with(&bytes, self.mapelem.as_deref().unwrap_or_default()) {
+        match Image::from_file_with_format(&bytes, None) {
-            Ok(m) => {
+            Ok(image) => {
-                self.maps.push(m);
+                self.textures.push(Tex { image, smooth: false });
-                self.maps.len() as i32 - 1
+                self.textures.len() as i32 - 1
             }
             Err(_) => -1,
         }
     }
-    fn sprite(&self, atlas: i32, idx: i32) -> Option<&crate::assets::Sprite> {
+    fn tex(&self, t: i32) -> Option<&Tex> {
-        let a = self.atlases.get(usize::try_from(atlas).ok()?)?;
+        self.textures.get(usize::try_from(t).ok()?)
-        a.sprites.get(usize::try_from(idx).ok()?)?.as_ref()
     }
-    pub fn sprite_count(&self, atlas: i32) -> i32 {
+    pub fn image(&self, t: i32) -> Option<&Image> {
-        usize::try_from(atlas).ok().and_then(|a| self.atlases.get(a)).map_or(0, |a| a.sprites.len() as i32 - 1)
+        self.tex(t).map(|t| &t.image)
     }
-    pub fn sprite_w(&self, atlas: i32, idx: i32) -> i32 {
-        self.sprite(atlas, idx).map_or(0, |s| s.w as i32)
-    }
-    pub fn sprite_h(&self, atlas: i32, idx: i32) -> i32 {
+    pub fn smooth(&self, t: i32) -> bool {
-        self.sprite(atlas, idx).map_or(0, |s| s.h as i32)
+        self.tex(t).is_some_and(|t| t.smooth)
     }
-    pub fn sprite_pivot_x(&self, atlas: i32, idx: i32) -> i32 {
+    pub fn texture_count(&self) -> usize {
-        self.sprite(atlas, idx).map_or(0, |s| s.px)
+        self.textures.len()
     }
-    pub fn sprite_pivot_y(&self, atlas: i32, idx: i32) -> i32 {
+    pub fn texture_width(&self, t: i32) -> i32 {
-        self.sprite(atlas, idx).map_or(0, |s| s.py)
+        self.tex(t).map_or(0, |t| t.image.width as i32)
     }
-    pub fn sprite_color(&self, atlas: i32, idx: i32) -> Color {
+    pub fn texture_height(&self, t: i32) -> i32 {
-        match (usize::try_from(atlas).ok().and_then(|a| self.atlases.get(a)), usize::try_from(idx).ok()) {
-            (Some(a), Some(i)) => a.avg_color(i),
+        self.tex(t).map_or(0, |t| t.image.height as i32)
-            _ => [0.0; 4],
-        }
     }
+    pub fn texture_set_smooth(&mut self, t: i32, smooth: bool) {
-    fn cell(&self, m: i32, x: i32, y: i32) -> Option<(&MapData, usize)> {
+        if let Some(tex) = usize::try_from(t).ok().and_then(|t| self.textures.get_mut(t)) {
-        let map = self.maps.get(usize::try_from(m).ok()?)?;
-        if x < 0 || y < 0 || x >= map.w || y >= map.h {
-            return None;
+            tex.smooth = smooth;
         }
-        Some((map, (y * map.w + x) as usize))
-    }
-    pub fn map_width(&self, m: i32) -> i32 {
-        usize::try_from(m).ok().and_then(|m| self.maps.get(m)).map_or(0, |m| m.w)
-    }
-    pub fn map_height(&self, m: i32) -> i32 {
-        usize::try_from(m).ok().and_then(|m| self.maps.get(m)).map_or(0, |m| m.h)
-    }
-    pub fn map_terrain(&self, m: i32, x: i32, y: i32) -> i32 {
-        self.cell(m, x, y).map_or(0, |(d, i)| d.terrain[i] as i32)
-    }
-    pub fn map_rotation(&self, m: i32, x: i32, y: i32) -> i32 {
-        self.cell(m, x, y).map_or(0, |(d, i)| d.rotation[i] as i32)
-    }
-    pub fn map_elevation(&self, m: i32, x: i32, y: i32) -> i32 {
-        self.cell(m, x, y).map_or(0, |(d, i)| d.elevation[i] as i32)
-    }
-    pub fn map_object(&self, m: i32, x: i32, y: i32) -> i32 {
-        self.cell(m, x, y).map_or(0, |(d, i)| d.object[i] as i32)
     }
 }
@@ -190,11 +173,24 @@ mod tests {
     #[test]
     fn preloaded_store_serves_only_inserted_files() {
         let mut s = AssetStore::preloaded();
-        assert_eq!(s.atlas_load("missing"), -1);
+        assert_eq!(s.texture_load("missing.png"), -1);
-        assert_eq!(s.map_load("maps/missing.map"), -1);
+        assert!(!s.file_exists("a.txt"));
-        s.insert("sprites/bad.rxx", vec![1, 2, 3]);
+        s.insert("bad.png", vec![1, 2, 3]);
+        s.insert("a.txt", b"hi".to_vec());
-        // Present but malformed: still a failure, not a panic.
+        // Present but undecodable: a failure, not a panic.
-        assert_eq!(s.atlas_load("bad"), -1);
+        assert_eq!(s.texture_load("bad.png"), -1);
-        assert_eq!(s.sprite_count(0), 0);
+        assert_eq!(s.texture_width(0), 0);
+        assert!(s.file_exists("a.txt"));
+        assert_eq!(s.file_load("a.txt"), b"hi");
+    }
+    #[test]
+    fn paths_escaping_the_root_are_rejected() {
+        for bad in ["../x", "a/../../x", "/etc/passwd", "a\\b", ""] {
+            assert!(!path_in_root(bad), "{bad}");
+        }
+        for ok in ["a.png", "sub/a.png", "./a.png"] {
+            assert!(path_in_root(ok), "{ok}");
+        }
     }
 }

plum-game/src/assets.rs DELETED Viewed

@@ -1,253 +0,0 @@
-//! 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 CHANGED Viewed

@@ -1,7 +1,6 @@
 //! Native and web host for Plum game programs.
 pub mod api;
-pub mod assets;
 pub mod mq;
 pub mod recorder;

plum-game/src/main.rs CHANGED Viewed

@@ -1,5 +1,6 @@
 //! `plum-game <module.wasm> [--assets DIR]`: runs a compiled Plum game in a
+//! macroquad window. The asset root defaults to `assets` beside the wasm, or
-//! macroquad window. With `PLUM_GAME_CAPTURE=<path.png>` (and optionally
+//! `$PLUM_GAME_ASSETS`. With `PLUM_GAME_CAPTURE=<path.png>` (and optionally
 //! `PLUM_GAME_FRAMES=<n>`, default 30) it saves the screen after n frames and
 //! exits 0.
@@ -12,7 +13,7 @@ fn window_conf() -> macroquad::window::Conf {
 }
 #[cfg(not(target_arch = "wasm32"))]
-fn parse_args() -> Result<(std::path::PathBuf, Option<std::path::PathBuf>), String> {
+fn parse_args() -> Result<(std::path::PathBuf, std::path::PathBuf), String> {
     let mut wasm = None;
     let mut assets = None;
     let mut args = std::env::args().skip(1);
@@ -25,11 +26,15 @@ fn parse_args() -> Result<(std::path::PathBuf, Option<std::path::PathBuf>), Stri
             return Err(format!("unexpected argument `{a}`"));
         }
     }
-    Ok((wasm.ok_or("usage: plum-game <module.wasm> [--assets DIR]")?, assets))
+    let wasm: std::path::PathBuf = wasm.ok_or("usage: plum-game <module.wasm> [--assets DIR]")?;
+    let assets = assets
+        .or_else(|| std::env::var_os("PLUM_GAME_ASSETS").map(Into::into))
+        .unwrap_or_else(|| wasm.parent().unwrap_or(std::path::Path::new(".")).join("assets"));
+    Ok((wasm, assets))
 }
 #[cfg(not(target_arch = "wasm32"))]
-async fn run(wasm: std::path::PathBuf, assets: Option<std::path::PathBuf>) -> Result<(), String> {
+async fn run(wasm: std::path::PathBuf, assets: std::path::PathBuf) -> Result<(), String> {
     let bytes = std::fs::read(&wasm).map_err(|e| format!("{}: {e}", wasm.display()))?;
     let mut game = PlumGame::load(&bytes, MqBackend::new(assets)).map_err(|e| format!("{e:#}"))?;
     game.init().map_err(|e| format!("init: {e:#}"))?;

plum-game/src/mq.rs CHANGED Viewed

@@ -2,7 +2,7 @@
 //! (`screen = (world - camera) * scale`), so every draw works in world units
 //! and `resetCamera` returns to screen pixels.
-use crate::api::{quarter_turns_radians, AssetStore, Backend, Color};
+use crate::api::{AssetStore, Backend, Color};
 use macroquad::prelude as mq;
 use std::path::PathBuf;
@@ -47,18 +47,18 @@ fn col(c: Color) -> mq::Color {
 pub struct MqBackend {
     assets: AssetStore,
-    /// Lazily uploaded textures, `[atlas][sprite]`.
+    /// Textures uploaded on first use, with the filter currently applied.
-    textures: Vec<Vec<Option<mq::Texture2D>>>,
+    uploaded: Vec<Option<(mq::Texture2D, bool)>>,
     cam: (f32, f32, f32),
 }
 impl MqBackend {
-    pub fn new(assets: Option<PathBuf>) -> Self {
+    pub fn new(root: PathBuf) -> Self {
-        Self::with_assets(AssetStore::new(assets))
+        Self::with_assets(AssetStore::new(root))
     }
     pub fn with_assets(assets: AssetStore) -> Self {
-        MqBackend { assets, textures: Vec::new(), cam: (0.0, 0.0, 1.0) }
+        MqBackend { assets, uploaded: Vec::new(), cam: (0.0, 0.0, 1.0) }
     }
     pub fn assets_mut(&mut self) -> &mut AssetStore {
@@ -69,22 +69,32 @@ impl MqBackend {
         ((x - self.cam.0) * self.cam.2, (y - self.cam.1) * self.cam.2)
     }
+    /// The GPU texture for handle `t`, uploaded on first use and refiltered
+    /// when `textureSetSmooth` changed.
-    fn texture(&mut self, atlas: i32, idx: i32) -> Option<mq::Texture2D> {
+    fn texture(&mut self, t: i32) -> Option<mq::Texture2D> {
-        let (a, i) = (usize::try_from(atlas).ok()?, usize::try_from(idx).ok()?);
+        let i = usize::try_from(t).ok()?;
+        let smooth = self.assets.smooth(t);
+        self.uploaded.resize(self.assets.texture_count(), None);
-        while self.textures.len() <= a {
+        if self.uploaded.get(i)?.is_none() {
+            let img = self.assets.image(t)?;
-            let n = self.assets.atlases.get(self.textures.len()).map_or(0, |at| at.sprites.len());
+            let tex = mq::Texture2D::from_rgba8(img.width, img.height, &img.bytes);
+            tex.set_filter(filter(smooth));
-            self.textures.push(vec![None; n]);
+            self.uploaded[i] = Some((tex, smooth));
         }
-        if i >= self.textures[a].len() {
+        let (tex, applied) = self.uploaded[i].as_mut()?;
+        if *applied != smooth {
+            tex.set_filter(filter(smooth));
-            return None;
+            *applied = smooth;
         }
-        if self.textures[a][i].is_none() {
+        Some(tex.clone())
-            let s = self.assets.atlases.get(a)?.sprites.get(i)?.as_ref()?;
-            let t = mq::Texture2D::from_rgba8(s.w, s.h, &s.rgba);
-            t.set_filter(mq::FilterMode::Nearest);
-            self.textures[a][i] = Some(t);
-        }
+    }
+}
-        self.textures[a].get(i)?.clone()
+fn filter(smooth: bool) -> mq::FilterMode {
+    if smooth {
+        mq::FilterMode::Linear
+    } else {
+        mq::FilterMode::Nearest
     }
 }
@@ -105,6 +115,10 @@ impl Backend for MqBackend {
         let (sx, sy) = self.to_screen(x, y);
         mq::draw_rectangle(sx, sy, w * self.cam.2, h * self.cam.2, col(c));
     }
+    fn draw_circle(&mut self, x: f32, y: f32, r: f32, c: Color) {
+        let (sx, sy) = self.to_screen(x, y);
+        mq::draw_circle(sx, sy, r * self.cam.2, col(c));
+    }
     fn draw_line(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, t: f32, c: Color) {
         let (a, b) = (self.to_screen(x1, y1), self.to_screen(x2, y2));
         mq::draw_line(a.0, a.1, b.0, b.1, t * self.cam.2, col(c));
@@ -122,51 +136,45 @@ impl Backend for MqBackend {
     fn reset_camera(&mut self) {
         self.cam = (0.0, 0.0, 1.0);
     }
-    fn atlas_load(&mut self, name: &str) -> i32 {
+    fn texture_load(&mut self, path: &str) -> i32 {
-        self.assets.atlas_load(name)
+        self.assets.texture_load(path)
-    }
-    fn sprite_count(&mut self, a: i32) -> i32 {
-        self.assets.sprite_count(a)
     }
-    fn sprite_w(&mut self, a: i32, i: i32) -> i32 {
+    fn texture_width(&mut self, t: i32) -> i32 {
-        self.assets.sprite_w(a, i)
+        self.assets.texture_width(t)
     }
-    fn sprite_h(&mut self, a: i32, i: i32) -> i32 {
+    fn texture_height(&mut self, t: i32) -> i32 {
-        self.assets.sprite_h(a, i)
+        self.assets.texture_height(t)
     }
-    fn sprite_pivot_x(&mut self, a: i32, i: i32) -> i32 {
+    fn texture_set_smooth(&mut self, t: i32, smooth: bool) {
-        self.assets.sprite_pivot_x(a, i)
+        self.assets.texture_set_smooth(t, smooth);
     }
-    fn sprite_pivot_y(&mut self, a: i32, i: i32) -> i32 {
-        self.assets.sprite_pivot_y(a, i)
-    }
-    fn sprite_color(&mut self, a: i32, i: i32) -> Color {
-        self.assets.sprite_color(a, i)
-    }
-    fn draw_sprite(&mut self, a: i32, i: i32, x: f32, y: f32, flip_x: bool, tint: Color) {
+    fn draw_texture(&mut self, t: i32, x: f32, y: f32, tint: Color) {
-        let Some(tex) = self.texture(a, i) else { return };
+        let Some(tex) = self.texture(t) else { return };
-        let (px, py) = (self.assets.sprite_pivot_x(a, i) as f32, self.assets.sprite_pivot_y(a, i) as f32);
-        let (sx, sy) = self.to_screen(x + px, y + py);
+        let (sx, sy) = self.to_screen(x, y);
         let s = self.cam.2;
-        let params = mq::DrawTextureParams {
-            dest_size: Some(mq::vec2(tex.width() * s, tex.height() * s)),
+        let params = mq::DrawTextureParams { dest_size: Some(mq::vec2(tex.width() * s, tex.height() * s)), ..Default::default() };
-            flip_x,
-            ..Default::default()
-        };
         mq::draw_texture_ex(&tex, sx, sy, col(tint), params);
     }
-    fn draw_tile(&mut self, a: i32, i: i32, x: f32, y: f32, size: f32, quarter_turns: i32, tint: Color) {
+    fn draw_texture_ex(&mut self, t: i32, src: [f32; 4], dest: [f32; 4], rotation: f32, flip_x: bool, tint: Color) {
-        let Some(tex) = self.texture(a, i) else { return };
+        let Some(tex) = self.texture(t) else { return };
-        let (sx, sy) = self.to_screen(x, y);
+        let (sx, sy) = self.to_screen(dest[0], dest[1]);
-        let side = size * self.cam.2;
+        let (w, h) = (dest[2] * self.cam.2, dest[3] * self.cam.2);
         let params = mq::DrawTextureParams {
-            dest_size: Some(mq::vec2(side, side)),
+            dest_size: Some(mq::vec2(w, h)),
-            rotation: quarter_turns_radians(quarter_turns),
+            source: Some(mq::Rect::new(src[0], src[1], src[2], src[3])),
+            rotation,
+            flip_x,
-            pivot: Some(mq::vec2(sx + side / 2.0, sy + side / 2.0)),
+            pivot: Some(mq::vec2(sx + w / 2.0, sy + h / 2.0)),
             ..Default::default()
         };
         mq::draw_texture_ex(&tex, sx, sy, col(tint), params);
     }
+    fn file_exists(&mut self, path: &str) -> bool {
+        self.assets.file_exists(path)
+    }
+    fn file_load(&mut self, path: &str) -> Vec<u8> {
+        self.assets.file_load(path)
+    }
     fn is_key_down(&mut self, k: i32) -> bool {
         key_code(k).is_some_and(mq::is_key_down)
     }
@@ -191,27 +199,6 @@ impl Backend for MqBackend {
             dy.signum()
         }
     }
-    fn map_load(&mut self, path: &str) -> i32 {
-        self.assets.map_load(path)
-    }
-    fn map_width(&mut self, m: i32) -> i32 {
-        self.assets.map_width(m)
-    }
-    fn map_height(&mut self, m: i32) -> i32 {
-        self.assets.map_height(m)
-    }
-    fn map_terrain(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.assets.map_terrain(m, x, y)
-    }
-    fn map_rotation(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.assets.map_rotation(m, x, y)
-    }
-    fn map_elevation(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.assets.map_elevation(m, x, y)
-    }
-    fn map_object(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.assets.map_object(m, x, y)
-    }
 }
 #[cfg(test)]

plum-game/src/native.rs CHANGED Viewed

@@ -63,6 +63,25 @@ fn str_arg<B: Backend>(caller: &mut Caller<'_, HostState<B>>, p: &[Val], i: usiz
     Ok(String::from_utf8_lossy(&str_bytes(caller, s)?).into_owned())
 }
+/// Builds a Plum `Str` holding `bytes` with the module's `strNew` and
+/// `strSetByte` exports.
+fn new_str<B: Backend>(caller: &mut Caller<'_, HostState<B>>, bytes: &[u8]) -> Result<Val> {
+    let export = |caller: &mut Caller<'_, HostState<B>>, name: &str| {
+        caller
+            .get_export(name)
+            .and_then(|e| e.into_func())
+            .ok_or_else(|| wasmtime::Error::msg(format!("module has no `{name}` export")))
+    };
+    let (new, set) = (export(caller, "strNew")?, export(caller, "strSetByte")?);
+    let mut out = [Val::AnyRef(None)];
+    new.call(&mut *caller, &[Val::I32(bytes.len() as i32)], &mut out)?;
+    for (i, b) in bytes.iter().enumerate() {
+        set.call(&mut *caller, &[out[0].clone(), Val::I32(i as i32), Val::I32(*b as i32)], &mut [])?;
+    }
+    let [s] = out;
+    Ok(s)
+}
 /// Calls the backend method behind the `plum` import `name`.
 fn dispatch<B: Backend>(name: &str, caller: &mut Caller<'_, HostState<B>>, p: &[Val], r: &mut [Val]) -> Result<()> {
     macro_rules! b {
@@ -78,6 +97,7 @@ fn dispatch<B: Backend>(name: &str, caller: &mut Caller<'_, HostState<B>>, p: &[
         "frameTime" => r[0] = fv(b!().frame_time()),
         "clear" => b!().clear(color(p, 0)),
         "drawRect" => b!().draw_rect(f(p, 0), f(p, 1), f(p, 2), f(p, 3), color(p, 4)),
+        "drawCircle" => b!().draw_circle(f(p, 0), f(p, 1), f(p, 2), color(p, 3)),
         "drawLine" => b!().draw_line(f(p, 0), f(p, 1), f(p, 2), f(p, 3), f(p, 4), color(p, 5)),
         "drawText" => {
             let s = str_arg(caller, p, 0)?;
@@ -85,23 +105,31 @@ fn dispatch<B: Backend>(name: &str, caller: &mut Caller<'_, HostState<B>>, p: &[
         }
         "setCamera" => b!().set_camera(f(p, 0), f(p, 1), f(p, 2)),
         "resetCamera" => b!().reset_camera(),
-        "atlasLoad" => {
+        "textureLoad" => {
             let s = str_arg(caller, p, 0)?;
-            r[0] = Val::I32(b!().atlas_load(&s));
+            r[0] = Val::I32(b!().texture_load(&s));
         }
+        "textureWidth" => r[0] = Val::I32(b!().texture_width(int(p, 0))),
-        "spriteCount" => r[0] = Val::I32(b!().sprite_count(int(p, 0))),
+        "textureHeight" => r[0] = Val::I32(b!().texture_height(int(p, 0))),
-        "spriteW" => r[0] = Val::I32(b!().sprite_w(int(p, 0), int(p, 1))),
-        "spriteH" => r[0] = Val::I32(b!().sprite_h(int(p, 0), int(p, 1))),
-        "spritePivotX" => r[0] = Val::I32(b!().sprite_pivot_x(int(p, 0), int(p, 1))),
+        "textureSetSmooth" => b!().texture_set_smooth(int(p, 0), int(p, 1) != 0),
-        "spritePivotY" => r[0] = Val::I32(b!().sprite_pivot_y(int(p, 0), int(p, 1))),
+        "drawTexture" => b!().draw_texture(int(p, 0), f(p, 1), f(p, 2), color(p, 3)),
+        "drawTextureEx" => b!().draw_texture_ex(
+            int(p, 0),
+            [f(p, 1), f(p, 2), f(p, 3), f(p, 4)],
+            [f(p, 5), f(p, 6), f(p, 7), f(p, 8)],
+            f(p, 9),
+            int(p, 10) != 0,
+            color(p, 11),
+        ),
-        "spriteColor" => {
+        "fileExists" => {
-            let c = b!().sprite_color(int(p, 0), int(p, 1));
+            let s = str_arg(caller, p, 0)?;
-            for (i, v) in c.into_iter().enumerate() {
+            r[0] = Val::I32(b!().file_exists(&s) as i32);
-                r[i] = fv(v);
-            }
+        }
+        "fileLoad" => {
+            let s = str_arg(caller, p, 0)?;
+            let bytes = b!().file_load(&s);
+            r[0] = new_str(caller, &bytes)?;
         }
-        "drawSprite" => b!().draw_sprite(int(p, 0), int(p, 1), f(p, 2), f(p, 3), int(p, 4) != 0, color(p, 5)),
-        "drawTile" => b!().draw_tile(int(p, 0), int(p, 1), f(p, 2), f(p, 3), f(p, 4), int(p, 5), color(p, 6)),
         "isKeyDown" => r[0] = Val::I32(b!().is_key_down(int(p, 0)) as i32),
         "isKeyPressed" => r[0] = Val::I32(b!().is_key_pressed(int(p, 0)) as i32),
         "mousePos" => {
@@ -112,16 +140,6 @@ fn dispatch<B: Backend>(name: &str, caller: &mut Caller<'_, HostState<B>>, p: &[
         "isMouseDown" => r[0] = Val::I32(b!().is_mouse_down(int(p, 0)) as i32),
         "isMousePressed" => r[0] = Val::I32(b!().is_mouse_pressed(int(p, 0)) as i32),
         "mouseWheel" => r[0] = fv(b!().mouse_wheel()),
-        "mapLoad" => {
-            let s = str_arg(caller, p, 0)?;
-            r[0] = Val::I32(b!().map_load(&s));
-        }
-        "mapWidth" => r[0] = Val::I32(b!().map_width(int(p, 0))),
-        "mapHeight" => r[0] = Val::I32(b!().map_height(int(p, 0))),
-        "mapTerrain" => r[0] = Val::I32(b!().map_terrain(int(p, 0), int(p, 1), int(p, 2))),
-        "mapRotation" => r[0] = Val::I32(b!().map_rotation(int(p, 0), int(p, 1), int(p, 2))),
-        "mapElevation" => r[0] = Val::I32(b!().map_elevation(int(p, 0), int(p, 1), int(p, 2))),
-        "mapObject" => r[0] = Val::I32(b!().map_object(int(p, 0), int(p, 1), int(p, 2))),
         other => return Err(wasmtime::Error::msg(format!("host function '{other}' is not available here"))),
     }
     Ok(())

plum-game/src/recorder.rs CHANGED Viewed

@@ -1,5 +1,5 @@
 //! A `Backend` that records every call as a string and answers input queries
-//! from scripted values. Asset calls go through a real `AssetStore`.
+//! from scripted values. Texture and file calls go through a real `AssetStore`.
 use crate::api::{AssetStore, Backend, Color};
 use std::collections::HashSet;
@@ -23,11 +23,12 @@ fn c4(c: Color) -> String {
 }
 impl Recorder {
+    /// A recorder whose asset root does not exist.
     pub fn new() -> Self {
-        Self::with_assets(None)
+        Self::with_assets(PathBuf::from("/nonexistent-plum-assets"))
     }
-    pub fn with_assets(root: Option<PathBuf>) -> Self {
+    pub fn with_assets(root: PathBuf) -> Self {
         Recorder {
             calls: Vec::new(),
             screen: (800.0, 600.0),
@@ -72,6 +73,9 @@ impl Backend for Recorder {
     fn draw_rect(&mut self, x: f32, y: f32, w: f32, h: f32, c: Color) {
         self.rec(format!("drawRect({x},{y},{w},{h},{})", c4(c)));
     }
+    fn draw_circle(&mut self, x: f32, y: f32, r: f32, c: Color) {
+        self.rec(format!("drawCircle({x},{y},{r},{})", c4(c)));
+    }
     fn draw_line(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, t: f32, c: Color) {
         self.rec(format!("drawLine({x1},{y1},{x2},{y2},{t},{})", c4(c)));
     }
@@ -84,39 +88,40 @@ impl Backend for Recorder {
     fn reset_camera(&mut self) {
         self.rec("resetCamera()".into());
     }
-    fn atlas_load(&mut self, name: &str) -> i32 {
+    fn texture_load(&mut self, path: &str) -> i32 {
+        let t = self.assets.texture_load(path);
-        self.rec(format!("atlasLoad({name:?})"));
+        self.rec(format!("textureLoad({path:?}) -> {t}"));
-        self.assets.atlas_load(name)
-    }
+        t
-    fn sprite_count(&mut self, a: i32) -> i32 {
-        self.rec(format!("spriteCount({a})"));
-        self.assets.sprite_count(a)
     }
-    fn sprite_w(&mut self, a: i32, i: i32) -> i32 {
+    fn texture_width(&mut self, t: i32) -> i32 {
-        self.rec(format!("spriteW({a},{i})"));
+        self.rec(format!("textureWidth({t})"));
-        self.assets.sprite_w(a, i)
+        self.assets.texture_width(t)
     }
-    fn sprite_h(&mut self, a: i32, i: i32) -> i32 {
+    fn texture_height(&mut self, t: i32) -> i32 {
-        self.rec(format!("spriteH({a},{i})"));
+        self.rec(format!("textureHeight({t})"));
-        self.assets.sprite_h(a, i)
+        self.assets.texture_height(t)
     }
-    fn sprite_pivot_x(&mut self, a: i32, i: i32) -> i32 {
+    fn texture_set_smooth(&mut self, t: i32, smooth: bool) {
-        self.rec(format!("spritePivotX({a},{i})"));
+        self.rec(format!("textureSetSmooth({t},{smooth})"));
-        self.assets.sprite_pivot_x(a, i)
+        self.assets.texture_set_smooth(t, smooth);
     }
-    fn sprite_pivot_y(&mut self, a: i32, i: i32) -> i32 {
+    fn draw_texture(&mut self, t: i32, x: f32, y: f32, tint: Color) {
-        self.rec(format!("spritePivotY({a},{i})"));
+        self.rec(format!("drawTexture({t},{x},{y},{})", c4(tint)));
-        self.assets.sprite_pivot_y(a, i)
     }
-    fn sprite_color(&mut self, a: i32, i: i32) -> Color {
+    fn draw_texture_ex(&mut self, t: i32, s: [f32; 4], d: [f32; 4], rotation: f32, flip_x: bool, tint: Color) {
-        self.rec(format!("spriteColor({a},{i})"));
-        self.assets.sprite_color(a, i)
+        self.rec(format!(
+            "drawTextureEx({t},{},{},{},{},{},{},{},{},{rotation},{flip_x},{})",
+            s[0], s[1], s[2], s[3], d[0], d[1], d[2], d[3], c4(tint)
+        ));
     }
-    fn draw_sprite(&mut self, a: i32, i: i32, x: f32, y: f32, flip_x: bool, tint: Color) {
+    fn file_exists(&mut self, path: &str) -> bool {
-        self.rec(format!("drawSprite({a},{i},{x},{y},{flip_x},{})", c4(tint)));
+        self.rec(format!("fileExists({path:?})"));
+        self.assets.file_exists(path)
     }
-    fn draw_tile(&mut self, a: i32, i: i32, x: f32, y: f32, size: f32, qt: i32, tint: Color) {
+    fn file_load(&mut self, path: &str) -> Vec<u8> {
+        let bytes = self.assets.file_load(path);
-        self.rec(format!("drawTile({a},{i},{x},{y},{size},{qt},{})", c4(tint)));
+        self.rec(format!("fileLoad({path:?}) -> {} bytes", bytes.len()));
+        bytes
     }
     fn is_key_down(&mut self, k: i32) -> bool {
         self.rec(format!("isKeyDown({k})"));
@@ -142,32 +147,4 @@ impl Backend for Recorder {
         self.rec("mouseWheel()".into());
         self.wheel
     }
-    fn map_load(&mut self, path: &str) -> i32 {
-        self.rec(format!("mapLoad({path:?})"));
-        self.assets.map_load(path)
-    }
-    fn map_width(&mut self, m: i32) -> i32 {
-        self.rec(format!("mapWidth({m})"));
-        self.assets.map_width(m)
-    }
-    fn map_height(&mut self, m: i32) -> i32 {
-        self.rec(format!("mapHeight({m})"));
-        self.assets.map_height(m)
-    }
-    fn map_terrain(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.rec(format!("mapTerrain({m},{x},{y})"));
-        self.assets.map_terrain(m, x, y)
-    }
-    fn map_rotation(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.rec(format!("mapRotation({m},{x},{y})"));
-        self.assets.map_rotation(m, x, y)
-    }
-    fn map_elevation(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.rec(format!("mapElevation({m},{x},{y})"));
-        self.assets.map_elevation(m, x, y)
-    }
-    fn map_object(&mut self, m: i32, x: i32, y: i32) -> i32 {
-        self.rec(format!("mapObject({m},{x},{y})"));
-        self.assets.map_object(m, x, y)
-    }
 }

plum-game/src/web.rs CHANGED Viewed

@@ -103,6 +103,10 @@ pub extern "C" fn pg_draw_rect(x: f32, y: f32, w: f32, h: f32, r: f32, g: f32, b
     with(|s| s.draw_rect(x, y, w, h, [r, g, b, a]))
 }
 #[no_mangle]
+pub extern "C" fn pg_draw_circle(x: f32, y: f32, r: f32, cr: f32, cg: f32, cb: f32, ca: f32) {
+    with(|s| s.draw_circle(x, y, r, [cr, cg, cb, ca]))
+}
+#[no_mangle]
 #[allow(clippy::too_many_arguments)]
 pub extern "C" fn pg_draw_line(x1: f32, y1: f32, x2: f32, y2: f32, t: f32, r: f32, g: f32, b: f32, a: f32) {
     with(|s| s.draw_line(x1, y1, x2, y2, t, [r, g, b, a]))
@@ -122,44 +126,75 @@ pub extern "C" fn pg_reset_camera() {
     with(|b| b.reset_camera())
 }
 #[no_mangle]
-pub extern "C" fn pg_atlas_load(p: *const u8, n: usize) -> i32 {
+pub extern "C" fn pg_texture_load(p: *const u8, n: usize) -> i32 {
     let s = text(p, n);
-    with(|b| b.atlas_load(&s))
+    with(|b| b.texture_load(&s))
 }
 #[no_mangle]
-pub extern "C" fn pg_sprite_count(a: i32) -> i32 {
+pub extern "C" fn pg_texture_width(t: i32) -> i32 {
-    with(|b| b.sprite_count(a))
+    with(|b| b.texture_width(t))
 }
 #[no_mangle]
-pub extern "C" fn pg_sprite_w(a: i32, i: i32) -> i32 {
+pub extern "C" fn pg_texture_height(t: i32) -> i32 {
-    with(|b| b.sprite_w(a, i))
+    with(|b| b.texture_height(t))
 }
 #[no_mangle]
-pub extern "C" fn pg_sprite_h(a: i32, i: i32) -> i32 {
+pub extern "C" fn pg_texture_set_smooth(t: i32, smooth: i32) {
-    with(|b| b.sprite_h(a, i))
+    with(|b| b.texture_set_smooth(t, smooth != 0))
 }
 #[no_mangle]
-pub extern "C" fn pg_sprite_pivot_x(a: i32, i: i32) -> i32 {
+pub extern "C" fn pg_draw_texture(t: i32, x: f32, y: f32, r: f32, g: f32, b: f32, a: f32) {
-    with(|b| b.sprite_pivot_x(a, i))
+    with(|s| s.draw_texture(t, x, y, [r, g, b, a]))
 }
 #[no_mangle]
+#[allow(clippy::too_many_arguments)]
+pub extern "C" fn pg_draw_texture_ex(
+    t: i32,
+    sx: f32,
+    sy: f32,
+    sw: f32,
+    sh: f32,
+    x: f32,
+    y: f32,
+    w: f32,
+    h: f32,
+    rotation: f32,
+    flip: i32,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+) {
+    with(|s| s.draw_texture_ex(t, [sx, sy, sw, sh], [x, y, w, h], rotation, flip != 0, [r, g, b, a]))
+}
+#[no_mangle]
-pub extern "C" fn pg_sprite_pivot_y(a: i32, i: i32) -> i32 {
+pub extern "C" fn pg_file_exists(p: *const u8, n: usize) -> i32 {
+    let s = text(p, n);
-    with(|b| b.sprite_pivot_y(a, i))
+    with(|b| b.file_exists(&s)) as i32
 }
+thread_local! {
-/// Channel `k` (0 = r .. 3 = a) of the sprite's average colour.
+    /// The file `pg_file_load` last read, until JS collects it with `pg_file_read`.
-#[no_mangle]
-pub extern "C" fn pg_sprite_color(a: i32, i: i32, k: i32) -> f32 {
+    static LOADED: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
-    with(|b| b.sprite_color(a, i)[(k & 3) as usize])
 }
+/// Loads the file and returns its length (0 when missing); `pg_file_read`
+/// then copies the bytes out.
 #[no_mangle]
-#[allow(clippy::too_many_arguments)]
-pub extern "C" fn pg_draw_sprite(a: i32, i: i32, x: f32, y: f32, flip: i32, r: f32, g: f32, b: f32, al: f32) {
+pub extern "C" fn pg_file_load(p: *const u8, n: usize) -> i32 {
+    let s = text(p, n);
-    with(|s| s.draw_sprite(a, i, x, y, flip != 0, [r, g, b, al]))
+    let bytes = with(|b| b.file_load(&s));
+    let len = bytes.len() as i32;
+    LOADED.with(|l| *l.borrow_mut() = bytes);
+    len
 }
+/// Copies the bytes of the last `pg_file_load` into `dst`, a `pg_alloc`
+/// buffer of that length.
 #[no_mangle]
-#[allow(clippy::too_many_arguments)]
-pub extern "C" fn pg_draw_tile(a: i32, i: i32, x: f32, y: f32, size: f32, qt: i32, r: f32, g: f32, b: f32, al: f32) {
+pub extern "C" fn pg_file_read(dst: *mut u8) {
+    LOADED.with(|l| {
+        let bytes = std::mem::take(&mut *l.borrow_mut());
+        // SAFETY: JS passes a live `pg_alloc` buffer of `bytes.len()` bytes.
-    with(|s| s.draw_tile(a, i, x, y, size, qt, [r, g, b, al]))
+        unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), dst, bytes.len()) }
+    })
 }
 #[no_mangle]
 pub extern "C" fn pg_is_key_down(k: i32) -> i32 {
@@ -189,32 +224,3 @@ pub extern "C" fn pg_is_mouse_pressed(k: i32) -> i32 {
 pub extern "C" fn pg_mouse_wheel() -> f32 {
     with(|b| b.mouse_wheel())
 }
-#[no_mangle]
-pub extern "C" fn pg_map_load(p: *const u8, n: usize) -> i32 {
-    let s = text(p, n);
-    with(|b| b.map_load(&s))
-}
-#[no_mangle]
-pub extern "C" fn pg_map_width(m: i32) -> i32 {
-    with(|b| b.map_width(m))
-}
-#[no_mangle]
-pub extern "C" fn pg_map_height(m: i32) -> i32 {
-    with(|b| b.map_height(m))
-}
-#[no_mangle]
-pub extern "C" fn pg_map_terrain(m: i32, x: i32, y: i32) -> i32 {
-    with(|b| b.map_terrain(m, x, y))
-}
-#[no_mangle]
-pub extern "C" fn pg_map_rotation(m: i32, x: i32, y: i32) -> i32 {
-    with(|b| b.map_rotation(m, x, y))
-}
-#[no_mangle]
-pub extern "C" fn pg_map_elevation(m: i32, x: i32, y: i32) -> i32 {
-    with(|b| b.map_elevation(m, x, y))
-}
-#[no_mangle]
-pub extern "C" fn pg_map_object(m: i32, x: i32, y: i32) -> i32 {
-    with(|b| b.map_object(m, x, y))
-}

plum-game/tests/assets_test.rs DELETED Viewed

@@ -1,114 +0,0 @@
-#![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}");
-    }
-}

plum-game/tests/fixtures/assets_fixture.plum ADDED Viewed

@@ -0,0 +1,30 @@
+module assets_fixture
+import std/Int
+import std/Float
+import std/Str
+import std/Os
+import std/Vec2
+import std/Color
+import std/Game
+record State(frames: Int)
+export fun init() -> State =
+  State(frames: 0)
+export fun update(g: State, dt: Float) =
+  g.frames = g.frames + 1
+# Loads a texture and files from the asset root and reports what came back as text.
+export fun draw(g: State) =
+  t := textureLoad("sprites.png")
+  drawText("size {textureWidth(t)}x{textureHeight(t)}", 0.0, 0.0, 8.0, Color.White)
+  textureSetSmooth(t, true)
+  drawTexture(t, 1.0, 2.0, Color.White)
+  drawTextureEx(t, 16.0, 0.0, 16.0, 16.0, 10.0, 20.0, 32.0, 48.0, 0.5, true, Color.Blue)
+  drawText("bad {textureWidth(99)} {textureLoad("missing.png")}", 0.0, 0.0, 8.0, Color.White)
+  if fileExists("hello.txt")
+    drawText("file [{fileLoad("hello.txt")}]", 0.0, 0.0, 8.0, Color.White)
+  drawText("missing [{fileLoad("nope.txt")}] {fileExists("nope.txt")}", 0.0, 0.0, 8.0, Color.White)
+  drawText("escape {textureLoad("../sprites.png")} {fileExists("../hello.txt")} [{fileLoad("../hello.txt")}]", 0.0, 0.0, 8.0, Color.White)
+  drawText("abs {textureLoad("/etc/hosts")} {fileExists("/etc/hosts")}", 0.0, 0.0, 8.0, Color.White)

plum-game/tests/fixtures/host_fixture.plum CHANGED Viewed

@@ -19,6 +19,7 @@ export fun update(g: State, dt: Float) =
 export fun draw(g: State) =
   clear(Color.Black)
   drawRect(1.0, 2.0, 3.0, 4.0, Color.Red)
+  drawCircle(5.0, 6.0, 7.0, Color.Green)
   p := mousePos()
   drawText("hi", p.x, p.y, 16.0, Color.White)
   if g.frames > 0

plum-game/tests/host_test.rs CHANGED Viewed

@@ -1,5 +1,4 @@
 #![allow(non_snake_case)]
-use plum_game::api::quarter_turns_radians;
 use plum_game::native::PlumGame;
 use plum_game::recorder::Recorder;
 use std::path::{Path, PathBuf};
@@ -32,7 +31,7 @@ fn callOrderAndArgs() {
     g.draw().unwrap();
     assert_eq!(
         g.backend().calls,
-        ["clear(0,0,0,1)", "drawRect(1,2,3,4,1,0,0,1)", "mousePos()", "drawText(\"hi\",5,6,16,1,1,1,1)"]
+        ["clear(0,0,0,1)", "drawRect(1,2,3,4,1,0,0,1)", "drawCircle(5,6,7,0,1,0,1)", "mousePos()", "drawText(\"hi\",5,6,16,1,1,1,1)"]
     );
 }
@@ -101,80 +100,104 @@ fn unknownImportTraps() {
 }
 #[test]
-fn quarterTurnsRotateClockwise() {
+fn manyFramesDoNotAccumulateRoots() {
-    use std::f32::consts::FRAC_PI_2;
+    let mut g = game(Recorder::new());
+    for _ in 0..2000 {
+        g.update(0.016).unwrap();
+        g.draw().unwrap();
+    }
-    assert_eq!(quarter_turns_radians(0), 0.0);
+    g.backend_mut().calls.clear();
-    assert_eq!(quarter_turns_radians(1), FRAC_PI_2);
-    assert_eq!(quarter_turns_radians(3), 3.0 * FRAC_PI_2);
-    assert_eq!(quarter_turns_radians(4), 0.0);
+    g.draw().unwrap();
-    assert_eq!(quarter_turns_radians(-1), 3.0 * FRAC_PI_2);
+    assert_eq!(g.backend().calls.last().unwrap(), "drawText(\"frames 2000\",0,0,8,1,1,1,1)");
 }
-#[test]
-fn intHandlesFailWithMinusOne() {
+fn examples_assets() -> PathBuf {
+    root().join("plum-examples/assets")
+}
+fn assets_fixture() -> Vec<u8> {
+    compile(&Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/assets_fixture.plum"))
+}
-    use plum_game::api::Backend;
+fn scratch(name: &str) -> PathBuf {
-    let mut rec = Recorder::with_assets(Some(PathBuf::from("/nonexistent-assets")));
+    let dir = std::env::temp_dir().join(format!("plum_game_{name}_{}", std::process::id()));
-    assert_eq!(rec.atlas_load("Tileset"), -1);
+    std::fs::create_dir_all(&dir).unwrap();
-    assert_eq!(rec.map_load("x.map"), -1);
-    assert_eq!(rec.sprite_w(5, 5), 0);
+    dir
-    assert_eq!(rec.map_terrain(-1, 0, 0), 0);
 }
 #[test]
-fn atlasAndMapThroughHost() {
+fn textureLoadFromAssetRoot() {
     use plum_game::api::Backend;
-    let assets = plum_game::assets::AssetRoot::resolve(None);
-    if !assets.join("sprites").is_dir() {
-        eprintln!("skipping: asset root {} not found", assets.display());
-        return;
-    }
-    let mut rec = Recorder::with_assets(None);
+    let mut rec = Recorder::with_assets(examples_assets());
-    let a = rec.atlas_load("Tileset");
+    let t = rec.texture_load("sprites.png");
-    assert_eq!(a, 0);
+    assert_eq!(t, 0);
-    assert_eq!(rec.sprite_w(a, 1), 32);
-    let m = rec.map_load("Maps/A new Beginning/A new Beginning.map");
-    assert_eq!(m, 0);
-    let (w, h) = (rec.map_width(m), rec.map_height(m));
+    assert_eq!((rec.texture_width(t), rec.texture_height(t)), (64, 48));
-    assert!((32..=256).contains(&w) && (32..=256).contains(&h));
-    assert!(rec.map_terrain(m, 0, 0) < 512);
-    assert_eq!(rec.map_terrain(m, w, 0), 0);
+    assert_eq!(rec.texture_load("missing.png"), -1);
+    assert_eq!((rec.texture_width(-1), rec.texture_height(99)), (0, 0));
+    let mut g = PlumGame::load(&assets_fixture(), Recorder::with_assets(examples_assets())).unwrap();
+    g.init().unwrap();
+    g.draw().unwrap();
+    let calls = &g.backend().calls;
+    assert!(calls.contains(&"textureLoad(\"sprites.png\") -> 0".to_string()), "{calls:?}");
+    assert!(calls.contains(&"drawText(\"size 64x48\",0,0,8,1,1,1,1)".to_string()), "{calls:?}");
+    assert!(calls.contains(&"textureSetSmooth(0,true)".to_string()));
+    assert!(calls.contains(&"drawTexture(0,1,2,1,1,1,1)".to_string()));
+    assert!(calls.contains(&"drawTextureEx(0,16,0,16,16,10,20,32,48,0.5,true,0,0,1,1)".to_string()), "{calls:?}");
+    assert!(calls.contains(&"drawText(\"bad 0 -1\",0,0,8,1,1,1,1)".to_string()));
 }
 #[test]
-fn manyFramesDoNotAccumulateRoots() {
+fn fileLoadReturnsContents() {
-    let mut g = game(Recorder::new());
+    let dir = scratch("fileload");
-    for _ in 0..2000 {
-        g.update(0.016).unwrap();
+    std::fs::write(dir.join("hello.txt"), "héllo\nworld").unwrap();
+    let mut g = PlumGame::load(&assets_fixture(), Recorder::with_assets(dir.clone())).unwrap();
-        g.draw().unwrap();
+    g.init().unwrap();
-    }
-    g.backend_mut().calls.clear();
     g.draw().unwrap();
+    let calls = g.backend().calls.clone();
+    let _ = std::fs::remove_dir_all(&dir);
+    assert!(calls.contains(&"fileLoad(\"hello.txt\") -> 12 bytes".to_string()), "{calls:?}");
+    assert!(calls.contains(&"drawText(\"file [héllo\\nworld]\",0,0,8,1,1,1,1)".to_string()), "{calls:?}");
-    assert_eq!(g.backend().calls.last().unwrap(), "drawText(\"frames 2000\",0,0,8,1,1,1,1)");
+    assert!(calls.contains(&"drawText(\"missing [] false\",0,0,8,1,1,1,1)".to_string()), "{calls:?}");
 }
 #[test]
-fn kamViewerInitAndDrawWithRealAssets() {
+fn assetPathEscapeRejected() {
     use plum_game::api::Backend;
+    // A secret one level above the asset root must stay unreachable.
-    let assets = plum_game::assets::AssetRoot::resolve(None);
+    let dir = scratch("escape");
-    if !assets.join("sprites").is_dir() {
+    let root = dir.join("assets");
+    std::fs::create_dir_all(&root).unwrap();
+    std::fs::write(dir.join("hello.txt"), "secret").unwrap();
+    std::fs::copy(examples_assets().join("sprites.png"), dir.join("sprites.png")).unwrap();
+    let mut rec = Recorder::with_assets(root.clone());
+    assert!(!rec.file_exists("../hello.txt"));
-        eprintln!("skipping: asset root {} not found", assets.display());
+    assert!(rec.file_load("../hello.txt").is_empty());
+    assert_eq!(rec.texture_load("../sprites.png"), -1);
+    assert!(!rec.file_exists("/etc/hosts"));
+    assert_eq!(rec.texture_load("sub/../../sprites.png"), -1);
+    let mut g = PlumGame::load(&assets_fixture(), Recorder::with_assets(root)).unwrap();
+    g.init().unwrap();
+    g.draw().unwrap();
+    let calls = g.backend().calls.clone();
+    let _ = std::fs::remove_dir_all(&dir);
+    assert!(calls.contains(&"drawText(\"escape -1 false []\",0,0,8,1,1,1,1)".to_string()), "{calls:?}");
+    assert!(calls.contains(&"drawText(\"abs -1 false\",0,0,8,1,1,1,1)".to_string()), "{calls:?}");
+}
-        return;
+#[test]
+fn exampleGameRunsFrames() {
+    let wasm = compile(&root().join("plum-examples/game.plum"));
+    let mut g = PlumGame::load(&wasm, Recorder::with_assets(examples_assets())).expect("load game");
+    g.init().expect("init");
+    for _ in 0..60 {
+        g.update(1.0 / 60.0).expect("update");
     }
-    // Map size, read through a separate backend so the minimap rect count is exact.
-    let mut probe = Recorder::with_assets(None);
-    let m = probe.map_load("Maps/A new Beginning/A new Beginning.map");
-    assert!(m >= 0);
-    let cells = (probe.map_width(m) * probe.map_height(m)) as usize;
-    let wasm = compile(&Path::new(env!("CARGO_MANIFEST_DIR")).join("kam/Main.plum"));
-    let mut g = PlumGame::load(&wasm, Recorder::with_assets(None)).expect("load viewer");
-    g.init().expect("init must not trap");
-    g.update(0.016).expect("update must not trap");
-    g.draw().expect("first draw must not trap");
+    g.draw().expect("draw");
-    g.draw().expect("second draw must not trap");
     let calls = &g.backend().calls;
-    assert!(calls.iter().any(|c| c.starts_with("drawTile(")), "no drawTile recorded");
+    assert!(calls.iter().any(|c| c.starts_with("drawTextureEx(0,")), "no drawTextureEx recorded");
-    let rects = calls.iter().filter(|c| c.starts_with("drawRect(")).count();
+    assert!(calls.iter().any(|c| c.starts_with("drawCircle(")));
-    assert!(rects >= cells, "minimap drew {rects} rects, expected at least {cells}");
-    assert!(!calls.iter().any(|c| c.contains("assets not found")), "assets-not-found was drawn");
+    assert!(calls.iter().any(|c| c.starts_with("drawText(\"Score ")));
 }

plum-game/web/bridge_check.mjs CHANGED Viewed

@@ -44,6 +44,10 @@ function stubHost() {
         if (name === "pg_free") return () => {};
         return (...a) => {
           calls.push([name, ...a]);
+          if (name === "pg_file_load") {
+            t.loaded.push(new TextDecoder().decode(new Uint8Array(memory.buffer, a[0], a[1])));
+            return 0;
+          }
           if (/load$/.test(name)) {
             // (ptr, len): the Str arrived intact in host memory.
             t.loaded.push(new TextDecoder().decode(new Uint8Array(memory.buffer, a[0], a[1])));

plum-game/web/plum_bridge.js CHANGED Viewed

@@ -21,39 +21,33 @@
     drawText: "pg_draw_text",
     setCamera: "pg_set_camera",
     resetCamera: "pg_reset_camera",
-    atlasLoad: "pg_atlas_load",
-    spriteCount: "pg_sprite_count",
-    spriteW: "pg_sprite_w",
-    spriteH: "pg_sprite_h",
-    spritePivotX: "pg_sprite_pivot_x",
-    spritePivotY: "pg_sprite_pivot_y",
-    drawSprite: "pg_draw_sprite",
-    drawTile: "pg_draw_tile",
+    drawCircle: "pg_draw_circle",
+    textureLoad: "pg_texture_load",
+    textureWidth: "pg_texture_width",
+    textureHeight: "pg_texture_height",
+    textureSetSmooth: "pg_texture_set_smooth",
+    drawTexture: "pg_draw_texture",
+    drawTextureEx: "pg_draw_texture_ex",
+    fileExists: "pg_file_exists",
     isKeyDown: "pg_is_key_down",
     isKeyPressed: "pg_is_key_pressed",
     isMouseDown: "pg_is_mouse_down",
     isMousePressed: "pg_is_mouse_pressed",
     mouseWheel: "pg_mouse_wheel",
-    mapLoad: "pg_map_load",
-    mapWidth: "pg_map_width",
-    mapHeight: "pg_map_height",
-    mapTerrain: "pg_map_terrain",
-    mapRotation: "pg_map_rotation",
-    mapElevation: "pg_map_elevation",
-    mapObject: "pg_map_object",
   };
   // Externs whose first parameter is a Str.
-  const STR_FIRST = new Set(["drawText", "atlasLoad", "mapLoad"]);
+  const STR_FIRST = new Set(["drawText", "textureLoad", "fileExists"]);
   // Externs with a multi-value result, built from several pg_* calls.
   const MULTI = {
     mousePos: (host) => [host.pg_mouse_x(), host.pg_mouse_y()],
-    spriteColor: (host, a, i) => [0, 1, 2, 3].map((k) => host.pg_sprite_color(a, i, k)),
   };
-  const MULTI_HOST = ["pg_mouse_x", "pg_mouse_y", "pg_sprite_color"];
+  const MULTI_HOST = ["pg_mouse_x", "pg_mouse_y"];
+  // fileLoad returns a Str: the host loads the file and JS copies it into a new Str.
+  const FILE_HOST = ["pg_file_load", "pg_file_read"];
   const MEMORY_HOST = ["pg_alloc", "pg_free"];
   // Every pg_* export the plugin may call.
-  const hostNames = [...new Set([...Object.values(DIRECT), ...MULTI_HOST, ...MEMORY_HOST])];
+  const hostNames = [...new Set([...Object.values(DIRECT), ...MULTI_HOST, ...FILE_HOST, ...MEMORY_HOST])];
   // Copies a Plum Str into a host buffer, calls f(ptr, len), frees the buffer.
   function withStr(host, plum, s, f) {
@@ -68,6 +62,23 @@
     }
   }
+  // Builds a Plum Str from the host's file at the Str path `s` (empty if missing).
+  function fileLoad(host, plum, s) {
+    const len = withStr(host, plum, s, (ptr, n) => host.pg_file_load(ptr, n));
+    const out = plum.strNew(len);
+    if (len > 0) {
+      const ptr = host.pg_alloc(len);
+      try {
+        host.pg_file_read(ptr);
+        const mem = new Uint8Array(host.memory.buffer, ptr, len);
+        for (let i = 0; i < len; i++) plum.strSetByte(out, i, mem[i]);
+      } finally {
+        host.pg_free(ptr, len);
+      }
+    }
+    return out;
+  }
   function strToJs(plum, s) {
     const n = plum.strLen(s);
     const bytes = new Uint8Array(n);
@@ -88,6 +99,8 @@
         plum[name] = (s) => {
           throw new Error("crash: " + strToJs(ctx.plum, s));
         };
+      } else if (name === "fileLoad") {
+        plum[name] = (s) => fileLoad(host, ctx.plum, s);
       } else if (MULTI[name]) {
         plum[name] = (...args) => MULTI[name](host, ...args);
       } else if (STR_FIRST.has(name)) {

plum-std/Game.plum CHANGED Viewed

@@ -5,9 +5,10 @@ import std/Str
 import std/Vec2
 import std/Color
-# The host API of a game: drawing, input, sprite atlases and KaM maps, all
+# The host API of a game: drawing, textures, files and input, all provided by
-# provided by the game host (`plum game`). Handles (`atlasLoad`, `mapLoad`)
+# the game host (`plum game`). Texture handles are -1 on failure. File and
+# texture paths are relative to the asset root; a path that escapes it fails
-# are -1 on failure. Coordinates are world units once `setCamera` is set.
+# like a missing file. Coordinates are world units once `setCamera` is set.
 extern fun screenWidth() -> Float
 extern fun screenHeight() -> Float
@@ -15,22 +16,29 @@ extern fun frameTime() -> Float
 extern fun clear(c: Color)
 extern fun drawRect(x: Float, y: Float, w: Float, h: Float, c: Color)
+extern fun drawCircle(x: Float, y: Float, r: Float, c: Color)
 extern fun drawLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, c: Color)
 extern fun drawText(s: Str, x: Float, y: Float, size: Float, c: Color)
 extern fun setCamera(x: Float, y: Float, scale: Float)
 extern fun resetCamera()
+# Loads any image the host decodes (PNG at least); -1 on failure.
-extern fun atlasLoad(name: Str) -> Int
+extern fun textureLoad(path: Str) -> Int
+# Size in pixels; 0 for a bad handle.
-extern fun spriteCount(atlas: Int) -> Int
+extern fun textureWidth(t: Int) -> Int
-extern fun spriteW(atlas: Int, idx: Int) -> Int
+extern fun textureHeight(t: Int) -> Int
-extern fun spriteH(atlas: Int, idx: Int) -> Int
+# Linear (true) or nearest (false, the default) filtering.
-extern fun spritePivotX(atlas: Int, idx: Int) -> Int
+extern fun textureSetSmooth(t: Int, smooth: Bool)
-extern fun spritePivotY(atlas: Int, idx: Int) -> Int
+# The texture at its natural size, top-left at (x, y).
-extern fun spriteColor(atlas: Int, idx: Int) -> Color
+extern fun drawTexture(t: Int, x: Float, y: Float, tint: Color)
+# The source rect (sx, sy, sw, sh) in texture pixels drawn into the dest rect
+# (x, y, w, h), rotated `rotation` radians clockwise about the dest centre.
+extern fun drawTextureEx(t: Int, sx: Float, sy: Float, sw: Float, sh: Float, x: Float, y: Float, w: Float, h: Float, rotation: Float, flipX: Bool, tint: Color)
-extern fun drawSprite(atlas: Int, idx: Int, x: Float, y: Float, flipX: Bool, tint: Color)
+extern fun fileExists(path: Str) -> Bool
+# The whole file; "" if it is missing.
-extern fun drawTile(atlas: Int, idx: Int, x: Float, y: Float, size: Float, quarterTurns: Int, tint: Color)
+extern fun fileLoad(path: Str) -> Str
 extern fun isKeyDown(k: Int) -> Bool
 extern fun isKeyPressed(k: Int) -> Bool
@@ -39,14 +47,6 @@ extern fun isMouseDown(b: Int) -> Bool
 extern fun isMousePressed(b: Int) -> Bool
 extern fun mouseWheel() -> Float
-extern fun mapLoad(path: Str) -> Int
-extern fun mapWidth(m: Int) -> Int
-extern fun mapHeight(m: Int) -> Int
-extern fun mapTerrain(m: Int, x: Int, y: Int) -> Int
-extern fun mapRotation(m: Int, x: Int, y: Int) -> Int
-extern fun mapElevation(m: Int, x: Int, y: Int) -> Int
-extern fun mapObject(m: Int, x: Int, y: Int) -> Int
 # Key codes (GLFW numbering) for `isKeyDown` / `isKeyPressed`.
 # Letter keys are `KeyA`..`KeyZ` (a constant name needs two characters).
 primitive Key =