feat: initial minetest support

crates/lib/src/games/definitions.rs

@@ -149,6 +149,7 @@ pub static GAMES: Map<&'static str, Game> = phf_map! {
     "zps" => game!("Zombie Panic: Source", 27015, Protocol::Valve(Engine::new(17_500))),
     "moe" => game!("Myth Of Empires", 12888, Protocol::Valve(Engine::new(1_371_580))),
     "mordhau" => game!("Mordhau", 27015, Protocol::Valve(Engine::new(629_760))),
+    // "minetest" => game!("Minetest", 30000, Protocol::PROPRIETARY(ProprietaryProtocol::Minetest)),
     "mindustry" => game!("Mindustry", crate::games::mindustry::DEFAULT_PORT, Protocol::PROPRIETARY(ProprietaryProtocol::Mindustry)),
     "nla" => game!("Nova-Life: Amboise", 27015, Protocol::Valve(Engine::new(885_570))),
 };

crates/lib/src/games/minetest/mod.rs

@@ -0,0 +1,8 @@
+/// The implementation.
+/// Reference: [Node-GameGig](https://github.com/gamedig/node-gamedig/blob/master/protocols/minetest.js)
+pub mod protocol;
+/// All types used by the implementation.
+pub mod types;
+
+pub use protocol::*;
+pub use types::*;

crates/lib/src/games/minetest/protocol.rs

@@ -0,0 +1,23 @@
+use crate::minetest_master_server::Server;
+use crate::{minetest_master_server, GDErrorKind, GDResult, TimeoutSettings};
+use std::net::IpAddr;
+
+pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Server> { query_with_timeout(address, port, &None) }
+
+pub fn query_with_timeout(
+    address: &IpAddr,
+    port: Option<u16>,
+    timeout_settings: &Option<TimeoutSettings>,
+) -> GDResult<Server> {
+    let address = address.to_string();
+    let port = port.unwrap_or(30000);
+
+    let servers = minetest_master_server::query(timeout_settings.unwrap_or_default())?;
+    for server in servers.list {
+        if server.ip == address && server.port == port {
+            return Ok(server);
+        }
+    }
+
+    Err(GDErrorKind::AutoQuery.context("Server not found in the master query list."))
+}

crates/lib/src/games/minetest/types.rs

@@ -0,0 +1,43 @@
+use crate::minetest_master_server::Server;
+use crate::protocols::types::{CommonPlayer, CommonResponse, GenericPlayer};
+use crate::protocols::GenericResponse;
+use serde::{Deserialize, Serialize};
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Player {
+    pub name: String,
+}
+
+impl CommonPlayer for Player {
+    fn as_original(&self) -> GenericPlayer { GenericPlayer::Minetest(self) }
+
+    fn name(&self) -> &str { &self.name }
+}
+
+impl CommonResponse for Server {
+    fn as_original(&self) -> GenericResponse { GenericResponse::Minetest(self) }
+
+    fn name(&self) -> Option<&str> { Some(&self.name) }
+
+    fn description(&self) -> Option<&str> { Some(&self.description) }
+
+    fn game_version(&self) -> Option<&str> { Some(&self.version) }
+
+    fn players_maximum(&self) -> u32 { self.clients_max }
+
+    fn players_online(&self) -> u32 { self.clients }
+
+    fn has_password(&self) -> Option<bool> { Some(self.password) }
+
+    fn players(&self) -> Option<Vec<&dyn CommonPlayer>> {
+        None
+        // Some(
+        // self.clients_list
+        // .iter()
+        // .map(|p| Player { name: p.clone() })
+        // .map(|p| p as &dyn CommonPlayer)
+        // .collect(),
+        // )
+    }
+}

crates/lib/src/games/mod.rs

@@ -7,13 +7,19 @@ pub mod quake;
 pub mod unreal2;
 pub mod valve;
 
+#[cfg(all(feature = "tls", feature = "serde", feature = "services"))]
+pub mod minetest;
+
 #[cfg(feature = "tls")]
 pub use epic::*;
 pub use gamespy::*;
 pub use quake::*;
 pub use unreal2::*;
 pub use valve::*;
 
+#[cfg(all(feature = "tls", feature = "serde", feature = "services"))]
+pub use minetest::*;
+
 /// Battalion 1944
 pub mod battalion1944;
 /// Eco

crates/lib/src/games/query.rs

@@ -2,6 +2,8 @@
 
 use std::net::{IpAddr, SocketAddr};
 
+#[cfg(all(feature = "services", feature = "tls", feature = "serde"))]
+use crate::games::minetest;
 use crate::games::types::Game;
 use crate::games::{eco, ffow, jc2m, mindustry, minecraft, savage2, theship};
 use crate::protocols;
@@ -125,6 +127,10 @@ pub fn query_with_timeout_and_extra_settings(
                     )
                     .map(Box::new)?
                 }
+                #[cfg(all(feature = "services", feature = "tls", feature = "serde"))]
+                ProprietaryProtocol::Minetest => {
+                    minetest::query_with_timeout(address, port, &timeout_settings).map(Box::new)?
+                }
             }
         }
     })

crates/lib/src/protocols/types.rs

@@ -23,6 +23,8 @@ pub enum ProprietaryProtocol {
     Savage2,
     Eco,
     Mindustry,
+    #[cfg(all(feature = "services", feature = "tls", feature = "serde"))]
+    Minetest,
 }
 
 /// Enumeration of all valid protocol types
@@ -63,6 +65,13 @@ pub enum GenericResponse<'a> {
     Savage2(&'a crate::games::savage2::Response),
     #[cfg(feature = "games")]
     Eco(&'a crate::games::eco::Response),
+    #[cfg(all(
+        feature = "services",
+        feature = "tls",
+        feature = "serde",
+        feature = "games"
+    ))]
+    Minetest(&'a crate::services::minetest_master_server::Server),
 }
 
 /// All player types
@@ -84,6 +93,13 @@ pub enum GenericPlayer<'a> {
     JCMP2(&'a crate::games::jc2m::Player),
     #[cfg(feature = "games")]
     Eco(&'a crate::games::eco::Player),
+    #[cfg(all(
+        feature = "services",
+        feature = "tls",
+        feature = "serde",
+        feature = "games"
+    ))]
+    Minetest(&'a crate::games::minetest::Player),
 }
 
 pub trait CommonResponse {

crates/lib/src/services/minetest_master_server/types.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct Server {
     pub address: String,
     pub clients: u32,