Eliminate Unnecessary Arc<Token>

Tokens already implement copy and clone, keeping a shared reference to the token doesn't actually do anything, and is larger than a token is to begin with.

clone copies

pumpkin/src/client/mod.rs

@@ -1,7 +1,6 @@
 use std::{
     io::{self, Write},
     net::SocketAddr,
-    sync::Arc,
 };
 
 use crate::{
@@ -71,7 +70,7 @@ pub struct Client {
     pub connection_state: ConnectionState,
     pub encryption: bool,
     pub closed: bool,
-    pub token: Arc<Token>,
+    pub token: Token,
     pub connection: TcpStream,
     pub address: SocketAddr,
     enc: PacketEncoder,
@@ -82,7 +81,7 @@ pub struct Client {
 }
 
 impl Client {
-    pub fn new(token: Arc<Token>, connection: TcpStream, address: SocketAddr) -> Self {
+    pub fn new(token: Token, connection: TcpStream, address: SocketAddr) -> Self {
         Self {
             protocol_version: 0,
             gameprofile: None,

pumpkin/src/client/player_packet.rs

@@ -340,7 +340,7 @@ impl Player {
                         let world = world.lock().await;
                         let attacked_player = world.get_by_entityid(self, entity_id.0 as EntityId);
                         if let Some(mut player) = attacked_player {
-                            let token = player.client.token.clone();
+                            let token = player.client.token;
                             let velo = player.velocity;
                             if config.protect_creative && player.gamemode == GameMode::Creative {
                                 return;

pumpkin/src/main.rs

@@ -81,7 +81,7 @@ fn main() -> io::Result<()> {
         let rcon = ADVANCED_CONFIG.rcon.clone();
 
         let mut clients: HashMap<Token, Client> = HashMap::new();
-        let mut players: HashMap<Arc<Token>, Arc<Mutex<Player>>> = HashMap::new();
+        let mut players: HashMap<Token, Arc<Mutex<Player>>> = HashMap::new();
 
         let server = Arc::new(tokio::sync::Mutex::new(Server::new()));
         log::info!("Started Server took {}ms", time.elapsed().as_millis());
@@ -150,8 +150,7 @@ fn main() -> io::Result<()> {
                             token,
                             Interest::READABLE.add(Interest::WRITABLE),
                         )?;
-                        let rc_token = Arc::new(token);
-                        let client = Client::new(Arc::clone(&rc_token), connection, addr);
+                        let client = Client::new(token, connection, addr);
                         clients.insert(token, client);
                     },
 
@@ -195,10 +194,9 @@ fn main() -> io::Result<()> {
                                 if done {
                                     poll.registry().deregister(&mut client.connection)?;
                                 } else if make_player {
-                                    let token = client.token.clone();
+                                    let token = client.token;
                                     let mut server = server.lock().await;
-                                    let (player, world) =
-                                        server.add_player(token.clone(), client).await;
+                                    let (player, world) = server.add_player(token, client).await;
                                     players.insert(token, player.clone());
                                     let mut world = world.lock().await;
                                     world.spawn_player(&BASIC_CONFIG, player).await;

pumpkin/src/server.rs

@@ -107,7 +107,7 @@ impl Server {
 
     pub async fn add_player(
         &mut self,
-        token: Arc<Token>,
+        token: Token,
         client: Client,
     ) -> (Arc<Mutex<Player>>, Arc<tokio::sync::Mutex<World>>) {
         let entity_id = self.new_entity_id();
@@ -129,7 +129,7 @@ impl Server {
     }
 
     /// Sends a Packet to all Players in all worlds
-    pub fn broadcast_packet_all<P>(&self, expect: &[&Arc<Token>], packet: &P)
+    pub fn broadcast_packet_all<P>(&self, expect: &[&Token], packet: &P)
     where
         P: ClientPacket,
     {

pumpkin/src/world/mod.rs

@@ -26,7 +26,7 @@ use crate::{client::Client, entity::player::Player};
 
 pub struct World {
     pub level: Arc<Mutex<Level>>,
-    pub current_players: HashMap<Arc<Token>, Arc<Mutex<Player>>>,
+    pub current_players: HashMap<Token, Arc<Mutex<Player>>>,
     // entities, players...
 }
 
@@ -39,7 +39,7 @@ impl World {
     }
 
     /// Sends a Packet to all Players, Expect some players. Because we can't lock them twice
-    pub fn broadcast_packet<P>(&self, expect: &[&Arc<Token>], packet: &P)
+    pub fn broadcast_packet<P>(&self, expect: &[&Token], packet: &P)
     where
         P: ClientPacket,
     {
@@ -139,7 +139,7 @@ impl World {
         for (_, playerr) in self
             .current_players
             .iter()
-            .filter(|c| c.0 != &player.client.token)
+            .filter(|(c, _)| **c != player.client.token)
         {
             let playerr = playerr.as_ref().lock().unwrap();
             let gameprofile = &playerr.gameprofile;
@@ -184,7 +184,7 @@ impl World {
             ),
         );
         // spawn players for our client
-        let token = player.client.token.clone();
+        let token = player.client.token;
         for (_, existing_player) in self.current_players.iter().filter(|c| c.0 != &token) {
             let existing_player = existing_player.as_ref().lock().unwrap();
             let entity = &existing_player.entity;
@@ -277,7 +277,7 @@ impl World {
         None
     }
 
-    pub fn add_player(&mut self, token: Arc<Token>, player: Arc<Mutex<Player>>) {
+    pub fn add_player(&mut self, token: Token, player: Arc<Mutex<Player>>) {
         self.current_players.insert(token, player);
     }