diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index cee0961..b4e6bc2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,3 +28,10 @@ jobs:
         override: true
     - name: Run MSRV
       run: cargo build
+    - name: Install nightly
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly
+        components: rustfmt
+    - name: Run formatting check
+      run: cargo +nightly fmt --check --verbose
diff --git a/examples/master_querant.rs b/examples/master_querant.rs
index 2feba87..109b9e7 100644
--- a/examples/master_querant.rs
+++ b/examples/master_querant.rs
@@ -1,8 +1,62 @@
-use gamedig::protocols::{gamespy, quake};
 use gamedig::protocols::minecraft::LegacyGroup;
 use gamedig::protocols::valve;
 use gamedig::protocols::valve::Engine;
-use gamedig::{aliens, aoc, arma2oa, ase, asrd, avorion, bat1944, bb2, bf1942, bm, bo, ccure, cosu, cs, cscz, csgo, css, dod, dods, doi, dst, ffow, gm, hl2dm, hldms, ins, insmic, inss, l4d, l4d2, mc, ohd, onset, pz, ror2, rust, sc, sdtd, ss, tf, tf2, tfc, ts, unturned, ut, vr, GDResult, cw, quake2, quake1, quake3a, hll, sof2};
+use gamedig::protocols::{gamespy, quake};
+use gamedig::{
+    aliens,
+    aoc,
+    arma2oa,
+    ase,
+    asrd,
+    avorion,
+    bat1944,
+    bb2,
+    bf1942,
+    bm,
+    bo,
+    ccure,
+    cosu,
+    cs,
+    cscz,
+    csgo,
+    css,
+    cw,
+    dod,
+    dods,
+    doi,
+    dst,
+    ffow,
+    gm,
+    hl2dm,
+    hldms,
+    hll,
+    ins,
+    insmic,
+    inss,
+    l4d,
+    l4d2,
+    mc,
+    ohd,
+    onset,
+    pz,
+    quake1,
+    quake2,
+    quake3a,
+    ror2,
+    rust,
+    sc,
+    sdtd,
+    sof2,
+    ss,
+    tf,
+    tf2,
+    tfc,
+    ts,
+    unturned,
+    ut,
+    vr,
+    GDResult,
+};
 use std::env;
 use std::net::{IpAddr, SocketAddr};
 
diff --git a/examples/tf2.rs b/examples/tf2.rs
index 9f05813..75cd95f 100644
--- a/examples/tf2.rs
+++ b/examples/tf2.rs
@@ -2,7 +2,7 @@ use gamedig::games::tf2;
 
 fn main() {
     let response = tf2::query(&"127.0.0.1".parse().unwrap(), None);
-        // or Some(27015), None is the default protocol port (which is 27015)
+    // or Some(27015), None is the default protocol port (which is 27015)
 
     match response {
         // Result type, must check what it is...
diff --git a/src/bufferer.rs b/src/bufferer.rs
index 74e05c7..55120e5 100644
--- a/src/bufferer.rs
+++ b/src/bufferer.rs
@@ -108,13 +108,9 @@ impl Bufferer {
         Ok(value)
     }
 
-    pub fn get_string_utf8(&mut self) -> GDResult<String> {
-        self.get_string_utf8_until(0)
-    }
+    pub fn get_string_utf8(&mut self) -> GDResult<String> { self.get_string_utf8_until(0) }
 
-    pub fn get_string_utf8_newline(&mut self) -> GDResult<String> {
-        self.get_string_utf8_until(10)
-    }
+    pub fn get_string_utf8_newline(&mut self) -> GDResult<String> { self.get_string_utf8_until(10) }
 
     pub fn get_string_utf8_optional(&mut self) -> GDResult<String> {
         match self.get_string_utf8() {
diff --git a/src/games/aliens.rs b/src/games/aliens.rs
index c67886b..e515978 100644
--- a/src/games/aliens.rs
+++ b/src/games/aliens.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/aoc.rs b/src/games/aoc.rs
index 5e05b25..acf88ae 100644
--- a/src/games/aoc.rs
+++ b/src/games/aoc.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/arma2oa.rs b/src/games/arma2oa.rs
index 20959d0..83f3c77 100644
--- a/src/games/arma2oa.rs
+++ b/src/games/arma2oa.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/ase.rs b/src/games/ase.rs
index 544cd69..07467dc 100644
--- a/src/games/ase.rs
+++ b/src/games/ase.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/asrd.rs b/src/games/asrd.rs
index 99aba4f..fcf5cdc 100644
--- a/src/games/asrd.rs
+++ b/src/games/asrd.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/avorion.rs b/src/games/avorion.rs
index 881e51e..8c91507 100644
--- a/src/games/avorion.rs
+++ b/src/games/avorion.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/bat1944.rs b/src/games/bat1944.rs
index 7a0aa0a..54b0295 100644
--- a/src/games/bat1944.rs
+++ b/src/games/bat1944.rs
@@ -1,9 +1,9 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDError::TypeParse,
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let mut valve_response = valve::query(
diff --git a/src/games/bb2.rs b/src/games/bb2.rs
index 9452657..a8102f0 100644
--- a/src/games/bb2.rs
+++ b/src/games/bb2.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/bf1942.rs b/src/games/bf1942.rs
index b3b1d6b..83e6437 100644
--- a/src/games/bf1942.rs
+++ b/src/games/bf1942.rs
@@ -1,7 +1,7 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::protocols::gamespy;
 use crate::protocols::gamespy::one::Response;
 use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response> {
     gamespy::one::query(&SocketAddr::new(*address, port.unwrap_or(23000)), None)
diff --git a/src/games/bm.rs b/src/games/bm.rs
index 08f9af0..71d02e4 100644
--- a/src/games/bm.rs
+++ b/src/games/bm.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/bo.rs b/src/games/bo.rs
index e07b996..fa4ae46 100644
--- a/src/games/bo.rs
+++ b/src/games/bo.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/ccure.rs b/src/games/ccure.rs
index b266d9d..4ec3188 100644
--- a/src/games/ccure.rs
+++ b/src/games/ccure.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/cosu.rs b/src/games/cosu.rs
index 8812a86..9db8559 100644
--- a/src/games/cosu.rs
+++ b/src/games/cosu.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/cs.rs b/src/games/cs.rs
index f69426f..f6a5c85 100644
--- a/src/games/cs.rs
+++ b/src/games/cs.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/cscz.rs b/src/games/cscz.rs
index f69c03e..84cb168 100644
--- a/src/games/cscz.rs
+++ b/src/games/cscz.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/csgo.rs b/src/games/csgo.rs
index 39a00ca..66ccd40 100644
--- a/src/games/csgo.rs
+++ b/src/games/csgo.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/css.rs b/src/games/css.rs
index 5f1c684..9bdb9e0 100644
--- a/src/games/css.rs
+++ b/src/games/css.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/cw.rs b/src/games/cw.rs
index 926893a..cc3cb30 100644
--- a/src/games/cw.rs
+++ b/src/games/cw.rs
@@ -1,7 +1,7 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::protocols::gamespy;
 use crate::protocols::gamespy::three::Response;
 use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response> {
     gamespy::three::query(&SocketAddr::new(*address, port.unwrap_or(64100)), None)
diff --git a/src/games/dod.rs b/src/games/dod.rs
index 9cbfc73..588f765 100644
--- a/src/games/dod.rs
+++ b/src/games/dod.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/dods.rs b/src/games/dods.rs
index 20b17ec..813718a 100644
--- a/src/games/dods.rs
+++ b/src/games/dods.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/doi.rs b/src/games/doi.rs
index b3e277a..b8b5222 100644
--- a/src/games/doi.rs
+++ b/src/games/doi.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/dst.rs b/src/games/dst.rs
index c5417b3..49f7252 100644
--- a/src/games/dst.rs
+++ b/src/games/dst.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/ffow.rs b/src/games/ffow.rs
index 4c972c4..06239cd 100644
--- a/src/games/ffow.rs
+++ b/src/games/ffow.rs
@@ -1,9 +1,9 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::protocols::types::TimeoutSettings;
 use crate::protocols::valve::{Engine, Environment, Server, ValveProtocol};
 use crate::GDResult;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::net::{IpAddr, SocketAddr};
 
 /// The query response.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -47,8 +47,15 @@ pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response> {
     query_with_timeout(address, port, TimeoutSettings::default())
 }
 
-pub fn query_with_timeout(address: &IpAddr, port: Option<u16>, timeout_settings: TimeoutSettings) -> GDResult<Response> {
-    let mut client = ValveProtocol::new(&SocketAddr::new(*address, port.unwrap_or(5478)), Some(timeout_settings))?;
+pub fn query_with_timeout(
+    address: &IpAddr,
+    port: Option<u16>,
+    timeout_settings: TimeoutSettings,
+) -> GDResult<Response> {
+    let mut client = ValveProtocol::new(
+        &SocketAddr::new(*address, port.unwrap_or(5478)),
+        Some(timeout_settings),
+    )?;
     let mut buffer = client.get_request_data(
         &Engine::GoldSrc(true),
         0,
diff --git a/src/games/gm.rs b/src/games/gm.rs
index f2a6b24..8d3c2e0 100644
--- a/src/games/gm.rs
+++ b/src/games/gm.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/hl2dm.rs b/src/games/hl2dm.rs
index 3c8a2fc..70f311d 100644
--- a/src/games/hl2dm.rs
+++ b/src/games/hl2dm.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/hldms.rs b/src/games/hldms.rs
index 70b8b26..f8236e0 100644
--- a/src/games/hldms.rs
+++ b/src/games/hldms.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/hll.rs b/src/games/hll.rs
index e49d135..078aaeb 100644
--- a/src/games/hll.rs
+++ b/src/games/hll.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/ins.rs b/src/games/ins.rs
index 4381fbb..a84c25a 100644
--- a/src/games/ins.rs
+++ b/src/games/ins.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/insmic.rs b/src/games/insmic.rs
index 6a987d1..76be407 100644
--- a/src/games/insmic.rs
+++ b/src/games/insmic.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/inss.rs b/src/games/inss.rs
index f757224..9be24e6 100644
--- a/src/games/inss.rs
+++ b/src/games/inss.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/l4d.rs b/src/games/l4d.rs
index f7ae027..126b56a 100644
--- a/src/games/l4d.rs
+++ b/src/games/l4d.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/l4d2.rs b/src/games/l4d2.rs
index 2411484..026382c 100644
--- a/src/games/l4d2.rs
+++ b/src/games/l4d2.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/mc.rs b/src/games/mc.rs
index 8111b9b..cbd7900 100644
--- a/src/games/mc.rs
+++ b/src/games/mc.rs
@@ -1,9 +1,9 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::minecraft::{self, BedrockResponse, JavaResponse, LegacyGroup},
     GDError,
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 /// Query with all the protocol variants one by one (Java -> Bedrock -> Legacy
 /// (1.6 -> 1.4 -> Beta 1.8)).
@@ -35,12 +35,19 @@ pub fn query_legacy(address: &IpAddr, port: Option<u16>) -> GDResult<JavaRespons
 
 /// Query a specific (Java) Legacy Server.
 pub fn query_legacy_specific(group: LegacyGroup, address: &IpAddr, port: Option<u16>) -> GDResult<JavaResponse> {
-    minecraft::query_legacy_specific(group, &SocketAddr::new(*address, port_or_java_default(port)), None)
+    minecraft::query_legacy_specific(
+        group,
+        &SocketAddr::new(*address, port_or_java_default(port)),
+        None,
+    )
 }
 
 /// Query a Bedrock Server.
 pub fn query_bedrock(address: &IpAddr, port: Option<u16>) -> GDResult<BedrockResponse> {
-    minecraft::query_bedrock(&SocketAddr::new(*address, port_or_bedrock_default(port)), None)
+    minecraft::query_bedrock(
+        &SocketAddr::new(*address, port_or_bedrock_default(port)),
+        None,
+    )
 }
 
 fn port_or_java_default(port: Option<u16>) -> u16 { port.unwrap_or(25565) }
diff --git a/src/games/mod.rs b/src/games/mod.rs
index fb182b3..0a4e006 100644
--- a/src/games/mod.rs
+++ b/src/games/mod.rs
@@ -34,6 +34,8 @@ pub mod cscz;
 pub mod csgo;
 /// Counter-Strike: Source
 pub mod css;
+/// Crysis Wars
+pub mod cw;
 /// Day of Defeat
 pub mod dod;
 /// Day of Defeat: Source
@@ -50,6 +52,8 @@ pub mod gm;
 pub mod hl2dm;
 /// Half-Life Deathmatch: Source
 pub mod hldms;
+/// Hell Let Loose
+pub mod hll;
 /// Insurgency
 pub mod ins;
 /// Insurgency: Modern Infantry Combat
@@ -68,6 +72,12 @@ pub mod ohd;
 pub mod onset;
 /// Project Zomboid
 pub mod pz;
+/// Quake 1
+pub mod quake1;
+/// Quake 2
+pub mod quake2;
+/// Quake 3: Arena
+pub mod quake3a;
 /// Risk of Rain 2
 pub mod ror2;
 /// Rust
@@ -76,6 +86,8 @@ pub mod rust;
 pub mod sc;
 /// 7 Days To Die
 pub mod sdtd;
+/// Soldier of Fortune 2
+pub mod sof2;
 /// Serious Sam
 pub mod ss;
 /// The Forest
@@ -92,15 +104,3 @@ pub mod unturned;
 pub mod ut;
 /// V Rising
 pub mod vr;
-/// Crysis Wars
-pub mod cw;
-/// Quake 2
-pub mod quake2;
-/// Quake 1
-pub mod quake1;
-/// Quake 3: Arena
-pub mod quake3a;
-/// Hell Let Loose
-pub mod hll;
-/// Soldier of Fortune 2
-pub mod sof2;
diff --git a/src/games/ohd.rs b/src/games/ohd.rs
index 6beb3b7..16d3502 100644
--- a/src/games/ohd.rs
+++ b/src/games/ohd.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/onset.rs b/src/games/onset.rs
index eb2e6e7..e83c33b 100644
--- a/src/games/onset.rs
+++ b/src/games/onset.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/pz.rs b/src/games/pz.rs
index 3cf4549..a7d5206 100644
--- a/src/games/pz.rs
+++ b/src/games/pz.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/quake1.rs b/src/games/quake1.rs
index 708df38..32359a4 100644
--- a/src/games/quake1.rs
+++ b/src/games/quake1.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
-use crate::GDResult;
 use crate::protocols::quake;
-use crate::protocols::quake::Response;
 use crate::protocols::quake::one::Player;
+use crate::protocols::quake::Response;
+use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response<Player>> {
     quake::one::query(&SocketAddr::new(*address, port.unwrap_or(27500)), None)
diff --git a/src/games/quake2.rs b/src/games/quake2.rs
index f0097f9..32481d0 100644
--- a/src/games/quake2.rs
+++ b/src/games/quake2.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
-use crate::GDResult;
 use crate::protocols::quake;
-use crate::protocols::quake::Response;
 use crate::protocols::quake::two::Player;
+use crate::protocols::quake::Response;
+use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response<Player>> {
     quake::two::query(&SocketAddr::new(*address, port.unwrap_or(27910)), None)
diff --git a/src/games/quake3a.rs b/src/games/quake3a.rs
index 4886957..eb38e4b 100644
--- a/src/games/quake3a.rs
+++ b/src/games/quake3a.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
-use crate::GDResult;
 use crate::protocols::quake;
-use crate::protocols::quake::Response;
 use crate::protocols::quake::two::Player;
+use crate::protocols::quake::Response;
+use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response<Player>> {
     quake::three::query(&SocketAddr::new(*address, port.unwrap_or(27960)), None)
diff --git a/src/games/ror2.rs b/src/games/ror2.rs
index 23e8ec5..ca0bfe8 100644
--- a/src/games/ror2.rs
+++ b/src/games/ror2.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/rust.rs b/src/games/rust.rs
index bd724f9..39bae1a 100644
--- a/src/games/rust.rs
+++ b/src/games/rust.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/sc.rs b/src/games/sc.rs
index 8765345..ff21b08 100644
--- a/src/games/sc.rs
+++ b/src/games/sc.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/sdtd.rs b/src/games/sdtd.rs
index 2c213e3..69b9e4e 100644
--- a/src/games/sdtd.rs
+++ b/src/games/sdtd.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/sof2.rs b/src/games/sof2.rs
index d8bd1a8..9f40059 100644
--- a/src/games/sof2.rs
+++ b/src/games/sof2.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
-use crate::GDResult;
 use crate::protocols::quake;
-use crate::protocols::quake::Response;
 use crate::protocols::quake::two::Player;
+use crate::protocols::quake::Response;
+use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response<Player>> {
     quake::three::query(&SocketAddr::new(*address, port.unwrap_or(20100)), None)
diff --git a/src/games/ss.rs b/src/games/ss.rs
index 33f2175..001d4e4 100644
--- a/src/games/ss.rs
+++ b/src/games/ss.rs
@@ -1,7 +1,7 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::protocols::gamespy;
 use crate::protocols::gamespy::one::Response;
 use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response> {
     gamespy::one::query(&SocketAddr::new(*address, port.unwrap_or(25601)), None)
diff --git a/src/games/tf.rs b/src/games/tf.rs
index 88d18f0..a9261af 100644
--- a/src/games/tf.rs
+++ b/src/games/tf.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/tf2.rs b/src/games/tf2.rs
index 7098bb7..e94b543 100644
--- a/src/games/tf2.rs
+++ b/src/games/tf2.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/tfc.rs b/src/games/tfc.rs
index beac79d..e8c8093 100644
--- a/src/games/tfc.rs
+++ b/src/games/tfc.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/ts.rs b/src/games/ts.rs
index a7356bf..089c0a2 100644
--- a/src/games/ts.rs
+++ b/src/games/ts.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, get_optional_extracted_data, Server, ServerPlayer, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 use std::collections::HashMap;
 
diff --git a/src/games/unturned.rs b/src/games/unturned.rs
index 0f00d9c..6ac05f1 100644
--- a/src/games/unturned.rs
+++ b/src/games/unturned.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/games/ut.rs b/src/games/ut.rs
index 9906b00..453b4f1 100644
--- a/src/games/ut.rs
+++ b/src/games/ut.rs
@@ -1,7 +1,7 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::protocols::gamespy;
 use crate::protocols::gamespy::one::Response;
 use crate::GDResult;
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response> {
     gamespy::one::query(&SocketAddr::new(*address, port.unwrap_or(7778)), None)
diff --git a/src/games/vr.rs b/src/games/vr.rs
index 65887c5..833897f 100644
--- a/src/games/vr.rs
+++ b/src/games/vr.rs
@@ -1,8 +1,8 @@
-use std::net::{IpAddr, SocketAddr};
 use crate::{
     protocols::valve::{self, game, SteamApp},
     GDResult,
 };
+use std::net::{IpAddr, SocketAddr};
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<game::Response> {
     let valve_response = valve::query(
diff --git a/src/lib.rs b/src/lib.rs
index 3254b53..f14f090 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,8 +15,8 @@
 //! # Crate features:
 //! Enabled by default: None
 //!
-//! `serde` - enables json serialization/deserialization for all response types. <br>
-//! `no_games` - disables the included games support. <br>
+//! `serde` - enables json serialization/deserialization for all response types.
+//! <br> `no_games` - disables the included games support. <br>
 //! `no_services` - disables the included services support.
 
 pub mod errors;
diff --git a/src/protocols/gamespy/protocols/one/protocol.rs b/src/protocols/gamespy/protocols/one/protocol.rs
index 43ba7dc..7e689d5 100644
--- a/src/protocols/gamespy/protocols/one/protocol.rs
+++ b/src/protocols/gamespy/protocols/one/protocol.rs
@@ -1,3 +1,4 @@
+use crate::protocols::gamespy::common::has_password;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -8,7 +9,6 @@ use crate::{
     GDError,
     GDResult,
 };
-use crate::protocols::gamespy::common::has_password;
 use std::collections::HashMap;
 use std::net::SocketAddr;
 
diff --git a/src/protocols/minecraft/protocol/bedrock.rs b/src/protocols/minecraft/protocol/bedrock.rs
index bd1a2df..6e83e7c 100644
--- a/src/protocols/minecraft/protocol/bedrock.rs
+++ b/src/protocols/minecraft/protocol/bedrock.rs
@@ -1,7 +1,6 @@
 // This file has code that has been documented by the NodeJS GameDig library
 // (MIT) from https://github.com/gamedig/node-gamedig/blob/master/protocols/minecraftbedrock.js
 
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -13,6 +12,7 @@ use crate::{
     GDError::{PacketBad, TypeParse},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct Bedrock {
     socket: UdpSocket,
diff --git a/src/protocols/minecraft/protocol/java.rs b/src/protocols/minecraft/protocol/java.rs
index eaf471a..19da757 100644
--- a/src/protocols/minecraft/protocol/java.rs
+++ b/src/protocols/minecraft/protocol/java.rs
@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -9,6 +8,7 @@ use crate::{
     GDError::{JsonParse, PacketBad},
     GDResult,
 };
+use std::net::SocketAddr;
 
 use serde_json::Value;
 
diff --git a/src/protocols/minecraft/protocol/legacy_bv1_8.rs b/src/protocols/minecraft/protocol/legacy_bv1_8.rs
index 183ffc6..13e4867 100644
--- a/src/protocols/minecraft/protocol/legacy_bv1_8.rs
+++ b/src/protocols/minecraft/protocol/legacy_bv1_8.rs
@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -10,6 +9,7 @@ use crate::{
     GDError::{PacketBad, ProtocolFormat},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct LegacyBV1_8 {
     socket: TcpSocket,
diff --git a/src/protocols/minecraft/protocol/legacy_v1_4.rs b/src/protocols/minecraft/protocol/legacy_v1_4.rs
index 44b6338..e9e5077 100644
--- a/src/protocols/minecraft/protocol/legacy_v1_4.rs
+++ b/src/protocols/minecraft/protocol/legacy_v1_4.rs
@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -10,6 +9,7 @@ use crate::{
     GDError::{PacketBad, ProtocolFormat},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct LegacyV1_4 {
     socket: TcpSocket,
diff --git a/src/protocols/minecraft/protocol/legacy_v1_6.rs b/src/protocols/minecraft/protocol/legacy_v1_6.rs
index 46e4953..e1f9d9c 100644
--- a/src/protocols/minecraft/protocol/legacy_v1_6.rs
+++ b/src/protocols/minecraft/protocol/legacy_v1_6.rs
@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -10,6 +9,7 @@ use crate::{
     GDError::{PacketBad, ProtocolFormat},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct LegacyV1_6 {
     socket: TcpSocket,
diff --git a/src/protocols/minecraft/protocol/mod.rs b/src/protocols/minecraft/protocol/mod.rs
index 35090b6..e555fc4 100644
--- a/src/protocols/minecraft/protocol/mod.rs
+++ b/src/protocols/minecraft/protocol/mod.rs
@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     protocols::minecraft::{
         protocol::{
@@ -16,6 +15,7 @@ use crate::{
     GDError::AutoQuery,
     GDResult,
 };
+use std::net::SocketAddr;
 
 mod bedrock;
 mod java;
diff --git a/src/protocols/mod.rs b/src/protocols/mod.rs
index 97fc5bd..6e3f288 100644
--- a/src/protocols/mod.rs
+++ b/src/protocols/mod.rs
@@ -8,9 +8,9 @@
 pub mod gamespy;
 /// Reference: [Server List Ping](https://wiki.vg/Server_List_Ping)
 pub mod minecraft;
+/// Reference: [node-GameDig](https://github.com/gamedig/node-gamedig/blob/master/protocols/quake1.js)
+pub mod quake;
 /// General types that are used by all protocols.
 pub mod types;
 /// Reference: [Server Query](https://developer.valvesoftware.com/wiki/Server_queries)
 pub mod valve;
-/// Reference: [node-GameDig](https://github.com/gamedig/node-gamedig/blob/master/protocols/quake1.js)
-pub mod quake;
diff --git a/src/protocols/quake/client.rs b/src/protocols/quake/client.rs
index 595c33b..a74502c 100644
--- a/src/protocols/quake/client.rs
+++ b/src/protocols/quake/client.rs
@@ -1,11 +1,11 @@
-use std::collections::HashMap;
-use std::net::SocketAddr;
-use std::slice::Iter;
 use crate::bufferer::{Bufferer, Endianess};
-use crate::{GDError, GDResult};
 use crate::protocols::quake::types::Response;
 use crate::protocols::types::TimeoutSettings;
 use crate::socket::{Socket, UdpSocket};
+use crate::{GDError, GDResult};
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 pub(crate) trait QuakeClient {
     type Player;
@@ -15,11 +15,21 @@ pub(crate) trait QuakeClient {
     fn parse_player_string(data: Iter<&str>) -> GDResult<Self::Player>;
 }
 
-fn get_data<Client: QuakeClient>(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Bufferer> {
+fn get_data<Client: QuakeClient>(
+    address: &SocketAddr,
+    timeout_settings: Option<TimeoutSettings>,
+) -> GDResult<Bufferer> {
     let mut socket = UdpSocket::new(address)?;
     socket.apply_timeout(timeout_settings)?;
 
-    socket.send(&[&[0xFF, 0xFF, 0xFF, 0xFF], Client::get_send_header().as_bytes(), &[0x00]].concat())?;
+    socket.send(
+        &[
+            &[0xFF, 0xFF, 0xFF, 0xFF],
+            Client::get_send_header().as_bytes(),
+            &[0x00],
+        ]
+        .concat(),
+    )?;
 
     let data = socket.receive(None)?;
     let mut bufferer = Bufferer::new_with_data(Endianess::Little, &data);
@@ -78,27 +88,34 @@ fn get_players<Client: QuakeClient>(bufferer: &mut Bufferer) -> GDResult<Vec<Cli
     Ok(players)
 }
 
-pub(crate) fn client_query<Client: QuakeClient>(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Response<Client::Player>> {
+pub(crate) fn client_query<Client: QuakeClient>(
+    address: &SocketAddr,
+    timeout_settings: Option<TimeoutSettings>,
+) -> GDResult<Response<Client::Player>> {
     let mut bufferer = get_data::<Client>(address, timeout_settings)?;
 
     let mut server_vars = get_server_values(&mut bufferer)?;
     let players = get_players::<Client>(&mut bufferer)?;
 
     Ok(Response {
-        name: server_vars.remove("hostname")
+        name: server_vars
+            .remove("hostname")
             .or(server_vars.remove("sv_hostname"))
             .ok_or(GDError::PacketBad)?,
-        map: server_vars.remove("mapname")
+        map: server_vars
+            .remove("mapname")
             .or(server_vars.remove("map"))
             .ok_or(GDError::PacketBad)?,
         players_online: players.len() as u8,
-        players_maximum: server_vars.remove("maxclients")
+        players_maximum: server_vars
+            .remove("maxclients")
             .or(server_vars.remove("sv_maxclients"))
             .ok_or(GDError::PacketBad)?
             .parse()
             .map_err(|_| GDError::TypeParse)?,
         players,
-        version: server_vars.remove("version")
+        version: server_vars
+            .remove("version")
             .or(server_vars.remove("*version"))
             .ok_or(GDError::PacketBad)?,
         unused_entries: server_vars,
@@ -108,6 +125,6 @@ pub(crate) fn client_query<Client: QuakeClient>(address: &SocketAddr, timeout_se
 pub(crate) fn remove_wrapping_quotes<'a>(string: &&'a str) -> &'a str {
     match string.starts_with('\"') && string.ends_with('\"') {
         false => string,
-        true => &string[1..string.len() - 1]
+        true => &string[1 .. string.len() - 1],
     }
 }
diff --git a/src/protocols/quake/mod.rs b/src/protocols/quake/mod.rs
index da11432..e20afcc 100644
--- a/src/protocols/quake/mod.rs
+++ b/src/protocols/quake/mod.rs
@@ -1,7 +1,6 @@
-
 pub mod one;
-pub mod two;
 pub mod three;
+pub mod two;
 
 /// All types used by the implementation.
 pub mod types;
diff --git a/src/protocols/quake/one.rs b/src/protocols/quake/one.rs
index 60fe4c0..a542bbf 100644
--- a/src/protocols/quake/one.rs
+++ b/src/protocols/quake/one.rs
@@ -1,11 +1,11 @@
-use std::net::SocketAddr;
-use std::slice::Iter;
-use crate::{GDError, GDResult};
+use crate::protocols::quake::client::{client_query, remove_wrapping_quotes, QuakeClient};
 use crate::protocols::quake::Response;
-use crate::protocols::quake::client::{QuakeClient, client_query, remove_wrapping_quotes};
 use crate::protocols::types::TimeoutSettings;
+use crate::{GDError, GDResult};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 /// Quake 1 player data.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -19,54 +19,50 @@ pub struct Player {
     pub name: String,
     pub skin: String,
     pub color_primary: u8,
-    pub color_secondary: u8
+    pub color_secondary: u8,
 }
 
 pub(crate) struct QuakeOne;
 impl QuakeClient for QuakeOne {
     type Player = Player;
 
-    fn get_send_header<'a>() -> &'a str {
-        "status"
-    }
+    fn get_send_header<'a>() -> &'a str { "status" }
 
-    fn get_response_header<'a>() -> &'a str {
-        "n"
-    }
+    fn get_response_header<'a>() -> &'a str { "n" }
 
     fn parse_player_string(mut data: Iter<&str>) -> GDResult<Self::Player> {
         Ok(Player {
             id: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             score: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             time: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             ping: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             name: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => remove_wrapping_quotes(v).to_string()
+                Some(v) => remove_wrapping_quotes(v).to_string(),
             },
             skin: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => remove_wrapping_quotes(v).to_string()
+                Some(v) => remove_wrapping_quotes(v).to_string(),
             },
             color_primary: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             color_secondary: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
         })
     }
diff --git a/src/protocols/quake/three.rs b/src/protocols/quake/three.rs
index 819e1e5..4942165 100644
--- a/src/protocols/quake/three.rs
+++ b/src/protocols/quake/three.rs
@@ -1,26 +1,20 @@
-use std::net::SocketAddr;
-use std::slice::Iter;
-use crate::GDResult;
+use crate::protocols::quake::client::{client_query, QuakeClient};
 use crate::protocols::quake::two::{Player, QuakeTwo};
 use crate::protocols::quake::Response;
-use crate::protocols::quake::client::{QuakeClient, client_query};
 use crate::protocols::types::TimeoutSettings;
+use crate::GDResult;
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 struct QuakeThree;
 impl QuakeClient for QuakeThree {
     type Player = Player;
 
-    fn get_send_header<'a>() -> &'a str {
-        "getstatus"
-    }
+    fn get_send_header<'a>() -> &'a str { "getstatus" }
 
-    fn get_response_header<'a>() -> &'a str {
-        "statusResponse\n"
-    }
+    fn get_response_header<'a>() -> &'a str { "statusResponse\n" }
 
-    fn parse_player_string(data: Iter<&str>) -> GDResult<Self::Player> {
-        QuakeTwo::parse_player_string(data)
-    }
+    fn parse_player_string(data: Iter<&str>) -> GDResult<Self::Player> { QuakeTwo::parse_player_string(data) }
 }
 
 pub fn query(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Response<Player>> {
diff --git a/src/protocols/quake/two.rs b/src/protocols/quake/two.rs
index 6eca4a4..be75e12 100644
--- a/src/protocols/quake/two.rs
+++ b/src/protocols/quake/two.rs
@@ -1,12 +1,12 @@
-use std::net::SocketAddr;
-use std::slice::Iter;
-use crate::{GDError, GDResult};
+use crate::protocols::quake::client::{client_query, remove_wrapping_quotes, QuakeClient};
 use crate::protocols::quake::one::QuakeOne;
 use crate::protocols::quake::Response;
-use crate::protocols::quake::client::{QuakeClient, client_query, remove_wrapping_quotes};
 use crate::protocols::types::TimeoutSettings;
+use crate::{GDError, GDResult};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 /// Quake 2 player data.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -14,35 +14,31 @@ use serde::{Deserialize, Serialize};
 pub struct Player {
     pub frags: i16,
     pub ping: u16,
-    pub name: String
+    pub name: String,
 }
 
 pub(crate) struct QuakeTwo;
 impl QuakeClient for QuakeTwo {
     type Player = Player;
 
-    fn get_send_header<'a>() -> &'a str {
-        QuakeOne::get_send_header()
-    }
+    fn get_send_header<'a>() -> &'a str { QuakeOne::get_send_header() }
 
-    fn get_response_header<'a>() -> &'a str {
-        "print\n"
-    }
+    fn get_response_header<'a>() -> &'a str { "print\n" }
 
     fn parse_player_string(mut data: Iter<&str>) -> GDResult<Self::Player> {
         Ok(Player {
             frags: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             ping: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             name: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => remove_wrapping_quotes(v).to_string()
-            }
+                Some(v) => remove_wrapping_quotes(v).to_string(),
+            },
         })
     }
 }
diff --git a/src/protocols/quake/types.rs b/src/protocols/quake/types.rs
index 526a9a4..2f8c145 100644
--- a/src/protocols/quake/types.rs
+++ b/src/protocols/quake/types.rs
@@ -1,6 +1,6 @@
-use std::collections::HashMap;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 /// General server information's.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
diff --git a/src/protocols/valve/protocol.rs b/src/protocols/valve/protocol.rs
index e4bc067..05dc737 100644
--- a/src/protocols/valve/protocol.rs
+++ b/src/protocols/valve/protocol.rs
@@ -418,12 +418,7 @@ pub fn query(
     timeout_settings: Option<TimeoutSettings>,
 ) -> GDResult<Response> {
     let response_gather_settings = gather_settings.unwrap_or_default();
-    get_response(
-        address,
-        engine,
-        response_gather_settings,
-        timeout_settings,
-    )
+    get_response(address, engine, response_gather_settings, timeout_settings)
 }
 
 fn get_response(
diff --git a/src/services/valve_master_server/service.rs b/src/services/valve_master_server/service.rs
index c3e2e80..9f73e6d 100644
--- a/src/services/valve_master_server/service.rs
+++ b/src/services/valve_master_server/service.rs
@@ -71,7 +71,12 @@ impl ValveMasterServer {
 
         let mut ips: Vec<(IpAddr, u16)> = Vec::new();
         while buf.remaining_length() > 0 {
-            let ip = IpAddr::V4(Ipv4Addr::new(buf.get_u8()?, buf.get_u8()?, buf.get_u8()?, buf.get_u8()?));
+            let ip = IpAddr::V4(Ipv4Addr::new(
+                buf.get_u8()?,
+                buf.get_u8()?,
+                buf.get_u8()?,
+                buf.get_u8()?,
+            ));
             let port = buf.get_u16()?;
 
             ips.push((ip, port));
diff --git a/src/services/valve_master_server/types.rs b/src/services/valve_master_server/types.rs
index 0bcd672..27f8c21 100644
--- a/src/services/valve_master_server/types.rs
+++ b/src/services/valve_master_server/types.rs
@@ -15,7 +15,8 @@ pub enum Filter {
     HasTags(Vec<String>),
     MatchName(String),
     MatchVersion(String),
-    /// Restrict to only a server if an IP hosts (on different ports) multiple servers.
+    /// Restrict to only a server if an IP hosts (on different ports) multiple
+    /// servers.
     RestrictUniqueIP(bool),
     /// Query for servers on a specific address.
     OnAddress(String),
@@ -133,7 +134,8 @@ impl Filter {
 ///             .insert(Filter::IsEmpty(false))
 ///             .insert(Filter::CanHavePassword(false));
 /// ```
-/// This will construct filters that search for servers that can't have a password, are not empty and run App ID 440.
+/// This will construct filters that search for servers that can't have a
+/// password, are not empty and run App ID 440.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SearchFilters {
     filters: HashMap<Discriminant<Filter>, Filter>,
@@ -208,8 +210,14 @@ impl SearchFilters {
             bytes.extend(filter.to_bytes())
         }
 
-        bytes.extend(SearchFilters::special_filter_to_bytes("nand", &self.nand_filters));
-        bytes.extend(SearchFilters::special_filter_to_bytes("nor", &self.nor_filters));
+        bytes.extend(SearchFilters::special_filter_to_bytes(
+            "nand",
+            &self.nand_filters,
+        ));
+        bytes.extend(SearchFilters::special_filter_to_bytes(
+            "nor",
+            &self.nor_filters,
+        ));
 
         bytes.extend([0x00]);
         bytes
diff --git a/src/socket.rs b/src/socket.rs
index b0714b2..8fa13d6 100644
--- a/src/socket.rs
+++ b/src/socket.rs
@@ -4,11 +4,11 @@ use crate::{
     GDResult,
 };
 
+use std::net::SocketAddr;
 use std::{
     io::{Read, Write},
     net,
 };
-use std::net::SocketAddr;
 
 const DEFAULT_PACKET_SIZE: usize = 1024;