improvements to many aspects of plugins

Resources/Server/TestPlugin/main.lua

@@ -5,7 +5,7 @@ function onPluginLoaded()
     print("HI!")
 end
 
-function onPlayerAuthenticated(joined_name)
+function onPlayerAuthenticated(joined_name, role, is_guest, identifiers)
     print("hi welcome mista " .. joined_name)
 
     print("current players:")
@@ -14,8 +14,15 @@ function onPlayerAuthenticated(joined_name)
     end
     print("yipee")
 
+    print("Player count: " .. MP.GetPlayerCount())
+
     return 0 -- 0 = do not block
 end
 
-MP.RegisterEventHandler("onPluginLoaded", "onPluginLoaded")
+function onPlayerDisconnect(pid)
-MP.RegisterEventHandler("onPlayerAuthenticated", "onPlayerAuthenticated")
+    print("Player with PID " .. pid .. " has left!")
+end
+
+MP.RegisterEventHandler("onInit", "onPluginLoaded")
+MP.RegisterEventHandler("onPlayerAuth", "onPlayerAuthenticated")
+MP.RegisterEventHandler("onPlayerDisconnect", "onPlayerDisconnect")

src/server/mod.rs

@@ -382,11 +382,10 @@ impl Server {
                         .clone();
                     info!("Welcome {name}!");
                     joined_names.push(name.clone());
-                    let arg = Argument::String(name);
                     let mut vrx = Vec::new();
                     for plugin in &self.plugins {
                         let (tx, rx) = tokio::sync::oneshot::channel();
-                        plugin.send_event(PluginBoundPluginEvent::CallEventHandler((ScriptEvent::OnPlayerAuthenticated, vec![arg.clone()], Some(tx)))).await;
+                        plugin.send_event(PluginBoundPluginEvent::CallEventHandler((ScriptEvent::OnPlayerAuthenticated { name: name.clone() }, Some(tx)))).await;
                         // TODO: This never returns, because it blocks the entire process function
                         //       from running, so it never manages to run the function correctly.
                         // let res = rx.await.unwrap_or(Argument::Number(-1f32));
@@ -447,8 +446,8 @@ impl Server {
                 debug!("event: {:?}", event);
                 // TODO: Error handling (?)
                 match event {
-                    ServerBoundPluginEvent::PluginLoaded => plugin.send_event(PluginBoundPluginEvent::CallEventHandler((ScriptEvent::OnPluginLoaded, Vec::new(), None))).await,
+                    ServerBoundPluginEvent::PluginLoaded => plugin.send_event(PluginBoundPluginEvent::CallEventHandler((ScriptEvent::OnPluginLoaded, None))).await,
-                    ServerBoundPluginEvent::RequestPlayerCount(responder) => { let _ = responder.send(PluginBoundPluginEvent::PlayerCount(self.clients.len())); }
+                    ServerBoundPluginEvent::RequestPlayerCount(responder) => { let _ = responder.send(PluginBoundPluginEvent::PlayerCount(self.clients.len() + self.clients_queue.len())); }
                     ServerBoundPluginEvent::RequestPlayers(responder) => {
                         trace!("request players received");
                         let mut players = HashMap::new();
@@ -487,6 +486,7 @@ impl Server {
         self.process_lua_events().await?;
 
         // I'm sorry for this code :(
+        // TODO: Clean this up. We should just grab the client once with `if let Some() = expr {}`
         for i in 0..self.clients.len() {
             if self.clients.get(i).ok_or(ServerError::ClientDoesntExist)?.state == ClientState::Disconnect {
                 let id = self.clients.get(i).ok_or(ServerError::ClientDoesntExist)?.id;
@@ -496,6 +496,12 @@ impl Server {
                     self.broadcast(Packet::Raw(RawPacket::from_str(&delete_packet)), None)
                         .await;
                 }
+
+                let id = self.clients[i].id;
+                for plugin in &mut self.plugins {
+                    plugin.send_event(PluginBoundPluginEvent::CallEventHandler((ScriptEvent::OnPlayerDisconnect { pid: id }, None))).await;
+                }
+
                 info!("Disconnecting client {}...", id);
                 self.clients.remove(i);
                 info!("Client {} disconnected!", id);

src/server/plugins/backend_lua.rs

@@ -134,10 +134,11 @@ impl Backend for BackendLua {
         Ok(())
     }
 
-    fn call_event_handler(&mut self, event: ScriptEvent, args: Vec<Argument>, resp: Option<oneshot::Sender<Argument>>) {
+    fn call_event_handler(&mut self, event: ScriptEvent, resp: Option<oneshot::Sender<Argument>>) {
-        let event_name = match event {
+        let (event_name, args) = match event {
-            ScriptEvent::OnPluginLoaded => "onPluginLoaded",
+            ScriptEvent::OnPluginLoaded => ("onInit", vec![]),
-            ScriptEvent::OnPlayerAuthenticated => "onPlayerAuthenticated",
+            ScriptEvent::OnPlayerAuthenticated { name } => ("onPlayerAuth", vec![Argument::String(name)]),
+            ScriptEvent::OnPlayerDisconnect { pid } => ("onPlayerDisconnect", vec![Argument::Number(pid as f32)]),
         };
 
         let mut ret = -1f32;

src/server/plugins/mod.rs

@@ -13,7 +13,7 @@ pub trait Backend: Send {
     fn load(&mut self, code: String) -> anyhow::Result<()>;
     fn load_api(&mut self, tx: Arc<Sender<ServerBoundPluginEvent>>) -> anyhow::Result<()>;
 
-    fn call_event_handler(&mut self, event: ScriptEvent, args: Vec<Argument>, resp: Option<oneshot::Sender<Argument>>);
+    fn call_event_handler(&mut self, event: ScriptEvent, resp: Option<oneshot::Sender<Argument>>);
 }
 
 // TODO: This is quite focused on Lua right now, perhaps in the future we want to modify this list
@@ -28,12 +28,15 @@ pub enum Argument {
 #[derive(Debug)]
 pub enum ScriptEvent {
     OnPluginLoaded,
-    OnPlayerAuthenticated,
+
+    OnPlayerAuthenticated { name: String },
+
+    OnPlayerDisconnect { pid: u8 },
 }
 
 #[derive(Debug)]
 pub enum PluginBoundPluginEvent {
-    CallEventHandler((ScriptEvent, Vec<Argument>, Option<oneshot::Sender<Argument>>)),
+    CallEventHandler((ScriptEvent, Option<oneshot::Sender<Argument>>)),
 
     PlayerCount(usize),
     Players(HashMap<u8, String>),
@@ -72,8 +75,8 @@ impl Plugin {
             loop {
                 if let Some(message) = pb_rx.blocking_recv() {
                     match message {
-                        PluginBoundPluginEvent::CallEventHandler((event, args, resp)) => {
+                        PluginBoundPluginEvent::CallEventHandler((event, resp)) => {
-                            backend.call_event_handler(event, args, resp);
+                            backend.call_event_handler(event, resp);
                         },
                         _ => {},
                     }