43b65ab | plum | pyrossh

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

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

43b65ab — Peter John 2026-11-02T13:56:10+05:30

T4: native host: Backend, wasmtime binding, macroquad, recorder

Files changed (8) hide show

plum-game/src/api.rs +149 -0
plum-game/src/lib.rs +9 -0
plum-game/src/main.rs +59 -0
plum-game/src/mq.rs +240 -0
plum-game/src/native.rs +195 -0
plum-game/src/recorder.rs +173 -0
plum-game/tests/fixtures/host_fixture.plum +25 -0
plum-game/tests/host_test.rs +141 -0

plum-game/src/api.rs ADDED Viewed

@@ -0,0 +1,149 @@
+//! The host API a Plum game programs against: one `Backend` method per
+//! extern in `plum-std/Game.plum`, in Rust types (`Float` is `f32`, `Int` is
+//! `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 std::path::PathBuf;
+pub type Color = [f32; 4];
+pub trait Backend: 'static {
+    fn screen_width(&mut self) -> f32;
+    fn screen_height(&mut self) -> f32;
+    fn frame_time(&mut self) -> f32;
+    fn clear(&mut self, c: Color);
+    fn draw_rect(&mut self, x: f32, y: f32, w: f32, h: 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 sprite_count(&mut self, atlas: 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 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);
+    #[allow(clippy::too_many_arguments)]
+    fn draw_tile(&mut self, atlas: i32, idx: i32, x: f32, y: f32, size: f32, quarter_turns: i32, tint: Color);
+    fn is_key_down(&mut self, k: i32) -> bool;
+    fn is_key_pressed(&mut self, k: i32) -> bool;
+    fn mouse_pos(&mut self) -> (f32, f32);
+    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
+/// about the tile's centre by this angle.
+pub fn quarter_turns_radians(quarter_turns: i32) -> f32 {
+    quarter_turns.rem_euclid(4) as f32 * std::f32::consts::FRAC_PI_2
+}
+/// Atlases and maps loaded from an asset root, addressed by handle. Shared by
+/// every backend so handle numbering and lookups behave the same everywhere.
+pub struct AssetStore {
+    root: PathBuf,
+    mapelem: Vec<u8>,
+    pub atlases: Vec<Atlas>,
+    pub maps: Vec<MapData>,
+}
+impl AssetStore {
+    pub fn new(root: Option<PathBuf>) -> Self {
+        let root = AssetRoot::resolve(root.as_deref());
+        let mapelem = std::fs::read(root.join("data/defines/mapelem.dat")).unwrap_or_default();
+        AssetStore { root, mapelem, atlases: Vec::new(), maps: Vec::new() }
+    }
+    pub fn atlas_load(&mut self, name: &str) -> i32 {
+        let path = self.root.join("sprites").join(format!("{name}.rxx"));
+        let Ok(bytes) = std::fs::read(&path) else { return -1 };
+        match Atlas::parse(&bytes) {
+            Ok(a) => {
+                self.atlases.push(a);
+                self.atlases.len() as i32 - 1
+            }
+            Err(_) => -1,
+        }
+    }
+    pub fn map_load(&mut self, path: &str) -> i32 {
+        let Ok(bytes) = std::fs::read(self.root.join(path)) else { return -1 };
+        match MapData::parse_with(&bytes, &self.mapelem) {
+            Ok(m) => {
+                self.maps.push(m);
+                self.maps.len() as i32 - 1
+            }
+            Err(_) => -1,
+        }
+    }
+    fn sprite(&self, atlas: i32, idx: i32) -> Option<&crate::assets::Sprite> {
+        let a = self.atlases.get(usize::try_from(atlas).ok()?)?;
+        a.sprites.get(usize::try_from(idx).ok()?)?.as_ref()
+    }
+    pub fn sprite_count(&self, atlas: i32) -> i32 {
+        usize::try_from(atlas).ok().and_then(|a| self.atlases.get(a)).map_or(0, |a| a.sprites.len() as i32 - 1)
+    }
+    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 {
+        self.sprite(atlas, idx).map_or(0, |s| s.h as i32)
+    }
+    pub fn sprite_pivot_x(&self, atlas: i32, idx: i32) -> i32 {
+        self.sprite(atlas, idx).map_or(0, |s| s.px)
+    }
+    pub fn sprite_pivot_y(&self, atlas: i32, idx: i32) -> i32 {
+        self.sprite(atlas, idx).map_or(0, |s| s.py)
+    }
+    pub fn sprite_color(&self, atlas: i32, idx: i32) -> Color {
+        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),
+            _ => [0.0; 4],
+        }
+    }
+    fn cell(&self, m: i32, x: i32, y: i32) -> Option<(&MapData, usize)> {
+        let map = self.maps.get(usize::try_from(m).ok()?)?;
+        if x < 0 || y < 0 || x >= map.w || y >= map.h {
+            return None;
+        }
+        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)
+    }
+}

plum-game/src/lib.rs CHANGED Viewed

@@ -1 +1,10 @@
+//! Native and web host for Plum game programs.
+pub mod api;
 pub mod assets;
+pub mod recorder;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod mq;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod native;

plum-game/src/main.rs ADDED Viewed

@@ -0,0 +1,59 @@
+//! `plum-game <module.wasm> [--assets DIR]`: runs a compiled Plum game in a
+//! macroquad window.
+#[cfg(not(target_arch = "wasm32"))]
+use plum_game::{mq::MqBackend, native::PlumGame};
+#[cfg(not(target_arch = "wasm32"))]
+fn window_conf() -> macroquad::window::Conf {
+    macroquad::window::Conf { window_title: "Plum Game".to_string(), window_width: 1280, window_height: 720, ..Default::default() }
+}
+#[cfg(not(target_arch = "wasm32"))]
+fn parse_args() -> Result<(std::path::PathBuf, Option<std::path::PathBuf>), String> {
+    let mut wasm = None;
+    let mut assets = None;
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        if a == "--assets" {
+            assets = Some(args.next().ok_or("--assets needs a directory")?.into());
+        } else if wasm.is_none() {
+            wasm = Some(a.into());
+        } else {
+            return Err(format!("unexpected argument `{a}`"));
+        }
+    }
+    Ok((wasm.ok_or("usage: plum-game <module.wasm> [--assets DIR]")?, assets))
+}
+#[cfg(not(target_arch = "wasm32"))]
+async fn run(wasm: std::path::PathBuf, assets: Option<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:#}"))?;
+    loop {
+        let dt = macroquad::time::get_frame_time();
+        game.update(dt).map_err(|e| format!("update: {e:#}"))?;
+        game.draw().map_err(|e| format!("draw: {e:#}"))?;
+        macroquad::window::next_frame().await;
+    }
+}
+#[cfg(not(target_arch = "wasm32"))]
+#[macroquad::main(window_conf)]
+async fn main() {
+    let (wasm, assets) = match parse_args() {
+        Ok(a) => a,
+        Err(e) => {
+            eprintln!("{e}");
+            std::process::exit(2);
+        }
+    };
+    if let Err(e) = run(wasm, assets).await {
+        eprintln!("{e}");
+        std::process::exit(1);
+    }
+}
+#[cfg(target_arch = "wasm32")]
+fn main() {}

plum-game/src/mq.rs ADDED Viewed

@@ -0,0 +1,240 @@
+//! The macroquad `Backend`. The camera set by `setCamera` is applied by hand
+//! (`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 macroquad::prelude as mq;
+use std::path::PathBuf;
+/// Maps the Design's GLFW key numbers to macroquad key codes.
+pub fn key_code(k: i32) -> Option<mq::KeyCode> {
+    use mq::KeyCode as K;
+    const LETTERS: [K; 26] = [
+        K::A, K::B, K::C, K::D, K::E, K::F, K::G, K::H, K::I, K::J, K::K, K::L, K::M,
+        K::N, K::O, K::P, K::Q, K::R, K::S, K::T, K::U, K::V, K::W, K::X, K::Y, K::Z,
+    ];
+    const DIGITS: [K; 10] = [K::Key0, K::Key1, K::Key2, K::Key3, K::Key4, K::Key5, K::Key6, K::Key7, K::Key8, K::Key9];
+    Some(match k {
+        32 => K::Space,
+        65..=90 => LETTERS[(k - 65) as usize],
+        48..=57 => DIGITS[(k - 48) as usize],
+        256 => K::Escape,
+        257 => K::Enter,
+        258 => K::Tab,
+        259 => K::Backspace,
+        262 => K::Right,
+        263 => K::Left,
+        264 => K::Down,
+        265 => K::Up,
+        340 => K::LeftShift,
+        341 => K::LeftControl,
+        _ => return None,
+    })
+}
+pub fn mouse_button(b: i32) -> Option<mq::MouseButton> {
+    match b {
+        0 => Some(mq::MouseButton::Left),
+        1 => Some(mq::MouseButton::Right),
+        2 => Some(mq::MouseButton::Middle),
+        _ => None,
+    }
+}
+fn col(c: Color) -> mq::Color {
+    mq::Color::new(c[0], c[1], c[2], c[3])
+}
+pub struct MqBackend {
+    assets: AssetStore,
+    /// Lazily uploaded textures, `[atlas][sprite]`.
+    textures: Vec<Vec<Option<mq::Texture2D>>>,
+    cam: (f32, f32, f32),
+}
+impl MqBackend {
+    pub fn new(assets: Option<PathBuf>) -> Self {
+        MqBackend { assets: AssetStore::new(assets), 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].get(i)?.clone()
+    }
+}
+impl Backend for MqBackend {
+    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));
+    }
+    /// `(x, y)` is the text's top-left corner.
+    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 {
+        self.assets.atlas_load(name)
+    }
+    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)
+    }
+    /// One notch per frame with scrolling, signed: positive is up.
+    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 {
+        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)]
+mod tests {
+    use super::*;
+    use macroquad::prelude::KeyCode as K;
+    #[test]
+    fn keys_map_to_the_design_numbers() {
+        assert_eq!(key_code(32), Some(K::Space));
+        assert_eq!(key_code(65), Some(K::A));
+        assert_eq!(key_code(87), Some(K::W));
+        assert_eq!(key_code(90), Some(K::Z));
+        assert_eq!(key_code(48), Some(K::Key0));
+        assert_eq!(key_code(57), Some(K::Key9));
+        assert_eq!(key_code(256), Some(K::Escape));
+        assert_eq!(key_code(257), Some(K::Enter));
+        assert_eq!(key_code(258), Some(K::Tab));
+        assert_eq!(key_code(259), Some(K::Backspace));
+        assert_eq!(key_code(262), Some(K::Right));
+        assert_eq!(key_code(263), Some(K::Left));
+        assert_eq!(key_code(264), Some(K::Down));
+        assert_eq!(key_code(265), Some(K::Up));
+        assert_eq!(key_code(340), Some(K::LeftShift));
+        assert_eq!(key_code(341), Some(K::LeftControl));
+        assert_eq!(key_code(1), None);
+    }
+    #[test]
+    fn mouse_buttons() {
+        assert_eq!(mouse_button(0), Some(mq::MouseButton::Left));
+        assert_eq!(mouse_button(1), Some(mq::MouseButton::Right));
+        assert_eq!(mouse_button(2), Some(mq::MouseButton::Middle));
+        assert_eq!(mouse_button(3), None);
+    }
+}

plum-game/src/native.rs ADDED Viewed

@@ -0,0 +1,195 @@
+//! Runs a compiled Plum game module under wasmtime, binding every `plum`
+//! import to a [`Backend`].
+use crate::api::{Backend, Color};
+use wasmtime::{AnyRef, Caller, Engine, Func, Instance, Linker, Module, OwnedRooted, Rooted, Store, Val};
+pub use wasmtime::Result;
+struct HostState<B> {
+    backend: B,
+}
+pub struct PlumGame<B: Backend> {
+    store: Store<HostState<B>>,
+    instance: Instance,
+    /// The `init` result, rooted across frames.
+    state: Option<OwnedRooted<AnyRef>>,
+}
+fn f(p: &[Val], i: usize) -> f32 {
+    match p[i] {
+        Val::F64(bits) => f64::from_bits(bits) as f32,
+        _ => 0.0,
+    }
+}
+fn int(p: &[Val], i: usize) -> i32 {
+    match p[i] {
+        Val::I32(v) => v,
+        _ => 0,
+    }
+}
+fn color(p: &[Val], i: usize) -> Color {
+    [f(p, i), f(p, i + 1), f(p, i + 2), f(p, i + 3)]
+}
+fn fv(v: f32) -> Val {
+    Val::F64((v as f64).to_bits())
+}
+/// Reads the bytes of a Plum `Str` (a struct of `data`, `start`, `len`).
+fn str_bytes(store: &mut impl wasmtime::AsContextMut, s: &Rooted<AnyRef>) -> Result<Vec<u8>> {
+    let st = s.unwrap_struct(&*store)?;
+    let Val::AnyRef(Some(data)) = st.field(&mut *store, 0)? else {
+        return Err(wasmtime::Error::msg("Str.data is not a byte array"));
+    };
+    let start = st.field(&mut *store, 1)?.unwrap_i64() as usize;
+    let len = st.field(&mut *store, 2)?.unwrap_i64() as usize;
+    let arr = data.unwrap_array(&*store)?;
+    let mut buf = vec![0u8; arr.len(&*store)? as usize];
+    arr.copy_to_i8_slice(&mut *store, &mut buf)?;
+    buf.get(start..start + len).map(|b| b.to_vec()).ok_or_else(|| wasmtime::Error::msg("Str view out of range"))
+}
+fn str_arg<B: Backend>(caller: &mut Caller<'_, HostState<B>>, p: &[Val], i: usize) -> Result<String> {
+    let Val::AnyRef(Some(s)) = &p[i] else {
+        return Err(wasmtime::Error::msg("expected a Str argument"));
+    };
+    Ok(String::from_utf8_lossy(&str_bytes(caller, s)?).into_owned())
+}
+/// 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 {
+        () => {
+            caller.data_mut().backend
+        };
+    }
+    match name {
+        "printLn" => println!("{}", str_arg(caller, p, 0)?),
+        "crash" => return Err(wasmtime::Error::msg(format!("crash: {}", str_arg(caller, p, 0)?))),
+        "screenWidth" => r[0] = fv(b!().screen_width()),
+        "screenHeight" => r[0] = fv(b!().screen_height()),
+        "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)),
+        "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)?;
+            b!().draw_text(&s, f(p, 1), f(p, 2), f(p, 3), color(p, 4));
+        }
+        "setCamera" => b!().set_camera(f(p, 0), f(p, 1), f(p, 2)),
+        "resetCamera" => b!().reset_camera(),
+        "atlasLoad" => {
+            let s = str_arg(caller, p, 0)?;
+            r[0] = Val::I32(b!().atlas_load(&s));
+        }
+        "spriteCount" => r[0] = Val::I32(b!().sprite_count(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))),
+        "spritePivotY" => r[0] = Val::I32(b!().sprite_pivot_y(int(p, 0), int(p, 1))),
+        "spriteColor" => {
+            let c = b!().sprite_color(int(p, 0), int(p, 1));
+            for (i, v) in c.into_iter().enumerate() {
+                r[i] = fv(v);
+            }
+        }
+        "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" => {
+            let (x, y) = b!().mouse_pos();
+            r[0] = fv(x);
+            r[1] = fv(y);
+        }
+        "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(())
+}
+impl<B: Backend> PlumGame<B> {
+    /// Instantiates `wasm`, requiring `init`, `update` and `draw` exports.
+    pub fn load(wasm: &[u8], backend: B) -> Result<Self> {
+        let mut config = wasmtime::Config::new();
+        config.wasm_gc(true);
+        config.wasm_function_references(true);
+        let engine = Engine::new(&config)?;
+        let module = Module::new(&engine, wasm)?;
+        for name in ["init", "update", "draw"] {
+            if module.get_export(name).is_none() {
+                return Err(wasmtime::Error::msg(format!("module has no `{name}` export")));
+            }
+        }
+        let mut store = Store::new(&engine, HostState { backend });
+        let mut linker: Linker<HostState<B>> = Linker::new(&engine);
+        for imp in module.imports() {
+            let Some(ty) = imp.ty().func().cloned() else { continue };
+            let name = imp.name().to_string();
+            let func = Func::new(&mut store, ty, {
+                let name = name.clone();
+                move |mut caller, p, r| dispatch(&name, &mut caller, p, r)
+            });
+            linker.define(&store, imp.module(), imp.name(), func)?;
+        }
+        let instance = linker.instantiate(&mut store, &module)?;
+        Ok(PlumGame { store, instance, state: None })
+    }
+    pub fn backend(&self) -> &B {
+        &self.store.data().backend
+    }
+    pub fn backend_mut(&mut self) -> &mut B {
+        &mut self.store.data_mut().backend
+    }
+    fn func(&mut self, name: &str) -> Result<Func> {
+        self.instance.get_func(&mut self.store, name).ok_or_else(|| wasmtime::Error::msg(format!("module has no `{name}` export")))
+    }
+    /// Calls `init` and keeps its result as the game state.
+    pub fn init(&mut self) -> Result<()> {
+        let init = self.func("init")?;
+        let mut out = [Val::AnyRef(None)];
+        init.call(&mut self.store, &[], &mut out)?;
+        let Val::AnyRef(Some(g)) = &out[0] else {
+            return Err(wasmtime::Error::msg("`init` returned no state"));
+        };
+        self.state = Some(g.to_owned_rooted(&mut self.store)?);
+        Ok(())
+    }
+    fn state_val(&mut self) -> Result<Val> {
+        let s = self.state.as_ref().ok_or_else(|| wasmtime::Error::msg("`init` has not run"))?;
+        Ok(Val::AnyRef(Some(s.to_rooted(&mut self.store))))
+    }
+    pub fn update(&mut self, dt: f32) -> Result<()> {
+        let update = self.func("update")?;
+        let g = self.state_val()?;
+        update.call(&mut self.store, &[g, fv(dt)], &mut [])
+    }
+    pub fn draw(&mut self) -> Result<()> {
+        let draw = self.func("draw")?;
+        let g = self.state_val()?;
+        draw.call(&mut self.store, &[g], &mut [])
+    }
+}

plum-game/src/recorder.rs ADDED Viewed

@@ -0,0 +1,173 @@
+//! A `Backend` that records every call as a string and answers input queries
+//! from scripted values. Asset calls go through a real `AssetStore`.
+use crate::api::{AssetStore, Backend, Color};
+use std::collections::HashSet;
+use std::path::PathBuf;
+pub struct Recorder {
+    pub calls: Vec<String>,
+    pub screen: (f32, f32),
+    pub frame_time: f32,
+    pub mouse: (f32, f32),
+    pub wheel: f32,
+    pub keys_down: HashSet<i32>,
+    pub keys_pressed: HashSet<i32>,
+    pub mouse_down: HashSet<i32>,
+    pub mouse_pressed: HashSet<i32>,
+    pub assets: AssetStore,
+}
+fn c4(c: Color) -> String {
+    format!("{},{},{},{}", c[0], c[1], c[2], c[3])
+}
+impl Recorder {
+    pub fn new() -> Self {
+        Self::with_assets(None)
+    }
+    pub fn with_assets(root: Option<PathBuf>) -> Self {
+        Recorder {
+            calls: Vec::new(),
+            screen: (800.0, 600.0),
+            frame_time: 1.0 / 60.0,
+            mouse: (0.0, 0.0),
+            wheel: 0.0,
+            keys_down: HashSet::new(),
+            keys_pressed: HashSet::new(),
+            mouse_down: HashSet::new(),
+            mouse_pressed: HashSet::new(),
+            assets: AssetStore::new(root),
+        }
+    }
+    fn rec(&mut self, s: String) {
+        self.calls.push(s);
+    }
+}
+impl Default for Recorder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl Backend for Recorder {
+    fn screen_width(&mut self) -> f32 {
+        self.rec("screenWidth()".into());
+        self.screen.0
+    }
+    fn screen_height(&mut self) -> f32 {
+        self.rec("screenHeight()".into());
+        self.screen.1
+    }
+    fn frame_time(&mut self) -> f32 {
+        self.rec("frameTime()".into());
+        self.frame_time
+    }
+    fn clear(&mut self, c: Color) {
+        self.rec(format!("clear({})", c4(c)));
+    }
+    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_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)));
+    }
+    fn draw_text(&mut self, s: &str, x: f32, y: f32, size: f32, c: Color) {
+        self.rec(format!("drawText({s:?},{x},{y},{size},{})", c4(c)));
+    }
+    fn set_camera(&mut self, x: f32, y: f32, scale: f32) {
+        self.rec(format!("setCamera({x},{y},{scale})"));
+    }
+    fn reset_camera(&mut self) {
+        self.rec("resetCamera()".into());
+    }
+    fn atlas_load(&mut self, name: &str) -> i32 {
+        self.rec(format!("atlasLoad({name:?})"));
+        self.assets.atlas_load(name)
+    }
+    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 {
+        self.rec(format!("spriteW({a},{i})"));
+        self.assets.sprite_w(a, i)
+    }
+    fn sprite_h(&mut self, a: i32, i: i32) -> i32 {
+        self.rec(format!("spriteH({a},{i})"));
+        self.assets.sprite_h(a, i)
+    }
+    fn sprite_pivot_x(&mut self, a: i32, i: i32) -> i32 {
+        self.rec(format!("spritePivotX({a},{i})"));
+        self.assets.sprite_pivot_x(a, i)
+    }
+    fn sprite_pivot_y(&mut self, a: i32, i: i32) -> i32 {
+        self.rec(format!("spritePivotY({a},{i})"));
+        self.assets.sprite_pivot_y(a, i)
+    }
+    fn sprite_color(&mut self, a: i32, i: i32) -> Color {
+        self.rec(format!("spriteColor({a},{i})"));
+        self.assets.sprite_color(a, i)
+    }
+    fn draw_sprite(&mut self, a: i32, i: i32, x: f32, y: f32, flip_x: bool, tint: Color) {
+        self.rec(format!("drawSprite({a},{i},{x},{y},{flip_x},{})", c4(tint)));
+    }
+    fn draw_tile(&mut self, a: i32, i: i32, x: f32, y: f32, size: f32, qt: i32, tint: Color) {
+        self.rec(format!("drawTile({a},{i},{x},{y},{size},{qt},{})", c4(tint)));
+    }
+    fn is_key_down(&mut self, k: i32) -> bool {
+        self.rec(format!("isKeyDown({k})"));
+        self.keys_down.contains(&k)
+    }
+    fn is_key_pressed(&mut self, k: i32) -> bool {
+        self.rec(format!("isKeyPressed({k})"));
+        self.keys_pressed.contains(&k)
+    }
+    fn mouse_pos(&mut self) -> (f32, f32) {
+        self.rec("mousePos()".into());
+        self.mouse
+    }
+    fn is_mouse_down(&mut self, b: i32) -> bool {
+        self.rec(format!("isMouseDown({b})"));
+        self.mouse_down.contains(&b)
+    }
+    fn is_mouse_pressed(&mut self, b: i32) -> bool {
+        self.rec(format!("isMousePressed({b})"));
+        self.mouse_pressed.contains(&b)
+    }
+    fn mouse_wheel(&mut self) -> f32 {
+        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/tests/fixtures/host_fixture.plum ADDED Viewed

@@ -0,0 +1,25 @@
+module host_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
+export fun draw(g: State) =
+  clear(Color.Black)
+  drawRect(1.0, 2.0, 3.0, 4.0, Color.Red)
+  p := mousePos()
+  drawText("hi", p.x, p.y, 16.0, Color.White)
+  if g.frames > 0
+    drawText("frames {g.frames}", 0.0, 0.0, 8.0, Color.White)

plum-game/tests/host_test.rs ADDED Viewed

@@ -0,0 +1,141 @@
+#![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};
+fn root() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn compile(src_path: &Path) -> Vec<u8> {
+    let source = plum_core::loadAndMerge(src_path, &root()).expect("load");
+    let typed = plum_wasm_codegen::typeCheckIn(&source, &src_path.display().to_string()).expect("typecheck");
+    plum_wasm_codegen::compileTyped(&source, typed).expect("compile")
+}
+fn fixture() -> Vec<u8> {
+    compile(&Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/host_fixture.plum"))
+}
+fn game(rec: Recorder) -> PlumGame<Recorder> {
+    let mut g = PlumGame::load(&fixture(), rec).expect("load game");
+    g.init().expect("init");
+    g
+}
+#[test]
+fn callOrderAndArgs() {
+    let mut rec = Recorder::new();
+    rec.mouse = (5.0, 6.0);
+    let mut g = game(rec);
+    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)"]
+    );
+}
+#[test]
+fn colorFlattened() {
+    let mut g = game(Recorder::new());
+    g.draw().unwrap();
+    assert!(g.backend().calls.contains(&"drawRect(1,2,3,4,1,0,0,1)".to_string()));
+}
+#[test]
+fn mousePosMultiValue() {
+    let mut rec = Recorder::new();
+    rec.mouse = (12.5, -3.0);
+    let mut g = game(rec);
+    g.draw().unwrap();
+    assert_eq!(g.backend().calls.last().unwrap(), "drawText(\"hi\",12.5,-3,16,1,1,1,1)");
+}
+#[test]
+fn stateSurvivesFrames() {
+    let mut g = game(Recorder::new());
+    for _ in 0..3 {
+        g.update(0.016).unwrap();
+    }
+    g.draw().unwrap();
+    assert_eq!(g.backend().calls.last().unwrap(), "drawText(\"frames 3\",0,0,8,1,1,1,1)");
+    g.update(0.016).unwrap();
+    g.backend_mut().calls.clear();
+    g.draw().unwrap();
+    assert_eq!(g.backend().calls.last().unwrap(), "drawText(\"frames 4\",0,0,8,1,1,1,1)");
+}
+#[test]
+fn missingExportErrors() {
+    let dir = std::env::temp_dir().join(format!("plum_game_missing_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("m.plum");
+    std::fs::write(
+        &path,
+        "import std/Int\nimport std/Float\nrecord State(n: Int)\n\nexport fun init() -> State =\n  State(n: 0)\nexport fun update(g: State, dt: Float) =\n  g.n = 1\n",
+    )
+    .unwrap();
+    let wasm = compile(&path);
+    let _ = std::fs::remove_dir_all(&dir);
+    let err = PlumGame::load(&wasm, Recorder::new()).err().expect("should fail");
+    assert!(err.to_string().contains("`draw`"), "{err}");
+}
+#[test]
+fn unknownImportTraps() {
+    let dir = std::env::temp_dir().join(format!("plum_game_unknown_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("m.plum");
+    std::fs::write(
+        &path,
+        "import std/Int\nimport std/Float\nimport std/Str\nimport std/Os\nrecord State(n: Int)\n\nexport fun init() -> State =\n  State(n: 0)\nexport fun update(g: State, dt: Float) =\n  g.n = 1\nexport fun draw(g: State) =\n  x := rawExists(\"a\")\n",
+    )
+    .unwrap();
+    let wasm = compile(&path);
+    let _ = std::fs::remove_dir_all(&dir);
+    let mut g = PlumGame::load(&wasm, Recorder::new()).unwrap();
+    g.init().unwrap();
+    let err = g.draw().unwrap_err();
+    assert!(format!("{err:?}").contains("is not available here"), "{err:?}");
+}
+#[test]
+fn quarterTurnsRotateClockwise() {
+    use std::f32::consts::FRAC_PI_2;
+    assert_eq!(quarter_turns_radians(0), 0.0);
+    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);
+    assert_eq!(quarter_turns_radians(-1), 3.0 * FRAC_PI_2);
+}
+#[test]
+fn intHandlesFailWithMinusOne() {
+    use plum_game::api::Backend;
+    let mut rec = Recorder::with_assets(Some(PathBuf::from("/nonexistent-assets")));
+    assert_eq!(rec.atlas_load("Tileset"), -1);
+    assert_eq!(rec.map_load("x.map"), -1);
+    assert_eq!(rec.sprite_w(5, 5), 0);
+    assert_eq!(rec.map_terrain(-1, 0, 0), 0);
+}
+#[test]
+fn atlasAndMapThroughHost() {
+    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 a = rec.atlas_load("Tileset");
+    assert_eq!(a, 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!((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);
+}