v0.4.7 RBXScriptSignal + RunService

lifetime annotations hold &mut Context while scripts are runnable

.cargo/config.toml

@@ -0,0 +1,2 @@
+[registries.strafesnet]
+index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"

Cargo.lock

@@ -32,6 +32,12 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
 [[package]]
 name = "blake3"
 version = "1.5.4"
@@ -95,9 +101,9 @@ dependencies = [
 
 [[package]]
 name = "glam"
-version = "0.28.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "779ae4bf7e8421cf91c0b3b64e7e8b40b862fba4d393f59150042de7c4965a94"
+checksum = "c28091a37a5d09b555cb6628fd954da299b536433834f5b8e59eba78e0cbbf8a"
 
 [[package]]
 name = "lazy_static"
@@ -121,6 +127,16 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "lock_api"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
 [[package]]
 name = "luau0-src"
 version = "0.10.3+luau640"
@@ -138,15 +154,15 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "mlua"
-version = "0.9.9"
+version = "0.10.0-beta.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d111deb18a9c9bd33e1541309f4742523bfab01d276bfa9a27519f6de9c11dc7"
+checksum = "200dd4c8e5f81416d43a023b9921c3cbf01d828094b23a90b26826c3840ba4f3"
 dependencies = [
  "bstr",
  "libloading",
  "mlua-sys",
  "num-traits",
- "once_cell",
+ "parking_lot",
  "rustc-hash",
 ]
 
@@ -172,10 +188,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "once_cell"
+name = "parking_lot"
-version = "1.19.0"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-targets",
+]
 
 [[package]]
 name = "paste"
@@ -183,6 +216,48 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
+[[package]]
+name = "phf"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+dependencies = [
+ "siphasher",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.30"
@@ -286,7 +361,7 @@ source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
 checksum = "d7a390c44034fa448c53bd0983dfc2d70d8d6b2f65be4f164d4bec8b6a2a2d09"
 dependencies = [
  "base64",
- "bitflags",
+ "bitflags 1.3.2",
  "blake3",
  "lazy_static",
  "rand",
@@ -294,6 +369,15 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
+dependencies = [
+ "bitflags 2.6.0",
+]
+
 [[package]]
 name = "rmp"
 version = "0.8.14"
@@ -318,10 +402,11 @@ dependencies = [
 
 [[package]]
 name = "roblox_emulator"
-version = "0.1.0"
+version = "0.4.7"
 dependencies = [
  "glam",
  "mlua",
+ "phf",
  "rbx_dom_weak",
  "rbx_reflection",
  "rbx_reflection_database",
@@ -334,6 +419,12 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
 
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
 [[package]]
 name = "serde"
 version = "1.0.210"
@@ -360,6 +451,18 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
 [[package]]
 name = "syn"
 version = "2.0.77"

Cargo.toml

@@ -1,15 +1,20 @@
 [package]
 name = "roblox_emulator"
-version = "0.1.0"
+version = "0.4.7"
 edition = "2021"
 repository = "https://git.itzana.me/StrafesNET/roblox_emulator"
 license = "MIT OR Apache-2.0"
 description = "Run embedded Luau scripts which manipulate the DOM."
 authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
+[features]
+default=["run-service"]
+run-service=[]
+
 [dependencies]
-glam = "0.28.0"
+glam = "0.29.0"
-mlua = { version = "0.9.9", features = ["luau"] }
+mlua = { version = "0.10.0-beta", features = ["luau"] }
+phf = { version = "0.11.2", features = ["macros"] }
 rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
 rbx_reflection = { version = "4.7.0", registry = "strafesnet" }
 rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }

src/context.rs

@@ -1,4 +1,4 @@
-use rbx_dom_weak::{types::Ref,WeakDom};
+use rbx_dom_weak::{types::Ref,InstanceBuilder,WeakDom};
 
 pub fn class_is_a(class:&str,superclass:&str)->bool{
 	class==superclass
@@ -16,8 +16,22 @@ pub struct Context{
 }
 
 impl Context{
-	pub const fn new(dom:WeakDom)->Context{
+	pub const fn new(dom:WeakDom)->Self{
-		Context{dom}
+		Self{dom}
+	}
+	pub fn script_singleton(source:String)->(Context,crate::runner::instance::Instance,Services){
+		let script=InstanceBuilder::new("Script")
+			.with_property("Source",rbx_types::Variant::String(source));
+		let script_ref=script.referent();
+		let mut context=Self::new(WeakDom::new(
+			InstanceBuilder::new("DataModel")
+			.with_child(script)
+		));
+		let services=context.convert_into_place();
+		(context,crate::runner::instance::Instance::new(script_ref),services)
+	}
+	pub fn from_ref(dom:&WeakDom)->&Context{
+		unsafe{&*(dom as *const WeakDom as *const Context)}
 	}
 	pub fn from_mut(dom:&mut WeakDom)->&mut Context{
 		unsafe{&mut *(dom as *mut WeakDom as *mut Context)}
@@ -28,7 +42,52 @@ impl Context{
 			class_is_a(instance.class.as_ref(),superclass)
 		).map(|instance|instance.referent())
 	}
-	pub fn scripts(&self)->Vec<crate::script::Script>{
+	pub fn scripts(&self)->Vec<crate::runner::instance::Instance>{
-		self.superclass_iter("LuaSourceContainer").map(crate::script::Script::new).collect()
+		self.superclass_iter("LuaSourceContainer").map(crate::runner::instance::Instance::new).collect()
+	}
+
+	pub fn find_services(&self)->Option<Services>{
+		Some(Services{
+			workspace:*self.dom.root().children().iter().find(|&&r|
+				self.dom.get_by_ref(r).is_some_and(|instance|instance.class=="Workspace")
+			)?,
+			game:self.dom.root_ref(),
+		})
+	}
+	pub fn convert_into_place(&mut self)->Services{
+		//snapshot root instances
+		let children=self.dom.root().children().to_owned();
+
+		//insert services
+		let game=self.dom.root_ref();
+		let terrain_bldr=InstanceBuilder::new("Terrain");
+		let workspace=self.dom.insert(game,
+			InstanceBuilder::new("Workspace")
+				//Set Workspace.Terrain property equal to Terrain
+				.with_property("Terrain",terrain_bldr.referent())
+				.with_child(terrain_bldr)
+		);
+		{
+			//Lowercase and upper case workspace property!
+			let game=self.dom.root_mut();
+			game.properties.insert("workspace".to_owned(),rbx_types::Variant::Ref(workspace));
+			game.properties.insert("Workspace".to_owned(),rbx_types::Variant::Ref(workspace));
+		}
+		self.dom.insert(game,InstanceBuilder::new("Lighting"));
+
+		//transfer original root instances into workspace
+		for instance in children{
+			self.dom.transfer_within(instance,workspace);
+		}
+
+		Services{
+			game,
+			workspace,
+		}
 	}
 }
+
+pub struct Services{
+	pub game:Ref,
+	pub workspace:Ref,
+}

src/lib.rs

@@ -1,9 +1,7 @@
-pub mod script;
-pub mod context;
-
 pub mod runner;
-
+pub mod context;
-pub type Result<T>=core::result::Result<T,script::Error>;
+#[cfg(feature="run-service")]
+pub(crate) mod scheduler;
 
 #[cfg(test)]
 mod tests;

src/runner/cframe.rs

@@ -4,7 +4,22 @@ use super::vector3::Vector3;
 pub struct CFrame(pub(crate)glam::Affine3A);
 
 impl CFrame{
-	pub fn new(x:f32,y:f32,z:f32)->Self{
+	pub fn new(
+		x:f32,y:f32,z:f32,
+		xx:f32,yx:f32,zx:f32,
+		xy:f32,yy:f32,zy:f32,
+		xz:f32,yz:f32,zz:f32,
+	)->Self{
+		Self(glam::Affine3A::from_mat3_translation(
+			glam::mat3(
+				glam::vec3(xx,yx,zx),
+				glam::vec3(xy,yy,zy),
+				glam::vec3(xz,yz,zz)
+			),
+			glam::vec3(x,y,z)
+		))
+	}
+	pub fn point(x:f32,y:f32,z:f32)->Self{
 		Self(glam::Affine3A::from_translation(glam::vec3(x,y,z)))
 	}
 	pub fn angles(x:f32,y:f32,z:f32)->Self{
@@ -12,14 +27,125 @@ impl CFrame{
 	}
 }
 
+fn vec3_to_glam(v:glam::Vec3A)->rbx_types::Vector3{
+	rbx_types::Vector3::new(v.x,v.y,v.z)
+}
+fn vec3_from_glam(v:rbx_types::Vector3)->glam::Vec3A{
+	glam::vec3a(v.x,v.y,v.z)
+}
+
+impl Into<rbx_types::CFrame> for CFrame{
+	fn into(self)->rbx_types::CFrame{
+		rbx_types::CFrame::new(
+			vec3_to_glam(self.0.translation),
+			rbx_types::Matrix3::new(
+				vec3_to_glam(self.0.matrix3.x_axis),
+				vec3_to_glam(self.0.matrix3.y_axis),
+				vec3_to_glam(self.0.matrix3.z_axis),
+			)
+		)
+	}
+}
+impl From<rbx_types::CFrame> for CFrame{
+	fn from(value:rbx_types::CFrame)->Self{
+		CFrame(glam::Affine3A{
+			matrix3:glam::mat3a(
+				vec3_from_glam(value.orientation.x),
+				vec3_from_glam(value.orientation.y),
+				vec3_from_glam(value.orientation.z),
+			),
+			translation:vec3_from_glam(value.position)
+		})
+	}
+}
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let cframe_table=lua.create_table()?;
+
+	//CFrame.new
+	cframe_table.raw_set("new",
+		lua.create_function(|_,tuple:(
+			mlua::Value,mlua::Value,Option<f32>,
+			Option<f32>,Option<f32>,Option<f32>,
+			Option<f32>,Option<f32>,Option<f32>,
+			Option<f32>,Option<f32>,Option<f32>,
+		)|match tuple{
+			//CFrame.new(pos)
+			(
+				mlua::Value::UserData(pos),mlua::Value::Nil,None,
+				None,None,None,
+				None,None,None,
+				None,None,None,
+			)=>{
+				let pos:Vector3=pos.take()?;
+				Ok(CFrame::point(pos.0.x,pos.0.y,pos.0.z))
+			},
+			//TODO: CFrame.new(pos,look)
+			(
+				mlua::Value::UserData(pos),mlua::Value::UserData(look),None,
+				None,None,None,
+				None,None,None,
+				None,None,None,
+			)=>{
+				let _pos:Vector3=pos.take()?;
+				let _look:Vector3=look.take()?;
+				Err(mlua::Error::runtime("Not yet implemented"))
+			},
+			//CFrame.new(x,y,z)
+			(
+				mlua::Value::Number(x),mlua::Value::Number(y),Some(z),
+				None,None,None,
+				None,None,None,
+				None,None,None,
+			)=>Ok(CFrame::point(x as f32,y as f32,z)),
+			//CFrame.new(x,y,z,xx,yx,zx,xy,yy,zy,xz,yz,zz)
+			(
+				mlua::Value::Number(x),mlua::Value::Number(y),Some(z),
+				Some(xx),Some(yx),Some(zx),
+				Some(xy),Some(yy),Some(zy),
+				Some(xz),Some(yz),Some(zz),
+			)=>Ok(CFrame::new(x as f32,y as f32,z,
+				xx,yx,zx,
+				xy,yy,zy,
+				xz,yz,zz,
+			)),
+			_=>Err(mlua::Error::runtime("Invalid arguments"))
+		})?
+	)?;
+
+	//CFrame.Angles
+	cframe_table.raw_set("Angles",
+		lua.create_function(|_,(x,y,z):(f32,f32,f32)|
+			Ok(CFrame::angles(x,y,z))
+		)?
+	)?;
+
+	globals.set("CFrame",cframe_table)?;
+
+	Ok(())
+}
+
 impl mlua::UserData for CFrame{
-	fn add_fields<'lua,F:mlua::UserDataFields<'lua,Self>>(fields:&mut F){
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
 		//CFrame.p
 		fields.add_field_method_get("p",|_,this|Ok(Vector3(this.0.translation)));
 	}
 
-	fn add_methods<'lua,M:mlua::UserDataMethods<'lua,Self>>(methods:&mut M){
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		//methods.add_method("area",|_,this,()|Ok(this.length*this.width));
+		methods.add_method("components",|_,this,()|Ok((
+			this.0.translation.x,
+			this.0.translation.y,
+			this.0.translation.z,
+			this.0.matrix3.x_axis.x,
+			this.0.matrix3.y_axis.x,
+			this.0.matrix3.z_axis.x,
+			this.0.matrix3.x_axis.y,
+			this.0.matrix3.y_axis.y,
+			this.0.matrix3.z_axis.y,
+			this.0.matrix3.x_axis.z,
+			this.0.matrix3.y_axis.z,
+			this.0.matrix3.z_axis.z,
+		)));
 
 		//methods.add_meta_method(mlua::MetaMethod::Mul,|_,this,val:&Vector3|Ok(Vector3(this.0.matrix3*val.0+this.0.translation)));
 		methods.add_meta_function(mlua::MetaMethod::Mul,|_,(this,val):(Self,Self)|Ok(Self(this.0*val.0)));
@@ -41,11 +167,5 @@ impl mlua::UserData for CFrame{
 		);
 	}
 }
-impl<'lua> mlua::FromLua<'lua> for CFrame{
+
-	fn from_lua(value:mlua::prelude::LuaValue<'lua>,_lua:&'lua mlua::prelude::Lua)->mlua::prelude::LuaResult<Self>{
+type_from_lua_userdata!(CFrame);
-		match value {
-			mlua::Value::UserData(ud) => Ok(*ud.borrow::<Self>()?),
-			_ => unreachable!(),
-		}
-	}
-}

src/runner/color3.rs

@@ -0,0 +1,68 @@
+#[derive(Clone,Copy)]
+pub struct Color3{
+	r:f32,
+	g:f32,
+	b:f32,
+}
+impl Color3{
+	pub const fn new(r:f32,g:f32,b:f32)->Self{
+		Self{r,g,b}
+	}
+}
+impl Into<rbx_types::Color3> for Color3{
+	fn into(self)->rbx_types::Color3{
+		rbx_types::Color3::new(self.r,self.g,self.b)
+	}
+}
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let color3_table=lua.create_table()?;
+
+	color3_table.raw_set("new",
+		lua.create_function(|_,(r,g,b):(f32,f32,f32)|
+			Ok(Color3::new(r,g,b))
+		)?
+	)?;
+	color3_table.raw_set("fromRGB",
+		lua.create_function(|_,(r,g,b):(u8,u8,u8)|
+			Ok(Color3::new(r as f32/255.0,g as f32/255.0,b as f32/255.0))
+		)?
+	)?;
+
+	globals.set("Color3",color3_table)?;
+
+	Ok(())
+}
+fn lerp(lhs:f32,rhs:f32,t:f32)->f32{
+	lhs+(rhs-lhs)*t
+}
+
+impl mlua::UserData for Color3{
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
+		fields.add_field_method_get("r",|_,this|Ok(this.r));
+		fields.add_field_method_set("r",|_,this,val|{
+			this.r=val;
+			Ok(())
+		});
+		fields.add_field_method_get("g",|_,this|Ok(this.g));
+		fields.add_field_method_set("g",|_,this,val|{
+			this.g=val;
+			Ok(())
+		});
+		fields.add_field_method_get("b",|_,this|Ok(this.b));
+		fields.add_field_method_set("b",|_,this,val|{
+			this.b=val;
+			Ok(())
+		});
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_method("Lerp",|_,this,(other,t):(Self,f32)|
+			Ok(Color3::new(
+				lerp(this.r,other.r,t),
+				lerp(this.g,other.g,t),
+				lerp(this.b,other.b,t),
+			))
+		)
+	}
+}
+type_from_lua_userdata!(Color3);

src/runner/color_sequence.rs

@@ -0,0 +1,31 @@
+#[derive(Clone,Copy)]
+pub struct ColorSequence{}
+impl ColorSequence{
+	pub const fn new()->Self{
+		Self{}
+	}
+}
+impl Into<rbx_types::ColorSequence> for ColorSequence{
+	fn into(self)->rbx_types::ColorSequence{
+		rbx_types::ColorSequence{
+			keypoints:Vec::new()
+		}
+	}
+}
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let number_sequence_table=lua.create_table()?;
+
+	number_sequence_table.raw_set("new",
+		lua.create_function(|_,_:mlua::MultiValue|
+			Ok(ColorSequence::new())
+		)?
+	)?;
+
+	globals.set("ColorSequence",number_sequence_table)?;
+
+	Ok(())
+}
+
+impl mlua::UserData for ColorSequence{}
+type_from_lua_userdata!(ColorSequence);

src/runner/enum.rs

@@ -0,0 +1,63 @@
+use mlua::IntoLua;
+
+#[derive(Clone,Copy)]
+pub struct Enum(u32);
+#[derive(Clone,Copy)]
+pub struct EnumItems;
+#[derive(Clone,Copy)]
+pub struct EnumItem<'a>{
+	ed:&'a rbx_reflection::EnumDescriptor<'a>,
+}
+
+impl Into<rbx_types::Enum> for Enum{
+	fn into(self)->rbx_types::Enum{
+		rbx_types::Enum::from_u32(self.0)
+	}
+}
+
+impl<'a> EnumItem<'a>{
+	const fn new(ed:&'a rbx_reflection::EnumDescriptor)->Self{
+		Self{ed}
+	}
+}
+
+pub fn set_globals(_lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	globals.set("Enum",EnumItems)
+}
+
+impl mlua::UserData for EnumItem<'_>{
+	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(this,val):(EnumItem<'_>,mlua::String)|{
+			match this.ed.items.get(&*val.to_str()?){
+				Some(&id)=>Enum(id).into_lua(lua),
+				None=>mlua::Value::Nil.into_lua(lua),
+			}
+		});
+	}
+}
+type_from_lua_userdata_lua_lifetime!(EnumItem);
+
+impl mlua::UserData for EnumItems{
+	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(_,val):(Self,mlua::String)|{
+			let db=rbx_reflection_database::get();
+			match db.enums.get(&*val.to_str()?){
+				Some(ed)=>EnumItem::new(ed).into_lua(lua),
+				None=>mlua::Value::Nil.into_lua(lua),
+			}
+		});
+	}
+}
+type_from_lua_userdata!(EnumItems);
+
+impl mlua::UserData for Enum{
+	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(_methods:&mut M){
+	}
+}
+type_from_lua_userdata!(Enum);

src/runner/instance.rs

@@ -1,117 +0,0 @@
-use rbx_dom_weak::WeakDom;
-
-use super::vector3::Vector3;
-
-pub struct Instance{
-	referent:rbx_types::Ref,
-}
-
-impl From<crate::script::Script> for Instance{
-	fn from(value:crate::script::Script)->Self{
-		Self{referent:value.script}
-	}
-}
-
-impl Instance{
-	pub const fn new(referent:rbx_types::Ref)->Self{
-		Self{referent}
-	}
-	pub fn get<'a>(&'a self,dom:&'a WeakDom)->mlua::Result<&'a rbx_dom_weak::Instance>{
-		dom.get_by_ref(self.referent).ok_or(mlua::Error::runtime("Instance missing"))
-	}
-	pub fn get_mut<'a>(&'a self,dom:&'a mut WeakDom)->mlua::Result<&'a mut rbx_dom_weak::Instance>{
-		dom.get_by_ref_mut(self.referent).ok_or(mlua::Error::runtime("Instance missing"))
-	}
-}
-
-// LMAO look at this function!
-fn dom<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
-	let dom=*lua.app_data_mut::<*mut WeakDom>().ok_or(mlua::Error::runtime("DataModel missing"))?;
-	f(unsafe{&mut *dom})
-}
-
-fn coerce_float(value:&mlua::Value)->Option<f32>{
-	match value{
-		&mlua::Value::Integer(i)=>Some(i as f32),
-		&mlua::Value::Number(f)=>Some(f as f32),
-		_=>None,
-	}
-}
-
-impl mlua::UserData for Instance{
-	fn add_fields<'lua,F:mlua::UserDataFields<'lua,Self>>(fields:&mut F){
-		fields.add_field_method_get("Parent",|lua,this|{
-			dom(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(Instance::new(instance.parent()))
-			})
-		});
-		fields.add_field_method_set("Parent",|lua,this,val:Self|{
-			dom(lua,|dom|{
-				dom.transfer_within(this.referent,val.referent);
-				Ok(())
-			})
-		});
-	}
-
-	fn add_methods<'lua,M:mlua::UserDataMethods<'lua,Self>>(methods:&mut M){
-		methods.add_method("GetChildren",|lua,this,_:()|
-			dom(lua,|dom|{
-				let instance=this.get(dom)?;
-				let children:Vec<_>=instance
-					.children()
-					.iter()
-					.copied()
-					.map(Instance::new)
-					.collect();
-				Ok(children)
-			})
-		);
-		methods.add_method("GetDescendants",|lua,this,_:()|
-			dom(lua,|dom|{
-				let children:Vec<_>=dom
-					.descendants_of(this.referent)
-					.map(|instance|
-						Instance::new(instance.referent())
-					)
-					.collect();
-				Ok(children)
-			})
-		);
-		methods.add_method("IsA",|lua,this,classname:mlua::String|
-			dom(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(crate::context::class_is_a(instance.class.as_str(),classname.to_str()?))
-			})
-		);
-		methods.add_meta_function(mlua::MetaMethod::NewIndex,|lua,(this,index,value):(Self,mlua::String,mlua::Value)|
-			dom(lua,|dom|{
-				let instance=this.get_mut(dom)?;
-				let index_str=index.to_str()?;
-				let class=rbx_reflection_database::get().classes.get(instance.class.as_str()).ok_or(mlua::Error::runtime("Class missing"))?;
-				let property=class.default_properties.get(index_str).ok_or(mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
-				match property{
-					rbx_types::Variant::Vector3(_)=>{
-						let typed_value:Vector3=value.as_userdata().ok_or(mlua::Error::runtime("Expected Userdata"))?.take()?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Vector3(typed_value.into()));
-					},
-					rbx_types::Variant::Float32(_)=>{
-						let typed_value:f32=coerce_float(&value).ok_or(mlua::Error::runtime("Expected f32"))?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
-					},
-					other=>println!("Unimplemented property type: {other:?}"),
-				}
-				Ok(())
-			})
-		);
-	}
-}
-
-impl<'lua> mlua::FromLua<'lua> for Instance{
-	fn from_lua(value:mlua::prelude::LuaValue<'lua>,_lua:&'lua mlua::prelude::Lua)->mlua::prelude::LuaResult<Self>{
-		match value{
-			mlua::Value::UserData(ud)=>ud.take(),
-			other=>Err(mlua::Error::runtime(format!("Expected Instance got {:?}",other))),
-		}
-	}
-}

src/runner/instance/instance.rs

@@ -0,0 +1,557 @@
+use std::collections::{hash_map::Entry,HashMap};
+
+use mlua::{FromLua,FromLuaMulti,IntoLua,IntoLuaMulti};
+use rbx_types::Ref;
+use rbx_dom_weak::{InstanceBuilder,WeakDom};
+
+use crate::runner::vector3::Vector3;
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	//class functions store
+	lua.set_app_data(ClassMethodsStore::default());
+	lua.set_app_data(InstanceValueStore::default());
+
+	let instance_table=lua.create_table()?;
+
+	//Instance.new
+	instance_table.raw_set("new",
+		lua.create_function(|lua,(class_name,parent):(mlua::String,Option<Instance>)|{
+			let class_name_str=&*class_name.to_str()?;
+			let parent=parent.ok_or_else(||mlua::Error::runtime("Nil Parent not yet supported"))?;
+			dom_mut(lua,|dom|{
+				//TODO: Nil instances
+				Ok(Instance::new(dom.insert(parent.referent,InstanceBuilder::new(class_name_str))))
+			})
+		})?
+	)?;
+
+	globals.set("Instance",instance_table)?;
+
+	Ok(())
+}
+
+// LMAO look at this function!
+pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
+	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
+	f(&mut *dom)
+}
+
+fn coerce_float32(value:&mlua::Value)->Option<f32>{
+	match value{
+		&mlua::Value::Integer(i)=>Some(i as f32),
+		&mlua::Value::Number(f)=>Some(f as f32),
+		_=>None,
+	}
+}
+
+fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
+	let mut full_name=instance.name.clone();
+	let mut pref=instance.parent();
+	while let Some(parent)=dom.get_by_ref(pref){
+		full_name.insert(0,'.');
+		full_name.insert_str(0,parent.name.as_str());
+		pref=parent.parent();
+	}
+	full_name
+}
+//helper function for script
+pub fn get_name_source(lua:&mlua::Lua,script:Instance)->Result<(String,String),mlua::Error>{
+	dom_mut(lua,|dom|{
+		let instance=script.get(dom)?;
+		let source=match instance.properties.get("Source"){
+			Some(rbx_dom_weak::types::Variant::String(s))=>s.clone(),
+			_=>Err(mlua::Error::external("Missing script.Source"))?,
+		};
+		Ok((get_full_name(dom,instance),source))
+	})
+}
+
+pub fn find_first_child<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
+	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.name==name)
+}
+pub fn find_first_descendant<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
+	dom.descendants_of(instance.referent()).find(|&inst|inst.name==name)
+}
+
+pub fn find_first_child_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.class==class)
+}
+pub fn find_first_descendant_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
+}
+
+#[derive(Clone,Copy)]
+pub struct Instance{
+	referent:Ref,
+}
+impl Instance{
+	pub const fn new(referent:Ref)->Self{
+		Self{referent}
+	}
+	pub fn get<'a>(&self,dom:&'a WeakDom)->mlua::Result<&'a rbx_dom_weak::Instance>{
+		dom.get_by_ref(self.referent).ok_or_else(||mlua::Error::runtime("Instance missing"))
+	}
+	pub fn get_mut<'a>(&self,dom:&'a mut WeakDom)->mlua::Result<&'a mut rbx_dom_weak::Instance>{
+		dom.get_by_ref_mut(self.referent).ok_or_else(||mlua::Error::runtime("Instance missing"))
+	}
+}
+type_from_lua_userdata!(Instance);
+
+//TODO: update rbx_reflection and use dom.superclasses_iter
+pub struct SuperClassIter<'a> {
+    database: &'a rbx_reflection::ReflectionDatabase<'a>,
+    descriptor: Option<&'a rbx_reflection::ClassDescriptor<'a>>,
+}
+impl<'a> SuperClassIter<'a> {
+    fn next_descriptor(&self) -> Option<&'a rbx_reflection::ClassDescriptor<'a>> {
+        let superclass = self.descriptor?.superclass.as_ref()?;
+        self.database.classes.get(superclass)
+    }
+}
+impl<'a> Iterator for SuperClassIter<'a> {
+    type Item = &'a rbx_reflection::ClassDescriptor<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let next_descriptor = self.next_descriptor();
+        std::mem::replace(&mut self.descriptor, next_descriptor)
+    }
+}
+
+impl mlua::UserData for Instance{
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
+		fields.add_field_method_get("Parent",|lua,this|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(Instance::new(instance.parent()))
+			})
+		});
+		fields.add_field_method_set("Parent",|lua,this,val:Option<Instance>|{
+			let parent=val.ok_or_else(||mlua::Error::runtime("Nil Parent not yet supported"))?;
+			dom_mut(lua,|dom|{
+				dom.transfer_within(this.referent,parent.referent);
+				Ok(())
+			})
+		});
+		fields.add_field_method_get("Name",|lua,this|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(instance.name.clone())
+			})
+		});
+		fields.add_field_method_set("Name",|lua,this,val:mlua::String|{
+			dom_mut(lua,|dom|{
+				let instance=this.get_mut(dom)?;
+				//Why does this need to be cloned?
+				instance.name=val.to_str()?.to_owned();
+				Ok(())
+			})
+		});
+		fields.add_field_method_get("ClassName",|lua,this|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(instance.class.clone())
+			})
+		});
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_method("GetChildren",|lua,this,_:()|
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				let children:Vec<_>=instance
+					.children()
+					.iter()
+					.copied()
+					.map(Instance::new)
+					.collect();
+				Ok(children)
+			})
+		);
+		fn ffc(lua:&mlua::Lua,this:&Instance,(name,search_descendants):(mlua::String,Option<bool>))->mlua::Result<Option<Instance>>{
+			let name_str=&*name.to_str()?;
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(
+					match search_descendants.unwrap_or(false){
+						true=>find_first_descendant(dom,instance,name_str),
+						false=>find_first_child(dom,instance,name_str),
+					}
+					.map(|instance|
+						Instance::new(instance.referent())
+					)
+				)
+			})
+		}
+		methods.add_method("FindFirstChild",ffc);
+		methods.add_method("WaitForChild",ffc);
+		methods.add_method("FindFirstChildOfClass",|lua,this,(class,search_descendants):(mlua::String,Option<bool>)|{
+			let class_str=&*class.to_str()?;
+			dom_mut(lua,|dom|{
+				Ok(
+					match search_descendants.unwrap_or(false){
+						true=>find_first_descendant_of_class(dom,this.get(dom)?,class_str),
+						false=>find_first_child_of_class(dom,this.get(dom)?,class_str),
+					}
+					.map(|instance|
+						Instance::new(instance.referent())
+					)
+				)
+			})
+		});
+		methods.add_method("GetDescendants",|lua,this,_:()|
+			dom_mut(lua,|dom|{
+				let children:Vec<_>=dom
+					.descendants_of(this.referent)
+					.map(|instance|
+						Instance::new(instance.referent())
+					)
+					.collect();
+				Ok(children)
+			})
+		);
+		methods.add_method("IsA",|lua,this,classname:mlua::String|
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(crate::context::class_is_a(instance.class.as_str(),&*classname.to_str()?))
+			})
+		);
+		methods.add_method("Destroy",|lua,this,()|
+			dom_mut(lua,|dom|{
+				dom.destroy(this.referent);
+				Ok(())
+			})
+		);
+		methods.add_meta_function(mlua::MetaMethod::ToString,|lua,this:Instance|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(instance.name.clone())
+			})
+		});
+		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(this,index):(Instance,mlua::String)|{
+			let index_str=&*index.to_str()?;
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				//println!("__index t={} i={index:?}",instance.name);
+				let db=rbx_reflection_database::get();
+				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
+				//Find existing property
+				match instance.properties.get(index_str)
+					.cloned()
+					//Find default value
+					.or_else(||db.find_default_property(class,index_str).cloned())
+					//Find virtual property
+					.or_else(||{
+						SuperClassIter{
+							database:db,
+							descriptor:Some(class),
+						}
+						.find_map(|class|
+							find_virtual_property(&instance.properties,class,index_str)
+						)
+					})
+				{
+					Some(rbx_types::Variant::Int32(val))=>return val.into_lua(lua),
+					Some(rbx_types::Variant::Int64(val))=>return val.into_lua(lua),
+					Some(rbx_types::Variant::Float32(val))=>return val.into_lua(lua),
+					Some(rbx_types::Variant::Float64(val))=>return val.into_lua(lua),
+					Some(rbx_types::Variant::Ref(val))=>return Instance::new(val).into_lua(lua),
+					Some(rbx_types::Variant::CFrame(cf))=>return Into::<crate::runner::cframe::CFrame>::into(cf).into_lua(lua),
+					Some(rbx_types::Variant::Vector3(v))=>return Into::<crate::runner::vector3::Vector3>::into(v).into_lua(lua),
+					None=>(),
+					other=>return Err(mlua::Error::runtime(format!("Instance.__index Unsupported property type instance={} index={index_str} value={other:?}",instance.name))),
+				}
+				//find a function with a matching name
+				if let Some(function)=class_methods_store_mut(lua,|cf|{
+					let mut iter=SuperClassIter{
+						database:db,
+						descriptor:Some(class),
+					};
+					iter.find_map(|class|{
+						let mut class_methods=cf.get_or_create_class_methods(&class.name)?;
+						class_methods.get_or_create_function(lua,index_str)
+							.transpose()
+					}).transpose()
+				})?{
+					return function.into_lua(lua);
+				}
+
+				//find or create an associated userdata object
+				if let Some(value)=instance_value_store_mut(lua,|ivs|{
+					//TODO: walk class tree somehow
+					match ivs.get_or_create_instance_values(&instance){
+						Some(mut instance_values)=>instance_values.get_or_create_value(lua,index_str),
+						None=>Ok(None)
+					}
+				})?{
+					return value.into_lua(lua);
+				}
+				//find a child with a matching name
+				find_first_child(dom,instance,index_str)
+				.map(|instance|Instance::new(instance.referent()))
+				.into_lua(lua)
+			})
+		});
+		methods.add_meta_function(mlua::MetaMethod::NewIndex,|lua,(this,index,value):(Instance,mlua::String,mlua::Value)|{
+			dom_mut(lua,|dom|{
+				let instance=this.get_mut(dom)?;
+				//println!("__newindex t={} i={index:?} v={value:?}",instance.name);
+				let index_str=&*index.to_str()?;
+				let db=rbx_reflection_database::get();
+				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
+				let mut iter=SuperClassIter{
+					database:db,
+					descriptor:Some(class),
+				};
+				let property=iter.find_map(|cls|cls.properties.get(index_str)).ok_or_else(||mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
+				match &property.data_type{
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Vector3)=>{
+						let typed_value:Vector3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Userdata"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Vector3(typed_value.into()));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Float32)=>{
+						let typed_value:f32=coerce_float32(&value).ok_or_else(||mlua::Error::runtime("Expected f32"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
+					},
+					rbx_reflection::DataType::Enum(enum_name)=>{
+						let typed_value=match &value{
+							&mlua::Value::Integer(int)=>Ok(rbx_types::Enum::from_u32(int as u32)),
+							&mlua::Value::Number(num)=>Ok(rbx_types::Enum::from_u32(num as u32)),
+							mlua::Value::String(s)=>{
+								let e=db.enums.get(enum_name).ok_or_else(||mlua::Error::runtime("Database DataType Enum name  does not exist"))?;
+								Ok(rbx_types::Enum::from_u32(*e.items.get(&*s.to_str()?).ok_or_else(||mlua::Error::runtime("Invalid enum item"))?))
+							},
+							mlua::Value::UserData(any_user_data)=>{
+								let e:crate::runner::r#enum::Enum=*any_user_data.borrow()?;
+								Ok(e.into())
+							},
+							_=>Err(mlua::Error::runtime("Expected Enum")),
+						}?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Color3)=>{
+						let typed_value:crate::runner::color3::Color3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Color3"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Color3(typed_value.into()));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Bool)=>{
+						let typed_value=value.as_boolean().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Bool(typed_value));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::String)=>{
+						let typed_value=value.as_str().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::String(typed_value.to_owned()));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::NumberSequence)=>{
+						let typed_value:crate::runner::number_sequence::NumberSequence=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected NumberSequence"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::NumberSequence(typed_value.into()));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::ColorSequence)=>{
+						let typed_value:crate::runner::color_sequence::ColorSequence=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected ColorSequence"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::ColorSequence(typed_value.into()));
+					},
+					other=>return Err(mlua::Error::runtime(format!("Unimplemented property type: {other:?}"))),
+				}
+				Ok(())
+			})
+		});
+	}
+}
+
+/// A class function definition shorthand.
+macro_rules! cf{
+	($f:expr)=>{
+		|lua,mut args|{
+			let this=Instance::from_lua(args.pop_front().unwrap_or(mlua::Value::Nil),lua)?;
+			$f(lua,this,FromLuaMulti::from_lua_multi(args,lua)?)?.into_lua_multi(lua)
+		}
+	};
+}
+type ClassFunctionPointer=fn(&mlua::Lua,mlua::MultiValue)->mlua::Result<mlua::MultiValue>;
+// TODO: use macros to define these with better organization
+/// A double hash map of function pointers.
+/// The class tree is walked by the Instance.__index metamethod to find available class methods.
+type CFD=phf::Map<&'static str,// Class name
+	phf::Map<&'static str,// Method name
+		ClassFunctionPointer
+	>
+>;
+static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
+	"DataModel"=>phf::phf_map!{
+		"GetService"=>cf!(|lua,_this,service:mlua::String|{
+			dom_mut(lua,|dom|{
+				//dom.root_ref()==this.referent ?
+				let service=&*service.to_str()?;
+				match service{
+					"Lighting"|"RunService"=>{
+						let referent=find_first_child_of_class(dom,dom.root(),service)
+        				.map(|instance|instance.referent())
+						.unwrap_or_else(||
+							dom.insert(dom.root_ref(),InstanceBuilder::new(service))
+						);
+						Ok(Instance::new(referent))
+					},
+					other=>Err::<Instance,_>(mlua::Error::runtime(format!("Service '{other}' not supported"))),
+				}
+			})
+		}),
+	},
+	"Terrain"=>phf::phf_map!{
+		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Vector3,crate::runner::r#enum::Enum)|mlua::Result::Ok(()))
+	},
+};
+
+/// A store of created functions for each Roblox class.
+/// Functions are created the first time they are accessed and stored in this data structure.
+#[derive(Default)]
+struct ClassMethodsStore{
+	classes:HashMap<&'static str,//ClassName
+		HashMap<&'static str,//Method name
+			mlua::Function
+		>
+	>
+}
+impl ClassMethodsStore{
+	/// return self.classes[class] or create the ClassMethods and then return it
+	fn get_or_create_class_methods(&mut self,class:&str)->Option<ClassMethods>{
+		// Use get_entry to get the &'static str keys of the database
+		// and use it as a key for the classes hashmap
+		CLASS_FUNCTION_DATABASE.get_entry(class)
+			.map(|(&static_class_str,method_pointers)|
+				ClassMethods{
+					method_pointers,
+					methods:self.classes.entry(static_class_str)
+					.or_insert_with(||HashMap::new()),
+				}
+			)
+	}
+}
+struct ClassMethods<'a>{
+	method_pointers:&'static phf::Map<&'static str,ClassFunctionPointer>,
+	methods:&'a mut HashMap<&'static str,mlua::Function>,
+}
+impl ClassMethods<'_>{
+	/// return self.methods[index] or create the function in the hashmap and then return it
+	fn get_or_create_function(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::Function>>{
+		Ok(match self.method_pointers.get_entry(index){
+			Some((&static_index_str,&function_pointer))=>Some(
+				match self.methods.entry(static_index_str){
+					Entry::Occupied(entry)=>entry.get().clone(),
+					Entry::Vacant(entry)=>entry.insert(
+						lua.create_function(function_pointer)?
+					).clone(),
+				}
+			),
+			None=>None,
+		})
+	}
+}
+fn class_methods_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut ClassMethodsStore)->mlua::Result<T>)->mlua::Result<T>{
+	let mut cf=lua.app_data_mut::<ClassMethodsStore>().ok_or_else(||mlua::Error::runtime("ClassMethodsStore missing"))?;
+	f(&mut *cf)
+}
+
+/// A virtual property pointer definition shorthand.
+type VirtualPropertyFunctionPointer=fn(&rbx_types::Variant)->Option<rbx_types::Variant>;
+const fn vpp(
+	property:&'static str,
+	pointer:VirtualPropertyFunctionPointer,
+)->VirtualProperty{
+	VirtualProperty{
+		property,
+		pointer,
+	}
+}
+struct VirtualProperty{
+	property:&'static str,// Source property name
+	pointer:VirtualPropertyFunctionPointer,
+}
+type VPD=phf::Map<&'static str,// Class name
+	phf::Map<&'static str,// Virtual property name
+		VirtualProperty
+	>
+>;
+static VIRTUAL_PROPERTY_DATABASE:VPD=phf::phf_map!{
+	"BasePart"=>phf::phf_map!{
+		"Position"=>vpp("CFrame",|c:&rbx_types::Variant|{
+			let c=match c{
+				rbx_types::Variant::CFrame(c)=>c,
+				_=>return None,//fail silently and ungracefully
+			};
+			Some(rbx_types::Variant::Vector3(c.position))
+		}),
+	},
+};
+
+fn find_virtual_property(
+	properties:&HashMap<String,rbx_types::Variant>,
+	class:&rbx_reflection::ClassDescriptor,
+	index:&str
+)->Option<rbx_types::Variant>{
+	//Find virtual property
+	let class_virtual_properties=VIRTUAL_PROPERTY_DATABASE.get(&class.name)?;
+	let virtual_property=class_virtual_properties.get(index)?;
+
+	//Get source property
+	let variant=properties.get(virtual_property.property)?;
+
+	//Transform Source property with provided function
+	(virtual_property.pointer)(variant)
+}
+
+// lazy-loaded per-instance userdata values
+// This whole thing is a bad idea and a garbage collection nightmare.
+// TODO: recreate rbx_dom_weak with my own instance type that owns this data.
+type CreateUserData=fn(&mlua::Lua)->mlua::Result<mlua::AnyUserData>;
+type LUD=phf::Map<&'static str,// Class name
+	phf::Map<&'static str,// Value name
+		CreateUserData
+	>
+>;
+static LAZY_USER_DATA:LUD=phf::phf_map!{
+	"RunService"=>phf::phf_map!{
+		"RenderStepped"=>|lua|{
+			lua.create_any_userdata(crate::runner::script_signal::ScriptSignal::new())
+		},
+	},
+};
+#[derive(Default)]
+pub struct InstanceValueStore{
+	values:HashMap<Ref,
+		HashMap<&'static str,
+			mlua::AnyUserData
+		>
+	>,
+}
+pub struct InstanceValues<'a>{
+	named_values:&'static phf::Map<&'static str,CreateUserData>,
+	values:&'a mut HashMap<&'static str,mlua::AnyUserData>,
+}
+impl InstanceValueStore{
+	pub fn get_or_create_instance_values(&mut self,instance:&rbx_dom_weak::Instance)->Option<InstanceValues>{
+		LAZY_USER_DATA.get(instance.class.as_str())
+			.map(|named_values|
+				InstanceValues{
+					named_values,
+					values:self.values.entry(instance.referent())
+					.or_insert_with(||HashMap::new()),
+				}
+			)
+	}
+}
+impl InstanceValues<'_>{
+	pub fn get_or_create_value(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
+		Ok(match self.named_values.get_entry(index){
+			Some((&static_index_str,&function_pointer))=>Some(
+				match self.values.entry(static_index_str){
+					Entry::Occupied(entry)=>entry.get().clone(),
+					Entry::Vacant(entry)=>entry.insert(
+						function_pointer(lua)?
+					).clone(),
+				}
+			),
+			None=>None,
+		})
+	}
+}
+
+pub fn instance_value_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut InstanceValueStore)->mlua::Result<T>)->mlua::Result<T>{
+	let mut cf=lua.app_data_mut::<InstanceValueStore>().ok_or_else(||mlua::Error::runtime("InstanceValueStore missing"))?;
+	f(&mut *cf)
+}

src/runner/instance/mod.rs

@@ -0,0 +1,2 @@
+pub mod instance;
+pub use instance::Instance;

src/runner/macros.rs

@@ -0,0 +1,24 @@
+macro_rules! type_from_lua_userdata{
+	($asd:ident)=>{
+		impl mlua::FromLua for $asd{
+			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
+				match value{
+					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
+				}
+			}
+		}
+	};
+}
+macro_rules! type_from_lua_userdata_lua_lifetime{
+	($asd:ident)=>{
+		impl mlua::FromLua for $asd<'static>{
+			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
+				match value{
+					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
+				}
+			}
+		}
+	};
+}

src/runner/mod.rs

@@ -1,7 +1,14 @@
+#[macro_use]
+mod macros;
 mod runner;
 
+mod r#enum;
+mod color3;
 mod cframe;
 mod vector3;
-mod instance;
+pub mod instance;
+mod script_signal;
+mod color_sequence;
+mod number_sequence;
 
-pub use runner::Runner;
+pub use runner::{Runner,Runnable,Error};

src/runner/number_sequence.rs

@@ -0,0 +1,31 @@
+#[derive(Clone,Copy)]
+pub struct NumberSequence{}
+impl NumberSequence{
+	pub const fn new()->Self{
+		Self{}
+	}
+}
+impl Into<rbx_types::NumberSequence> for NumberSequence{
+	fn into(self)->rbx_types::NumberSequence{
+		rbx_types::NumberSequence{
+			keypoints:Vec::new()
+		}
+	}
+}
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let number_sequence_table=lua.create_table()?;
+
+	number_sequence_table.raw_set("new",
+		lua.create_function(|_,_:mlua::MultiValue|
+			Ok(NumberSequence::new())
+		)?
+	)?;
+
+	globals.set("NumberSequence",number_sequence_table)?;
+
+	Ok(())
+}
+
+impl mlua::UserData for NumberSequence{}
+type_from_lua_userdata!(NumberSequence);

src/runner/runner.rs

@@ -1,28 +1,29 @@
 use crate::context::Context;
-
+#[cfg(feature="run-service")]
-use super::vector3::Vector3;
+use crate::scheduler::scheduler_mut;
-use super::cframe::CFrame;
 
 pub struct Runner{
 	lua:mlua::Lua,
 }
 #[derive(Debug)]
 pub enum Error{
-	Lua(mlua::Error),
+	Lua{
-	Script(crate::script::Error),
+		source:String,
-	/// If the lua.remove_app_data function fails
+		error:mlua::Error
-	RemoveAppData,
-}
-impl Error{
-	pub fn print(self){
-		match self{
-			Self::Lua(mlua::Error::RuntimeError(s))=>{
-				println!("lua error: {s}");
 	},
-			other=>println!("{:?}",other),
+	RustLua(mlua::Error),
+	NoServices,
+}
+impl std::fmt::Display for Error{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		match self{
+			Self::Lua{source,error}=>write!(f,"lua error: source:\n{source}\n{error}"),
+			Self::RustLua(error)=>write!(f,"rust-side lua error: {error}"),
+			other=>write!(f,"{other:?}"),
 		}
 	}
 }
+impl std::error::Error for Error{}
 
 fn init(lua:&mlua::Lua)->mlua::Result<()>{
 	lua.sandbox(true)?;
@@ -30,62 +31,113 @@ fn init(lua:&mlua::Lua)->mlua::Result<()>{
 	//global environment
 	let globals=lua.globals();
 
-	//Vector3
+	#[cfg(feature="run-service")]
-	{
+	crate::scheduler::set_globals(lua,&globals)?;
-		let vector3_table=lua.create_table()?;
+	super::script_signal::set_globals(lua,&globals)?;
-
+	super::r#enum::set_globals(lua,&globals)?;
-		//Vector3.new
+	super::color3::set_globals(lua,&globals)?;
-		vector3_table.raw_set("new",
+	super::vector3::set_globals(lua,&globals)?;
-			lua.create_function(|ctx,(x,y,z):(f32,f32,f32)|
+	super::cframe::set_globals(lua,&globals)?;
-				Ok(ctx.create_userdata(Vector3::new(x,y,z)))
+	super::instance::instance::set_globals(lua,&globals)?;
-			)?
+	super::number_sequence::set_globals(lua,&globals)?;
-		)?;
+	super::color_sequence::set_globals(lua,&globals)?;
-
-		globals.set("Vector3",vector3_table)?;
-	}
-
-	//CFrame
-	{
-		let cframe_table=lua.create_table()?;
-
-		//CFrame.new
-		cframe_table.raw_set("new",
-			lua.create_function(|ctx,(x,y,z):(f32,f32,f32)|
-				Ok(ctx.create_userdata(CFrame::new(x,y,z)))
-			)?
-		)?;
-
-		//CFrame.Angles
-		cframe_table.raw_set("Angles",
-			lua.create_function(|ctx,(x,y,z):(f32,f32,f32)|
-				Ok(ctx.create_userdata(CFrame::angles(x,y,z)))
-			)?
-		)?;
-
-		globals.set("CFrame",cframe_table)?;
-	}
 
 	Ok(())
 }
 
 impl Runner{
-	pub fn new()->mlua::Result<Self>{
+	pub fn new()->Result<Self,Error>{
 		let runner=Self{
 			lua:mlua::Lua::new(),
 		};
-		init(&runner.lua)?;
+		init(&runner.lua).map_err(Error::RustLua)?;
 		Ok(runner)
 	}
-	pub fn run_script(&self,script:crate::script::Script,context:&mut Context)->Result<(),Error>{
+	pub fn runnable_context<'a>(self,context:&'a mut Context)->Result<Runnable<'a>,Error>{
-		let yoink=script.name_source(context);
+		let services=context.find_services().ok_or(Error::NoServices)?;
+		self.runnable_context_with_services(context,&services)
+	}
+	pub fn runnable_context_with_services<'a>(self,context:&'a mut Context,services:&crate::context::Services)->Result<Runnable<'a>,Error>{
+		{
+			let globals=self.lua.globals();
+			globals.set("game",super::instance::Instance::new(services.game)).map_err(Error::RustLua)?;
+			globals.set("workspace",super::instance::Instance::new(services.workspace)).map_err(Error::RustLua)?;
+		}
 		//this makes set_app_data shut up about the lifetime
-		self.lua.set_app_data::<*mut rbx_dom_weak::WeakDom>(&mut context.dom);
+		self.lua.set_app_data::<&'static mut rbx_dom_weak::WeakDom>(unsafe{core::mem::transmute(&mut context.dom)});
-		let (name,source)=yoink.map_err(Error::Script)?;
+		#[cfg(feature="run-service")]
-			self.lua.globals().set("script",super::instance::Instance::from(script)).map_err(Error::Lua)?;
+		self.lua.set_app_data::<crate::scheduler::Scheduler>(crate::scheduler::Scheduler::default());
-		self.lua.load(source)
+		Ok(Runnable{
-		.set_name(name)
+			lua:self.lua,
-		.exec().map_err(Error::Lua)?;
+			_lifetime:&std::marker::PhantomData
-		self.lua.remove_app_data::<*mut rbx_dom_weak::WeakDom>();
+		})
+	}
+}
+
+//Runnable is the same thing but has context set, which it holds the lifetime for.
+pub struct Runnable<'a>{
+	lua:mlua::Lua,
+	_lifetime:&'a std::marker::PhantomData<()>
+}
+impl Runnable<'_>{
+	pub fn drop_context(self)->Runner{
+		self.lua.remove_app_data::<&'static mut rbx_dom_weak::WeakDom>();
+		#[cfg(feature="run-service")]
+		self.lua.remove_app_data::<crate::scheduler::Scheduler>();
+		Runner{
+			lua:self.lua,
+		}
+	}
+	pub fn run_script(&self,script:super::instance::Instance)->Result<(),Error>{
+		let (name,source)=super::instance::instance::get_name_source(&self.lua,script).map_err(Error::RustLua)?;
+		self.lua.globals().raw_set("script",script).map_err(Error::RustLua)?;
+		let f=self.lua.load(source.as_str())
+		.set_name(name).into_function().map_err(Error::RustLua)?;
+		// TODO: set_environment without losing the ability to print from Lua
+		let thread=self.lua.create_thread(f).map_err(Error::RustLua)?;
+		thread.resume::<mlua::MultiValue>(()).map_err(|error|Error::Lua{source,error})?;
+		// wait() is called from inside Lua and goes to a rust function that schedules the thread and then yields
+		// No need to schedule the thread here
+		Ok(())
+	}
+	#[cfg(feature="run-service")]
+	pub fn has_scheduled_threads(&self)->Result<bool,mlua::Error>{
+		scheduler_mut(&self.lua,|scheduler|
+			Ok(scheduler.has_scheduled_threads())
+		)
+	}
+	#[cfg(feature="run-service")]
+	pub fn game_tick(&self)->Result<(),mlua::Error>{
+		if let Some(threads)=scheduler_mut(&self.lua,|scheduler|Ok(scheduler.tick_threads()))?{
+			for thread in threads{
+				//TODO: return dt and total run time
+				let result=thread.resume::<mlua::MultiValue>((1.0/30.0,0.0))
+					.map_err(|error|Error::Lua{source:"source unavailable".to_owned(),error});
+				match result{
+					Ok(_)=>(),
+					Err(e)=>println!("game_tick Error: {e}"),
+				}
+			}
+		}
+		Ok(())
+	}
+	#[cfg(feature="run-service")]
+	pub fn run_service_step(&self)->Result<(),mlua::Error>{
+		let render_stepped=super::instance::instance::dom_mut(&self.lua,|dom|{
+			let run_service=super::instance::instance::find_first_child_of_class(dom,dom.root(),"RunService").ok_or_else(||mlua::Error::runtime("RunService missing"))?;
+			super::instance::instance::instance_value_store_mut(&self.lua,|instance_value_store|{
+				//unwrap because I trust my find_first_child_of_class function to
+				let mut instance_values=instance_value_store.get_or_create_instance_values(run_service).ok_or_else(||mlua::Error::runtime("RunService InstanceValues missing"))?;
+				let render_stepped=instance_values.get_or_create_value(&self.lua,"RenderStepped")?;
+				//let stepped=instance_values.get_or_create_value(&self.lua,"Stepped")?;
+				//let heartbeat=instance_values.get_or_create_value(&self.lua,"Heartbeat")?;
+				Ok(render_stepped)
+			})
+		})?;
+		if let Some(render_stepped)=render_stepped{
+			let signal:&super::script_signal::ScriptSignal=&*render_stepped.borrow()?;
+			signal.fire(&mlua::MultiValue::new());
+		}
 		Ok(())
 	}
 }

src/runner/script_signal.rs

@@ -0,0 +1,172 @@
+use std::{cell::RefCell,rc::Rc};
+
+use mlua::UserDataFields;
+
+#[derive(Clone)]
+struct FunctionList{
+	functions:Vec<mlua::Function>,
+}
+impl FunctionList{
+	pub fn new()->Self{
+		Self{
+			functions:Vec::new(),
+		}
+	}
+	// This eats the Lua error
+	pub fn fire(self,args:&mlua::MultiValue){
+		// Make a copy of the list in case Lua attempts to modify it during the loop
+		for function in self.functions{
+			//wee let's allocate for our function calls
+			if let Err(e)=function.call::<mlua::MultiValue>(args.clone()){
+				println!("Script Signal Error: {e}");
+			}
+		}
+	}
+}
+#[derive(Clone)]
+struct RcFunctionList{
+	functions:Rc<RefCell<FunctionList>>,
+}
+impl RcFunctionList{
+	pub fn new()->Self{
+		Self{
+			functions:Rc::new(RefCell::new(FunctionList::new())),
+		}
+	}
+	pub fn fire(&self,args:&mlua::MultiValue){
+		// Make a copy of the list in case Lua attempts to modify it during the loop
+		self.functions.borrow().clone().fire(args)
+	}
+}
+#[derive(Clone)]
+pub struct ScriptSignal{
+	// Emulate the garbage roblox api.
+	// ScriptConnection should not exist.
+	// :Disconnect should be a method on ScriptSignal, and this would be avoided entirely.
+	connections:RcFunctionList,
+	once:RcFunctionList,
+	wait:Rc<RefCell<Vec<mlua::Thread>>>,
+}
+pub struct ScriptConnection{
+	connection:RcFunctionList,
+	function:mlua::Function,
+}
+impl ScriptSignal{
+	pub fn new()->Self{
+		Self{
+			connections:RcFunctionList::new(),
+			once:RcFunctionList::new(),
+			wait:Rc::new(RefCell::new(Vec::new())),
+		}
+	}
+	pub fn fire(&self,args:&mlua::MultiValue){
+		self.connections.fire(args);
+		//Replace the FunctionList with an empty one and drop the borrow
+		let once=std::mem::replace(&mut *self.once.functions.borrow_mut(),FunctionList::new());
+		once.fire(args);
+		//resume threads waiting for this signal
+		let threads=std::mem::replace(&mut *self.wait.borrow_mut(),Vec::new());
+		for thread in threads{
+			if let Err(e)=thread.resume::<mlua::MultiValue>(args.clone()){
+				println!("Script Signal thread resume Error: {e}");
+			}
+		}
+	}
+	pub fn connect(&self,function:mlua::Function)->ScriptConnection{
+		self.connections.functions.borrow_mut().functions.push(function.clone());
+		ScriptConnection{
+			connection:self.connections.clone(),
+			function,
+		}
+	}
+	pub fn once(&self,function:mlua::Function)->ScriptConnection{
+		self.once.functions.borrow_mut().functions.push(function.clone());
+		ScriptConnection{
+			connection:self.once.clone(),
+			function,
+		}
+	}
+	pub fn wait(&self,thread:mlua::Thread){
+		self.wait.borrow_mut().push(thread);
+	}
+}
+impl ScriptConnection{
+	pub fn position(&self)->Option<usize>{
+		self.connection.functions.borrow().functions.iter().position(|function|function==&self.function)
+	}
+}
+
+impl mlua::UserData for ScriptSignal{
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_method("Connect",|_lua,this,f:mlua::Function|
+			Ok(this.connect(f))
+		);
+		methods.add_method("Once",|_lua,this,f:mlua::Function|
+			Ok(this.once(f))
+		);
+		// Fire is not allowed to be called from Lua
+		// methods.add_method("Fire",|_lua,this,args:mlua::MultiValue|
+		// 	Ok(this.fire(args))
+		// );
+	}
+}
+impl mlua::FromLua for ScriptSignal{
+	fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
+		match value{
+			mlua::Value::UserData(ud)=>Ok(ud.borrow::<Self>()?.clone()),
+			other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!(ScriptSignal),other))),
+		}
+	}
+}
+
+impl mlua::UserData for ScriptConnection{
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
+		fields.add_field_method_get("Connected",|_,this|{
+			Ok(this.position().is_some())
+		});
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_method("Disconnect",|_,this,_:()|{
+			if let Some(index)=this.position(){
+				this.connection.functions.borrow_mut().functions.remove(index);
+			}
+			Ok(())
+		});
+	}
+}
+
+fn wait_thread(lua:&mlua::Lua,this:ScriptSignal)->Result<(),mlua::Error>{
+	Ok(this.wait(lua.current_thread()))
+}
+
+// This is used to avoid calling coroutine.yield from the rust side.
+const LUA_WAIT:&str=
+"local coroutine_yield=coroutine.yield
+local wait_thread=wait_thread
+return function(signal)
+	wait_thread(signal)
+	return coroutine_yield()
+end";
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let coroutine_table=globals.get::<mlua::Table>("coroutine")?;
+	let wait_thread=lua.create_function(wait_thread)?;
+
+	//create wait function environment
+	let wait_env=lua.create_table()?;
+	wait_env.raw_set("coroutine",coroutine_table)?;
+	wait_env.raw_set("wait_thread",wait_thread)?;
+
+	//construct wait function from Lua code
+	let wait=lua.load(LUA_WAIT)
+	.set_name("wait")
+	.set_environment(wait_env)
+	.call::<mlua::Function>(())?;
+
+	lua.register_userdata_type::<ScriptSignal>(|reg|{
+		reg.add_field("Wait",wait);
+		mlua::UserData::register(reg);
+	})?;
+
+	Ok(())
+}

src/runner/vector3.rs

@@ -7,36 +7,68 @@ impl Vector3{
 	}
 }
 
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let vector3_table=lua.create_table()?;
+
+	//Vector3.new
+	vector3_table.raw_set("new",
+		lua.create_function(|_,(x,y,z):(f32,f32,f32)|
+			Ok(Vector3::new(x,y,z))
+		)?
+	)?;
+
+	globals.set("Vector3",vector3_table)?;
+
+	Ok(())
+}
+
 impl Into<rbx_types::Vector3> for Vector3{
 	fn into(self)->rbx_types::Vector3{
 		rbx_types::Vector3::new(self.0.x,self.0.y,self.0.z)
 	}
 }
 
+impl From<rbx_types::Vector3> for Vector3{
+	fn from(value:rbx_types::Vector3)->Vector3{
+		Vector3::new(value.x,value.y,value.z)
+	}
+}
+
 impl mlua::UserData for Vector3{
-	fn add_fields<'lua,F: mlua::UserDataFields<'lua,Self>>(fields: &mut F) {
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("magnitude",|_,this| Ok(this.0.length()));
+		fields.add_field_method_get("magnitude",|_,this|Ok(this.0.length()));
-		fields.add_field_method_get("x",|_,this| Ok(this.0.x));
+		fields.add_field_method_get("x",|_,this|Ok(this.0.x));
-		fields.add_field_method_set("x",|_,this,val| {
+		fields.add_field_method_set("x",|_,this,val|{
-			this.0.x = val;
+			this.0.x=val;
 			Ok(())
 		});
-		fields.add_field_method_get("y",|_,this| Ok(this.0.y));
+		fields.add_field_method_get("y",|_,this|Ok(this.0.y));
-		fields.add_field_method_set("y",|_,this,val| {
+		fields.add_field_method_set("y",|_,this,val|{
-			this.0.y = val;
+			this.0.y=val;
 			Ok(())
 		});
-		fields.add_field_method_get("z",|_,this| Ok(this.0.z));
+		fields.add_field_method_get("z",|_,this|Ok(this.0.z));
-		fields.add_field_method_set("z",|_,this,val| {
+		fields.add_field_method_set("z",|_,this,val|{
-			this.0.z = val;
+			this.0.z=val;
 			Ok(())
 		});
 	}
 
-	fn add_methods<'lua,M: mlua::UserDataMethods<'lua,Self>>(methods:&mut M){
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
 		//methods.add_method("area",|_,this,()| Ok(this.length * this.width));
 
 		methods.add_meta_function(mlua::MetaMethod::Add,|_,(this,val):(Self,Self)|Ok(Self(this.0+val.0)));
+		methods.add_meta_function(mlua::MetaMethod::Div,|_,(this,val):(Self,mlua::Value)|{
+			match val{
+				mlua::Value::Integer(n)=>Ok(Self(this.0/(n as f32))),
+				mlua::Value::Number(n)=>Ok(Self(this.0/(n as f32))),
+				mlua::Value::UserData(ud)=>{
+					let rhs:Vector3=ud.take()?;
+					Ok(Self(this.0/rhs.0))
+				},
+				other=>Err(mlua::Error::runtime(format!("Attempt to divide Vector3 by {other:?}"))),
+			}
+		});
 		methods.add_meta_function(mlua::MetaMethod::ToString,|_,this:Self|
 			Ok(format!("Vector3.new({},{},{})",
 				this.0.x,
@@ -47,11 +79,4 @@ impl mlua::UserData for Vector3{
 	}
 }
 
-impl<'lua> mlua::FromLua<'lua> for Vector3{
+type_from_lua_userdata!(Vector3);
-	fn from_lua(value:mlua::prelude::LuaValue<'lua>,_lua:&'lua mlua::prelude::Lua)->mlua::prelude::LuaResult<Self>{
-		match value{
-			mlua::Value::UserData(ud)=>ud.take(),
-			other=>Err(mlua::Error::runtime(format!("Expected Vector3 got {:?}",other))),
-		}
-	}
-}

src/scheduler.rs

@@ -0,0 +1,106 @@
+pub use tick::Tick;
+mod tick{
+	#[derive(Clone,Copy,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
+	pub struct Tick(u64);
+	impl std::ops::Add<u64> for Tick{
+		type Output=Self;
+		fn add(self,rhs:u64)->Self::Output{
+			Self(self.0+rhs)
+		}
+	}
+	impl std::ops::Sub<u64> for Tick{
+		type Output=Self;
+		fn sub(self,rhs:u64)->Self::Output{
+			Self(self.0-rhs)
+		}
+	}
+	impl std::ops::AddAssign<u64> for Tick{
+		fn add_assign(&mut self,rhs:u64){
+			self.0+=rhs;
+		}
+	}
+	impl std::ops::SubAssign<u64> for Tick{
+		fn sub_assign(&mut self,rhs:u64){
+			self.0-=rhs;
+		}
+	}
+}
+#[derive(Default)]
+pub struct Scheduler{
+	tick:Tick,
+	schedule:std::collections::HashMap<Tick,Vec<mlua::Thread>>,
+}
+
+impl Scheduler{
+	pub fn has_scheduled_threads(&self)->bool{
+		!self.schedule.is_empty()
+	}
+	pub fn schedule_thread(&mut self,delay:u64,thread:mlua::Thread){
+		self.schedule.entry(self.tick+delay.max(1))
+		.or_insert(Vec::new())
+		.push(thread);
+	}
+	pub fn tick_threads(&mut self)->Option<Vec<mlua::Thread>>{
+		self.tick+=1;
+		self.schedule.remove(&self.tick)
+	}
+}
+
+pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut crate::scheduler::Scheduler)->mlua::Result<T>)->mlua::Result<T>{
+	let mut scheduler=lua.app_data_mut::<crate::scheduler::Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
+	f(&mut *scheduler)
+}
+
+fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
+	let delay=match dt{
+		mlua::Value::Integer(i)=>i.max(0) as u64*60,
+		mlua::Value::Number(f)=>{
+			let delay=f.max(0.0)*60.0;
+			match delay.classify(){
+				std::num::FpCategory::Nan=>Err(mlua::Error::runtime("NaN"))?,
+				// cases where the number is too large to schedule
+				std::num::FpCategory::Infinite=>return Ok(()),
+				std::num::FpCategory::Normal=>if (u64::MAX as f64)<delay{
+					return Ok(());
+				},
+				_=>(),
+			}
+			delay as u64
+		},
+		mlua::Value::Nil=>0,
+		_=>Err(mlua::Error::runtime("Expected float"))?,
+	};
+	scheduler_mut(lua,|scheduler|{
+		scheduler.schedule_thread(delay.max(2),lua.current_thread());
+		Ok(())
+	})
+}
+
+// This is used to avoid calling coroutine.yield from the rust side.
+const LUA_WAIT:&str=
+"local coroutine_yield=coroutine.yield
+local schedule_thread=schedule_thread
+return function(dt)
+	schedule_thread(dt)
+	return coroutine_yield()
+end";
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let coroutine_table=globals.get::<mlua::Table>("coroutine")?;
+	let schedule_thread=lua.create_function(schedule_thread)?;
+
+	//create wait function environment
+	let wait_env=lua.create_table()?;
+	wait_env.raw_set("coroutine",coroutine_table)?;
+	wait_env.raw_set("schedule_thread",schedule_thread)?;
+
+	//construct wait function from Lua code
+	let wait=lua.load(LUA_WAIT)
+	.set_name("wait")
+	.set_environment(wait_env)
+	.call::<mlua::Function>(())?;
+
+	globals.raw_set("wait",wait)?;
+
+	Ok(())
+}

src/script.rs

@@ -1,37 +0,0 @@
-use rbx_dom_weak::types::Ref;
-
-use crate::context::Context;
-
-#[derive(Debug)]
-pub enum Error{
-	NoScript,
-	NoSource,
-}
-
-fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
-	let mut full_name=instance.name.clone();
-	let mut pref=instance.parent();
-	while let Some(parent)=dom.get_by_ref(pref){
-		full_name.insert(0,'.');
-		full_name.insert_str(0,parent.name.as_str());
-		pref=parent.parent();
-	}
-	full_name
-}
-
-pub struct Script{
-	pub(crate)script:Ref,
-}
-impl Script{
-	pub const fn new(script:Ref)->Self{
-		Self{script}
-	}
-	pub fn name_source(&self,context:&Context)->Result<(String,String),Error>{
-		let instance=context.dom.get_by_ref(self.script).ok_or(Error::NoScript)?;
-		let source=match instance.properties.get("Source").ok_or(Error::NoSource)?{
-			rbx_dom_weak::types::Variant::String(s)=>s.clone(),
-			_=>Err(Error::NoSource)?,
-		};
-		Ok((get_full_name(&context.dom,instance),source))
-	}
-}