Clippy + fmt

pumpkin-protocol/src/bytebuf/deserializer.rs

@@ -1,10 +1,8 @@
-use std::{error, fmt::Display};
+use std::fmt::Display;
 
-use serde::de::{self, DeserializeOwned, DeserializeSeed, SeqAccess};
+use serde::de::{self, DeserializeSeed, SeqAccess};
 use thiserror::Error;
 
-use crate::VarInt;
-
 use super::ByteBuffer;
 
 pub struct Deserializer<'a> {
@@ -34,7 +32,7 @@ impl<'a> Deserializer<'a> {
 impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
     type Error = DeserializerError;
 
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
@@ -43,7 +41,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
         )
     }
 
-    fn deserialize_bool<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
@@ -120,7 +118,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
         visitor.visit_f64(self.inner.get_f64())
     }
 
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
@@ -131,10 +129,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
     where
         V: de::Visitor<'de>,
     {
-        let string = self
+        let string = self.inner.get_string().map_err(DeserializerError::Stdio)?;
-            .inner
-            .get_string()
-            .map_err(|e| DeserializerError::Stdio(e))?;
         visitor.visit_str(&string)
     }
 
@@ -142,35 +137,32 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
     where
         V: de::Visitor<'de>,
     {
-        let string = self
+        let string = self.inner.get_string().map_err(DeserializerError::Stdio)?;
-            .inner
-            .get_string()
-            .map_err(|e| DeserializerError::Stdio(e))?;
         visitor.visit_str(&string)
     }
 
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
         unimplemented!()
     }
 
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
         unimplemented!()
     }
 
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
         unimplemented!()
     }
 
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
@@ -179,8 +171,8 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
 
     fn deserialize_unit_struct<V>(
         self,
-        name: &'static str,
+        _name: &'static str,
-        visitor: V,
+        _visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
@@ -190,8 +182,8 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
 
     fn deserialize_newtype_struct<V>(
         self,
-        name: &'static str,
+        _name: &'static str,
-        visitor: V,
+        _visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
@@ -217,7 +209,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
                 let value = DeserializeSeed::deserialize(
                     seed,
                     Deserializer {
-                        inner: &mut self.deserializer.inner,
+                        inner: self.deserializer.inner,
                     },
                 )?;
                 Ok(Some(value))
@@ -252,7 +244,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
                     let value = DeserializeSeed::deserialize(
                         seed,
                         Deserializer {
-                            inner: &mut self.deserializer.inner,
+                            inner: self.deserializer.inner,
                         },
                     )?;
                     Ok(Some(value))
@@ -272,9 +264,9 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
 
     fn deserialize_tuple_struct<V>(
         self,
-        name: &'static str,
+        _name: &'static str,
-        len: usize,
+        _len: usize,
-        visitor: V,
+        _visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
@@ -282,7 +274,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
         unimplemented!()
     }
 
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
@@ -291,7 +283,7 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
 
     fn deserialize_struct<V>(
         self,
-        name: &'static str,
+        _name: &'static str,
         fields: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value, Self::Error>
@@ -303,9 +295,9 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
 
     fn deserialize_enum<V>(
         self,
-        name: &'static str,
+        _name: &'static str,
-        variants: &'static [&'static str],
+        _variants: &'static [&'static str],
-        visitor: V,
+        _visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
@@ -313,14 +305,14 @@ impl<'a, 'de> de::Deserializer<'de> for Deserializer<'a> {
         unimplemented!()
     }
 
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
         unimplemented!()
     }
 
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {

pumpkin-protocol/src/bytebuf/mod.rs

@@ -308,7 +308,10 @@ impl ByteBuffer {
 mod test {
     use serde::{Deserialize, Serialize};
 
-    use crate::{bytebuf::{deserializer, serializer, ByteBuffer}, VarInt};
+    use crate::{
+        bytebuf::{deserializer, serializer, ByteBuffer},
+        VarInt,
+    };
 
     #[test]
     fn test_i32_reserialize() {

pumpkin-protocol/src/server/config/s_client_information.rs

@@ -1,6 +1,6 @@
 use pumpkin_macros::packet;
 
-use crate::{bytebuf::ByteBuffer, Identifier, ServerPacket, VarInt};
+use crate::VarInt;
 
 #[derive(serde::Deserialize)]
 #[packet(0x00)]

pumpkin-protocol/src/server/config/s_known_packs.rs

@@ -1,6 +1,6 @@
 use pumpkin_macros::packet;
 
-use crate::{bytebuf::ByteBuffer, Identifier, ServerPacket, VarInt};
+use crate::VarInt;
 
 #[derive(serde::Deserialize)]
 #[packet(0x07)]

pumpkin-protocol/src/server/config/s_plugin_message.rs

@@ -2,7 +2,7 @@ use pumpkin_macros::packet;
 
 use crate::{
     bytebuf::{ByteBuffer, DeserializerError},
-    Identifier, ServerPacket, VarInt,
+    Identifier, ServerPacket,
 };
 
 #[packet(0x02)]

pumpkin-protocol/src/server/login/s_login_response.rs

@@ -1,7 +1,5 @@
 use pumpkin_macros::packet;
 
-use crate::{bytebuf::ByteBuffer, ServerPacket, VarInt};
-
 // Acknowledgement to the Login Success packet sent to the server.
 #[derive(serde::Deserialize)]
 #[packet(0x03)]

pumpkin-protocol/src/server/login/s_login_start.rs

@@ -2,7 +2,7 @@ use pumpkin_macros::packet;
 
 use crate::{
     bytebuf::{ByteBuffer, DeserializerError},
-    ServerPacket, VarInt,
+    ServerPacket,
 };
 
 #[packet(0x00)]

pumpkin-protocol/src/server/play/mod.rs

@@ -1,12 +1,12 @@
-mod s_confirm_teleport;
 mod s_chat_command;
+mod s_confirm_teleport;
 mod s_player_command;
 mod s_player_position;
 mod s_player_position_rotation;
 mod s_player_rotation;
 
-pub use s_confirm_teleport::*;
 pub use s_chat_command::*;
+pub use s_confirm_teleport::*;
 pub use s_player_command::*;
 pub use s_player_position::*;
 pub use s_player_position_rotation::*;

pumpkin-protocol/src/server/play/s_chat_command.rs

@@ -1,9 +1,5 @@
-use num_derive::FromPrimitive;
-use num_traits::FromPrimitive;
 use pumpkin_macros::packet;
 
-use crate::{ServerPacket, VarInt};
-
 #[derive(serde::Deserialize)]
 #[packet(0x04)]
 pub struct SChatCommand {

pumpkin-protocol/src/server/play/s_confirm_teleport.rs

@@ -1,8 +1,6 @@
-use num_derive::FromPrimitive;
-use num_traits::FromPrimitive;
 use pumpkin_macros::packet;
 
-use crate::{ServerPacket, VarInt};
+use crate::VarInt;
 
 #[derive(serde::Deserialize)]
 #[packet(0x00)]

pumpkin-protocol/src/server/play/s_player_position.rs

@@ -1,9 +1,5 @@
-use num_derive::FromPrimitive;
-use num_traits::FromPrimitive;
 use pumpkin_macros::packet;
 
-use crate::{ServerPacket, VarInt};
-
 #[derive(serde::Deserialize)]
 #[packet(0x1A)]
 pub struct SPlayerPosition {

pumpkin-protocol/src/server/play/s_player_position_rotation.rs

@@ -1,16 +1,12 @@
-use num_derive::FromPrimitive;
-use num_traits::FromPrimitive;
 use pumpkin_macros::packet;
 
-use crate::{ServerPacket, VarInt};
-
 #[derive(serde::Deserialize)]
 #[packet(0x1B)]
 pub struct SPlayerPositionRotation {
-  pub x: f64,
+    pub x: f64,
-  pub feet_y: f64,
+    pub feet_y: f64,
-  pub z: f64,
+    pub z: f64,
-  pub yaw: f32,
+    pub yaw: f32,
-  pub pitch: f32,
+    pub pitch: f32,
-  pub ground: bool,
+    pub ground: bool,
 }

pumpkin-protocol/src/server/play/s_player_rotation.rs

@@ -1,9 +1,5 @@
-use num_derive::FromPrimitive;
-use num_traits::FromPrimitive;
 use pumpkin_macros::packet;
 
-use crate::{ServerPacket, VarInt};
-
 #[derive(serde::Deserialize)]
 #[packet(0x1C)]
 pub struct SPlayerRotation {

pumpkin-protocol/src/server/status/mod.rs

@@ -1,5 +1,3 @@
-use crate::{bytebuf::ByteBuffer, ServerPacket, VarInt};
-
 mod s_ping_request;
 mod s_status_request;
 

pumpkin/src/client/mod.rs

@@ -14,11 +14,15 @@ use authentication::GameProfile;
 use mio::{event::Event, net::TcpStream, Token};
 use num_traits::ToPrimitive;
 use pumpkin_protocol::{
-    bytebuf::packet_id::Packet, client::{
+    bytebuf::packet_id::Packet,
+    client::{
         config::CConfigDisconnect,
         login::CLoginDisconnect,
         play::{CGameEvent, CPlayDisconnect, CSyncPlayerPostion, CSystemChatMessge},
-    }, packet_decoder::PacketDecoder, packet_encoder::PacketEncoder, server::{
+    },
+    packet_decoder::PacketDecoder,
+    packet_encoder::PacketEncoder,
+    server::{
         config::{SAcknowledgeFinishConfig, SClientInformation, SKnownPacks, SPluginMessage},
         handshake::SHandShake,
         login::{SEncryptionResponse, SLoginAcknowledged, SLoginPluginResponse, SLoginStart},
@@ -27,7 +31,9 @@ use pumpkin_protocol::{
             SPlayerPositionRotation, SPlayerRotation,
         },
         status::{SPingRequest, SStatusRequest},
-    }, text::TextComponent, ClientPacket, ConnectionState, PacketError, RawPacket, ServerPacket
+    },
+    text::TextComponent,
+    ClientPacket, ConnectionState, PacketError, RawPacket, ServerPacket,
 };
 
 use std::io::Read;
@@ -165,7 +171,9 @@ impl Client {
         let bytebuf = &mut packet.bytebuf;
         match self.connection_state {
             pumpkin_protocol::ConnectionState::HandShake => match packet.id.0 {
-                SHandShake::PACKET_ID => self.handle_handshake(server, SHandShake::read(bytebuf).unwrap()),
+                SHandShake::PACKET_ID => {
+                    self.handle_handshake(server, SHandShake::read(bytebuf).unwrap())
+                }
                 _ => log::error!(
                     "Failed to handle packet id {} while in Handshake state",
                     packet.id.0
@@ -187,30 +195,29 @@ impl Client {
                 SLoginStart::PACKET_ID => {
                     self.handle_login_start(server, SLoginStart::read(bytebuf).unwrap())
                 }
-                SEncryptionResponse::PACKET_ID => {
+                SEncryptionResponse::PACKET_ID => self.handle_encryption_response(
-                    self.handle_encryption_response(server, SEncryptionResponse::read(bytebuf).unwrap())
+                    server,
-                }
+                    SEncryptionResponse::read(bytebuf).unwrap(),
-                SLoginPluginResponse::PACKET_ID => {
+                ),
-                    self.handle_plugin_response(server, SLoginPluginResponse::read(bytebuf).unwrap())
+                SLoginPluginResponse::PACKET_ID => self
-                }
+                    .handle_plugin_response(server, SLoginPluginResponse::read(bytebuf).unwrap()),
-                SLoginAcknowledged::PACKET_ID => {
+                SLoginAcknowledged::PACKET_ID => self
-                    self.handle_login_acknowledged(server, SLoginAcknowledged::read(bytebuf).unwrap())
+                    .handle_login_acknowledged(server, SLoginAcknowledged::read(bytebuf).unwrap()),
-                }
                 _ => log::error!(
                     "Failed to handle packet id {} while in Login state",
                     packet.id.0
                 ),
             },
             pumpkin_protocol::ConnectionState::Config => match packet.id.0 {
-                SClientInformation::PACKET_ID => {
+                SClientInformation::PACKET_ID => self
-                    self.handle_client_information(server, SClientInformation::read(bytebuf).unwrap())
+                    .handle_client_information(server, SClientInformation::read(bytebuf).unwrap()),
-                }
                 SPluginMessage::PACKET_ID => {
                     self.handle_plugin_message(server, SPluginMessage::read(bytebuf).unwrap())
                 }
-                SAcknowledgeFinishConfig::PACKET_ID => {
+                SAcknowledgeFinishConfig::PACKET_ID => self.handle_config_acknowledged(
-                    self.handle_config_acknowledged(server, SAcknowledgeFinishConfig::read(bytebuf).unwrap())
+                    server,
-                }
+                    SAcknowledgeFinishConfig::read(bytebuf).unwrap(),
+                ),
                 SKnownPacks::PACKET_ID => {
                     self.handle_known_packs(server, SKnownPacks::read(bytebuf).unwrap())
                 }
@@ -243,9 +250,8 @@ impl Client {
             SPlayerPosition::PACKET_ID => {
                 self.handle_position(server, SPlayerPosition::read(bytebuf).unwrap())
             }
-            SPlayerPositionRotation::PACKET_ID => {
+            SPlayerPositionRotation::PACKET_ID => self
-                self.handle_position_rotation(server, SPlayerPositionRotation::read(bytebuf).unwrap())
+                .handle_position_rotation(server, SPlayerPositionRotation::read(bytebuf).unwrap()),
-            }
             SPlayerRotation::PACKET_ID => {
                 self.handle_rotation(server, SPlayerRotation::read(bytebuf).unwrap())
             }

pumpkin/src/main.rs

@@ -6,11 +6,7 @@ use client::Client;
 use commands::handle_command;
 use configuration::AdvancedConfiguration;
 
-use std::{
+use std::{collections::HashMap, rc::Rc, thread};
-    collections::HashMap,
-    rc::Rc,
-    thread,
-};
 
 use client::interrupted;
 use configuration::BasicConfiguration;
@@ -64,10 +60,7 @@ fn main() -> io::Result<()> {
 
     let mut connections: HashMap<Token, Rc<RefCell<Client>>> = HashMap::new();
 
-    let mut server = Server::new((
+    let mut server = Server::new((basic_config, advanced_configuration));
-        basic_config,
-        advanced_configuration,
-    ));
     log::info!("Started Server took {}ms", time.elapsed().as_millis());
     log::info!("You now can connect to the server");
 
@@ -126,8 +119,7 @@ fn main() -> io::Result<()> {
                         connection,
                         addr,
                     )));
-                    server
+                    server.add_client(rc_token, Rc::clone(&client));
-                        .add_client(rc_token, Rc::clone(&client));
                     connections.insert(token, client);
                 },