goofy ahh once cell function storage code

src/runner/runner.rs

@@ -137,7 +137,7 @@ impl Runnable<'_>{
 		})?;
 		if let Some(render_stepped)=render_stepped{
 			let signal:&super::script_signal::ScriptSignal=&*render_stepped.borrow()?;
-			signal.fire(mlua::MultiValue::new());
+			signal.fire(&mlua::MultiValue::new());
 		}
 		Ok(())
 	}

src/runner/script_signal.rs

@@ -1,52 +1,147 @@
 use std::{cell::RefCell,rc::Rc};
 
 #[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.
-	callbacks:Rc<RefCell<Vec<mlua::Function>>>,
+struct FunctionList{
+	functions:Vec<mlua::Function>,
 }
-pub struct ScriptConnection{
-	signal:ScriptSignal,
-	function:mlua::Function,
-}
-impl ScriptSignal{
+impl FunctionList{
 	pub fn new()->Self{
 		Self{
-			callbacks:Rc::new(RefCell::new(Vec::new())),
+			functions:Vec::new(),
 		}
 	}
 	// This eats the Lua error
-	pub fn fire(&self,args:mlua::MultiValue){
+	pub fn fire(self,args:&mlua::MultiValue){
 		// Make a copy of the list in case Lua attempts to modify it during the loop
-		let functions=self.callbacks.borrow().clone();
-		for function in functions{
+		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.
+	callbacks:RcFunctionList,
+	once:RcFunctionList,
+	wait:Rc<RefCell<Vec<mlua::Thread>>>,
+	wait_function:std::cell::OnceCell<mlua::Function>,
+}
+pub struct ScriptConnection{
+	connection:RcFunctionList,
+	function:mlua::Function,
+}
+impl ScriptSignal{
+	pub fn new()->Self{
+		Self{
+			callbacks:RcFunctionList::new(),
+			once:RcFunctionList::new(),
+			wait:Rc::new(RefCell::new(Vec::new())),
+			wait_function:std::cell::OnceCell::new(),
+		}
+	}
+	pub fn fire(&self,args:&mlua::MultiValue){
+		self.callbacks.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.callbacks.borrow_mut().push(function.clone());
+		self.callbacks.functions.borrow_mut().functions.push(function.clone());
 		ScriptConnection{
-			signal:self.clone(),
+			connection:self.callbacks.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.signal.callbacks.borrow().iter().position(|function|function==&self.function)
+		self.connection.functions.borrow().functions.iter().position(|function|function==&self.function)
 	}
 }
 
+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()
+	wait_thread()
+	return coroutine_yield()
+end";
+
 impl mlua::UserData for ScriptSignal{
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
+		fields.add_field_method_get("Wait",|lua,this|{
+			Ok(match this.wait_function.get(){
+				Some(f)=>f.clone(),
+				None=>{
+					let coroutine_table=lua.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>(())?;
+
+					this.wait_function.set(wait.clone()).unwrap();
+					wait
+				}
+			})
+		});
+	}
 	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))
@@ -71,7 +166,7 @@ impl mlua::UserData for ScriptConnection{
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
 		methods.add_method("Disconnect",|_,this,_:()|{
 			if let Some(index)=this.position(){
-				this.signal.callbacks.borrow_mut().remove(index);
+				this.connection.functions.borrow_mut().functions.remove(index);
 			}
 			Ok(())
 		});