Create a script system

1 files changed, 318 insertions, 0 deletions

diff --git a/scripts/src/lib.rs b/scripts/src/lib.rs
new file mode 100644
index 0000000..214001c
--- /dev/null
+++ b/scripts/src/lib.rs
@@ -0,0 +1,318 @@
+use std::{collections::HashMap, path::Path};
+
+pub use vtable::VTableScript;
+use wasmtime::{Engine, IntoFunc, Linker, Module, Store};
+
+pub use wasm::InvalidWasmScript;
+use wasm::{WasmScript, WasmScriptState};
+
+mod libs;
+mod vtable;
+mod wasm;
+
+/// A sturcture to contain and use any needed scripts.
+///
+/// # Performance
+///
+/// V-Table scripts are faster than WebAssembly scripts. WebAssembly scripting
+/// is provided to make hot-reloading possible. Either way, scripts should be
+/// reasonably fast.
+///
+/// A single long WebAssembly script is typically faster than lots of small
+/// scripts. Try to keep the number of scripts small. No more than twenty
+/// scripts should be enabled at once.
+#[derive(Default)]
+pub struct ScriptManager {
+	script_map: HashMap<Box<str>, ScriptId>,
+
+	vtable_scripts: Vec<Script<VTableScript>>,
+	wasm_scripts: Vec<Script<WasmScript>>,
+
+	relink_every_frame: bool,
+	wasm_engine: Engine,
+	wasm_imports: Linker<WasmScriptState>,
+}
+
+impl ScriptManager {
+	/// Creates a new, empty script manager
+	pub fn new() -> Self {
+		let wasm_engine = Engine::default();
+		let mut wasm_imports = Linker::new(&wasm_engine);
+		wasm_imports.allow_shadowing(true);
+
+		let mut this = Self {
+			script_map: HashMap::new(),
+			vtable_scripts: Vec::new(),
+			wasm_scripts: Vec::new(),
+			relink_every_frame: false,
+			wasm_imports,
+			wasm_engine,
+		};
+		libs::add_alligator_library(&mut this);
+
+		this
+	}
+
+	/// If set to `true`, then every frame, the scripts will be relinked with
+	/// it's dependencies on each call.
+	///
+	/// The main reason to do this would be to ensure that the state is reset
+	/// each frame. However, the link is slow, so it's not recommended to use
+	/// this setting for releasing a game. This is only recommended for
+	/// debugging.
+	pub fn set_relink_every_frame(&mut self, setting: bool) {
+		self.relink_every_frame = setting;
+	}
+
+	/// Returns `true` if the scripts are set to be relinked each frame. See
+	/// [`set_relink_every_frame`] for more details.
+	pub fn relink_every_frame(&self) -> bool {
+		self.relink_every_frame
+	}
+
+	/// Adds a script to this manager.
+	///
+	/// By  default, all scripts are disabled. To enable it, call
+	/// [`enable_script`].
+	pub fn add_vtable_script(&mut self, name: Box<str>, script: VTableScript) -> ScriptId {
+		let idx = self.vtable_scripts.len();
+		self.vtable_scripts.push(Script::new(script));
+		let id = ScriptId {
+			kind: ScriptKind::VTable,
+			idx,
+		};
+		self.script_map.insert(name, id);
+		id
+	}
+
+	/// Adds a WebAssembly script to this manager.
+	///
+	/// By  default, all scripts are disabled. To enable it, call
+	/// [`enable_script`].
+	///
+	/// # Errors
+	///
+	/// This function returns an error if it could not use the given script.
+	pub fn add_wasm_script(
+		&mut self,
+		name: Box<str>,
+		path: impl AsRef<Path>,
+		trusted: bool,
+	) -> Result<ScriptId, InvalidWasmScript> {
+		let idx = self.vtable_scripts.len();
+		let script = WasmScript::new(
+			path.as_ref(),
+			&self.wasm_engine,
+			&self.wasm_imports,
+			trusted,
+		)?;
+		self.wasm_scripts.push(Script::new(script));
+		let id = ScriptId {
+			kind: ScriptKind::Wasm,
+			idx,
+		};
+		self.script_map.insert(name, id);
+		Ok(id)
+	}
+
+	/// Add a WebAssembly module which can be called by other WebAssembly
+	/// scripts.
+	///
+	/// If there are two libraries with the same name, only the newest module
+	/// is used. This feature can be used to allow libraries to be hot
+	/// reloaded.
+	///
+	/// The `trusted` parameter refers to whether this library can call
+	/// functions which require trust.
+	///
+	/// # Performance
+	///
+	/// Running this function relinks all WebAssembly scripts. For best
+	/// performance, all WebAssembly libraries should be added before any
+	/// scripts are loaded.
+	pub fn add_wasm_library(
+		&mut self,
+		name: &str,
+		path: impl AsRef<Path>,
+		trusted: bool,
+	) -> Result<(), InvalidWasmScript> {
+		let module = Module::from_file(&self.wasm_engine, path)?;
+		let mut store = Store::new(&self.wasm_engine, WasmScriptState::new(trusted));
+		let instance = self.wasm_imports.instantiate(&mut store, &module)?;
+		self.wasm_imports.instance(store, name, instance)?;
+
+		for script in &mut self.wasm_scripts {
+			if let Err(e) = script.inner.relink(&self.wasm_engine, &self.wasm_imports) {
+				log::error!("{e}");
+			}
+		}
+
+		Ok(())
+	}
+
+	/// Reloads a WebAssembly script from disk.
+	pub fn reload_script(&mut self, name: &str) -> Option<Result<(), InvalidWasmScript>> {
+		let id = self.script_map.get(name).unwrap();
+		let result = match id.kind {
+			ScriptKind::Wasm => self
+				.wasm_scripts
+				.get_mut(id.idx)
+				.unwrap()
+				.inner
+				.reload(&self.wasm_engine, &self.wasm_imports),
+			_ => return None,
+		};
+		Some(result)
+	}
+
+	/// Adds a library to the manager
+	pub fn add_library_function<Params, Args>(
+		&mut self,
+		module: &str,
+		name: &str,
+		func: impl IntoFunc<WasmScriptState, Params, Args> + Clone,
+	) -> Option<()> {
+		self.wasm_imports.func_wrap(module, name, func).ok()?;
+		Some(())
+	}
+
+	/// Checks if the script with the given name is enabled
+	pub fn is_script_enabled(&self, name: &str) -> Option<bool> {
+		let id = self.script_map.get(name)?;
+		let enabled = match id.kind {
+			ScriptKind::VTable => self.vtable_scripts.get(id.idx)?.is_enabled(),
+			ScriptKind::Wasm => self.wasm_scripts.get(id.idx)?.is_enabled(),
+		};
+		Some(enabled)
+	}
+
+	/// Checks if the script with the given name is trusted
+	pub fn is_script_trusted(&self, name: &str) -> Option<bool> {
+		let id = self.script_map.get(name)?;
+		let trusted = match id.kind {
+			ScriptKind::VTable => true,
+			ScriptKind::Wasm => self.wasm_scripts.get(id.idx)?.inner.is_trusted(),
+		};
+		Some(trusted)
+	}
+
+	/// This enables the script, allowing it to run each frame.
+	///
+	/// Calling this automatically calls the `begin` function for the script.
+	pub fn enable_script(&mut self, name: &str) -> Option<()> {
+		let id = self.script_map.get(name)?;
+		match id.kind {
+			ScriptKind::VTable => {
+				let script = self.vtable_scripts.get_mut(id.idx)?;
+				if script.is_enabled() {
+					// avoid calling `begin` if the script is already enabled
+					return Some(());
+				}
+
+				script.enable();
+				script.inner.begin();
+			}
+			ScriptKind::Wasm => {
+				let script = self.wasm_scripts.get_mut(id.idx)?;
+				if script.is_enabled() {
+					return Some(());
+				}
+
+				script.enable();
+				if let Err(e) = script.inner.begin() {
+					log::error!("{}", e);
+				}
+			}
+		};
+		Some(())
+	}
+
+	/// This disables the script, preventing it from running
+	pub fn disable_script(&mut self, name: &str) -> Option<()> {
+		let id = self.script_map.get(name)?;
+		match id.kind {
+			ScriptKind::VTable => self.vtable_scripts.get_mut(id.idx)?.disable(),
+			ScriptKind::Wasm => self.wasm_scripts.get_mut(id.idx)?.disable(),
+		};
+		Some(())
+	}
+
+	/// This allows the script to run functions which require trust
+	pub fn trust_script(&mut self, name: &str) -> Option<()> {
+		let id = self.script_map.get(name)?;
+		if id.kind == ScriptKind::Wasm {
+			self.wasm_scripts.get_mut(id.idx)?.inner.trust();
+		}
+		Some(())
+	}
+
+	/// This prevents the script from running functions which require trust
+	pub fn untrust_script(&mut self, name: &str) -> Option<()> {
+		let id = self.script_map.get(name)?;
+		if id.kind == ScriptKind::Wasm {
+			self.wasm_scripts.get_mut(id.idx)?.inner.untrust();
+		}
+		Some(())
+	}
+
+	/// Runs the `update` function for all enabled scripts
+	pub fn run_update_scripts(&mut self) {
+		for script in &mut self.vtable_scripts {
+			if script.is_enabled() {
+				script.inner.update();
+			}
+		}
+
+		for script in &mut self.wasm_scripts {
+			if script.is_enabled() {
+				if self.relink_every_frame {
+					if let Err(e) = script.inner.relink(&self.wasm_engine, &self.wasm_imports) {
+						log::error!("{e}");
+					}
+				}
+				if let Err(e) = script.inner.update() {
+					log::error!("{}", e);
+				}
+			}
+		}
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum ScriptKind {
+	VTable,
+	Wasm,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ScriptId {
+	kind: ScriptKind,
+	idx: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+struct Script<S> {
+	inner: S,
+	enabled: bool,
+}
+
+impl<S> Script<S> {
+	fn new(inner: S) -> Self {
+		Self {
+			inner,
+			enabled: true,
+		}
+	}
+
+	fn is_enabled(&self) -> bool {
+		self.enabled
+	}
+
+	fn enable(&mut self) {
+		self.enabled = true;
+	}
+
+	fn disable(&mut self) {
+		self.enabled = false;
+	}
+}