fix everything but why does it not work

src/runner/instance.rs

@@ -9,6 +9,7 @@ use super::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()?;
 
@@ -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>{
+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(mlua::Error::runtime("DataModel missing"))?;
 	f(&mut *dom)
 }
-fn class_functions_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(mlua::Error::runtime("ClassFunctions missing"))?;
-	f(&mut *cf)
-}
 
 fn coerce_float32(value:&mlua::Value)->Option<f32>{
 	match value{
@@ -262,7 +259,7 @@ impl mlua::UserData for Instance{
 					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()))
@@ -434,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(mlua::Error::runtime("ClassMethodsStore missing"))?;
+	f(&mut *cf)
+}
 
 /// A virtual property pointer definition shorthand.
 type VirtualPropertyFunctionPointer=fn(&rbx_types::Variant)->Option<rbx_types::Variant>;
@@ -499,19 +511,20 @@ static LAZY_USER_DATA:LUD=phf::phf_map!{
 		},
 	},
 };
-struct InstanceValueStore{
+#[derive(Default)]
+pub struct InstanceValueStore{
 	values:HashMap<Ref,
 		HashMap<&'static str,
 			mlua::AnyUserData
 		>
 	>,
 }
-struct InstanceValues<'a>{
+pub struct InstanceValues<'a>{
 	named_values:&'static phf::Map<&'static str,CreateUserData>,
 	values:&'a mut HashMap<&'static str,mlua::AnyUserData>,
 }
 impl InstanceValueStore{
-	fn get_or_create_instance_values(&mut self,instance:&rbx_dom_weak::Instance)->Option<InstanceValues>{
+	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{
@@ -523,7 +536,7 @@ impl InstanceValueStore{
 	}
 }
 impl InstanceValues<'_>{
-	fn get_or_create_value(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
+	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){
@@ -537,3 +550,8 @@ impl InstanceValues<'_>{
 		})
 	}
 }
+
+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(mlua::Error::runtime("InstanceValueStore missing"))?;
+	f(&mut *cf)
+}

src/runner/runner.rs

@@ -120,4 +120,23 @@ impl Runnable<'_>{
 		}
 		Ok(())
 	}
+	#[cfg(feature="run-service")]
+	pub fn run_service_step(&self)->Result<(),mlua::Error>{
+		let render_stepped=super::instance::dom_mut(&self.lua,|dom|{
+			let run_service=super::instance::find_first_child_of_class(dom,dom.root(),"RunService").ok_or_else(||mlua::Error::runtime("RunService missing"))?;
+			super::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).unwrap();
+				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

@@ -53,7 +53,14 @@ impl mlua::UserData for ScriptSignal{
 		// );
 	}
 }
-//type_from_lua_userdata!(ScriptSignal);
+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){

src/scheduler.rs

@@ -61,45 +61,56 @@ pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut crate::scheduler::S
 	let mut scheduler=lua.app_data_mut::<crate::scheduler::Scheduler>().ok_or(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 schedule_thread=lua.create_function(|lua,dt:mlua::Value|{
-		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(())
-		})
-	})?;
+	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",globals.get::<mlua::Table>("coroutine")?)?;
+	wait_env.raw_set("coroutine",coroutine_table)?;
 	wait_env.raw_set("schedule_thread",schedule_thread)?;
-	let wait=lua.load("
-		local coroutine_yield=coroutine.yield
-		local schedule_thread=schedule_thread
-		return function(dt)
-			schedule_thread(dt)
-			return coroutine_yield()
-		end
-	")
+
+	//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(())