chore: fix style issues

Author: andybrwr

src/args.rs

@@ -31,7 +31,7 @@ pub struct Args {
     #[arg(short, long, default_value = "25565", env = "LIMBO_PORT")]
     pub port: u16,
     // Whether or not to enable Velocity forwarding.
-    #[arg(short, long, default_value = "true", env = "LIMBO_VELOCITY_FORWARDING")]
+    #[arg(short, long, env = "LIMBO_VELOCITY_FORWARDING")]
     pub velocity_forwarding: bool,
     /// The x coordinate of the spawnpoint.
     #[arg(short = 'x', long, default_value = "0", env = "LIMBO_SPAWN_X")]

src/net/cache.rs

@@ -25,15 +25,14 @@ use crate::{
     protocol::{
         datatypes::VarInt,
         packets::{
-            login::registry::{AllRegistries, Registry, AllTags},
+            login::registry::{AllRegistries, AllTags, Registry},
             play::ChunkDataUpdateLightC,
         },
         Encoder,
     },
     world::{blocks::Blocks, BlockEntity, Container, World},
     CrawlState,
 };
-use crate::protocol::packets::login::registry::RegistryItem;
 
 #[derive(Debug)]
 pub struct WorldCache {
@@ -57,7 +56,7 @@ impl WorldCache {
 
         let containers = chunks
             .iter()
-            .map(|(_, c)| {
+            .flat_map(|(_, c)| {
                 c.block_entities
                     .iter()
                     .filter_map(|block_entity| {
@@ -78,9 +77,7 @@ impl WorldCache {
                                 },
                             );
 
-                        let Some(block_entity) = block_entity else {
-                            return None;
-                        };
+                        let block_entity = block_entity?;
 
                         match block_entity.id.as_str() {
                             "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => {
@@ -97,7 +94,6 @@ impl WorldCache {
                     })
                     .collect::<Vec<((i32, i32, i32), Container)>>()
             })
-            .flatten()
             .collect();
 
         debug!("Containers: {:?}", containers);
@@ -133,12 +129,10 @@ impl From<&AllTags> for TagCache {
     fn from(tags: &AllTags) -> Self {
         let mut encoder = Encoder::new();
 
-        encoder
-            .append_packet(tags)
-            .expect("Failed to encode tags");
+        encoder.append_packet(tags).expect("Failed to encode tags");
 
         Self {
-            encoded: encoder.take().to_vec()
+            encoded: encoder.take().to_vec(),
         }
     }
 }

src/net/io.rs

@@ -107,7 +107,7 @@ impl NetIo {
                 if read_half
                     .read_buf(&mut buf)
                     .await
-                    .context("failed read_buf")?
+                    .wrap_err("failed read_buf")?
                     == 0
                 {
                     let mut c = self.connected.write().await;
@@ -132,18 +132,24 @@ impl NetIo {
         trace!("raw packet is {} bytes", bytes.len());
         trace!("{:?}", bytes.to_vec());
         let mut writer = self.write_half.lock().await;
-        Ok(writer.write_all(&bytes).await?)
+        writer
+            .write_all(&bytes)
+            .await
+            .wrap_err("failed to write bytes")
     }
 
     pub async fn tx_raw(&self, packet: &[u8]) -> Result<()> {
         trace!("Sending packet {:?}", packet);
         let mut writer = self.write_half.lock().await;
-        Ok(writer.write_all(packet).await?)
+        writer
+            .write_all(packet)
+            .await
+            .wrap_err("failed to write bytes")
     }
 
     pub async fn rx_raw(&self) -> Result<Frame> {
         let mut decoder = self.decoder.lock().await;
-        if let Some(frame) = decoder.try_read_next().context("failed try_read_next")? {
+        if let Some(frame) = decoder.try_read_next().wrap_err("failed try_read_next")? {
             return Ok(frame);
         };
 
@@ -152,7 +158,12 @@ impl NetIo {
 
         {
             let mut reader = self.read_half.lock().await;
-            if reader.read_buf(&mut buf).await.context("failed read_buf")? == 0 {
+            if reader
+                .read_buf(&mut buf)
+                .await
+                .wrap_err("failed read_buf")?
+                == 0
+            {
                 let mut c = self.connected.write().await;
                 *c = false;
                 return Err(std::io::Error::from(ErrorKind::UnexpectedEof).into());

src/net/player.rs

@@ -25,7 +25,7 @@ use std::{
     time::Duration,
 };
 
-use color_eyre::eyre::{bail, Result};
+use color_eyre::eyre::{bail, Context, Result};
 use rand::Rng;
 use serde_json::json;
 use thiserror::Error;
@@ -51,13 +51,14 @@ use crate::{
         Frame, Packet, ProtocolState,
     },
     server::window::{Window, WindowType},
+    world::Container,
     CrawlState,
 };
 
+use super::{entity::Entity, io::NetIo};
 #[cfg(feature = "encryption")]
 use crate::protocol::{datatypes::Bytes, packets::login::PluginRequestC};
 use crate::protocol::{PacketDirection, PACKETS};
-use super::{entity::Entity, io::NetIo};
 
 #[derive(Debug)]
 pub struct Player {
@@ -148,7 +149,7 @@ impl SharedPlayer {
                 );
 
                 match self.begin_play().await {
-                    Ok(()) => debug!("Play loop for {} done.", self.id()),
+                    Ok(()) => debug!("Spawned play loop for player {}.", self.id()),
                     Err(why) => error!("Failed to play player {}! {why}", self.id()),
                 }
             }
@@ -214,9 +215,12 @@ impl SharedPlayer {
         self.0.io.tx(&res).await?;
         let ping: PingS = self.0.io.rx::<PingS>().await?.decode()?;
 
-        self.0.io.tx(&PingC {
-            payload: ping.payload
-        }).await?;
+        self.0
+            .io
+            .tx(&PingC {
+                payload: ping.payload,
+            })
+            .await?;
 
         Ok(())
     }
@@ -532,7 +536,10 @@ impl SharedPlayer {
         let resource = PACKETS
             .get_resource_id(packet_state, PacketDirection::Serverbound, frame.id)
             .unwrap_or_else(|| {
-                panic!("{} cannot map to any resource in state {:?}", frame.id, packet_state)
+                panic!(
+                    "{} cannot map to any resource in state {:?}",
+                    frame.id, packet_state
+                )
             })
             .as_str();
 
@@ -569,7 +576,7 @@ impl SharedPlayer {
             }
 
             id => {
-                debug!(
+                trace!(
                     "Got packet with id {id} from player {}, ignoring",
                     self.0.id
                 );
@@ -583,49 +590,56 @@ impl SharedPlayer {
         let crawlstate = self.0.crawlstate.clone();
         let server = crawlstate.get_server().await;
 
-        let x = packet.location.x as i32;
-        let y = packet.location.y as i32;
-        let z = packet.location.z as i32;
+        let x = packet.location.x;
+        let y = packet.location.y;
+        let z = packet.location.z;
 
         debug!("Player {} clicked at {}, {}, {}", self.id(), x, y, z);
 
         match server.get_container(x, y, z) {
             None => (),
-            Some(container) => {
-                let id = {
-                    let mut next_window_id = self.0.next_window_id.lock().await;
-                    let id = *next_window_id;
-                    *next_window_id = next_window_id.wrapping_add(1);
-                    if *next_window_id == 0 {
-                        *next_window_id = 1;
-                    }
-                    id
-                };
-
-                let window = Window {
-                    id,
-                    kind: WindowType::Generic9x3,
-                    title: "Hi".into(),
-                };
-
-                self.0.io.tx(&OpenScreenC::from(&window)).await?;
-
-                self.0
-                    .io
-                    .tx(&SetContainerContentC {
-                        window_id: id,
-                        // FIXME: track this correctly
-                        state_id: 0,
-                        slot_data: container.0,
-                        carried_item: Slot::default(),
-                    })
-                    .await?;
-
-                {
-                    let mut sw = self.0.window.write().await;
-                    *sw = Some(window);
-                }
+            Some(container) => self
+                .open_container(container)
+                .await
+                .wrap_err_with(|| format!("failed to open container at {x}, {y}, {z}"))?,
+        }
+
+        Ok(())
+    }
+
+    async fn open_container(&self, container: Container) -> Result<()> {
+        let id = {
+            let mut next_window_id = self.0.next_window_id.lock().await;
+            let id = *next_window_id;
+            *next_window_id = next_window_id.wrapping_add(1);
+            if *next_window_id == 0 {
+                *next_window_id = 1;
             }
+            id
+        };
+
+        let window = Window {
+            id,
+            kind: WindowType::Generic9x3,
+            title: "Hi".into(),
+        };
+
+        self.0.io.tx(&OpenScreenC::from(&window)).await?;
+
+        self.0
+            .io
+            .tx(&SetContainerContentC {
+                window_id: id,
+                // FIXME: track this correctly
+                state_id: 0,
+                slot_data: container.0,
+                carried_item: Slot::default(),
+            })
+            .await?;
+
+        {
+            let mut sw = self.0.window.write().await;
+            *sw = Some(window);
         }
 
         Ok(())

src/protocol/datatypes/slot.rs

@@ -21,7 +21,7 @@ use crate::{protocol::Encode, server::registries::REGISTRIES, world::Item};
 
 use super::VarInt;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Slot {
     item_count: i8,
     item_id: Option<i32>,
@@ -52,17 +52,6 @@ impl From<Item> for Slot {
     }
 }
 
-impl Default for Slot {
-    fn default() -> Self {
-        Self {
-            item_count: 0,
-            item_id: None,
-            components_to_add: None,
-            components_to_remove: None,
-        }
-    }
-}
-
 impl Encode for Slot {
     fn encode(&self, mut w: impl std::io::Write) -> color_eyre::eyre::Result<()> {
         self.item_count.encode(&mut w)?;