fixed the event handler registration stuff

Resources/Server/TestPlugin/main.lua

@@ -1,8 +1,13 @@
 print("test from lua")
 print("Player count: " .. MP.GetPlayerCount())
 
-function onPluginLoaded()
+function onPluginLoaded2()
     print("HI!")
 end
 
-MP.RegisterEventHandler("onPluginLoaded", "onPluginLoaded")
+function onPlayerAuthenticated2(name)
+    print("hi welcome mista " .. name)
+end
+
+MP.RegisterEventHandler("onPluginLoaded", "onPluginLoaded2")
+MP.RegisterEventHandler("onPlayerAuthenticated", "onPlayerAuthenticated2")

src/server/mod.rs

@@ -363,6 +363,13 @@ impl Server {
                 match event {
                     ServerBoundPluginEvent::PluginLoaded => plugin.send_event(PluginBoundPluginEvent::CallEventHandler((ScriptEvent::OnPluginLoaded, Vec::new()))).await,
                     ServerBoundPluginEvent::RequestPlayerCount(responder) => { let _ = responder.send(PluginBoundPluginEvent::PlayerCount(self.clients.len())); }
+                    ServerBoundPluginEvent::RequestPlayers(responder) => {
+                        let mut players = HashMap::new();
+                        for client in &self.clients {
+                            players.insert(client.id, client.get_name().to_string());
+                        }
+                        let _ = responder.send(PluginBoundPluginEvent::Players(players));
+                    }
                     _ => {},
                 }
             }

src/server/plugins/backend_lua.rs

@@ -6,7 +6,8 @@ use super::{
     Argument
 };
 
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
+use std::collections::HashMap;
 
 use tokio::sync::mpsc::{Sender, Receiver};
 use tokio::sync::oneshot;
@@ -17,12 +18,16 @@ use mlua::{UserData, UserDataMethods, Value, Function, Variadic};
 #[derive(Clone)]
 struct Context {
     tx: Arc<Sender<ServerBoundPluginEvent>>,
+
+    handlers: Arc<Mutex<HashMap<String, String>>>,
 }
 
 impl Context {
     fn new(tx: Arc<Sender<ServerBoundPluginEvent>>) -> Self {
         Self {
             tx,
+
+            handlers: Arc::new(Mutex::new(HashMap::new())),
         }
     }
 }
@@ -43,8 +48,7 @@ impl UserData for Context {
         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 (?)
+            me.handlers.lock().expect("Lock is poisoned!").insert(event_name, handler_name);
-            let _ = me.tx.blocking_send(ServerBoundPluginEvent::RegisterEventHandler((event_name, handler_name)));
             Ok(())
         });
 
@@ -70,23 +74,27 @@ impl UserData for Context {
             }
         });
 
-        // methods.add_function("GetPlayers", |lua, ()| {
+        methods.add_function("GetPlayers", |lua, ()| {
-        //     let me: Context = lua.globals().get("MP")?;
+            let me: Context = lua.globals().get("MP")?;
-        //     let (tx, rx) = oneshot::channel();
+            let (tx, rx) = oneshot::channel();
-        //     if let Err(e) = me.tx.blocking_send(ServerBoundPluginEvent::RequestPlayerCount(tx)) {
+            if let Err(e) = me.tx.blocking_send(ServerBoundPluginEvent::RequestPlayers(tx)) {
-        //         error!("Failed to send packet: {:?}", e);
+                error!("Failed to send packet: {:?}", e);
-        //     }
+            }
-        //     let message = rx.blocking_recv();
+            let message = rx.blocking_recv();
-        //     if let Ok(message) = message {
+            if let Ok(message) = message {
-        //         if let PluginBoundPluginEvent::PlayerCount(player_count) = message {
+                if let PluginBoundPluginEvent::Players(players) = message {
-        //             Ok(player_count)
+                    let table = lua.create_table()?;
-        //         } else {
+                    for (id, name) in players {
-        //             unreachable!() // This really should never be reachable
+                        table.set(id, name)?;
-        //         }
+                    }
-        //     } else {
+                    Ok(table)
-        //         todo!("Receiving a response from the server failed! How?")
+                } else {
-        //     }
+                    unreachable!() // This really should never be reachable
-        // });
+                }
+            } else {
+                todo!("Receiving a response from the server failed! How?")
+            }
+        });
     }
 }
 
@@ -128,19 +136,25 @@ impl Backend for BackendLua {
     fn call_event_handler(&mut self, event: ScriptEvent, args: Vec<Argument>) {
         let event_name = match event {
             ScriptEvent::OnPluginLoaded => "onPluginLoaded",
+            ScriptEvent::OnPlayerAuthenticated => "onPlayerAuthenticated",
         };
 
-        let func: LuaResult<Function> = self.lua.globals().get(event_name);
+        // TODO: Error handling
-        if let Ok(func) = func {
+        let ctx: Context = self.lua.globals().get("MP").expect("MP is missing!");
-            let mapped_args = args.into_iter().map(|arg| {
+        let lock = ctx.handlers.lock().expect("Mutex is poisoned!");
-                match arg {
+        if let Some(handler_name) = lock.get(event_name) {
-                    Argument::String(s) => if let Ok(lua_str) = self.lua.create_string(&s) { Some(Value::String(lua_str)) } else { None },
+            let func: LuaResult<Function> = self.lua.globals().get(handler_name.clone());
-                    Argument::Boolean(b) => Some(Value::Boolean(b)),
+            if let Ok(func) = func {
-                    Argument::Number(f) => Some(Value::Number(f as f64)),
+                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);
                 }
-            }).filter(|v| v.is_some());
-            if let Err(e) = func.call::<_, ()>(Variadic::from_iter(mapped_args)) {
-                error!("[LUA] {}", e);
             }
         }
     }

src/server/plugins/mod.rs

@@ -1,8 +1,8 @@
 pub mod backend_lua;
 
 use std::sync::Arc;
+use std::collections::HashMap;
 use tokio::runtime::Runtime;
-use tokio::sync::Mutex;
 use tokio::sync::mpsc::{self, Sender, Receiver};
 use tokio::sync::oneshot;
 
@@ -28,21 +28,23 @@ pub enum Argument {
 #[derive(Debug)]
 pub enum ScriptEvent {
     OnPluginLoaded,
+    OnPlayerAuthenticated,
 }
 
 #[derive(Debug)]
 pub enum PluginBoundPluginEvent {
     CallEventHandler((ScriptEvent, Vec<Argument>)),
+
     PlayerCount(usize),
+    Players(HashMap<u8, String>),
 }
 
 #[derive(Debug)]
 pub enum ServerBoundPluginEvent {
     PluginLoaded,
 
-    /// Arguments: (event name, handler function name)
-    RegisterEventHandler((String, String)),
     RequestPlayerCount(oneshot::Sender<PluginBoundPluginEvent>),
+    RequestPlayers(oneshot::Sender<PluginBoundPluginEvent>),
 }
 
 pub struct Plugin {