improve ease of exposing component types

Author: lenscas

core/src/lib.rs

@@ -21,4 +21,5 @@ pub use async_trait::async_trait;
 pub use serde;
 pub use serde_json;
 
+pub mod lua;
 pub mod test;

core/src/lua/create_component.rs

@@ -0,0 +1,168 @@
+use std::borrow::Cow;
+
+use hv_lua::{FromLua, ToLua};
+use tealr::{NamePart, TealType, TypeName};
+
+///This trait is used to limit what types can be set in the create_type_component_container macro
+///It doesn't really have a use outside of that.
+pub trait Component {
+    fn is_component() {}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CopyComponent<T>(T);
+impl<T> Component for CopyComponent<T> {}
+impl<T: Send + Sync + 'static + Clone + Copy> hv_lua::UserData for CopyComponent<T>
+where
+    T: for<'a> ToLua<'a> + for<'a> FromLua<'a>,
+{
+    #[allow(clippy::unit_arg)]
+    fn add_fields<'lua, F: hv_lua::UserDataFields<'lua, Self>>(fields: &mut F) {
+        fields.add_field_method_get("value", |_, this| Ok(this.0));
+        fields.add_field_method_set("value", |_, this, value| Ok(this.0 = value));
+    }
+    fn on_metatable_init(t: hv_alchemy::Type<Self>) {
+        use hv_lua::hv::LuaUserDataTypeExt;
+        t.add_clone().add_copy().mark_component();
+    }
+    fn add_type_methods<'lua, M: hv_lua::UserDataMethods<'lua, hv_alchemy::Type<Self>>>(
+        methods: &mut M,
+    ) {
+        methods.add_function("new", |_, i: T| Ok(Self(i)));
+    }
+    fn on_type_metatable_init(t: hv_alchemy::Type<hv_alchemy::Type<Self>>) {
+        use hv_lua::hv::LuaUserDataTypeTypeExt;
+        t.mark_component_type();
+    }
+}
+impl<T: tealr::TypeName> tealr::TypeName for CopyComponent<T> {
+    fn get_type_parts() -> std::borrow::Cow<'static, [tealr::NamePart]> {
+        let name = tealr::NamePart::Type(TealType {
+            name: Cow::Borrowed("Component"),
+            type_kind: tealr::KindOfType::External,
+            generics: None,
+        });
+        let mut type_name = vec![name, NamePart::Symbol(Cow::Borrowed("<"))];
+        type_name.append(&mut T::get_type_parts().into_owned());
+        type_name.push(NamePart::Symbol(Cow::Borrowed(">")));
+        Cow::Owned(type_name)
+    }
+}
+impl<T: TypeName> tealr::TypeBody for CopyComponent<T> {
+    fn get_type_body(gen: &mut tealr::TypeGenerator) {
+        get_type_body_component::<T, Self>(gen)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CloneComponent<T>(T);
+impl<T> Component for CloneComponent<T> {}
+impl<T: Send + Sync + 'static + Clone> hv_lua::UserData for CloneComponent<T>
+where
+    T: for<'a> ToLua<'a> + for<'a> FromLua<'a>,
+{
+    #[allow(clippy::unit_arg)]
+    fn add_fields<'lua, F: hv_lua::UserDataFields<'lua, Self>>(fields: &mut F) {
+        fields.add_field_method_get("value", |_, this| Ok(this.0.clone()));
+        fields.add_field_method_set("value", |_, this, value| Ok(this.0 = value));
+    }
+    fn on_metatable_init(t: hv_alchemy::Type<Self>) {
+        use hv_lua::hv::LuaUserDataTypeExt;
+        t.add_clone().mark_component();
+    }
+    fn add_type_methods<'lua, M: hv_lua::UserDataMethods<'lua, hv_alchemy::Type<Self>>>(
+        methods: &mut M,
+    ) {
+        methods.add_function("new", |_, i: T| Ok(Self(i)));
+    }
+    fn on_type_metatable_init(t: hv_alchemy::Type<hv_alchemy::Type<Self>>) {
+        use hv_lua::hv::LuaUserDataTypeTypeExt;
+        t.mark_component_type();
+    }
+}
+impl<T: tealr::TypeName> tealr::TypeName for CloneComponent<T> {
+    fn get_type_parts() -> std::borrow::Cow<'static, [tealr::NamePart]> {
+        let name = tealr::NamePart::Type(TealType {
+            name: Cow::Borrowed("Component"),
+            type_kind: tealr::KindOfType::External,
+            generics: None,
+        });
+        let mut type_name = vec![name, NamePart::Symbol(Cow::Borrowed("<"))];
+        type_name.append(&mut T::get_type_parts().into_owned());
+        type_name.push(NamePart::Symbol(Cow::Borrowed(">")));
+        Cow::Owned(type_name)
+    }
+}
+impl<T: TypeName> tealr::TypeBody for CloneComponent<T> {
+    fn get_type_body(gen: &mut tealr::TypeGenerator) {
+        get_type_body_component::<T, Self>(gen)
+    }
+}
+
+fn get_type_body_component<T: TypeName, SelfType: TypeName>(gen: &mut tealr::TypeGenerator) {
+    let mut signature = vec![NamePart::Symbol(Cow::Borrowed("function("))];
+    signature.append(&mut T::get_type_parts().into_owned());
+    signature.push(NamePart::Symbol(Cow::Borrowed("):")));
+    signature.append(&mut SelfType::get_type_parts().into_owned());
+
+    gen.methods.push(tealr::ExportedFunction {
+        name: Cow::Borrowed("new").into(),
+        signature: Cow::Owned(signature),
+        is_meta_method: false,
+    });
+    gen.fields.push((
+        Cow::Borrowed("value"),
+        tealr::type_parts_to_str(<T as tealr::TypeName>::get_type_parts()),
+    ));
+}
+
+#[macro_export]
+macro_rules! create_type_component_container {
+    ($name:ident with $($field_name:ident of $type_name:ty,)+) => {
+        #[derive(Debug, Clone)]
+        pub struct $name<'lua>(hv_lua::Table<'lua>);
+        impl<'lua> hv_lua::ToLua<'lua> for $name<'lua> {
+            fn to_lua(
+                self,
+                lua: &'lua hv_lua::Lua,
+            ) -> std::result::Result<hv_lua::Value<'lua>, hv_lua::Error> {
+                self.0.to_lua(lua)
+            }
+        }
+        impl<'lua> tealr::TypeName for $name<'lua> {
+            fn get_type_parts() -> std::borrow::Cow<'static, [tealr::NamePart]> {
+                use tealr::new_type;
+                new_type!(Components)
+            }
+        }
+        impl<'lua> tealr::TypeBody for $name<'lua> {
+            fn get_type_body(gen: &mut tealr::TypeGenerator) {
+                $(
+                    <$type_name as $crate::lua::Component>::is_component();
+                    gen.fields.push(
+                        (
+                            std::borrow::Cow::Borrowed(
+                                stringify!($field_name)
+                            ),
+                            tealr::type_parts_to_str(
+                                <$type_name as tealr::TypeName>::get_type_parts()
+                            )
+                        )
+                    );
+                )*
+
+            }
+        }
+        impl<'lua> $name<'lua> {
+            pub fn new(lua: &'lua hv_lua::Lua) -> Result<Self, Box<dyn std::error::Error>> {
+                let table = lua.create_table()?;
+                use $crate::lua::Component;
+                $(
+                    <$type_name as Component>::is_component();
+                    table.set(stringify!($field_name),lua.create_userdata_type::<$type_name>()?)?;
+                )*
+                Ok(Self(table))
+            }
+        }
+    };
+}

core/src/lua/mod.rs

@@ -0,0 +1,112 @@
+mod create_component;
+pub use create_component::{CloneComponent, Component, CopyComponent};
+
+use std::{error::Error, os::unix::prelude::OsStrExt, path::Path};
+
+use hv_lua::{chunk, hv::types, Function, Lua, Table, Value};
+
+const LUA_ENTRY: &str = "main";
+
+crate::create_type_component_container!(
+    TypeContainer with
+    I32 of CopyComponent<i32>,
+    Bool of CopyComponent<bool>,
+);
+
+pub fn init_lua<RegisterTypes: Fn(&Lua) -> Result<Value, Box<dyn Error>>>(
+    mod_dir: &Path,
+    register_types: RegisterTypes,
+) -> Result<Lua, Box<dyn Error>> {
+    let lua = Lua::new();
+    let hv = types(&lua)?;
+    let component_types = register_types(&lua)?;
+    let dir = mod_dir.as_os_str().as_bytes().to_owned();
+    {
+        let globals = lua.globals();
+        //a table containing all the mods
+        globals.set("mods", lua.create_table()?)?;
+        //this table is used to have quick access to every event that needs to run.
+        globals.set("events", lua.create_table()?)?;
+
+        //we don't want users to simply use `require` to load their files as that will either result in conflicts or annoying path names
+        //to drive this point home, I rename the `require` function here and add 2 other functions to load mod files
+        let req = globals.get::<_, Function>("require")?;
+        globals.set("require_lib", req)?;
+        globals.set("require", hv_lua::Nil)?;
+
+        globals.set("hv", hv)?;
+        globals.set("type_components", component_types)?;
+
+        //this function allows people to load a file from arbitrary mods
+        //this allows "library only" mods to exist.
+        //there will also be a function that loads from the current mod. However, that one needs to be defined when loading the mod
+        let load_any_mod_file = lua.create_function(
+            move |lua, (from_mod, path): (hv_lua::String, hv_lua::String)| {
+                //TODO: a way to go from `mod id` to `mod folder`
+                let globals = lua.globals();
+                let req = globals.get::<_, Function>("require_lib")?;
+                let mod_folder = globals
+                    .get::<_, Table>("mods")?
+                    .get::<_, Table>(from_mod)?
+                    .get::<_, hv_lua::String>("dir_name")?;
+
+                let mut full_path = Vec::new();
+                full_path.extend_from_slice(&dir);
+                full_path.extend_from_slice(b".");
+                full_path.extend_from_slice(mod_folder.as_bytes());
+                full_path.extend_from_slice(b".");
+                full_path.extend_from_slice(path.as_bytes());
+                let full_path = lua.create_string(&full_path)?;
+                req.call::<_, hv_lua::Value>(full_path)
+            },
+        )?;
+        globals.set("require_from", load_any_mod_file)?;
+    }
+    Ok(lua)
+}
+
+pub fn load_lua<P: AsRef<[u8]>>(
+    mod_id: String,
+    mod_folder: P,
+    lua: &Lua,
+) -> Result<(), Box<dyn Error>> {
+    let name = mod_id;
+    let name_to_transfer = name.clone();
+    //ideally, we use a lua string but... those don't get transferred properly for some reason....
+    let dir = String::from_utf8_lossy(mod_folder.as_ref());
+    let entry = LUA_ENTRY.to_string();
+    let chunk = chunk! {
+        local name = $name_to_transfer
+        local dir = $dir
+        local entry = $entry
+
+        function require(load_path)
+            return require_from(name , load_path)
+        end
+        local function init_mod()
+            return require(entry)
+        end
+        local mod_config = {
+            dir_name = dir,
+            require = require,
+            mod_id = name
+        }
+        mods[name] = mod_config
+
+        local mod_events = init_mod()
+        mod_config["events"] = mod_events
+        if type(mod_events) == "table" then
+            for k, _ in pairs(mod_events) do
+                local event_list = events[k] or {}
+                table.insert(event_list, mod_config)
+                events[k] = event_list
+            end
+        end
+        require = nil
+    };
+    lua.load(chunk)
+        .set_name(&format!("Load mod: {:?}", name))?
+        .exec()?;
+
+    Ok(())
+}

mods/test_lua_mod_one/main.lua

@@ -4,10 +4,14 @@ local entity;
 return {
     init = function(world)
         print "Run init"
+        local I32 = type_components.I32
+        local Bool = type_components.Bool
         entity = world:spawn { I32.new(5), Bool.new(true) }
     end,
     fixed_update_physics_bodies = function(world)
         local Query = hv.ecs.Query
+        local I32 = type_components.I32
+        local Bool = type_components.Bool
         local query = Query.new { Query.write(I32), Query.read(Bool) }
         world:query_one(query, entity, function(item)
             print("Got item:",item)