Interoperability between Rust Fn and mlua Function about mlua HOT 6 CLOSED

#[allow(dead_code)]
#[derive(Clone, Debug)]
pub struct RGBColor {
    r: u8,
    g: u8,
    b: u8
}

#[allow(dead_code)]
impl RGBColor {
    pub fn new(red: u8, green: u8, blue: u8) -> Self {
        Self {
            r: red,
            g: green,
            b: blue,
        }
    }

    pub fn to_u32(&self) -> u32 {
        let (r, g, b) = (self.r as u32, self.g as u32, self.b as u32);
        (r << 16) | (g << 8) | b
    }

    pub fn lua_color(lua: &Lua) -> LuaResult<LuaTable> {
        let exports = lua.create_table()?;

        exports.set("new", lua.create_function(RGBColor::lua_new)?)?;

        Ok(exports)
    }

    pub fn lua_new(_: &Lua, (r, g, b): (u32, u32, u32)) -> LuaResult<RGBColor> {
        Ok(RGBColor::new(r as u8, g as u8, b as u8))
    }
}

impl UserData for RGBColor {}

extern crate mlua;

use std::sync::{Arc, Mutex};

use mlua::prelude::*;
use mlua::{UserData, UserDataMethods};

#[derive(Clone, Copy)]
#[allow(dead_code)]
struct Action {
    value: i32,
    f_value: f32,
}

impl UserData for Action {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_method("print", |_, this, ()| {
            println!("f_value: {}", this.f_value);

            Ok(())
        });
    }
}

#[derive(Clone)]
struct ActionsList {
    pub actions: Vec<Action>
}

#[allow(dead_code)]
impl ActionsList {
    pub fn new() -> Self {
        Self {
            actions: Vec::new()
        }
    }

    pub fn add_action(&mut self, action : Action) {
        self.actions.push(action)
    }

    pub fn get_action(&self, id : usize) -> Action {
        self.actions[id].clone()
    }
}

fn main() -> mlua::Result<()> {
    // Based on: https://doc.rust-lang.org/book/ch16-03-shared-state.html
    // Creates the action list
    let list = Arc::new(Mutex::new(ActionsList::new()));

    // Creates the lua context
    let lua = Lua::new();

    // We are going to make our functions calls inside a scope
    lua.scope(|scope| {
        let globals = lua.globals();

        // Creates the lua function: newAction(value, f_value) 
        globals.set("newAction", scope.create_function(|_, (v, f): (i32, f32)| {
            list.lock().unwrap().add_action(Action {
                value: v,
                f_value: f
            });

            Ok(list.lock().unwrap().actions.len()-1)
        })?)?;

        // Loads the script
        lua.load(r#"
        local test1 = newAction(32, 293.0)
        local test2 = newAction(399, 39.0)
        
        print("Test 2: " .. tostring(test2).."\n")
        
        function onAction(action_id, action)
            print(string.format("Receveid action_id, action: %d, %s", action_id, tostring(action)))
        
            action:print()
        
            if action_id == test1 then
                print("Action: test1\n")
            elseif action_id == test2 then
                print("Action: test2\n")
            end
        end
        "#).exec()?;

        // Run the test
        let on_action_fn : mlua::Function = globals.get("onAction")?;

        on_action_fn.call::<_, ()>((0, list.lock().unwrap().get_action(0)))?;
        on_action_fn.call::<_, ()>((1, list.lock().unwrap().get_action(1)))?;

        Ok(())
    })?;

    Ok(())
}

enum FunctionType<'a, 'lua> {
    LuaFunction(LuaFunction<'lua>),
    RustFunction(&'a dyn Fn(&mut Player, &mut Player)),
}

#[derive(Builder, Clone, Default)]
#[builder(default)]
pub struct Action {
    name: String,
    description: String,
    health_added: i64,
    cost: i64,
    #[builder(setter(strip_option))]
    action: Option<Arc<Box<dyn Fn(&mut Player, &mut Player)>>>,
}

impl LuaUserData for Action {}

pub struct Player;

impl LuaUserData for &mut Player {}

let lua = Lua::new().into_static();

let action_constructor = lua.create_function(|lua, arguments: LuaTable| {
    let mut ret = ActionBuilder::default();

    if let LuaValue::Function(action) = arguments.get("action")? {
        ret.action(Arc::new(Box::new(move |p1: &mut Player, p2: &mut Player| {
            lua.scope(|scope| {
                let p1 = scope.create_nonstatic_userdata(p1)?;
                let p2 = scope.create_nonstatic_userdata(p2)?;
                action.call::<_, ()>((p1, p2))
            }).expect("action failed");
        })));
    }

    Ok(ret.build())
})?;