From dab13669f513ec00b24b591188bf3382d2bad96b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 25 Oct 2026 19:53:09 +0100 Subject: [PATCH] Creative screen drops reach the server: SetCreativeModeSlot(-1) A stack picked from a creative tab exists only on the client. Thrown out of the creative screen as a server's client, it went out as a ContainerClick to slot -999, which the server had no carried stack for, so nothing dropped. The client now sends handleCreativeModeItemDrop's SetCreativeModeSlot(-1, stack), and the server drops it from the player's hand, with vanilla's drop spam throttle. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 8 +++-- crates/horizon-client/src/game/lan_actions.rs | 33 +++++++++++++++++++ crates/horizon-client/src/game/remote.rs | 28 ++++++++++++++++ 3 files changed, 67 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 7fcb3be89..88972eebe 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2163,7 +2163,7 @@ impl Game<'_> { self.player_drop(thrown); } /// `Player.drop`: the statistics and a thrown item entity in front of the player. - fn player_drop(&mut self, thrown: ItemStack) { + pub(super) fn player_drop(&mut self, thrown: ItemStack) { let Some(eye) = self.eye_position() else { return; }; @@ -6326,7 +6326,11 @@ impl Game<'_> { use horizon_client::menu::Input; let button = i32::from(right); if self.remote.is_some() { - self.remote_throw(right, input); + if self.screen == Screen::Creative { + self.remote_creative_drop(right); + } else { + self.remote_throw(right, input); + } return; } let before = self.carried.clone(); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 2c7019c73..2e5890b5b 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -38,6 +38,9 @@ pub(super) struct GuestPlay { use_delay: u32, /// The shield's ItemCooldowns entry: an axe disabled it for this many ticks. pub(super) shield_cooldown: u32, + /// `ServerGamePacketListenerImpl.dropSpamThrottler` (`TickThrottler(20, 1480)`): 20 for each + /// item a creative player drops from the creative screen, one less each tick. + creative_drops: u32, attack_ticks: u32, /// The main hand's item at the guest's last tick (`Game::attack_item`). attack_item: Option>, @@ -1015,6 +1018,35 @@ impl Game<'_> { } S::MoveVehicle(p) => self.guest_move_vehicle(host, conn, &p), S::PaddleBoat(p) => self.guest_paddle_boat(host, conn, [p.left, p.right]), + // handleSetCreativeModeSlot's drop: a slot below 0 is a stack thrown out of the + // creative screen (`handleCreativeModeItemDrop`), dropped from the player's hand. + S::SetCreativeModeSlot(p) if p.slot < 0 => { + if !host.hub.guests[gi].creative() { + return; + } + let Some(stack) = self.item_from_network(host, &p.item) else { + return; + }; + if stack.count + > self + .res + .items() + .get(&stack.item) + .map_or(64, |i| i.max_stack) + { + return; + } + let play = host.play.entry(conn).or_default(); + if play.creative_drops >= 1480 { + eprintln!( + "Player {} was dropping items too fast in creative mode, ignoring.", + host.hub.guests[gi].name + ); + return; + } + play.creative_drops += 20; + self.as_guest(host, conn, |g| g.player_drop(stack)); + } S::SetCreativeModeSlot(p) => { let g = &mut host.hub.guests[gi]; if !g.creative() || !(0..46).contains(&p.slot) { @@ -1701,6 +1733,7 @@ impl Game<'_> { // Player.tick's ItemCooldowns.tick, once a tick for each player // (the shield an axe disabled). play.shield_cooldown = play.shield_cooldown.saturating_sub(1); + play.creative_drops = play.creative_drops.saturating_sub(1); let digging = play.digging; let using = play.using.is_some(); let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100; diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 620d145bf..53abd4b1f 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -4831,6 +4831,34 @@ impl Game<'_> { carried, })); } + /// `CreativeModeInventoryScreen.slotClicked` outside the window: the server knows nothing of + /// a stack picked from the creative screen, so the carried stack (an item tab's right click: + /// one of it) is dropped through `handleCreativeModeItemDrop`, a SetCreativeModeSlot to slot + /// -1, and the hand swings as `Player.drop` predicts. + pub(super) fn remote_creative_drop(&mut self, right: bool) { + let one = right && !self.creative_inventory_open(); + let Some(carried) = self.carried.as_mut() else { + return; + }; + let thrown = if one && carried.count > 1 { + carried.count -= 1; + ItemStack { + count: 1, + ..carried.clone() + } + } else { + self.carried.take().expect("carried") + }; + if !self.creative { + return; + } + self.swing_arm(); + let item = self.to_network(&Some(thrown)); + self.send(S::SetCreativeModeSlot(play::SetCreativeModeSlot { + slot: -1, + item, + })); + } pub(super) fn remote_close_container(&mut self) { let id = self .remote