implement VectorToWorldSpace

Cargo.lock

@@ -16,9 +16,9 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "base64"
@@ -40,9 +40,9 @@ checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "blake3"
-version = "1.5.4"
+version = "1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
+checksum = "b8ee0c1824c4dea5b5f81736aff91bae041d2c07ee1192bec91054e10e3e601e"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -53,9 +53,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c"
+checksum = "1a68f1f47cdf0ec8ee4b941b2eee2a80cb796db73118c0dd09ac63fbe405be22"
 dependencies = [
  "memchr",
  "serde",
@@ -69,9 +69,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cc"
-version = "1.1.19"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d74707dde2ba56f86ae90effb3b43ddd369504387e718014de010cec7959800"
+checksum = "fd9de9f2205d5ef3fd67e685b0df337994ddd4495e2a28d185500d0e1edfea47"
 dependencies = [
  "shlex",
 ]
@@ -88,6 +88,12 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
 
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
 [[package]]
 name = "getrandom"
 version = "0.2.15"
@@ -101,9 +107,9 @@ dependencies = [
 
 [[package]]
 name = "glam"
-version = "0.29.0"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28091a37a5d09b555cb6628fd954da299b536433834f5b8e59eba78e0cbbf8a"
+checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677"
 
 [[package]]
 name = "lazy_static"
@@ -113,9 +119,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.166"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "c2ccc108bbc0b1331bd061864e7cd823c0cab660bbe6970e66e2c0614decde36"
 
 [[package]]
 name = "libloading"
@@ -139,9 +145,9 @@ dependencies = [
 
 [[package]]
 name = "luau0-src"
-version = "0.10.3+luau640"
+version = "0.11.2+luau653"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f39d12b514a676c943990cfbe6200fedcb9c293c8c9219d29be512a6969be92"
+checksum = "02313a53daf1fae25e82f7e7ca56180b72d1f08c514426672877cd957298201c"
 dependencies = [
  "cc",
 ]
@@ -154,11 +160,12 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "mlua"
-version = "0.10.0-beta.2"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "200dd4c8e5f81416d43a023b9921c3cbf01d828094b23a90b26826c3840ba4f3"
+checksum = "0ae9546e4a268c309804e8bbb7526e31cbfdedca7cd60ac1b987d0b212e0d876"
 dependencies = [
  "bstr",
+ "either",
  "libloading",
  "mlua-sys",
  "num-traits",
@@ -168,9 +175,9 @@ dependencies = [
 
 [[package]]
 name = "mlua-sys"
-version = "0.6.3"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebe026d6bd1583a9cf9080e189030ddaea7e6f5f0deb366a8e26f8a26c4135b8"
+checksum = "efa6bf1a64f06848749b7e7727417f4ec2121599e2a10ef0a8a3888b0e9a5a0d"
 dependencies = [
  "cc",
  "cfg-if",
@@ -260,9 +267,9 @@ dependencies = [
 
 [[package]]
 name = "pkg-config"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "ppv-lite86"
@@ -275,9 +282,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
@@ -402,7 +409,7 @@ dependencies = [
 
 [[package]]
 name = "roblox_emulator"
-version = "0.4.6"
+version = "0.4.7"
 dependencies = [
  "glam",
  "mlua",
@@ -427,18 +434,18 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "serde"
-version = "1.0.210"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.210"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -465,9 +472,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "syn"
-version = "2.0.77"
+version = "2.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -476,18 +483,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -496,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
 
 [[package]]
 name = "wasi"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.4.6"
+version = "0.4.7"
 edition = "2021"
 repository = "https://git.itzana.me/StrafesNET/roblox_emulator"
 license = "MIT OR Apache-2.0"
@@ -13,7 +13,7 @@ run-service=[]
 
 [dependencies]
 glam = "0.29.0"
-mlua = { version = "0.10.0-beta", features = ["luau"] }
+mlua = { version = "0.10.1", 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" }

src/runner/cframe.rs

@@ -146,6 +146,9 @@ impl mlua::UserData for CFrame{
 			this.0.matrix3.y_axis.z,
 			this.0.matrix3.z_axis.z,
 		)));
+		methods.add_method("VectorToWorldSpace",|_,this,v:Vector3|
+			Ok(Vector3(this.0.transform_vector3a(v.0)))
+		);
 
 		//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)));

src/runner/instance/instance.rs

@@ -4,11 +4,12 @@ use mlua::{FromLua,FromLuaMulti,IntoLua,IntoLuaMulti};
 use rbx_types::Ref;
 use rbx_dom_weak::{InstanceBuilder,WeakDom};
 
-use super::vector3::Vector3;
+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(ClassFunctions::default());
+	lua.set_app_data(ClassMethodsStore::default());
+	lua.set_app_data(InstanceValueStore::default());
 
 	let instance_table=lua.create_table()?;
 
@@ -16,7 +17,7 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 	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(mlua::Error::runtime("Nil Parent not yet supported"))?;
+			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))))
@@ -30,14 +31,10 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 }
 
 // LMAO look at this function!
-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(mlua::Error::runtime("DataModel missing"))?;
+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 class_functions_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut ClassFunctions)->mlua::Result<T>)->mlua::Result<T>{
-	let mut cf=lua.app_data_mut::<ClassFunctions>().ok_or(mlua::Error::runtime("ClassFunctions missing"))?;
-	f(&mut *cf)
-}
 
 fn coerce_float32(value:&mlua::Value)->Option<f32>{
 	match value{
@@ -92,10 +89,10 @@ impl Instance{
 		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(mlua::Error::runtime("Instance missing"))
+		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(mlua::Error::runtime("Instance missing"))
+		dom.get_by_ref_mut(self.referent).ok_or_else(||mlua::Error::runtime("Instance missing"))
 	}
 }
 type_from_lua_userdata!(Instance);
@@ -128,7 +125,7 @@ impl mlua::UserData for Instance{
 			})
 		});
 		fields.add_field_method_set("Parent",|lua,this,val:Option<Instance>|{
-			let parent=val.ok_or(mlua::Error::runtime("Nil Parent not yet supported"))?;
+			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(())
@@ -234,7 +231,7 @@ impl mlua::UserData for Instance{
 				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(mlua::Error::runtime("Class missing"))?;
+				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()
@@ -256,13 +253,13 @@ impl mlua::UserData for Instance{
 					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::<super::cframe::CFrame>::into(cf).into_lua(lua),
-					Some(rbx_types::Variant::Vector3(v))=>return Into::<super::vector3::Vector3>::into(v).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_functions_mut(lua,|cf|{
+				if let Some(function)=class_methods_store_mut(lua,|cf|{
 					let mut iter=SuperClassIter{
 						database:db,
 						descriptor:Some(class),
@@ -275,6 +272,17 @@ impl mlua::UserData for Instance{
 				})?{
 					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()))
@@ -287,19 +295,19 @@ impl mlua::UserData for Instance{
 				//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(mlua::Error::runtime("Class missing"))?;
+				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(mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
+				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(mlua::Error::runtime("Expected Userdata"))?.borrow()?;
+						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(mlua::Error::runtime("Expected f32"))?;
+						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)=>{
@@ -307,11 +315,11 @@ impl mlua::UserData for Instance{
 							&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(mlua::Error::runtime("Database DataType Enum name  does not exist"))?;
-								Ok(rbx_types::Enum::from_u32(*e.items.get(&*s.to_str()?).ok_or(mlua::Error::runtime("Invalid enum item"))?))
+								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:super::r#enum::Enum=*any_user_data.borrow()?;
+								let e:crate::runner::r#enum::Enum=*any_user_data.borrow()?;
 								Ok(e.into())
 							},
 							_=>Err(mlua::Error::runtime("Expected Enum")),
@@ -319,23 +327,23 @@ impl mlua::UserData for Instance{
 						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value));
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::Color3)=>{
-						let typed_value:super::color3::Color3=*value.as_userdata().ok_or(mlua::Error::runtime("Expected Color3"))?.borrow()?;
+						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(mlua::Error::runtime("Expected boolean"))?;
+						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(mlua::Error::runtime("Expected boolean"))?;
+						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:super::number_sequence::NumberSequence=*value.as_userdata().ok_or(mlua::Error::runtime("Expected NumberSequence"))?.borrow()?;
+						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:super::color_sequence::ColorSequence=*value.as_userdata().ok_or(mlua::Error::runtime("Expected ColorSequence"))?.borrow()?;
+						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:?}"))),
@@ -369,12 +377,13 @@ static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
 		"GetService"=>cf!(|lua,_this,service:mlua::String|{
 			dom_mut(lua,|dom|{
 				//dom.root_ref()==this.referent ?
-				match &*service.to_str()?{
-					"Lighting"=>{
-						let referent=find_first_child_of_class(dom,dom.root(),"Lighting")
+				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("Lighting"))
+							dom.insert(dom.root_ref(),InstanceBuilder::new(service))
 						);
 						Ok(Instance::new(referent))
 					},
@@ -384,21 +393,21 @@ static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
 		}),
 	},
 	"Terrain"=>phf::phf_map!{
-		"FillBlock"=>cf!(|_lua,_,_:(super::cframe::CFrame,Vector3,super::r#enum::Enum)|mlua::Result::Ok(()))
+		"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 ClassFunctions{
+struct ClassMethodsStore{
 	classes:HashMap<&'static str,//ClassName
 		HashMap<&'static str,//Method name
 			mlua::Function
 		>
 	>
 }
-impl ClassFunctions{
+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
@@ -433,6 +442,10 @@ impl ClassMethods<'_>{
 		})
 	}
 }
+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>;
@@ -481,3 +494,64 @@ fn find_virtual_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/mod.rs

@@ -7,7 +7,8 @@ mod color3;
 mod cframe;
 mod vector3;
 pub mod instance;
-mod number_sequence;
+mod script_signal;
 mod color_sequence;
+mod number_sequence;
 
 pub use runner::{Runner,Runnable,Error};

src/runner/runner.rs

@@ -33,11 +33,12 @@ fn init(lua:&mlua::Lua)->mlua::Result<()>{
 
 	#[cfg(feature="run-service")]
 	crate::scheduler::set_globals(lua,&globals)?;
+	super::script_signal::set_globals(lua,&globals)?;
 	super::r#enum::set_globals(lua,&globals)?;
 	super::color3::set_globals(lua,&globals)?;
 	super::vector3::set_globals(lua,&globals)?;
 	super::cframe::set_globals(lua,&globals)?;
-	super::instance::set_globals(lua,&globals)?;
+	super::instance::instance::set_globals(lua,&globals)?;
 	super::number_sequence::set_globals(lua,&globals)?;
 	super::color_sequence::set_globals(lua,&globals)?;
 
@@ -88,7 +89,7 @@ impl Runnable<'_>{
 		}
 	}
 	pub fn run_script(&self,script:super::instance::Instance)->Result<(),Error>{
-		let (name,source)=super::instance::get_name_source(&self.lua,script).map_err(Error::RustLua)?;
+		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)?;
@@ -120,4 +121,23 @@ impl Runnable<'_>{
 		}
 		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/scheduler.rs

@@ -2,14 +2,6 @@ pub use tick::Tick;
 mod tick{
 	#[derive(Clone,Copy,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
 	pub struct Tick(u64);
-	impl Tick{
-		pub const fn new(value:u64)->Self{
-			Self(value)
-		}
-		pub const fn get(&self)->u64{
-			self.0
-		}
-	}
 	impl std::ops::Add<u64> for Tick{
 		type Output=Self;
 		fn add(self,rhs:u64)->Self::Output{
@@ -40,9 +32,6 @@ pub struct Scheduler{
 }
 
 impl Scheduler{
-	pub const fn tick(&self)->Tick{
-		self.tick
-	}
 	pub fn has_scheduled_threads(&self)->bool{
 		!self.schedule.is_empty()
 	}
@@ -58,7 +47,7 @@ impl Scheduler{
 }
 
 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(mlua::Error::runtime("Scheduler missing"))?;
+	let mut scheduler=lua.app_data_mut::<crate::scheduler::Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
 	f(&mut *scheduler)
 }