send the main hand and skin parts from the options

pomme-client/src/app/mod.rs

@@ -199,6 +199,7 @@ fn start_connecting(
         core.menu.render_distance,
         world.is_some(),
         core.menu.chat_options,
+        core.menu.skin_options(),
         block_definitions,
         protocol,
     );
@@ -559,7 +560,7 @@ impl ApplicationHandler for App {
                     MenuUpdateResult::Connect {
                         connect_args,
                         world,
-                    } => start_connecting(&mut self.core, gfx, panorama, connect_args, world),
+                    } => start_connecting(&mut self.core, gfx, panorama, *connect_args, world),
                     _ => AppPhase::InMenu { gfx, panorama },
                 }
             }
@@ -1095,7 +1096,7 @@ impl ApplicationHandler for App {
                             MenuUpdateResult::Connect {
                                 connect_args,
                                 world,
-                            } => start_connecting(core, gfx, panorama, connect_args, world),
+                            } => start_connecting(core, gfx, panorama, *connect_args, world),
                             MenuUpdateResult::Quit => {
                                 event_loop.exit();
                                 AppPhase::InMenu { gfx, panorama }

pomme-client/src/app/phases/in_game.rs

@@ -278,6 +278,7 @@ pub struct GameState {
     pub last_render_distance: u32,
     pub last_chat_visibility: crate::ui::chat::ChatVisibilitySetting,
     pub last_chat_colors: bool,
+    pub last_skin_options: crate::ui::menu::SkinOptions,
     pub server_render_distance: u32,
     pub server_simulation_distance: u32,
     pub item_entity_store: ItemEntityStore,
@@ -374,12 +375,14 @@ impl GameState {
         self.recent_sounds.push_back(sound.event_name().to_owned());
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         mesh_source: &impl MeshSource,
         resource_packs: Option<&ResourcePackManager>,
         render_distance: u32,
         singleplayer: bool,
         chat_options: crate::ui::chat::ChatOptions,
+        skin_options: crate::ui::menu::SkinOptions,
         block_definitions: Rc<BlockDefinitions>,
         protocol: i32,
     ) -> Self {
@@ -417,6 +420,7 @@ impl GameState {
             last_render_distance: render_distance,
             last_chat_visibility: chat_options.visibility,
             last_chat_colors: chat_options.colors,
+            last_skin_options: skin_options,
             server_render_distance: 0,
             server_simulation_distance: 0,
             item_entity_store: ItemEntityStore::new(),
@@ -1030,32 +1034,40 @@ impl GameState {
         ]);
     }
 
-    /// Whether the chat options `ClientInformation` carries differ from the
-    /// last ones sent.
-    fn chat_information_changed(&self, chat_options: crate::ui::chat::ChatOptions) -> bool {
+    /// Whether the chat or skin options `ClientInformation` carries differ
+    /// from the last ones sent.
+    fn client_options_changed(
+        &self,
+        chat_options: crate::ui::chat::ChatOptions,
+        skin_options: crate::ui::menu::SkinOptions,
+    ) -> bool {
         self.last_chat_visibility != chat_options.visibility
             || self.last_chat_colors != chat_options.colors
+            || self.last_skin_options != skin_options
     }
 
     pub fn sync_client_information(
         &mut self,
         connection: &ConnectionHandle,
         render_distance: u32,
         chat_options: crate::ui::chat::ChatOptions,
+        skin_options: crate::ui::menu::SkinOptions,
     ) {
         let render_changed = self.last_render_distance != render_distance;
-        let chat_changed = self.chat_information_changed(chat_options);
+        let options_changed = self.client_options_changed(chat_options, skin_options);
         self.last_render_distance = render_distance;
         self.last_chat_visibility = chat_options.visibility;
         self.last_chat_colors = chat_options.colors;
+        self.last_skin_options = skin_options;
         if render_changed {
             tracing::info!("Render distance changed to {render_distance}");
         }
-        if chat_changed {
+        if options_changed {
             tracing::info!(
                 visibility = ?chat_options.visibility,
                 colors = chat_options.colors,
-                "Chat client information changed"
+                skin = ?skin_options,
+                "Client information options changed"
             );
         }
 
@@ -1066,6 +1078,7 @@ impl GameState {
                     client_information: crate::net::client_information(
                         render_distance as u8,
                         chat_options,
+                        skin_options,
                     ),
                 },
             ));
@@ -1902,14 +1915,24 @@ fn apply_render_distance(
     rd: u32,
 ) {
     core.menu.set_bench_render_distance(rd);
-    game.sync_client_information(connection, rd, core.menu.chat_options);
+    game.sync_client_information(
+        connection,
+        rd,
+        core.menu.chat_options,
+        core.menu.skin_options(),
+    );
 }
 
 /// Puts back the render distance the chunk-load benchmark replaced, on the
 /// server too.
 fn end_chunk_load(core: &mut AppCore, game: &mut GameState, connection: &ConnectionHandle) {
     if let Some(rd) = core.menu.restore_bench_render_distance() {
-        game.sync_client_information(connection, rd, core.menu.chat_options);
+        game.sync_client_information(
+            connection,
+            rd,
+            core.menu.chat_options,
+            core.menu.skin_options(),
+        );
     }
 }
 
@@ -4275,19 +4298,23 @@ pub fn update_game(
         PauseAction::None => {}
     }
 
+    // Vanilla `Options.broadcastOptions`, which sends only what changed.
+    let (chat_options, skin_options) = (core.menu.chat_options, core.menu.skin_options());
+    if core.menu.take_options_saved()
+        && (core.menu.render_distance != game.last_render_distance
+            || game.client_options_changed(chat_options, skin_options))
+    {
+        game.sync_client_information(
+            connection,
+            core.menu.render_distance,
+            chat_options,
+            skin_options,
+        );
+    }
     if game.options_from_game {
         // TODO: a resource-pack toggle's `menu.reload_assets` is only applied
         // once back on the title screen.
         core.apply_font_options(&mut gfx.renderer);
-        if core.menu.render_distance != game.last_render_distance
-            || game.chat_information_changed(core.menu.chat_options)
-        {
-            game.sync_client_information(
-                connection,
-                core.menu.render_distance,
-                core.menu.chat_options,
-            );
-        }
         if !core.menu.is_options_screen() {
             game.options_from_game = false;
             // Chat Settings opened from chat return to it, unpaused.

pomme-client/src/app/phases/in_menu.rs

@@ -8,7 +8,7 @@ use crate::ui::menu::{MenuAction, PanoramaTheme};
 pub enum MenuUpdateResult {
     None,
     Connect {
-        connect_args: ConnectArgs,
+        connect_args: Box<ConnectArgs>,
         world: Option<World>,
     },
     Quit,
@@ -35,14 +35,14 @@ pub fn open_world(core: &mut AppCore, folder: &str) -> MenuUpdateResult {
     core.audio.stop_menu_music();
     let username = core.user.username.clone();
     MenuUpdateResult::Connect {
-        connect_args: connect_args(
+        connect_args: Box::new(connect_args(
             core,
             Transport::Memory {
                 end: client_end,
                 protocol: singleplayer::PROTOCOL,
             },
             username,
-        ),
+        )),
         world: Some(world),
     }
 }
@@ -53,14 +53,14 @@ pub fn quick_play(core: &mut AppCore, play: QuickPlay) -> MenuUpdateResult {
         QuickPlay::Multiplayer(server) => MenuUpdateResult::Connect {
             // TODO: read the saved server list's protocol for this address to
             // skip the join-time probe.
-            connect_args: connect_args(
+            connect_args: Box::new(connect_args(
                 core,
                 Transport::Remote {
                     server,
                     protocol: None,
                 },
                 core.user.username.clone(),
-            ),
+            )),
             world: None,
         },
         QuickPlay::Singleplayer(folder) => open_world(core, &folder),
@@ -75,6 +75,7 @@ pub fn connect_args(core: &AppCore, transport: Transport, username: String) -> C
         access_token: core.user.access_token.clone(),
         view_distance: core.view_distance(),
         chat_options: core.menu.chat_options,
+        skin_options: core.menu.skin_options(),
     }
 }
 
@@ -181,7 +182,11 @@ pub fn update_menu(
             core.audio.stop_menu_music();
 
             return MenuUpdateResult::Connect {
-                connect_args: connect_args(core, Transport::Remote { server, protocol }, username),
+                connect_args: Box::new(connect_args(
+                    core,
+                    Transport::Remote { server, protocol },
+                    username,
+                )),
                 world: None,
             };
         }

pomme-client/src/harness/exec.rs

@@ -180,11 +180,13 @@ fn bind_keys(core: &mut AppCore, bind: &protocol::Bind) -> Result<Value, String>
     Ok(Value::Null)
 }
 
+/// Sets options as their screen would, then saves them as it does closing.
 fn set_options(core: &mut AppCore, options: &protocol::OptionSet) -> Result<Value, String> {
     if let Some(hand) = options.main_hand {
         core.menu
             .set_main_hand_right(hand == protocol::Hand::Right, &core.input.key_bindings);
     }
+    core.menu.save_options(&core.input.key_bindings);
     Ok(Value::Null)
 }
 

pomme-client/src/headless.rs

@@ -23,7 +23,7 @@ use crate::renderer::RenderTimings;
 use crate::renderer::chunk::mesh_source::CpuMeshAssets;
 use crate::singleplayer::World;
 use crate::ui::chat::ChatOptions;
-use crate::ui::menu::saved_chunk_detail;
+use crate::ui::menu::{SkinOptions, saved_chunk_detail};
 use crate::ui::world_list::WorldList;
 use crate::user::UserData;
 use crate::world::block::block_registry::BlockDefinitions;
@@ -71,6 +71,7 @@ pub fn run(
         AssetIndex::load(&dirs.indexes_dir, &dirs.objects_dir, version),
     );
     let chat_options = ChatOptions::default();
+    let skin_options = SkinOptions::default();
     let connection = spawn_connection(
         rt,
         ConnectArgs {
@@ -80,6 +81,7 @@ pub fn run(
             access_token: user.access_token,
             view_distance: rd as u8,
             chat_options,
+            skin_options,
         },
     );
     let mut game = GameState::new(
@@ -88,6 +90,7 @@ pub fn run(
         rd,
         world.is_some(),
         chat_options,
+        skin_options,
         Rc::new(BlockDefinitions::new()),
         crate::version::selected_protocol(),
     );
@@ -152,6 +155,7 @@ fn drive(
     dirs: &DataDirs,
 ) -> i32 {
     let chunk_detail = saved_chunk_detail(&dirs.game_dir);
+    let skin_options = game.last_skin_options;
     // Columns with at least one non-empty section, as the GPU buffers count
     // them.
     let mut drawn: HashMap<ChunkPos, u32> = HashMap::new();
@@ -271,7 +275,7 @@ fn drive(
                 BenchMode::Headless,
                 *game.player.position,
             ));
-            game.sync_client_information(connection, CHUNK_LOAD_MIN_RD, chat_options);
+            game.sync_client_information(connection, CHUNK_LOAD_MIN_RD, chat_options, skin_options);
         }
         // Taken for the step, as in `update_game`, so a new distance can be
         // sent; `drain_meshes` records the mesh timings into it meanwhile.
@@ -284,7 +288,7 @@ fn drive(
             ) {
                 ChunkLoadStep::Wait => {}
                 ChunkLoadStep::Load(rd) => {
-                    game.sync_client_information(connection, rd, chat_options);
+                    game.sync_client_information(connection, rd, chat_options, skin_options);
                 }
                 ChunkLoadStep::Done(result) => {
                     result.save(&dirs.game_dir);

pomme-client/src/net/azalea_compat.rs

@@ -6836,3 +6836,17 @@ fn lifecycle_packets_match_azalea() {
     };
     assert_eq!(plain(&reason), "bye");
 }
+
+#[test]
+fn client_information_reports_the_skin_options() {
+    use azalea_entity::HumanoidArm;
+    let skin = crate::ui::menu::SkinOptions {
+        hat: false,
+        main_hand_right: false,
+        ..Default::default()
+    };
+    let info = super::client_information(8, crate::ui::chat::ChatOptions::default(), skin);
+    assert_eq!(info.main_hand, HumanoidArm::Left);
+    assert!(!info.model_customization.hat);
+    assert!(info.model_customization.cape);
+}