[Crate] Add formatting (#22)

* chore: add standard for formatting

* chore: manually tidy up imports and format

* chore: remove vscode and add to gitignore

* chore: alphabetically order and fix

* chore: format

* chore: fix format issue with payload

* chore: format as merge had unformatted code

* [format] Fix comments, change max width and binop operator

---------

Co-authored-by: CosminPerRam <cosmin.p@live.com>

src/games/aliens.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::ALIENS.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::ALIENS.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/aoc.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::AOC.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::AOC.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/arma2oa.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(2304), SteamApp::ARMA2OA.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(2304),
+        SteamApp::ARMA2OA.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/ase.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::ASE.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::ASE.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/asrd.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::ASRD.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::ASRD.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/avorion.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27020), SteamApp::AVORION.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27020),
+        SteamApp::AVORION.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/bat1944.rs

@@ -1,10 +1,17 @@
-use crate::GDError::TypeParse;
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDError::TypeParse,
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let mut valve_response = valve::query(address, port.unwrap_or(7780), SteamApp::BAT1944.as_engine(), None, None)?;
+    let mut valve_response = valve::query(
+        address,
+        port.unwrap_or(7780),
+        SteamApp::BAT1944.as_engine(),
+        None,
+        None,
+    )?;
 
     if let Some(rules) = &mut valve_response.rules {
         if let Some(bat_max_players) = rules.get("bat_max_players_i") {

src/games/bb2.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::BB2.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::BB2.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/bf1942.rs

@@ -1,6 +1,7 @@
-use crate::GDResult;
-use crate::protocols::gamespy;
-use crate::protocols::gamespy::Response;
+use crate::{
+    protocols::gamespy::{self, Response},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<Response> {
     gamespy::one::query(address, port.unwrap_or(23000), None)

src/games/bm.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::BM.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::BM.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/bo.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27016), SteamApp::BO.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27016),
+        SteamApp::BO.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/ccure.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::CCURE.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::CCURE.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/cosu.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27004), SteamApp::COSU.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27004),
+        SteamApp::COSU.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/cs.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::CS.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::CS.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/cscz.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::CSCZ.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::CSCZ.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/csgo.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::CSGO.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::CSGO.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/css.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::CSS.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::CSS.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/dod.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::DOD.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::DOD.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/dods.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::DODS.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::DODS.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/doi.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::DOI.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::DOI.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/dst.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27016), SteamApp::DST.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27016),
+        SteamApp::DST.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/gm.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27016), SteamApp::GM.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27016),
+        SteamApp::GM.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/hl2dm.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::HL2DM.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::HL2DM.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/hldms.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::HLDMS.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::HLDMS.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/ins.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::INS.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::INS.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/insmic.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::INSMIC.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::INSMIC.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/inss.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27131), SteamApp::INSS.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27131),
+        SteamApp::INSS.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/l4d.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::L4D.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::L4D.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/l4d2.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::L4D2.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::L4D2.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/mc.rs

@@ -1,48 +1,47 @@
-use crate::{GDError, GDResult};
-use crate::protocols::minecraft;
-use crate::protocols::minecraft::{JavaResponse, LegacyGroup, BedrockResponse};
-
-/// Query with all the protocol variants one by one (Java -> Bedrock -> Legacy (1.6 -> 1.4 -> Beta 1.8)).
-pub fn query(address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
-    if let Ok(response) = query_java(address, port) {
-        return Ok(response);
-    }
-
-    if let Ok(response) = query_bedrock(address, port) {
-        return Ok(JavaResponse::from_bedrock_response(response));
-    }
-
-    if let Ok(response) = query_legacy(address, port) {
-        return Ok(response);
-    }
-
-    Err(GDError::AutoQuery)
-}
-
-/// Query a Java Server.
-pub fn query_java(address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
-    minecraft::query_java(address, port_or_java_default(port), None)
-}
-
-/// Query a (Java) Legacy Server (1.6 -> 1.4 -> Beta 1.8).
-pub fn query_legacy(address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
-    minecraft::query_legacy(address, port_or_java_default(port), None)
-}
-
-/// Query a specific (Java) Legacy Server.
-pub fn query_legacy_specific(group: LegacyGroup, address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
-    minecraft::query_legacy_specific(group, address, port_or_java_default(port), None)
-}
-
-/// Query a Bedrock Server.
-pub fn query_bedrock(address: &str, port: Option<u16>) -> GDResult<BedrockResponse> {
-    minecraft::query_bedrock(address, port_or_bedrock_default(port), None)
-}
-
-fn port_or_java_default(port: Option<u16>) -> u16 {
-    port.unwrap_or(25565)
-}
-
-fn port_or_bedrock_default(port: Option<u16>) -> u16 {
-    port.unwrap_or(19132)
-}
+use crate::{
+    protocols::minecraft::{self, BedrockResponse, JavaResponse, LegacyGroup},
+    GDError,
+    GDResult,
+};
+
+/// Query with all the protocol variants one by one (Java -> Bedrock -> Legacy
+/// (1.6 -> 1.4 -> Beta 1.8)).
+pub fn query(address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
+    if let Ok(response) = query_java(address, port) {
+        return Ok(response);
+    }
+
+    if let Ok(response) = query_bedrock(address, port) {
+        return Ok(JavaResponse::from_bedrock_response(response));
+    }
+
+    if let Ok(response) = query_legacy(address, port) {
+        return Ok(response);
+    }
+
+    Err(GDError::AutoQuery)
+}
+
+/// Query a Java Server.
+pub fn query_java(address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
+    minecraft::query_java(address, port_or_java_default(port), None)
+}
+
+/// Query a (Java) Legacy Server (1.6 -> 1.4 -> Beta 1.8).
+pub fn query_legacy(address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
+    minecraft::query_legacy(address, port_or_java_default(port), None)
+}
+
+/// Query a specific (Java) Legacy Server.
+pub fn query_legacy_specific(group: LegacyGroup, address: &str, port: Option<u16>) -> GDResult<JavaResponse> {
+    minecraft::query_legacy_specific(group, address, port_or_java_default(port), None)
+}
+
+/// Query a Bedrock Server.
+pub fn query_bedrock(address: &str, port: Option<u16>) -> GDResult<BedrockResponse> {
+    minecraft::query_bedrock(address, port_or_bedrock_default(port), None)
+}
+
+fn port_or_java_default(port: Option<u16>) -> u16 { port.unwrap_or(25565) }
+
+fn port_or_bedrock_default(port: Option<u16>) -> u16 { port.unwrap_or(19132) }

src/games/mod.rs

@@ -1,93 +1,92 @@
-
-//! Currently supported games.
-
-/// Team Fortress 2
-pub mod tf2;
-/// The Ship
-pub mod ts;
-/// Counter-Strike: Global Offensive
-pub mod csgo;
-/// Counter-Strike: Source
-pub mod css;
-/// Day of Defeat: Source
-pub mod dods;
-/// Garry's Mod
-pub mod gm;
-/// Left 4 Dead
-pub mod l4d;
-/// Left 4 Dead 2
-pub mod l4d2;
-/// Half-Life 2 Deathmatch
-pub mod hl2dm;
-/// Alien Swarm
-pub mod aliens;
-/// Alien Swarm: Reactive Drop
-pub mod asrd;
-/// Insurgency
-pub mod ins;
-/// Insurgency: Sandstorm
-pub mod inss;
-/// Insurgency: Modern Infantry Combat
-pub mod insmic;
-/// Counter Strike: Condition Zero
-pub mod cscz;
-/// Day of Defeat
-pub mod dod;
-/// Minecraft
-pub mod mc;
-/// 7 Days To Die
-pub mod sdtd;
-/// ARK: Survival Evolved
-pub mod ase;
-/// Unturned
-pub mod unturned;
-/// The Forest
-pub mod tf;
-/// Team Fortress Classic
-pub mod tfc;
-/// Sven Co-op
-pub mod sc;
-/// Rust
-pub mod rust;
-/// Counter-Strike
-pub mod cs;
-/// ARMA 2: Operation Arrowhead
-pub mod arma2oa;
-/// Day of Infamy
-pub mod doi;
-/// Half-Life Deathmatch: Source
-pub mod hldms;
-/// Risk of Rain 2
-pub mod ror2;
-/// Battalion 1944
-pub mod bat1944;
-/// Black Mesa
-pub mod bm;
-/// Project Zomboid
-pub mod pz;
-/// Age of Chivalry
-pub mod aoc;
-/// Don't Starve Together
-pub mod dst;
-/// Colony Survival
-pub mod cosu;
-/// Onset
-pub mod onset;
-/// Codename CURE
-pub mod ccure;
-/// Ballistic Overkill
-pub mod bo;
-/// BrainBread 2
-pub mod bb2;
-/// Avorion
-pub mod avorion;
-/// Operation: Harsh Doorstop
-pub mod ohd;
-/// V Rising
-pub mod vr;
-/// Unreal Tournament
-pub mod ut;
-/// Battlefield 1942
-pub mod bf1942;
-/// Serious Sam
-pub mod ss;
+//! Currently supported games.
+
+/// Alien Swarm
+pub mod aliens;
+/// Age of Chivalry
+pub mod aoc;
+/// ARMA 2: Operation Arrowhead
+pub mod arma2oa;
+/// ARK: Survival Evolved
+pub mod ase;
+/// Alien Swarm: Reactive Drop
+pub mod asrd;
+/// Avorion
+pub mod avorion;
+/// Battalion 1944
+pub mod bat1944;
+/// BrainBread 2
+pub mod bb2;
+/// Battlefield 1942
+pub mod bf1942;
+/// Black Mesa
+pub mod bm;
+/// Ballistic Overkill
+pub mod bo;
+/// Codename CURE
+pub mod ccure;
+/// Colony Survival
+pub mod cosu;
+/// Counter-Strike
+pub mod cs;
+/// Counter Strike: Condition Zero
+pub mod cscz;
+/// Counter-Strike: Global Offensive
+pub mod csgo;
+/// Counter-Strike: Source
+pub mod css;
+/// Day of Defeat
+pub mod dod;
+/// Day of Defeat: Source
+pub mod dods;
+/// Day of Infamy
+pub mod doi;
+/// Don't Starve Together
+pub mod dst;
+/// Garry's Mod
+pub mod gm;
+/// Half-Life 2 Deathmatch
+pub mod hl2dm;
+/// Half-Life Deathmatch: Source
+pub mod hldms;
+/// Insurgency
+pub mod ins;
+/// Insurgency: Modern Infantry Combat
+pub mod insmic;
+/// Insurgency: Sandstorm
+pub mod inss;
+/// Left 4 Dead
+pub mod l4d;
+/// Left 4 Dead 2
+pub mod l4d2;
+/// Minecraft
+pub mod mc;
+/// Operation: Harsh Doorstop
+pub mod ohd;
+/// Onset
+pub mod onset;
+/// Project Zomboid
+pub mod pz;
+/// Risk of Rain 2
+pub mod ror2;
+/// Rust
+pub mod rust;
+/// Sven Co-op
+pub mod sc;
+/// 7 Days To Die
+pub mod sdtd;
+/// Serious Sam
+pub mod ss;
+/// The Forest
+pub mod tf;
+/// Team Fortress 2
+pub mod tf2;
+/// Team Fortress Classic
+pub mod tfc;
+/// The Ship
+pub mod ts;
+/// Unturned
+pub mod unturned;
+/// Unreal Tournament
+pub mod ut;
+/// V Rising
+pub mod vr;

src/games/ohd.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27005), SteamApp::OHD.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27005),
+        SteamApp::OHD.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/onset.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(7776), SteamApp::ONSET.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(7776),
+        SteamApp::ONSET.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/pz.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(16261), SteamApp::PZ.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(16261),
+        SteamApp::PZ.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/ror2.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27016), SteamApp::ROR2.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27016),
+        SteamApp::ROR2.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }

src/games/rust.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::RUST.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::RUST.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/sc.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::SC.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::SC.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/sdtd.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(26900), SteamApp::SDTD.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(26900),
+        SteamApp::SDTD.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/ss.rs

@@ -1,6 +1,7 @@
-use crate::GDResult;
-use crate::protocols::gamespy;
-use crate::protocols::gamespy::Response;
+use crate::{
+    protocols::gamespy::{self, Response},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<Response> {
     gamespy::one::query(address, port.unwrap_or(25601), None)

src/games/tf.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27016), SteamApp::TF.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27016),
+        SteamApp::TF.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/tf2.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::TF2.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::TF2.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/tfc.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::TFC.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::TFC.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/ts.rs

@@ -1,93 +1,106 @@
-use std::collections::HashMap;
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{Server, ServerPlayer, get_optional_extracted_data, SteamApp};
-
-#[cfg (feature = "serde")]
-use serde::{Serialize, Deserialize};
-
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
-pub struct TheShipPlayer {
-    pub name: String,
-    pub score: u32,
-    pub duration: f32,
-    pub deaths: u32,
-    pub money: u32
-}
-
-impl TheShipPlayer {
-    pub fn new_from_valve_player(player: &ServerPlayer) -> Self {
-        Self {
-            name: player.name.clone(),
-            score: player.score,
-            duration: player.duration,
-            deaths: player.deaths.unwrap(),
-            money: player.money.unwrap()
-        }
-    }
-}
-
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone, PartialEq)]
-pub struct Response {
-    pub protocol: u8,
-    pub name: String,
-    pub map: String,
-    pub game: String,
-    pub players: u8,
-    pub players_details: Vec<TheShipPlayer>,
-    pub max_players: u8,
-    pub bots: u8,
-    pub server_type: Server,
-    pub has_password: bool,
-    pub vac_secured: bool,
-    pub version: String,
-    pub port: Option<u16>,
-    pub steam_id: Option<u64>,
-    pub tv_port: Option<u16>,
-    pub tv_name: Option<String>,
-    pub keywords: Option<String>,
-    pub rules: HashMap<String, String>,
-    pub mode: u8,
-    pub witnesses: u8,
-    pub duration: u8
-}
-
-impl Response {
-    pub fn new_from_valve_response(response: valve::Response) -> Self {
-        let (port, steam_id, tv_port, tv_name, keywords) = get_optional_extracted_data(response.info.extra_data);
-
-        let the_unwrapped_ship = response.info.the_ship.unwrap();
-
-        Self {
-            protocol: response.info.protocol,
-            name: response.info.name,
-            map: response.info.map,
-            game: response.info.game,
-            players: response.info.players_online,
-            players_details: response.players.unwrap().iter().map(TheShipPlayer::new_from_valve_player).collect(),
-            max_players: response.info.players_maximum,
-            bots: response.info.players_bots,
-            server_type: response.info.server_type,
-            has_password: response.info.has_password,
-            vac_secured: response.info.vac_secured,
-            version: response.info.version,
-            port,
-            steam_id,
-            tv_port,
-            tv_name,
-            keywords,
-            rules: response.rules.unwrap(),
-            mode: the_unwrapped_ship.mode,
-            witnesses: the_unwrapped_ship.witnesses,
-            duration: the_unwrapped_ship.duration
-        }
-    }
-}
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::TS.as_engine(), None, None)?;
-
-    Ok(Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, get_optional_extracted_data, Server, ServerPlayer, SteamApp},
+    GDResult,
+};
+
+use std::collections::HashMap;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct TheShipPlayer {
+    pub name: String,
+    pub score: u32,
+    pub duration: f32,
+    pub deaths: u32,
+    pub money: u32,
+}
+
+impl TheShipPlayer {
+    pub fn new_from_valve_player(player: &ServerPlayer) -> Self {
+        Self {
+            name: player.name.clone(),
+            score: player.score,
+            duration: player.duration,
+            deaths: player.deaths.unwrap(),
+            money: player.money.unwrap(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq)]
+pub struct Response {
+    pub protocol: u8,
+    pub name: String,
+    pub map: String,
+    pub game: String,
+    pub players: u8,
+    pub players_details: Vec<TheShipPlayer>,
+    pub max_players: u8,
+    pub bots: u8,
+    pub server_type: Server,
+    pub has_password: bool,
+    pub vac_secured: bool,
+    pub version: String,
+    pub port: Option<u16>,
+    pub steam_id: Option<u64>,
+    pub tv_port: Option<u16>,
+    pub tv_name: Option<String>,
+    pub keywords: Option<String>,
+    pub rules: HashMap<String, String>,
+    pub mode: u8,
+    pub witnesses: u8,
+    pub duration: u8,
+}
+
+impl Response {
+    pub fn new_from_valve_response(response: valve::Response) -> Self {
+        let (port, steam_id, tv_port, tv_name, keywords) = get_optional_extracted_data(response.info.extra_data);
+
+        let the_unwrapped_ship = response.info.the_ship.unwrap();
+
+        Self {
+            protocol: response.info.protocol,
+            name: response.info.name,
+            map: response.info.map,
+            game: response.info.game,
+            players: response.info.players_online,
+            players_details: response
+                .players
+                .unwrap()
+                .iter()
+                .map(TheShipPlayer::new_from_valve_player)
+                .collect(),
+            max_players: response.info.players_maximum,
+            bots: response.info.players_bots,
+            server_type: response.info.server_type,
+            has_password: response.info.has_password,
+            vac_secured: response.info.vac_secured,
+            version: response.info.version,
+            port,
+            steam_id,
+            tv_port,
+            tv_name,
+            keywords,
+            rules: response.rules.unwrap(),
+            mode: the_unwrapped_ship.mode,
+            witnesses: the_unwrapped_ship.witnesses,
+            duration: the_unwrapped_ship.duration,
+        }
+    }
+}
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::TS.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(Response::new_from_valve_response(valve_response))
+}

src/games/unturned.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
-
-pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27015), SteamApp::UNTURNED.as_engine(), None, None)?;
-
-    Ok(game::Response::new_from_valve_response(valve_response))
-}
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
+
+pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27015),
+        SteamApp::UNTURNED.as_engine(),
+        None,
+        None,
+    )?;
+
+    Ok(game::Response::new_from_valve_response(valve_response))
+}

src/games/ut.rs

@@ -1,6 +1,7 @@
-use crate::GDResult;
-use crate::protocols::gamespy;
-use crate::protocols::gamespy::Response;
+use crate::{
+    protocols::gamespy::{self, Response},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<Response> {
     gamespy::one::query(address, port.unwrap_or(7778), None)

src/games/vr.rs

@@ -1,9 +1,16 @@
-use crate::GDResult;
-use crate::protocols::valve;
-use crate::protocols::valve::{game, SteamApp};
+use crate::{
+    protocols::valve::{self, game, SteamApp},
+    GDResult,
+};
 
 pub fn query(address: &str, port: Option<u16>) -> GDResult<game::Response> {
-    let valve_response = valve::query(address, port.unwrap_or(27016), SteamApp::VR.as_engine(), None, None)?;
+    let valve_response = valve::query(
+        address,
+        port.unwrap_or(27016),
+        SteamApp::VR.as_engine(),
+        None,
+        None,
+    )?;
 
     Ok(game::Response::new_from_valve_response(valve_response))
 }