wip player identifiers stuff

src/server/plugins/backend_lua.rs

@@ -137,8 +137,8 @@ impl Backend for BackendLua {
     fn call_event_handler(&mut self, event: ScriptEvent, resp: Option<oneshot::Sender<Argument>>) {
         let (event_name, args) = match event {
             ScriptEvent::OnPluginLoaded => ("onInit", vec![]),
-            ScriptEvent::OnPlayerAuthenticated { name } => ("onPlayerAuth", vec![Argument::String(name)]),
-            ScriptEvent::OnPlayerDisconnect { pid } => ("onPlayerDisconnect", vec![Argument::Number(pid as f32)]),
+            ScriptEvent::OnPlayerAuthenticated { name, role, is_guest, identifiers } => ("onPlayerAuth", vec![Argument::String(name), Argument::String(role), Argument::Boolean(is_guest), Argument::Table(identifiers.to_map())]),
+            ScriptEvent::OnPlayerDisconnect { pid, name } => ("onPlayerDisconnect", vec![Argument::Number(pid as f32), Argument::String(name)]),
         };
 
         let mut ret = -1f32;
@@ -150,11 +150,7 @@ impl Backend for BackendLua {
                 let func: LuaResult<Function> = self.lua.globals().get(handler_name.clone());
                 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)),
-                        }
+                        arg_to_value(&self.lua, arg)
                     }).filter(|v| v.is_some());
                     match func.call::<_, Option<f32>>(Variadic::from_iter(mapped_args)) {
                         Ok(res) => { trace!("fn ret: {:?}", ret); ret = res.unwrap_or(-1f32); }
@@ -172,3 +168,26 @@ impl Backend for BackendLua {
         debug!("call_event_handler done");
     }
 }
+
+fn arg_to_value(lua: &Lua, arg: Argument) -> Option<Value> {
+    match arg {
+        Argument::String(s) => if let Ok(lua_str) = 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)),
+        Argument::Integer(i) => Some(Value::Integer(i as i64)),
+        Argument::Table(t) => {
+            if let Ok(table) = lua.create_table() {
+                for (key, value) in t {
+                    if let Some(v) = arg_to_value(lua, value) {
+                        if let Err(e) = table.set(key, v) {
+                            error!("[LUA] Error occured trying to put data into table: {:?}", e);
+                        }
+                    }
+                }
+                Some(Value::Table(table))
+            } else {
+                None
+            }
+        }
+    }
+}

src/server/plugins/mod.rs

@@ -23,23 +23,43 @@ pub enum Argument {
     String(String),
     Boolean(bool),
     Number(f32),
+    Integer(i64),
+    Table(HashMap<String, Argument>),
+}
+
+#[derive(Debug)]
+pub struct PlayerIdentifiers {
+    pub ip: String,
+    pub beammp_id: u64,
+}
+
+impl PlayerIdentifiers {
+    pub fn to_map(&self) -> HashMap<String, Argument> {
+        let mut m = HashMap::new();
+        m.insert(String::from("ip"), Argument::String(self.ip.clone()));
+        m.insert(String::from("beammp"), Argument::Integer(self.beammp_id as i64)); // TODO: Uhh we could lose data here
+        m
+    }
 }
 
 #[derive(Debug)]
 pub enum ScriptEvent {
     OnPluginLoaded,
 
-    OnPlayerAuthenticated { name: String },
+    OnPlayerAuthenticated { name: String, role: String, is_guest: bool, identifiers: PlayerIdentifiers },
 
-    OnPlayerDisconnect { pid: u8 },
+    OnPlayerDisconnect { pid: u8, name: String },
 }
 
 #[derive(Debug)]
 pub enum PluginBoundPluginEvent {
+    None,
+
     CallEventHandler((ScriptEvent, Option<oneshot::Sender<Argument>>)),
 
     PlayerCount(usize),
     Players(HashMap<u8, String>),
+    PlayerIdentifiers(PlayerIdentifiers),
 }
 
 #[derive(Debug)]
@@ -48,6 +68,7 @@ pub enum ServerBoundPluginEvent {
 
     RequestPlayerCount(oneshot::Sender<PluginBoundPluginEvent>),
     RequestPlayers(oneshot::Sender<PluginBoundPluginEvent>),
+    RequestPlayerIdentifiers((u8, oneshot::Sender<PluginBoundPluginEvent>)),
 }
 
 pub struct Plugin {