feat: add support for skins

Author: Quozul

Cargo.lock

@@ -27,12 +27,14 @@ members = [
 anyhow = "1.0.99"
 clap = { version = "4.5.47", features = ["derive"] }
 flate2 = "1.1.2"
+futures = "0.3.31"
 hmac = "0.12.1"
 proc-macro2 = "1.0.101"
 quick-xml = "0.38.3"
 quote = "1.0.40"
 rand = "0.9.2"
 rayon = "1.11.0"
+reqwest = { version = "0.12.23", features = ["json"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.143"
 sha2 = "0.10.9"

Cargo.toml

@@ -31,7 +31,7 @@ in Rust, designed primarily as an AFK or waiting server. Its core focus is on ef
 packets required for client login and maintaining connection (keep-alive) without unnecessary overhead.
 
 While not aiming to replicate every Minecraft server feature, PicoLimbo supports **all Minecraft versions from 1.7.2
-through 1.21.8**, excluding snapshots, with only 27 implemented packets covering over 47 different protocol versions or
+through 1.21.8**, excluding snapshots, with only 36 implemented packets covering over 47 different protocol versions or
 75 Minecraft versions.
 
 ## Features
@@ -46,6 +46,10 @@ layers.
 Uses **0% CPU while idle** and handles **hundreds of players** under 10 MB RAM.
 [View benchmarks](https://picolimbo.quozul.dev/about/benchmarks.html).
 
+### 👤 Skin Support
+
+Player skins are supported. What else to say about that?
+
 ### 🔀 Built-in Proxy Support
 
 Integrates with all major Minecraft proxies:

README.md

@@ -0,0 +1 @@
+pub mod property;

crates/minecraft_packets/src/login/data/mod.rs

@@ -0,0 +1,45 @@
+use minecraft_protocol::prelude::*;
+
+#[derive(PacketOut, PacketIn, Clone)]
+pub struct Property {
+    name: String,
+    value: String,
+    signature: Optional<String>,
+}
+
+impl Property {
+    const TEXTURES_NAMES: &'static str = "textures";
+
+    pub fn new(name: String, value: String, signature: Option<String>) -> Self {
+        Self {
+            name,
+            value,
+            signature: signature.into(),
+        }
+    }
+
+    pub fn textures<S>(value: &S, signature: Option<&S>) -> Self
+    where
+        S: ToString + ?Sized,
+    {
+        let signature = signature.map(|t| t.to_string());
+
+        Self {
+            name: Self::TEXTURES_NAMES.to_string(),
+            value: value.to_string(),
+            signature: signature.into(),
+        }
+    }
+
+    pub fn is_textures(&self) -> bool {
+        self.name == Self::TEXTURES_NAMES
+    }
+
+    pub fn value(&self) -> &str {
+        &self.value
+    }
+
+    pub fn signature(&self) -> Option<String> {
+        self.signature.clone().into()
+    }
+}

crates/minecraft_packets/src/login/data/property.rs

@@ -1,4 +1,4 @@
-use crate::login::login_success_packet::Property;
+use crate::login::Property;
 use minecraft_protocol::prelude::*;
 
 /// This is the equivalent of LoginSuccessPacket but for versions before 1.21.2.

crates/minecraft_packets/src/login/game_profile_packet.rs

@@ -1,3 +1,4 @@
+use crate::login::Property;
 use minecraft_protocol::prelude::*;
 
 /// This packet was introduced in 1.21.2, previous versions uses the GameProfilePacket.
@@ -18,26 +19,3 @@ impl LoginSuccessPacket {
         }
     }
 }
-
-pub struct Property {
-    pub name: String,
-    pub value: String,
-    pub is_signed: bool,
-    pub signature: Option<String>,
-}
-
-impl EncodePacket for Property {
-    fn encode(
-        &self,
-        writer: &mut BinaryWriter,
-        protocol_version: ProtocolVersion,
-    ) -> Result<(), BinaryWriterError> {
-        self.name.encode(writer, protocol_version)?;
-        self.value.encode(writer, protocol_version)?;
-        self.is_signed.encode(writer, protocol_version)?;
-        if let Some(signature) = &self.signature {
-            signature.encode(writer, protocol_version)?;
-        }
-        Ok(())
-    }
-}

crates/minecraft_packets/src/login/login_success_packet.rs

@@ -1,7 +1,10 @@
 pub mod custom_query_answer_packet;
 pub mod custom_query_packet;
+mod data;
 pub mod game_profile_packet;
 pub mod login_acknowledged_packet;
 pub mod login_disconnect_packet;
 pub mod login_state_packet;
 pub mod login_success_packet;
+
+pub use data::property::Property;

crates/minecraft_packets/src/login/mod.rs

@@ -7,9 +7,11 @@ pub mod game_event_packet;
 pub mod legacy_chat_message_packet;
 pub mod login_packet;
 pub mod play_client_bound_plugin_message_packet;
+pub mod player_info_update_packet;
 pub mod player_position_packet;
 pub mod set_chunk_cache_center_packet;
 pub mod set_default_spawn_position_packet;
+pub mod set_entity_data_packet;
 pub mod set_player_position_and_rotation_packet;
 pub mod set_player_position_packet;
 pub mod synchronize_player_position_packet;

crates/minecraft_packets/src/play/mod.rs

@@ -0,0 +1,122 @@
+use crate::login::Property;
+use minecraft_protocol::prelude::*;
+use pico_text_component::prelude::Component;
+
+#[derive(PacketOut)]
+pub struct PlayerInfoUpdatePacket {
+    #[pvn(..761)]
+    action: VarInt,
+
+    #[pvn(761..)]
+    v1_19_3_mask: u8,
+    players: LengthPaddedVec<Player>,
+}
+
+impl PlayerInfoUpdatePacket {
+    pub fn skin(name: String, uuid: Uuid, property: Property) -> Self {
+        let properties = LengthPaddedVec::new(vec![property]);
+        let add_player_action = AddPlayer {
+            name,
+            properties,
+            game_mode: VarInt::new(1),
+            ping: VarInt::new(1),
+            display_name: Optional::None,
+            sig_data: Optional::None,
+        };
+
+        let actions = vec![
+            PlayerActions::AddPlayer(add_player_action.clone()),
+            PlayerActions::UpdateListed { listed: true },
+        ];
+
+        let mut mask = 0;
+        for action in &actions {
+            mask |= action.get_mask();
+        }
+
+        let (most_sig, least_sig) = uuid.as_u64_pair();
+
+        let player_action = Player {
+            v1_16_uuid: uuid,
+            uuid_most_sig: most_sig,
+            uuid_least_sig: least_sig,
+            action: add_player_action,
+            actions,
+        };
+
+        Self {
+            action: VarInt::new(0),
+            v1_19_3_mask: mask,
+            players: LengthPaddedVec::new(vec![player_action]),
+        }
+    }
+}
+
+#[derive(PacketOut)]
+struct Player {
+    #[pvn(735..)]
+    v1_16_uuid: Uuid,
+    #[pvn(..735)]
+    uuid_most_sig: u64,
+    #[pvn(..735)]
+    uuid_least_sig: u64,
+    #[pvn(..761)]
+    action: AddPlayer,
+    #[pvn(761..)]
+    actions: Vec<PlayerActions>,
+}
+
+#[derive(PacketOut, Clone)]
+struct AddPlayer {
+    name: String,
+    properties: LengthPaddedVec<Property>,
+    #[pvn(..761)]
+    game_mode: VarInt,
+    #[pvn(..761)]
+    ping: VarInt,
+    #[pvn(..761)]
+    display_name: Optional<Component>,
+    #[pvn(759..761)]
+    sig_data: Optional<SigData>,
+}
+
+#[derive(PacketOut, Clone)]
+struct SigData {
+    timestamp: i64,
+    public_key: LengthPaddedVec<i8>,
+    signature: LengthPaddedVec<i8>,
+}
+
+#[derive(Clone)]
+enum PlayerActions {
+    AddPlayer(AddPlayer),
+    UpdateListed { listed: bool },
+}
+
+impl PlayerActions {
+    fn get_mask(&self) -> u8 {
+        match self {
+            PlayerActions::AddPlayer { .. } => 0x01,
+            PlayerActions::UpdateListed { .. } => 0x08,
+        }
+    }
+}
+
+impl EncodePacket for PlayerActions {
+    fn encode(
+        &self,
+        writer: &mut BinaryWriter,
+        protocol_version: ProtocolVersion,
+    ) -> Result<(), BinaryWriterError> {
+        match self {
+            PlayerActions::AddPlayer(value) => {
+                value.encode(writer, protocol_version)?;
+                Ok(())
+            }
+            PlayerActions::UpdateListed { listed } => {
+                listed.encode(writer, protocol_version)?;
+                Ok(())
+            }
+        }
+    }
+}