wip lua event stuff

src/server/plugins/backend_lua.rs

@@ -1,8 +1,18 @@
-use super::{Backend, ServerBoundPluginEvent};
+use super::{
+    Backend,
+    ServerBoundPluginEvent,
+    PluginBoundPluginEvent,
+    ScriptEvent,
+    Argument
+};
+
 use std::sync::Arc;
-use tokio::sync::mpsc::Sender;
+
+use tokio::sync::mpsc::{Sender, Receiver};
+use tokio::sync::oneshot;
+
 use mlua::prelude::*;
-use mlua::{UserData, UserDataMethods, Value};
+use mlua::{UserData, UserDataMethods, Value, Function, Variadic};
 
 #[derive(Clone)]
 struct Context {
@@ -28,13 +38,32 @@ impl<'lua> FromLua<'lua> for Context {
 
 impl UserData for Context {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("RegisterEventHandler", |lua, _, (event_name, handler_name): (String, String)| {
+        // Implement all the API functions here
+
+        methods.add_function("RegisterEventHandler", |lua, (event_name, handler_name): (String, String)| {
             debug!("Event handler registered: {} (EVENT) = {} (LUA)", event_name, handler_name);
             let me: Context = lua.globals().get("MP")?;
             // TODO: Figure out how to handle these errors (?)
             let _ = me.tx.blocking_send(ServerBoundPluginEvent::RegisterEventHandler((event_name, handler_name)));
             Ok(())
         });
+
+        methods.add_function("GetPlayerCount", |lua, ()| {
+            let me: Context = lua.globals().get("MP")?;
+            let (tx, rx) = oneshot::channel();
+            let r = me.tx.blocking_send(ServerBoundPluginEvent::RequestPlayerCount(tx));
+            debug!("{:?}", r);
+            let message = rx.blocking_recv();
+            if let Ok(message) = message {
+                if let PluginBoundPluginEvent::PlayerCount(player_count) = message {
+                    Ok(player_count)
+                } else {
+                    unreachable!() // This really should never be reachable
+                }
+            } else {
+                todo!("Receiving a response from the server failed! How?")
+            }
+        });
     }
 }
 
@@ -79,4 +108,24 @@ impl Backend for BackendLua {
 
         Ok(())
     }
+
+    fn call_event_handler(&mut self, event: ScriptEvent, args: Vec<Argument>) {
+        let event_name = match event {
+            ScriptEvent::OnPluginLoaded => "onPluginLoaded",
+        };
+
+        let func: LuaResult<Function> = self.lua.globals().get(event_name);
+        if let Ok(func) = func {
+            let mapped_args = args.into_iter().map(|arg| {
+                match arg {
+                    Argument::String(s) => if let Ok(lua_str) = self.lua.create_string(&s) { Some(Value::String(lua_str)) } else { None },
+                    Argument::Boolean(b) => Some(Value::Boolean(b)),
+                    Argument::Number(f) => Some(Value::Number(f as f64)),
+                }
+            }).filter(|v| v.is_some());
+            if let Err(e) = func.call::<_, ()>(Variadic::from_iter(mapped_args)) {
+                error!("[LUA] {}", e);
+            }
+        }
+    }
 }