8ffa113 | plum | pyrossh

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

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

8ffa113 — Peter John 2026-11-02T14:02:19+05:30

T5: web bridge + `plum game` + README

Files changed (9) hide show

.gitignore +1 -0
README.md +50 -0
plum-cli/src/game.rs +178 -0
plum-cli/src/main.rs +33 -3
plum-game/src/lib.rs +3 -2
plum-game/src/main.rs +33 -1
plum-game/src/web.rs +403 -0
plum-game/web/index.html +23 -0
plum-game/web/plum_bridge.js +140 -0

.gitignore CHANGED Viewed

@@ -18,6 +18,7 @@ codegen
 # `cargo make dist-macos`/`dist-linux-docker` output — uploaded to R2, not committed
 /dist
+dist/
 # superlite: dependency, build and cache folders
 .superlite/

README.md CHANGED Viewed

@@ -92,6 +92,7 @@ test "glance"
 | a namespace of constants and functions | `primitive Math =` |
 | a test | `test "name"` with `assert` |
 | host function | `extern fun printLn(s: Str)` |
+| a function the host calls | `export fun draw(g: Game)` |
 ## Installing
@@ -133,6 +134,7 @@ plum test file.plum dir/      # run the `test` blocks of files and directories (
 plum compile file.plum        # write file.wasm
 plum build file.plum          # embed the module into a native executable
 plum format file.plum         # rewrite in place (--check, --stdin)
+plum game file.plum           # run a game (see Games); --web writes a static web build
 plum editor helix|vscode      # install highlighting and the language server
 ```
@@ -1000,6 +1002,54 @@ hello from plum
 hello, world!
 ```
+## `export fun`
+```plum
+export fun step(n: Int, v: Vec2) -> Vec2 =
+  Vec2(x: v.x + 1.0, y: v.y * 2.0)
+```
+`export fun` (top level only: not a method, not generic, no error-union result) is an ordinary Plum function that is also exported from the wasm module under its own name. Its boundary uses the `extern fun` ABI: `Int` is narrowed to `i32`, `Float` is `f64`, `Bool` is `i32`, a struct is flattened into its fields' values, and `Str` and records are GC references. Plum code can still call it directly with the normal internal ABI. A function can't be both `extern` and `export`.
+Every module that imports `std/Str` also exports four helpers for hosts that can't read GC structs: `strLen(s) -> i32`, `strByte(s, i) -> i32`, `strNew(n) -> Str` (n zero bytes) and `strSetByte(s, i, b)` (for a fresh `strNew` result only).
+## Games
+`plum game file.plum` compiles a game and runs it in a native window (macroquad, with the module under wasmtime). `plum game --web file.plum [-o dist] [--preload path]...` writes a static web build instead: `index.html`, `mq_js_bundle.js`, `plum_bridge.js`, `plum-game.wasm`, `plum.wasm`, `preload.txt` and an `assets/` copy of the preloaded files (the six `sprites/*.rxx` and `data/defines/mapelem.dat` are always preloaded; `dist` defaults to the source file's directory). Serve it from any static host; the browser needs wasm GC support. The web build needs `rustup target add wasm32-unknown-unknown`.
+A game declares three exports. `G` is any record and holds all game state (there are no globals):
+```plum
+export fun init() -> G
+export fun update(g: G, dt: Float)
+export fun draw(g: G)
+```
+The host calls `init` once after the window exists, then `update` and `draw` every frame. A game imports `std/Game`, `std/Vec2` and `std/Color`; pure logic can import `std/Vec2` and `std/Color` alone. Under `plum test` and `plum run` the host functions are stubs that trap with `host function 'X' is not available here`, so `test` blocks work as long as they don't call the host.
+**Assets** are never part of the repository. The asset root is `--assets DIR`, else `$PLUM_GAME_ASSETS`, else `../kam_macroquad/assets` beside the repository. `--web` copies only the preloaded files into `dist/assets`.
+**Host API** (`std/Game`; `Int` handles are `-1` on failure; coordinates are world units once a camera is set):
+| function | meaning |
+|---|---|
+| `screenWidth()`, `screenHeight()`, `frameTime()` | window size in pixels, last frame time in seconds |
+| `clear(c)` | fill the screen |
+| `drawRect(x, y, w, h, c)`, `drawLine(x1, y1, x2, y2, thickness, c)`, `drawText(s, x, y, size, c)` | shapes and text (`x, y` is the text's top-left) |
+| `setCamera(x, y, scale)`, `resetCamera()` | world point `(x, y)` maps to the screen's top-left, one world unit is `scale` pixels |
+| `atlasLoad(name)` | load `<assets>/sprites/<name>.rxx` |
+| `spriteCount(a)`, `spriteW(a, i)`, `spriteH`, `spritePivotX`, `spritePivotY`, `spriteColor(a, i)` | sprite info (0 for a missing sprite); `spriteColor` is the average opaque colour |
+| `drawSprite(a, i, x, y, flipX, tint)` | sprite at its natural size, top-left at `(x + pivotX, y + pivotY)` |
+| `drawTile(a, i, x, y, size, quarterTurns, tint)` | sprite stretched to a square, rotated clockwise about its centre |
+| `isKeyDown(k)`, `isKeyPressed(k)`, `isMouseDown(b)`, `isMousePressed(b)` | input; `k` is a `Key` constant, `b` a `Mouse` constant |
+| `mousePos()`, `mouseWheel()` | pointer in screen pixels; wheel direction this frame (+ is up) |
+| `mapLoad(path)`, `mapWidth(m)`, `mapHeight(m)` | load a KaM `.map` relative to the asset root |
+| `mapTerrain(m, x, y)`, `mapRotation`, `mapElevation`, `mapObject` | per-tile data; row 0 is the map's first row. The Tileset sprite for a terrain id is `id + 1`; `mapObject` is a `Trees_a` sprite index (0 for none) |
+`Key` constants use GLFW numbering: `Key.Space`, `Key.KeyA` to `Key.KeyZ`, `Key.Num0` to `Key.Num9`, `Key.Escape`, `Key.Enter`, `Key.Tab`, `Key.Backspace`, `Key.Right`, `Key.Left`, `Key.Down`, `Key.Up`, `Key.LeftShift`, `Key.LeftControl`. `Mouse` has `Mouse.Left`, `Mouse.Right` and `Mouse.Middle`. `Color` holds RGBA channels in 0..1 with the constants `White`, `Black`, `Red`, `Green`, `Blue`, `Yellow` and `Transparent`, plus `Color.rgb(r, g, b)` and `withAlpha(a)`.
+`plum-game/kam/Main.plum` is a Knights and Merchants map viewer built on this API: `plum game plum-game/kam/Main.plum`.
 ## Standard library highlights
 - **`Bool`** — `true`/`false`, `if`, `&&`/`||`/`!` and `==` are built in (no import); `toStr` (also used by `"{b}"` interpolation) and `Bool.parse("true")` need `import std/Bool`

plum-cli/src/game.rs ADDED Viewed

@@ -0,0 +1,178 @@
+//! `plum game`: compile a game and run it natively, or write a static web build.
+use std::fs;
+use std::path::{Path, PathBuf};
+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"))
+        .parent()
+        .expect("plum-cli lives inside the repository")
+        .to_path_buf()
+}
+fn gameManifest() -> PathBuf {
+    repoRoot().join("plum-game/Cargo.toml")
+}
+fn assetRoot(cli: Option<PathBuf>) -> PathBuf {
+    cli.or_else(|| std::env::var_os("PLUM_GAME_ASSETS").map(PathBuf::from))
+        .unwrap_or_else(|| repoRoot().join("../kam_macroquad/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);
+    if web {
+        let dist = output.unwrap_or_else(|| {
+            file.parent()
+                .filter(|p| !p.as_os_str().is_empty())
+                .unwrap_or(Path::new("."))
+                .join("dist")
+        });
+        return writeWeb(&wasm, &dist, &preload, &assets);
+    }
+    runNative(&wasm, &assets)
+}
+fn runNative(wasm: &[u8], assets: &Path) -> Result<()> {
+    let dir = std::env::temp_dir().join(format!("plum_game_{}", std::process::id()));
+    fs::create_dir_all(&dir)?;
+    let path = dir.join("game.wasm");
+    fs::write(&path, wasm).with_context(|| format!("failed to write {}", path.display()))?;
+    let status = Command::new("cargo")
+        .args(["run", "--release", "--manifest-path"])
+        .arg(gameManifest())
+        .arg("--")
+        .arg(&path)
+        .arg("--assets")
+        .arg(assets)
+        .status()
+        .context("failed to run cargo")?;
+    let _ = fs::remove_dir_all(&dir);
+    if !status.success() {
+        bail!("the game host exited with {status}");
+    }
+    Ok(())
+}
+/// Path of macroquad's `mq_js_bundle.js`, found through the host crate's
+/// locked dependency (the bundle must match the crate version).
+fn jsBundle() -> Result<PathBuf> {
+    let out = Command::new("cargo")
+        .args(["metadata", "--format-version", "1", "--manifest-path"])
+        .arg(gameManifest())
+        .output()
+        .context("failed to run cargo metadata")?;
+    if !out.status.success() {
+        bail!(
+            "cargo metadata failed: {}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+    }
+    let json = String::from_utf8_lossy(&out.stdout);
+    // `"manifest_path":".../macroquad-0.4.x/Cargo.toml"` of the macroquad package.
+    let mut rest = json.as_ref();
+    while let Some(i) = rest.find("\"manifest_path\":\"") {
+        rest = &rest[i + 17..];
+        let end = rest.find('"').unwrap_or(rest.len());
+        let manifest = &rest[..end];
+        if Path::new(manifest)
+            .parent()
+            .and_then(|d| d.file_name())
+            .is_some_and(|n| n.to_string_lossy().starts_with("macroquad-"))
+        {
+            let bundle = Path::new(manifest).with_file_name("js/mq_js_bundle.js");
+            if bundle.is_file() {
+                return Ok(bundle);
+            }
+        }
+    }
+    bail!("macroquad's mq_js_bundle.js not found; run `cargo fetch --manifest-path plum-game/Cargo.toml`")
+}
+/// Builds the host for the browser and returns the path of its wasm.
+fn buildHostWasm() -> Result<PathBuf> {
+    let status = Command::new("cargo")
+        .args(["build", "--release", "--target", "wasm32-unknown-unknown"])
+        .arg("--manifest-path")
+        .arg(gameManifest())
+        .status()
+        .context("failed to run cargo")?;
+    if !status.success() {
+        bail!("building the web host failed (is the wasm32-unknown-unknown target installed?)");
+    }
+    let target = std::env::var_os("CARGO_TARGET_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| repoRoot().join("plum-game/target"));
+    Ok(target.join("wasm32-unknown-unknown/release/plum-game.wasm"))
+}
+fn writeWeb(wasm: &[u8], dist: &Path, preload: &[String], assets: &Path) -> Result<()> {
+    let hostWasm = buildHostWasm()?;
+    let bundle = jsBundle()?;
+    // Defaults that are missing from the asset root are skipped with a
+    // warning; files asked for with --preload must exist.
+    let mut files: Vec<String> = 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");
+    for name in ["index.html", "plum_bridge.js"] {
+        fs::copy(web.join(name), dist.join(name))
+            .with_context(|| format!("failed to copy {name}"))?;
+    }
+    fs::copy(&bundle, dist.join("mq_js_bundle.js"))?;
+    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")?;
+    for rel in &files {
+        let to = dist.join("assets").join(rel);
+        fs::create_dir_all(to.parent().expect("asset has a parent"))?;
+        fs::copy(assets.join(rel), &to)?;
+    }
+    eprintln!("wrote web build to {}", dist.display());
+    Ok(())
+}

plum-cli/src/main.rs CHANGED Viewed

@@ -12,6 +12,7 @@ use clap::{Parser, Subcommand};
 use plum_core::formatSource;
 mod editor;
+mod game;
 use editor::EditorType;
 #[derive(Parser)]
@@ -75,6 +76,26 @@ enum Command {
         #[arg(long, default_value = ".")]
         lib_path: std::path::PathBuf,
     },
+    /// Compile a Plum game and run it natively, or package it for the browser with --web
+    Game {
+        /// Source file with `export fun init/update/draw`
+        file: std::path::PathBuf,
+        /// Write a static web build instead of opening a window
+        #[arg(long)]
+        web: bool,
+        /// 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
+        #[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)
+        #[arg(long)]
+        lib_path: Option<std::path::PathBuf>,
+    },
     /// Install Plum syntax highlighting into an editor's configuration
     Editor {
         /// Editor to install support for
@@ -108,6 +129,14 @@ fn run() -> Result<()> {
             lib_path,
         } => cmdBuild(file, output, lib_path),
         Command::Test { paths, lib_path } => cmdTest(paths, lib_path),
+        Command::Game {
+            file,
+            web,
+            output,
+            preload,
+            assets,
+            lib_path,
+        } => game::cmdGame(file, web, output, preload, assets, lib_path),
         Command::Editor { editor, insiders } => editor::install(editor, insiders),
     }
 }
@@ -580,9 +609,10 @@ fn hostImports(
                 // is stubbed with a function that traps when called, so a program
                 // that imports it can still run or test code that never calls it.
                 ("plum", n) => {
+                    let func_ty =
-                    let func_ty = imp.ty().func().cloned().ok_or_else(|| {
+                        imp.ty().func().cloned().ok_or_else(|| {
-                        anyhow::anyhow!("plum::{n} import must be a function")
+                            anyhow::anyhow!("plum::{n} import must be a function")
-                    })?;
+                        })?;
                     let name = n.to_string();
                     Ok(wasmtime::Extern::Func(wasmtime::Func::new(
                         &mut *store,

plum-game/src/lib.rs CHANGED Viewed

@@ -2,9 +2,10 @@
 pub mod api;
 pub mod assets;
+pub mod mq;
 pub mod recorder;
-#[cfg(not(target_arch = "wasm32"))]
-pub mod mq;
 #[cfg(not(target_arch = "wasm32"))]
 pub mod native;
+#[cfg(target_arch = "wasm32")]
+pub mod web;

plum-game/src/main.rs CHANGED Viewed

@@ -55,5 +55,37 @@ async fn main() {
     }
 }
+/// Fetches every file in `preload.txt`, waits for the JS plugin to have
+/// instantiated `plum.wasm`, then runs the frame loop.
 #[cfg(target_arch = "wasm32")]
+async fn run_web() -> Result<(), String> {
+    use macroquad::file::{load_file, load_string};
+    use macroquad::window::next_frame;
+    let list = load_string("preload.txt").await.map_err(|e| format!("preload.txt: {e}"))?;
+    for path in list.lines().map(str::trim).filter(|l| !l.is_empty()) {
+        let bytes = load_file(&format!("assets/{path}")).await.map_err(|e| format!("{path}: {e}"))?;
+        plum_game::web::preload(path, bytes);
+    }
+    while !plum_game::web::bridge_ready() {
+        next_frame().await;
+    }
+    plum_game::web::bridge_init();
+    loop {
+        plum_game::web::bridge_update(macroquad::time::get_frame_time());
+        plum_game::web::bridge_draw();
+        next_frame().await;
+    }
+}
+#[cfg(target_arch = "wasm32")]
+#[macroquad::main("Plum Game")]
-fn main() {}
+async fn main() {
+    if let Err(e) = run_web().await {
+        use macroquad::prelude::*;
+        loop {
+            clear_background(BLACK);
+            draw_text(&e, 20.0, 40.0, 24.0, RED);
+            next_frame().await;
+        }
+    }
+}

plum-game/src/web.rs ADDED Viewed

@@ -0,0 +1,403 @@
+//! The browser side of the host. The page's `plum_bridge.js` plugin runs
+//! `plum.wasm` and implements its `plum` imports by calling the `pg_*`
+//! exports below; this module draws with macroquad and answers input
+//! queries. Every `pg_*` call borrows the backend only for its own body, so a
+//! frame can re-enter Rust from JS (Rust -> `plum_bridge_draw` -> Plum -> `pg_*`)
+//! without a borrow held across the JS call.
+//!
+//! Strings cross as UTF-8 bytes in host memory: JS asks `pg_alloc` for a
+//! buffer, copies the Plum `Str` into it with `strLen`/`strByte`, passes
+//! `(ptr, len)` to the `pg_*` function and releases the buffer with `pg_free`.
+use crate::api::{quarter_turns_radians, AssetStore, Backend, Color};
+use crate::assets::{Atlas, MapData};
+use crate::mq::{key_code, mouse_button};
+use macroquad::prelude as mq;
+use std::cell::RefCell;
+use std::collections::HashMap;
+extern "C" {
+    /// 1 once `plum.wasm` is instantiated and its exports are callable.
+    fn plum_bridge_ready() -> i32;
+    fn plum_bridge_init();
+    fn plum_bridge_update(dt: f32);
+    fn plum_bridge_draw();
+}
+/// Version the JS plugin checks against its own.
+#[no_mangle]
+pub extern "C" fn plum_bridge_crate_version() -> u32 {
+    1
+}
+pub fn bridge_ready() -> bool {
+    unsafe { plum_bridge_ready() != 0 }
+}
+pub fn bridge_init() {
+    unsafe { plum_bridge_init() }
+}
+pub fn bridge_update(dt: f32) {
+    unsafe { plum_bridge_update(dt) }
+}
+pub fn bridge_draw() {
+    unsafe { plum_bridge_draw() }
+}
+const MAPELEM: &str = "data/defines/mapelem.dat";
+/// The files fetched before the first frame, keyed by their path relative to
+/// the asset root. Atlases and maps are served from here.
+pub struct WebBackend {
+    files: HashMap<String, Vec<u8>>,
+    assets: AssetStore,
+    textures: Vec<Vec<Option<mq::Texture2D>>>,
+    cam: (f32, f32, f32),
+}
+thread_local! {
+    static BACKEND: RefCell<WebBackend> = RefCell::new(WebBackend::new());
+}
+/// Runs `f` on the backend. `f` never calls back into JS.
+fn with<R>(f: impl FnOnce(&mut WebBackend) -> R) -> R {
+    BACKEND.with(|b| f(&mut b.borrow_mut()))
+}
+/// Registers a fetched file under its asset-root-relative path.
+pub fn preload(path: &str, bytes: Vec<u8>) {
+    with(|b| {
+        b.files.insert(path.to_string(), bytes);
+    });
+}
+fn col(c: Color) -> mq::Color {
+    mq::Color::new(c[0], c[1], c[2], c[3])
+}
+impl WebBackend {
+    fn new() -> Self {
+        WebBackend { files: HashMap::new(), assets: AssetStore::new(None), textures: Vec::new(), cam: (0.0, 0.0, 1.0) }
+    }
+    fn to_screen(&self, x: f32, y: f32) -> (f32, f32) {
+        ((x - self.cam.0) * self.cam.2, (y - self.cam.1) * self.cam.2)
+    }
+    fn texture(&mut self, atlas: i32, idx: i32) -> Option<mq::Texture2D> {
+        let (a, i) = (usize::try_from(atlas).ok()?, usize::try_from(idx).ok()?);
+        while self.textures.len() <= a {
+            let n = self.assets.atlases.get(self.textures.len()).map_or(0, |at| at.sprites.len());
+            self.textures.push(vec![None; n]);
+        }
+        if i >= self.textures[a].len() {
+            return None;
+        }
+        if self.textures[a][i].is_none() {
+            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][i].clone()
+    }
+}
+impl Backend for WebBackend {
+    fn screen_width(&mut self) -> f32 {
+        mq::screen_width()
+    }
+    fn screen_height(&mut self) -> f32 {
+        mq::screen_height()
+    }
+    fn frame_time(&mut self) -> f32 {
+        mq::get_frame_time()
+    }
+    fn clear(&mut self, c: Color) {
+        mq::clear_background(col(c));
+    }
+    fn draw_rect(&mut self, x: f32, y: f32, w: f32, h: f32, c: Color) {
+        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_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));
+    }
+    fn draw_text(&mut self, s: &str, x: f32, y: f32, size: f32, c: Color) {
+        let (sx, sy) = self.to_screen(x, y);
+        let px = size * self.cam.2;
+        let dims = mq::measure_text(s, None, px.max(1.0) as u16, 1.0);
+        mq::draw_text(s, sx, sy + dims.offset_y, px, col(c));
+    }
+    fn set_camera(&mut self, x: f32, y: f32, scale: f32) {
+        self.cam = (x, y, scale);
+    }
+    fn reset_camera(&mut self) {
+        self.cam = (0.0, 0.0, 1.0);
+    }
+    fn atlas_load(&mut self, name: &str) -> i32 {
+        let Some(bytes) = self.files.get(&format!("sprites/{name}.rxx")) else { return -1 };
+        match Atlas::parse(bytes) {
+            Ok(a) => {
+                self.assets.atlases.push(a);
+                self.assets.atlases.len() as i32 - 1
+            }
+            Err(_) => -1,
+        }
+    }
+    fn sprite_count(&mut self, a: i32) -> i32 {
+        self.assets.sprite_count(a)
+    }
+    fn sprite_w(&mut self, a: i32, i: i32) -> i32 {
+        self.assets.sprite_w(a, i)
+    }
+    fn sprite_h(&mut self, a: i32, i: i32) -> i32 {
+        self.assets.sprite_h(a, i)
+    }
+    fn sprite_pivot_x(&mut self, a: i32, i: i32) -> i32 {
+        self.assets.sprite_pivot_x(a, i)
+    }
+    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) {
+        let Some(tex) = self.texture(a, i) 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 s = self.cam.2;
+        let params = mq::DrawTextureParams { dest_size: Some(mq::vec2(tex.width() * s, tex.height() * s)), 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) {
+        let Some(tex) = self.texture(a, i) else { return };
+        let (sx, sy) = self.to_screen(x, y);
+        let side = size * self.cam.2;
+        let params = mq::DrawTextureParams {
+            dest_size: Some(mq::vec2(side, side)),
+            rotation: quarter_turns_radians(quarter_turns),
+            pivot: Some(mq::vec2(sx + side / 2.0, sy + side / 2.0)),
+            ..Default::default()
+        };
+        mq::draw_texture_ex(&tex, sx, sy, col(tint), params);
+    }
+    fn is_key_down(&mut self, k: i32) -> bool {
+        key_code(k).is_some_and(mq::is_key_down)
+    }
+    fn is_key_pressed(&mut self, k: i32) -> bool {
+        key_code(k).is_some_and(mq::is_key_pressed)
+    }
+    fn mouse_pos(&mut self) -> (f32, f32) {
+        mq::mouse_position()
+    }
+    fn is_mouse_down(&mut self, b: i32) -> bool {
+        mouse_button(b).is_some_and(mq::is_mouse_button_down)
+    }
+    fn is_mouse_pressed(&mut self, b: i32) -> bool {
+        mouse_button(b).is_some_and(mq::is_mouse_button_pressed)
+    }
+    fn mouse_wheel(&mut self) -> f32 {
+        let dy = mq::mouse_wheel().1;
+        if dy == 0.0 {
+            0.0
+        } else {
+            dy.signum()
+        }
+    }
+    fn map_load(&mut self, path: &str) -> i32 {
+        let Some(bytes) = self.files.get(path) else { return -1 };
+        let mapelem = self.files.get(MAPELEM).map_or(&[][..], |v| v.as_slice());
+        match MapData::parse_with(bytes, mapelem) {
+            Ok(m) => {
+                self.assets.maps.push(m);
+                self.assets.maps.len() as i32 - 1
+            }
+            Err(_) => -1,
+        }
+    }
+    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)
+    }
+}
+// --- exports called by plum_bridge.js ----------------------------------------
+/// A buffer of `n` bytes in host memory, for JS to fill.
+#[no_mangle]
+pub extern "C" fn pg_alloc(n: usize) -> *mut u8 {
+    let mut v = vec![0u8; n.max(1)];
+    let p = v.as_mut_ptr();
+    std::mem::forget(v);
+    p
+}
+/// Releases a buffer from [`pg_alloc`] of the same `n`.
+///
+/// # Safety
+/// `p` must come from `pg_alloc(n)` and not have been freed.
+#[no_mangle]
+pub unsafe extern "C" fn pg_free(p: *mut u8, n: usize) {
+    drop(Vec::from_raw_parts(p, n.max(1), n.max(1)));
+}
+fn text(p: *const u8, n: usize) -> String {
+    // SAFETY: JS passes a live `pg_alloc` buffer of `n` bytes.
+    String::from_utf8_lossy(unsafe { std::slice::from_raw_parts(p, n) }).into_owned()
+}
+#[no_mangle]
+pub extern "C" fn pg_screen_width() -> f32 {
+    with(|b| b.screen_width())
+}
+#[no_mangle]
+pub extern "C" fn pg_screen_height() -> f32 {
+    with(|b| b.screen_height())
+}
+#[no_mangle]
+pub extern "C" fn pg_frame_time() -> f32 {
+    with(|b| b.frame_time())
+}
+#[no_mangle]
+pub extern "C" fn pg_clear(r: f32, g: f32, b: f32, a: f32) {
+    with(|s| s.clear([r, g, b, a]))
+}
+#[no_mangle]
+pub extern "C" fn pg_draw_rect(x: f32, y: f32, w: f32, h: f32, r: f32, g: f32, b: f32, a: f32) {
+    with(|s| s.draw_rect(x, y, w, h, [r, g, b, a]))
+}
+#[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]))
+}
+#[no_mangle]
+#[allow(clippy::too_many_arguments)]
+pub extern "C" fn pg_draw_text(p: *const u8, n: usize, x: f32, y: f32, size: f32, r: f32, g: f32, b: f32, a: f32) {
+    let s = text(p, n);
+    with(|st| st.draw_text(&s, x, y, size, [r, g, b, a]))
+}
+#[no_mangle]
+pub extern "C" fn pg_set_camera(x: f32, y: f32, scale: f32) {
+    with(|b| b.set_camera(x, y, scale))
+}
+#[no_mangle]
+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 {
+    let s = text(p, n);
+    with(|b| b.atlas_load(&s))
+}
+#[no_mangle]
+pub extern "C" fn pg_sprite_count(a: i32) -> i32 {
+    with(|b| b.sprite_count(a))
+}
+#[no_mangle]
+pub extern "C" fn pg_sprite_w(a: i32, i: i32) -> i32 {
+    with(|b| b.sprite_w(a, i))
+}
+#[no_mangle]
+pub extern "C" fn pg_sprite_h(a: i32, i: i32) -> i32 {
+    with(|b| b.sprite_h(a, i))
+}
+#[no_mangle]
+pub extern "C" fn pg_sprite_pivot_x(a: i32, i: i32) -> i32 {
+    with(|b| b.sprite_pivot_x(a, i))
+}
+#[no_mangle]
+pub extern "C" fn pg_sprite_pivot_y(a: i32, i: i32) -> i32 {
+    with(|b| b.sprite_pivot_y(a, i))
+}
+/// Channel `k` (0 = r .. 3 = a) of the sprite's average colour.
+#[no_mangle]
+pub extern "C" fn pg_sprite_color(a: i32, i: i32, k: i32) -> f32 {
+    with(|b| b.sprite_color(a, i)[(k & 3) as usize])
+}
+#[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) {
+    with(|s| s.draw_sprite(a, i, x, y, flip != 0, [r, g, b, al]))
+}
+#[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) {
+    with(|s| s.draw_tile(a, i, x, y, size, qt, [r, g, b, al]))
+}
+#[no_mangle]
+pub extern "C" fn pg_is_key_down(k: i32) -> i32 {
+    with(|b| b.is_key_down(k)) as i32
+}
+#[no_mangle]
+pub extern "C" fn pg_is_key_pressed(k: i32) -> i32 {
+    with(|b| b.is_key_pressed(k)) as i32
+}
+#[no_mangle]
+pub extern "C" fn pg_mouse_x() -> f32 {
+    with(|b| b.mouse_pos().0)
+}
+#[no_mangle]
+pub extern "C" fn pg_mouse_y() -> f32 {
+    with(|b| b.mouse_pos().1)
+}
+#[no_mangle]
+pub extern "C" fn pg_is_mouse_down(k: i32) -> i32 {
+    with(|b| b.is_mouse_down(k)) as i32
+}
+#[no_mangle]
+pub extern "C" fn pg_is_mouse_pressed(k: i32) -> i32 {
+    with(|b| b.is_mouse_pressed(k)) as i32
+}
+#[no_mangle]
+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/web/index.html ADDED Viewed

@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Plum Game</title>
+  <link rel="icon" href="data:,">
+  <style>
+    html, body, canvas { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background: #000; }
+    canvas:focus { outline: none; }
+  </style>
+</head>
+<body>
+  <canvas id="glcanvas" tabindex="1"></canvas>
+  <script src="mq_js_bundle.js"></script>
+  <script src="plum_bridge.js"></script>
+  <script>
+    // Right-click is a game input; keep the browser's context menu out of it.
+    document.addEventListener("contextmenu", (e) => e.preventDefault());
+    load("plum-game.wasm");
+  </script>
+</body>
+</html>

plum-game/web/plum_bridge.js ADDED Viewed

@@ -0,0 +1,140 @@
+// miniquad plugin that runs plum.wasm beside the macroquad host wasm.
+//
+// The host wasm (plum-game.wasm) calls plum_bridge_ready/init/update/draw; this
+// plugin forwards them to plum.wasm's exports. plum.wasm's `plum` imports are
+// implemented here by calling the host's `pg_*` exports. Plum's `Str` is a GC
+// struct JS can't read, so it is copied byte by byte through the module's
+// `strLen`/`strByte` exports into a host buffer from `pg_alloc`.
+(function () {
+  "use strict";
+  // Each Game.plum extern -> the pg_* export that implements it. Plum's flattened
+  // parameters (Int/Bool as i32, Float as f64, Color as four f64) are exactly the
+  // host's parameters; a leading Str is passed as (ptr, len).
+  const DIRECT = {
+    screenWidth: "pg_screen_width",
+    screenHeight: "pg_screen_height",
+    frameTime: "pg_frame_time",
+    clear: "pg_clear",
+    drawRect: "pg_draw_rect",
+    drawLine: "pg_draw_line",
+    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",
+    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"]);
+  // 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 MEMORY_HOST = ["pg_alloc", "pg_free"];
+  // Every pg_* export the plugin may call.
+  const hostNames = [...new Set([...Object.values(DIRECT), ...MULTI_HOST, ...MEMORY_HOST])];
+  // Copies a Plum Str into a host buffer, calls f(ptr, len), frees the buffer.
+  function withStr(host, plum, s, f) {
+    const n = plum.strLen(s);
+    const ptr = host.pg_alloc(n);
+    const mem = new Uint8Array(host.memory.buffer, ptr, n);
+    for (let i = 0; i < n; i++) mem[i] = plum.strByte(s, i);
+    try {
+      return f(ptr, n);
+    } finally {
+      host.pg_free(ptr, n);
+    }
+  }
+  function strToJs(plum, s) {
+    const n = plum.strLen(s);
+    const bytes = new Uint8Array(n);
+    for (let i = 0; i < n; i++) bytes[i] = plum.strByte(s, i);
+    return new TextDecoder().decode(bytes);
+  }
+  // The `plum` import object for `module`. `ctx.plum` must hold the instance's
+  // exports before any import runs.
+  function makeImports(module, host, ctx) {
+    const plum = {};
+    for (const imp of WebAssembly.Module.imports(module)) {
+      if (imp.module !== "plum" || imp.kind !== "function") continue;
+      const name = imp.name;
+      if (name === "printLn") {
+        plum[name] = (s) => console.log(strToJs(ctx.plum, s));
+      } else if (name === "crash") {
+        plum[name] = (s) => {
+          throw new Error("crash: " + strToJs(ctx.plum, s));
+        };
+      } else if (MULTI[name]) {
+        plum[name] = (...args) => MULTI[name](host, ...args);
+      } else if (STR_FIRST.has(name)) {
+        const pg = DIRECT[name];
+        plum[name] = (s, ...rest) => withStr(host, ctx.plum, s, (ptr, n) => host[pg](ptr, n, ...rest));
+      } else if (DIRECT[name]) {
+        const pg = DIRECT[name];
+        plum[name] = (...args) => host[pg](...args);
+      } else {
+        plum[name] = () => {
+          throw new Error("host function '" + name + "' is not available here");
+        };
+      }
+    }
+    return { plum };
+  }
+  const bridge = { DIRECT, MULTI, STR_FIRST, hostNames, makeImports, withStr };
+  globalThis.PlumBridge = bridge;
+  let ctx = { plum: null };
+  let state = null;
+  let ready = false;
+  function register_plugin(importObject) {
+    const env = importObject.env;
+    env.plum_bridge_ready = () => (ready ? 1 : 0);
+    env.plum_bridge_init = () => {
+      state = ctx.plum.init();
+    };
+    env.plum_bridge_update = (dt) => ctx.plum.update(state, dt);
+    env.plum_bridge_draw = () => ctx.plum.draw(state);
+  }
+  // Runs after plum-game.wasm is instantiated and before its main().
+  function on_init() {
+    const host = wasm_exports;
+    WebAssembly.compileStreaming(fetch("plum.wasm"))
+      .then((module) => WebAssembly.instantiate(module, makeImports(module, host, ctx)))
+      .then((instance) => {
+        ctx.plum = instance.exports;
+        ready = true;
+      })
+      .catch((e) => console.error("plum.wasm failed to load:", e));
+  }
+  if (typeof miniquad_add_plugin === "function") {
+    miniquad_add_plugin({ register_plugin, on_init, name: "plum_bridge", version: 1 });
+  }
+})();