Rune support (#99)

* Add support for Rune

Adds initial functionality neccesary to support the Rune programming language. Specifically, it adds a `ScriptHost` implementation along with a few supporting data structures.

* Add minimal Rune example

* Add Rune event recipient example

* Cleanup

* Cache Vm

* Update CI

---------

Co-authored-by: Luke Van Wingerden <=>

Author: baby-steve

.github/workflows/ci.yml

@@ -41,14 +41,14 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --workspace --features=${{ matrix.run_args.lua }},rhai,teal,lua_script_api,rhai_script_api
+          args: --workspace --features=${{ matrix.run_args.lua }},rhai,teal,lua_script_api,rhai_script_api,rune
       # for non x86 cross-compiled builds
       - if: matrix.run_args.cross != null
         uses: houseabsolute/actions-rust-cross@v0
         with:
           command: check
           target: ${{ matrix.run_args.cross }}
-          args: --workspace --features=${{ matrix.run_args.lua }},rhai,teal,lua_script_api,rhai_script_api --profile=ephemeral-build
+          args: --workspace --features=${{ matrix.run_args.lua }},rhai,teal,lua_script_api,rhai_script_api,rune --profile=ephemeral-build
 
   fmt:
     name: Rustfmt
@@ -87,7 +87,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: clippy
-          args: --features=lua54,rhai,teal,lua_script_api,rhai_script_api --profile=ephemeral-build -- -D warnings 
+          args: --features=lua54,rhai,teal,lua_script_api,rhai_script_api,rune --profile=ephemeral-build -- -D warnings 
   tests:
     name: Tests
     runs-on: ubuntu-latest
@@ -116,7 +116,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --workspace --features=lua54,rhai,teal,lua_script_api,rhai_script_api --profile=ephemeral-build
+          args: --workspace --features=lua54,rhai,teal,lua_script_api,rhai_script_api,rune --profile=ephemeral-build
   docs:
     name: Docs
     runs-on: ubuntu-latest

Cargo.toml

@@ -21,14 +21,15 @@ name = "bevy_mod_scripting"
 path = "src/lib.rs"
 
 [package.metadata."docs.rs"]
-features = ["lua", "lua54", "rhai", "lua_script_api", "rhai_script_api", "teal"]
+features = ["lua", "lua54", "rhai", "lua_script_api", "rhai_script_api", "teal", "rune"]
 
 [package.metadata.release]
 pre-release-replacements = [
     { file = "Cargo.toml", search = '^version\s*=\s*.*$', replace = "version = \"{{version}}\"", exactly = 1 },
     { file = "Cargo.toml", search = '^(?P<h>bevy_mod_scripting_core\s*=.*)version\s*=\s*".*"(?P<t>.*)$', replace = "${h}version = \"{{version}}\"${t}", exactly = 1 },
     { file = "Cargo.toml", search = '^(?P<h>bevy_mod_scripting_lua\s*=.*)version\s*=\s*".*"(?P<t>.*)$', replace = "${h}version = \"{{version}}\"${t}", exactly = 1 },
     { file = "Cargo.toml", search = '^(?P<h>bevy_mod_scripting_rhai\s*=.*)version\s*=\s*".*"(?P<t>.*)$', replace = "${h}version = \"{{version}}\"${t}", exactly = 1 },
+    { file = "Cargo.toml", search = '^(?P<h>bevy_mod_scripting_rune\s*=.*)version\s*=\s*".*"(?P<t>.*)$', replace = "${h}version = \"{{version}}\"${t}", exactly = 1 },
     { file = "Cargo.toml", search = '^(?P<h>bevy_script_api\s*=.*)version\s*=\s*".*"(?P<t>.*)$', replace = "${h}version = \"{{version}}\"${t}", exactly = 1 },
 ]
 
@@ -58,11 +59,15 @@ mlua_async = ["bevy_mod_scripting_lua/mlua_async"]
 rhai = ["bevy_mod_scripting_rhai"]
 rhai_script_api = ["bevy_script_api/rhai"]
 
+## rune
+rune = ["bevy_mod_scripting_rune"]
+
 [dependencies]
 bevy = { version = "0.11", default-features = false }
 bevy_mod_scripting_core = { path = "bevy_mod_scripting_core", version = "0.3.0" }
 bevy_mod_scripting_lua = { path = "languages/bevy_mod_scripting_lua", version = "0.3.0", optional = true }
 bevy_mod_scripting_rhai = { path = "languages/bevy_mod_scripting_rhai", version = "0.3.0", optional = true }
+bevy_mod_scripting_rune = { path = "languages/bevy_mod_scripting_rune", version = "0.3.0", optional = true }
 bevy_script_api = { path = "bevy_script_api", version = "0.3.0", optional = true }
 
 [dev-dependencies]
@@ -84,6 +89,7 @@ members = [
     "languages/bevy_mod_scripting_lua_derive",
     "languages/bevy_mod_scripting_rhai",
     "languages/bevy_mod_scripting_rhai_derive",
+    "languages/bevy_mod_scripting_rune",
     "bevy_mod_scripting_common",
 ]
 
@@ -139,7 +145,6 @@ name = "documentation_gen_lua"
 path = "examples/lua/documentation_gen.rs"
 required-features = ["lua54", "teal", "lua_script_api"]
 
-
 [[example]]
 name = "bevy_api_lua"
 path = "examples/lua/bevy_api.rs"
@@ -159,3 +164,13 @@ required-features = ["rhai", "rhai_script_api"]
 name = "wrappers"
 path = "examples/wrappers.rs"
 required-features = ["lua54", "lua_script_api"]
+
+[[example]]
+name = "minimal_rune"
+path = "examples/rune/minimal.rs"
+required-features = ["rune"]
+
+[[example]]
+name = "event_recipients_rune"
+path = "examples/rune/event_recipients.rs"
+required-features = ["rune"]

assets/scripts/event_recipients.rune

@@ -0,0 +1,3 @@
+pub fn on_event(id) {
+    info(`id: ${id}`);
+}

assets/scripts/minimal.rune

@@ -0,0 +1,3 @@
+pub fn on_event() {
+    print_fancy("Hello, World!");
+}

examples/rune/event_recipients.rs

@@ -0,0 +1,124 @@
+use bevy::asset::ChangeWatcher;
+use bevy::prelude::*;
+use bevy_mod_scripting::prelude::*;
+use rand::prelude::SliceRandom;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering::Relaxed;
+use std::time::Duration;
+
+#[derive(Clone)]
+pub struct MyRuneArg(usize);
+
+impl Args for MyRuneArg {
+    fn into_stack(self, stack: &mut rune::runtime::Stack) -> rune::runtime::VmResult<()> {
+        (self.0,).into_stack(stack)
+    }
+
+    fn try_into_vec(self) -> rune::runtime::VmResult<rune::alloc::Vec<rune::Value>> {
+        (self.0,).try_into_vec()
+    }
+
+    fn count(&self) -> usize {
+        1
+    }
+}
+
+/// A custom Rune API.
+#[derive(Default)]
+pub struct RuneAPIProvider;
+
+impl APIProvider for RuneAPIProvider {
+    type APITarget = Context;
+    type DocTarget = RuneDocFragment;
+    type ScriptContext = RuneScriptContext;
+
+    fn attach_api(&mut self, ctx: &mut Self::APITarget) -> Result<(), ScriptError> {
+        let mut module = rune::Module::new();
+
+        module
+            .function("info", |msg: String| info!("{msg}"))
+            .build()
+            .map_err(ScriptError::new_other)?;
+
+        ctx.install(module).map_err(ScriptError::new_other)?;
+
+        Ok(())
+    }
+}
+
+static COUNTER: AtomicU32 = AtomicU32::new(0);
+
+/// Utility for generating random events from a list.
+fn fire_random_event(
+    w: &mut PriorityEventWriter<RuneEvent<MyRuneArg>>,
+    events: &[ScriptEventData],
+) {
+    let mut rng = rand::thread_rng();
+    let id = COUNTER.fetch_add(1, Relaxed);
+    let arg = MyRuneArg(id as usize);
+    let event = events
+        .choose(&mut rng)
+        .map(|v| RuneEvent {
+            hook_name: v.0.to_string(),
+            args: arg,
+            recipients: v.1.clone(),
+        })
+        .unwrap();
+
+    info!(
+        "\t - event: {},\t recipients: {:?},\t id: {}",
+        event.hook_name, event.recipients, id
+    );
+    w.send(event, 0);
+}
+
+fn do_update(mut w: PriorityEventWriter<RuneEvent<MyRuneArg>>) {
+    info!("Update, firing:");
+
+    let all_events = [
+        ScriptEventData("on_event", Recipients::All),
+        ScriptEventData("on_event", Recipients::ScriptID(0)),
+        ScriptEventData("on_event", Recipients::ScriptID(1)),
+        ScriptEventData(
+            "on_event",
+            Recipients::ScriptName("scripts/event_recipients.rune".to_owned()),
+        ),
+    ];
+
+    // fire random event, for any of the system sets
+    fire_random_event(&mut w, &all_events);
+}
+
+#[derive(Clone)]
+pub struct ScriptEventData(&'static str, Recipients);
+
+fn load_scripts(server: Res<AssetServer>, mut commands: Commands) {
+    // Spawn two identical scripts.
+    // Their id's will be 0 and 1.
+    let path = "scripts/event_recipients.rune";
+    let handle = server.load::<RuneFile, &str>(path);
+    let scripts = (0..2)
+        .map(|_| Script::<RuneFile>::new(path.to_string(), handle.clone()))
+        .collect();
+
+    commands
+        .spawn(())
+        .insert(ScriptCollection::<RuneFile> { scripts });
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(AssetPlugin {
+            watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+            ..Default::default()
+        }))
+        .add_plugins(ScriptingPlugin)
+        .add_systems(Startup, load_scripts)
+        // Randomly fire events for either all scripts, the script with an id of `0`,
+        // or the script with an id of `1`.
+        .add_systems(Update, do_update)
+        .add_script_handler::<RuneScriptHost<MyRuneArg>, 0, 0>(PostUpdate)
+        .add_script_host::<RuneScriptHost<MyRuneArg>>(PostUpdate)
+        .add_api_provider::<RuneScriptHost<MyRuneArg>>(Box::new(RuneAPIProvider))
+        .run()
+}

examples/rune/minimal.rs

@@ -0,0 +1,57 @@
+use bevy::prelude::*;
+use bevy_mod_scripting::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(ScriptingPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(Update, update)
+        .add_script_host::<RuneScriptHost<()>>(PostUpdate)
+        .add_script_handler::<RuneScriptHost<()>, 0, 1>(PostUpdate)
+        .add_api_provider::<RuneScriptHost<()>>(Box::new(MyAPIProvider))
+        .run()
+}
+
+struct MyAPIProvider;
+
+impl APIProvider for MyAPIProvider {
+    type APITarget = Context;
+    type ScriptContext = RuneScriptContext;
+    type DocTarget = RuneDocFragment;
+
+    fn attach_api(&mut self, api: &mut Self::APITarget) -> Result<(), ScriptError> {
+        let mut module = rune::Module::new();
+
+        module
+            .function("print_fancy", |msg: &str| println!("✨ {msg} ✨"))
+            .build()
+            .map_err(ScriptError::new_other)?;
+
+        api.install(module).map_err(ScriptError::new_other)?;
+
+        Ok(())
+    }
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    let script_path = "scripts/minimal.rune";
+
+    commands.spawn(ScriptCollection::<RuneFile> {
+        scripts: vec![Script::new(
+            script_path.to_owned(),
+            asset_server.load(script_path),
+        )],
+    });
+}
+
+fn update(mut events: PriorityEventWriter<RuneEvent<()>>) {
+    events.send(
+        RuneEvent {
+            hook_name: "on_event".into(),
+            args: (),
+            recipients: Recipients::All,
+        },
+        0,
+    );
+}

languages/bevy_mod_scripting_rune/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "bevy_mod_scripting_rune"
+version = "0.3.0"
+edition = "2021"
+license = "MIT"
+description = "Necessary functionality for Rune support with bevy_mod_scripting"
+repository = "https://github.com/makspll/bevy_mod_scripting"
+homepage = "https://github.com/makspll/bevy_mod_scripting"
+keywords = ["bevy", "gamedev", "scripting", "rune"]
+categories = ["game-development"]
+readme = "readme.md"
+
+[package.metadata.release]
+pre-release-replacements = [
+    { file = "Cargo.toml", search = '^version\s*=\s*.*$', replace = "version = \"{{version}}\"", exactly = 1 },
+    { file = "Cargo.toml", search = '^(?P<h>bevy_mod_scripting_core\s*=.*)version\s*=\s*".*"(?P<t>.*)$', replace = "${h}version = \"{{version}}\"${t}", exactly = 1 },
+]
+
+[lib]
+name = "bevy_mod_scripting_rune"
+path = "src/lib.rs"
+
+[dependencies]
+bevy_mod_scripting_core = { path = "../../bevy_mod_scripting_core", version = "0.3.0" }
+bevy = "0.11"
+rune = "0.13.1"
+rune-modules = "0.13.1"

languages/bevy_mod_scripting_rune/readme.md

@@ -0,0 +1,3 @@
+# bevy_mod_scripting_rune
+
+This crate is a part of the ["bevy_mod_scripting" workspace](https://github.com/makspll/bevy_mod_scripting).

languages/bevy_mod_scripting_rune/src/assests.rs

@@ -0,0 +1,44 @@
+use bevy::{
+    asset::{AssetLoader, LoadedAsset},
+    reflect::{TypePath, TypeUuid},
+};
+use bevy_mod_scripting_core::prelude::*;
+use std::sync::Arc;
+
+#[derive(Debug, TypeUuid, TypePath)]
+#[uuid = "e4f7d00d-5acd-45fb-a29c-6472718771fc"]
+/// A loaded rune file in bytes.
+pub struct RuneFile {
+    /// File content in bytes.
+    pub bytes: Arc<[u8]>,
+}
+
+impl CodeAsset for RuneFile {
+    fn bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+
+#[derive(Default)]
+/// Enables loading Rune scripts from `.rune` and `.rn` files.
+pub struct RuneLoader;
+
+impl AssetLoader for RuneLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut bevy::asset::LoadContext,
+    ) -> bevy::utils::BoxedFuture<'a, Result<(), bevy::asset::Error>> {
+        Box::pin(async move {
+            load_context.set_default_asset(LoadedAsset::new(RuneFile {
+                bytes: bytes.into(),
+            }));
+
+            Ok(())
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["rune", "rn"]
+    }
+}

languages/bevy_mod_scripting_rune/src/docs.rs

@@ -0,0 +1,17 @@
+use bevy_mod_scripting_core::prelude::*;
+
+pub struct RuneDocFragment;
+
+impl DocFragment for RuneDocFragment {
+    fn merge(self, _o: Self) -> Self {
+        todo!()
+    }
+
+    fn gen_docs(self) -> Result<(), ScriptError> {
+        todo!()
+    }
+
+    fn name(&self) -> &'static str {
+        todo!()
+    }
+}