Instance FindFirstChild + WaitForChild (no difference in implementation)

src/runner/instance.rs

@@ -87,6 +87,24 @@ macro_rules! class_composition{
 	};
 }
 
+//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)
+    }
+}
 
 class!(Instance);
 class_composition!(Instance,(Instance));
@@ -140,6 +158,29 @@ impl Instance{
 				Ok(children)
 			})
 		);
+		let ffc=|lua,this:&T,(name,search_descendants):(mlua::String,mlua::Value)|{
+			let name_str=name.to_str()?;
+			let search_descendants=match search_descendants{
+				mlua::Value::Nil=>false,
+				mlua::Value::Boolean(b)=>b,
+				_=>Err(mlua::Error::runtime("Invalid argument #3 bool expected"))?,
+			};
+			dom(lua,|dom|{
+				let instance=this.get(dom)?;
+				let child=match search_descendants{
+					true=>dom.descendants_of(this.referent()).find(|inst|inst.name==name_str),
+					false=>instance.children().iter().filter_map(|&r|
+						dom.get_by_ref(r)
+					).find(|inst|inst.name==name_str),
+				};
+				match child{
+					Some(instance)=>Instance::new(instance.referent()).into_lua(lua),
+					None=>mlua::Value::Nil.into_lua(lua),
+				}
+			})
+		};
+		methods.add_method("FindFirstChild",ffc);
+		methods.add_method("WaitForChild",ffc);
 		methods.add_method("GetDescendants",|lua,this,_:()|
 			dom(lua,|dom|{
 				let children:Vec<_>=dom
@@ -183,28 +224,48 @@ impl Instance{
 				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 property=db.find_default_property(class,index_str).ok_or(mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
-				match property{
-					rbx_types::Variant::Vector3(_)=>{
+				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)))?;
+				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"))?.take()?;
 						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Vector3(typed_value.into()));
 					},
-					rbx_types::Variant::Float32(_)=>{
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Float32)=>{
 						let typed_value:f32=coerce_float32(&value).ok_or(mlua::Error::runtime("Expected f32"))?;
 						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
 					},
-					rbx_types::Variant::Enum(_)=>{
-						let typed_value:super::r#enum::Enum=value.as_userdata().ok_or(mlua::Error::runtime("Expected Enum"))?.take()?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value.into()));
+					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(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"))?))
+							},
+							mlua::Value::UserData(any_user_data)=>{
+								let e:super::r#enum::Enum=any_user_data.take()?;
+								Ok(e.into())
+							},
+							_=>Err(mlua::Error::runtime("Expected Enum")),
+						}?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value));
 					},
-					rbx_types::Variant::Color3(_)=>{
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Color3)=>{
 						let typed_value:super::color3::Color3=value.as_userdata().ok_or(mlua::Error::runtime("Expected Color3"))?.take()?;
 						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Color3(typed_value.into()));
 					},
-					rbx_types::Variant::Bool(_)=>{
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Bool)=>{
 						let typed_value=value.as_boolean().ok_or(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"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::String(typed_value.to_owned()));
+					},
 					other=>return Err(mlua::Error::runtime(format!("Unimplemented property type: {other:?}"))),
 				}
 				Ok(())