fix: Always send player info even when no skin

Author: Quozul

crates/minecraft_packets/src/play/player_info_update_packet.rs

@@ -14,7 +14,15 @@ pub struct PlayerInfoUpdatePacket {
 
 impl PlayerInfoUpdatePacket {
     pub fn skin(name: String, uuid: Uuid, property: Property) -> Self {
-        let properties = LengthPaddedVec::new(vec![property]);
+        Self::new(name, uuid, vec![property])
+    }
+
+    pub fn skinless(name: String, uuid: Uuid) -> Self {
+        Self::new(name, uuid, Vec::new())
+    }
+
+    fn new(name: String, uuid: Uuid, properties: Vec<Property>) -> Self {
+        let properties = LengthPaddedVec::new(properties);
         let add_player_action = AddPlayer {
             name,
             properties,

pico_limbo/src/handlers/configuration.rs

@@ -27,7 +27,6 @@ use pico_structures::prelude::SchematicError;
 use pico_text_component::prelude::Component;
 use registries::{Registries, get_dimension_index, get_registries, get_void_biome_index};
 use std::num::TryFromIntError;
-use tracing::debug;
 
 impl PacketHandler for AcknowledgeConfigurationPacket {
     fn handle(
@@ -276,13 +275,12 @@ fn send_skin_packets(
                 None
             };
 
-            if let Some(textures) = textures {
-                let packet = PlayerInfoUpdatePacket::skin(username, unique_id, textures);
-                Some(PacketRegistry::PlayerInfoUpdate(packet))
+            let packet = if let Some(textures) = textures {
+                PlayerInfoUpdatePacket::skin(username, unique_id, textures)
             } else {
-                debug!("No skin for player {username}");
-                None
-            }
+                PlayerInfoUpdatePacket::skinless(username, unique_id)
+            };
+            PacketRegistry::PlayerInfoUpdate(packet)
         });
     }
 

pico_limbo/src/server/batch.rs

@@ -5,7 +5,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 type AsyncClosure<T> =
-    Box<dyn FnOnce() -> Pin<Box<dyn Future<Output = Option<T>> + Send>> + Send + 'static>;
+    Box<dyn FnOnce() -> Pin<Box<dyn Future<Output = T> + Send>> + Send + 'static>;
 
 enum Producer<T> {
     SyncClosure(Box<dyn FnOnce() -> T + Send + 'static>),
@@ -36,9 +36,9 @@ impl<T: Send + 'static> Batch<T> {
     pub fn queue_async<F, Fut>(&mut self, f: F)
     where
         F: FnOnce() -> Fut + Send + 'static,
-        Fut: Future<Output = Option<T>> + Send + 'static,
+        Fut: Future<Output = T> + Send + 'static,
     {
-        let closure = move || -> Pin<Box<dyn Future<Output = Option<T>> + Send>> { Box::pin(f()) };
+        let closure = move || -> Pin<Box<dyn Future<Output = T> + Send>> { Box::pin(f()) };
         self.producers
             .push_back(Producer::AsyncClosure(Box::new(closure)));
     }
@@ -63,7 +63,7 @@ impl<T: Send + 'static> Batch<T> {
 
 enum Current<T> {
     Idle,
-    Future(Pin<Box<dyn Future<Output = Option<T>> + Send>>),
+    Future(Pin<Box<dyn Future<Output = T> + Send>>),
     Iterator(Box<dyn Iterator<Item = T> + Send>),
 }
 
@@ -80,18 +80,15 @@ impl<T: Send + 'static> Stream for BatchStream<T> {
 
         loop {
             match &mut this.current {
-                Current::Future(fut) => match fut.as_mut().poll(cx) {
-                    Poll::Ready(Some(item)) => {
-                        this.current = Current::Idle;
-                        return Poll::Ready(Some(item));
-                    }
-                    Poll::Ready(None) => {
-                        this.current = Current::Idle;
-                    }
-                    Poll::Pending => {
-                        return Poll::Pending;
-                    }
-                },
+                Current::Future(fut) => {
+                    return match fut.as_mut().poll(cx) {
+                        Poll::Ready(item) => {
+                            this.current = Current::Idle;
+                            Poll::Ready(Some(item))
+                        }
+                        Poll::Pending => Poll::Pending,
+                    };
+                }
                 Current::Iterator(iter) => {
                     if let Some(item) = iter.next() {
                         return Poll::Ready(Some(item));
@@ -127,7 +124,7 @@ mod tests {
         let mut batch = Batch::new();
 
         batch.queue(|| 1);
-        batch.queue_async(|| async { Some(2) });
+        batch.queue_async(|| async { 2 });
         batch.chain_iter(3..5);
 
         let mut stream = batch.into_stream();