Use the off hand when the main hand passes: place blocks, eat, charge anchors

Minecraft.startUseItem tries each InteractionHand in turn: useItemOn, then
useItem, stopping at the first that succeeds or fails. Item uses now act on
the hand that started them (Game::hand), so blocks, food, potions, buckets,
spawn eggs and the rest work from the off hand, the swing and the
re-equip animation follow that hand, and the empty-hand block use
(useWithoutItem) stays main-hand only. The respawn anchor passes on the
main hand when the off hand holds glowstone, as vanilla does, replacing the
special case for it.

The use_item_on harness now puts items in the off hand too.

Part of #276

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-15 11:00:55 +02:00
parent ffd0297dc4
commit 5e2935747b
18 changed files with 232 additions and 194 deletions
+140 -101
View File
@@ -136,6 +136,7 @@ use horizon_client::{
creative::{Creative, Names},
entities::{Experience, ExperienceOrb, ItemEntity},
environment::Environment,
first_person::Hand,
gfx::{Frame, Renderer},
hud::{HudAtlas, HudBatch, rgba},
hud_layout, hud_overlays,
@@ -796,6 +797,9 @@ struct Game<'a> {
armor: [Option<ItemStack>; 4],
/// The off hand (Inventory slot 40, saved as slot 150; menu slot 504 here).
offhand: Option<ItemStack>,
/// The hand an item use acts with (`InteractionHand`): the off hand only
/// for its turn in `use_item` and while its item is being used.
hand: Hand,
/// The shield's item cooldown after an axe disabled it (ticks).
shield_cooldown: u32,
/// The source of a command run through /execute (the player otherwise).
@@ -1194,8 +1198,26 @@ impl Game<'_> {
}
None
}
/// The stack in the hand that acts (`getItemInHand(hand)`).
fn held(&self) -> Option<&ItemStack> {
self.inventory[self.selected].as_ref()
self.stack_in(self.held_slot())
}
fn held_mut(&mut self) -> &mut Option<ItemStack> {
self.stack_in_mut(self.held_slot())
}
/// The slot of the hand that acts: the selected one, or `OFFHAND_SLOT`.
fn held_slot(&self) -> usize {
match self.hand {
Hand::Main => self.selected,
Hand::Off => shield::OFFHAND_SLOT,
}
}
/// Run `f` with `hand` acting (`held`, `consume_held`, `swing_arm`).
fn with_hand<T>(&mut self, hand: Hand, f: impl FnOnce(&mut Self) -> T) -> T {
let prior = std::mem::replace(&mut self.hand, hand);
let out = f(self);
self.hand = prior;
out
}
/// Inventory.add: returns the stack that did not fit.
fn give(&mut self, mut stack: ItemStack) -> Option<ItemStack> {
@@ -2234,20 +2256,22 @@ impl Game<'_> {
self.process_level_events()?;
Ok(())
}
fn use_item(&mut self) -> Result<()> {
/// The hand whose use ended the click, if any.
fn use_item(&mut self) -> Result<Option<Hand>> {
self.with_player_actor(|game| game.use_item_as_player())
}
fn use_item_as_player(&mut self) -> Result<()> {
/// `Minecraft.startUseItem`: the main hand, then the off hand.
fn use_item_as_player(&mut self) -> Result<Option<Hand>> {
// Spectators only look (MultiPlayerGameMode.useItemOn/useItem pass).
if self.spectator() {
return Ok(());
return Ok(None);
}
// A carrot or warped fungus on a stick boosts the ridden pig or strider.
if self.riding.is_some()
&& let Some(item) = self.held().map(|s| s.item.clone())
&& self.use_steering_stick(&item)
{
return Ok(());
return Ok(Some(Hand::Main));
}
if self.interact_frame()
|| self.interact_armor_stand()
@@ -2256,7 +2280,7 @@ impl Game<'_> {
|| self.interact_mob()?
|| self.interact_knot()
{
return Ok(());
return Ok(Some(Hand::Main));
}
// An EntityHitResult may fall through to Item.use, never to useItemOn.
let block_hit = if self.entity_targeted() {
@@ -2264,59 +2288,72 @@ impl Game<'_> {
} else {
self.pick()
};
for hand in Hand::BOTH {
if self.with_hand(hand, |game| game.use_hand(block_hit.as_ref()))? {
return Ok(Some(hand));
}
}
Ok(None)
}
/// One hand's turn in `startUseItem`: `useItemOn` the block aimed at,
/// then `useItem`. Whether the click ends here (it acted or failed).
fn use_hand(&mut self, block_hit: Option<&Hit>) -> Result<bool> {
// isSecondaryUseActive with something in either hand keeps blocks
// from reacting.
let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
let mut anchor_passed = None;
// MultiPlayerGameMode.useItemOn: blocks react first unless sneaking with an item.
if !(sneaking && self.held().is_some())
&& let Some(hit) = block_hit.as_ref()
let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
let mut anchor_passed = false;
// MultiPlayerGameMode.useItemOn: blocks react first.
if !(sneaking && hands_full)
&& let Some(hit) = block_hit
{
let held = self.held().cloned();
if self.use_lectern(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(());
return Ok(true);
}
if self.use_jukebox(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(());
return Ok(true);
}
if self.use_composter(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(());
return Ok(true);
}
match self.use_respawn_anchor(hit.pos, held.as_ref())? {
respawn_anchor::AnchorUse::Charged => {
self.swing_arm();
return Ok(());
return Ok(true);
}
// The main hand passes; its item is used, then the off hand's glowstone.
respawn_anchor::AnchorUse::Pass => anchor_passed = Some(hit.pos),
respawn_anchor::AnchorUse::Pass => anchor_passed = true,
respawn_anchor::AnchorUse::Other => {}
}
let face = match hit.face {
[0, 1, 0] => Direction::Up,
[0, -1, 0] => Direction::Down,
[0, 0, -1] => Direction::North,
[0, 0, 1] => Direction::South,
[-1, 0, 0] => Direction::West,
_ => Direction::East,
};
let player = PlayerContext {
yaw: self.yaw,
pitch: self.pitch,
may_build: self.may_build(),
can_eat: self.creative
|| self
.player
.as_ref()
.is_some_and(|p| p.health.food.food < 20),
game_master: false,
};
let at = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
let item = held.as_ref().map(|s| s.item.to_string());
let result = if anchor_passed.is_some() {
horizon_world::level::InteractionResult::Pass
} else {
self.with_level(|b, level, ticks| {
// TRY_WITH_EMPTY_HAND: only the main hand's turn uses the block
// itself (useWithoutItem).
if !anchor_passed && self.hand == Hand::Main {
let face = match hit.face {
[0, 1, 0] => Direction::Up,
[0, -1, 0] => Direction::Down,
[0, 0, -1] => Direction::North,
[0, 0, 1] => Direction::South,
[-1, 0, 0] => Direction::West,
_ => Direction::East,
};
let player = PlayerContext {
yaw: self.yaw,
pitch: self.pitch,
may_build: self.may_build(),
can_eat: self.creative
|| self
.player
.as_ref()
.is_some_and(|p| p.health.food.food < 20),
game_master: false,
};
let at = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
let item = held.as_ref().map(|s| s.item.to_string());
let result = self.with_level(|b, level, ticks| {
b.use_item_on(
level,
ticks,
@@ -2326,29 +2363,22 @@ impl Game<'_> {
player,
item.as_deref(),
)
})
};
self.process_level_events()?;
if result.consumes_action() {
self.swing_arm();
return Ok(());
});
self.process_level_events()?;
if result.consumes_action() {
self.swing_arm();
return Ok(true);
}
}
}
let Some(stack) = self.held().cloned() else {
// Minecraft.startUseItem goes on to the off hand.
if let Some(pos) = anchor_passed
&& self.charge_anchor_from_offhand(pos)?
{
return Ok(());
}
self.use_offhand();
return Ok(());
return Ok(false);
};
let Some(info) = self.res.items.get(&stack.item).cloned() else {
return Ok(());
return Ok(false);
};
if block_hit.is_some() && (self.use_bone_meal(&stack)? || self.ignite_tnt(&stack)?) {
return Ok(());
return Ok(true);
}
use horizon_client::first_person::UseResult;
let swings = self.swings_started;
@@ -2357,18 +2387,18 @@ impl Game<'_> {
if (UseResult::Success { swing }).should_swing(swings, self.swings_started) {
self.swing_arm();
}
return Ok(());
return Ok(true);
}
UseResult::Fail => return Ok(()),
UseResult::Fail => return Ok(true),
UseResult::Pass => {}
}
if self.use_potion_item(&stack)?
|| ((block_hit.is_some() || !stack.item.ends_with("_spawn_egg"))
&& self.throw_item(&stack)?)
{
return Ok(());
return Ok(true);
}
if self.raise_shield(self.selected)
if self.raise_shield(self.held_slot())
|| self.use_fishing_rod(&stack)
|| self.use_crossbow(&stack)
|| self.use_trident(&stack)
@@ -2379,29 +2409,29 @@ impl Game<'_> {
// placed first (useItemOn before useItem).
|| (!(info.block.is_some() && block_hit.is_some()) && self.equip_from_hand(&stack))
{
return Ok(());
return Ok(true);
}
if &*stack.item == "minecraft:spyglass" {
self.use_spyglass();
return Ok(());
return Ok(true);
}
if &*stack.item == "minecraft:bow" {
if self.using.is_none()
&& (self.creative || self.projectile_slot("minecraft:bow").is_some())
{
self.using = Some((self.selected, 0));
self.using = Some((self.held_slot(), 0));
}
return Ok(());
return Ok(true);
}
// Block foods attempt placement before starting consumption.
if !(info.block.is_some() && block_hit.is_some()) && self.start_eating(&info) {
return Ok(());
return Ok(true);
}
// BoatItem.use also performs its own fluid/block raycast.
if self.place_boat(&stack) {
return Ok(());
return Ok(true);
}
if let Some(hit) = block_hit.as_ref()
if let Some(hit) = block_hit
&& (self.launch_firework(hit, &stack)
|| self.place_minecart(hit, &stack)
|| self.place_painting(hit, &stack)
@@ -2409,28 +2439,20 @@ impl Game<'_> {
|| self.place_armor_stand(hit, &stack)
|| self.place_end_crystal(hit, &stack))
{
return Ok(());
return Ok(true);
}
if self.use_ender_eye(&stack, block_hit.is_some())? {
return Ok(());
return Ok(true);
}
let Some(hit) = block_hit else {
self.use_offhand();
return Ok(());
return Ok(false);
};
if info.block.is_none() {
if let Some(pos) = anchor_passed
&& self.charge_anchor_from_offhand(pos)?
{
return Ok(());
}
self.use_offhand();
return Ok(());
return Ok(false);
}
if !self.may_build() {
// ItemStack.useOn passes in adventure mode; useItem eats.
self.start_eating(&info);
return Ok(());
return Ok(self.start_eating(&info));
}
let face = match hit.face {
[0, 1, 0] => Direction::Up,
@@ -2460,7 +2482,7 @@ impl Game<'_> {
if self.start_eating(&info) {
self.stats.add("used", &stack.item, 1);
}
return Ok(());
return Ok(true);
};
let target = [pos.x, pos.y, pos.z];
if let Some(entity) = BlockEntity::for_block(&self.res.facts.get(state).name) {
@@ -2497,9 +2519,9 @@ impl Game<'_> {
self.consume_held();
// SolidBucketItem.useOn: BucketItem.getEmptySuccessItem in hand.
if solid_bucket && !self.creative {
self.inventory[self.selected] = Some(ItemStack::new("minecraft:bucket", 1));
*self.held_mut() = Some(ItemStack::new("minecraft:bucket", 1));
}
Ok(())
Ok(true)
}
/// `Consumable.startConsuming` for held food the player can eat
/// (`Player.canEat`): the right click is held for `consume_seconds`.
@@ -2514,7 +2536,7 @@ impl Game<'_> {
return false;
}
if self.using.is_none() {
self.using = Some((self.selected, 0));
self.using = Some((self.held_slot(), 0));
}
true
}
@@ -2522,16 +2544,29 @@ impl Game<'_> {
if self.creative {
return;
}
if let Some(s) = self.inventory[self.selected].as_mut() {
let cell = self.held_mut();
if let Some(s) = cell.as_mut() {
s.count -= 1;
if s.count == 0 {
self.inventory[self.selected] = None;
*cell = None;
}
}
}
fn tick_using(&mut self) {
// ItemCooldowns.tick for the shield.
self.shield_cooldown = self.shield_cooldown.saturating_sub(1);
let Some((slot, _)) = self.using else {
return;
};
let hand = if slot == shield::OFFHAND_SLOT {
Hand::Off
} else {
Hand::Main
};
self.with_hand(hand, Self::tick_used_item);
}
/// `LivingEntity.updatingUsingItem` for the item in use, its hand acting.
fn tick_used_item(&mut self) {
let Some((slot, ticks)) = self.using else {
return;
};
@@ -2542,13 +2577,13 @@ impl Game<'_> {
// Switching hotbar slots only ends a main-hand use.
let hand_changed = slot != self.selected && slot != shield::OFFHAND_SLOT;
if !self.right || hand_changed || self.screen != Screen::Playing {
if &*stack.item == "minecraft:bow" && slot == self.selected {
if &*stack.item == "minecraft:bow" && !hand_changed {
self.release_bow(ticks);
}
if &*stack.item == "minecraft:spyglass" {
self.stop_spyglass();
}
if &*stack.item == "minecraft:trident" && slot == self.selected {
if &*stack.item == "minecraft:trident" && !hand_changed {
self.release_trident(ticks);
}
self.using = None;
@@ -6479,8 +6514,7 @@ impl Game<'_> {
self.0.creative
}
fn hand(&mut self) -> &mut Option<ItemStack> {
let selected = self.0.selected;
&mut self.0.inventory[selected]
self.0.held_mut()
}
fn add(&mut self, stack: &mut ItemStack) -> bool {
let before = stack.count;
@@ -6512,7 +6546,7 @@ impl Game<'_> {
else {
return Ok(false);
};
let Some(held) = self.inventory[self.selected].as_ref() else {
let Some(held) = self.held() else {
return Ok(false);
};
let removes_dye = cauldron::removes_dye(&self.res.items, &held.item);
@@ -6659,19 +6693,23 @@ impl Game<'_> {
if self.creative {
return;
}
let amount = match self.inventory[self.selected].clone() {
let amount = match self.held().cloned() {
Some(held) => self.durability_loss(&held, amount),
None => amount,
};
if let Some(stack) = self.inventory[self.selected].as_mut()
&& let Some(info) = self.res.items.get(&stack.item)
&& info.max_damage > 0
let max = self
.held()
.and_then(|s| self.res.items.get(&s.item))
.map_or(0, |i| i.max_damage);
let cell = self.held_mut();
if let Some(stack) = cell.as_mut()
&& max > 0
{
stack.damage += amount;
if stack.damage >= info.max_damage {
if stack.damage >= max {
let broken = stack.item.clone();
*cell = None;
self.stats.add("broken", &broken, 1);
self.inventory[self.selected] = None;
if let Some(eye) = self.eye_position() {
self.audio.play(
"minecraft:entity.item.break",
@@ -6751,8 +6789,8 @@ impl Game<'_> {
damage: 0,
extra: None,
};
if self.inventory[self.selected].is_none() {
self.inventory[self.selected] = Some(filled);
if self.held().is_none() {
*self.held_mut() = Some(filled);
} else if let Some(rest) = self.give(filled)
&& let Some(eye) = self.eye_position()
{
@@ -6806,7 +6844,7 @@ impl Game<'_> {
}
self.trigger_block("minecraft:placed_block", target, stack);
if !self.creative {
self.inventory[self.selected] = Some(ItemStack::new("minecraft:bucket", 1));
*self.held_mut() = Some(ItemStack::new("minecraft:bucket", 1));
}
return Ok(UseResult::Success { swing: true });
}
@@ -7140,7 +7178,7 @@ impl Game<'_> {
// FirstPersonHandsAndItemsRenderer: the swing of the hand that
// swings, and its inverse arm height (the swap scale is 1 for every
// item but spears).
let attack = if self.swing.attack_hand() == horizon_client::first_person::Hand::Main {
let attack = if self.swing.attack_hand() == Hand::Main {
self.swing.animation(a)
} else {
0.0
@@ -9597,6 +9635,7 @@ pub fn run() -> Result<()> {
title: None,
armor: [None, None, None, None],
offhand: None,
hand: Hand::Main,
shield_cooldown: 0,
command_source: None,
titles: Default::default(),
@@ -565,9 +565,9 @@ impl Game<'_> {
held.count -= 1;
if held.count == 0 {
// The worn piece comes back to the hand.
self.inventory[self.selected] = current;
*self.held_mut() = current;
} else {
self.inventory[self.selected] = Some(held);
*self.held_mut() = Some(held);
if let Some(old) = current
&& let Some(rest) = self.give(old)
&& let Some(eye) = self.eye_position()
+2 -2
View File
@@ -59,7 +59,7 @@ impl Game<'_> {
pages.push(String::new());
}
BookScreen::Edit {
slot: self.selected,
slot: self.held_slot(),
pages,
page: 0,
signing: false,
@@ -104,7 +104,7 @@ impl Game<'_> {
while pages.len() > 1 && pages.last().is_some_and(String::is_empty) {
pages.pop();
}
if let Some(stack) = self.inventory.get_mut(slot).and_then(Option::as_mut)
if let Some(stack) = self.stack_in_mut(slot).as_mut()
&& &*stack.item == "minecraft:writable_book"
{
if sign {
+4 -4
View File
@@ -2569,11 +2569,11 @@ impl Game<'_> {
self.audio.play(sound, Some(eye), 0.5, pitch);
self.swing_arm();
if !self.creative
&& let Some(s) = self.inventory[self.selected].as_mut()
&& let Some(s) = self.held_mut().as_mut()
{
s.count -= 1;
if s.count == 0 {
self.inventory[self.selected] = None;
*self.held_mut() = None;
}
}
Ok(true)
@@ -2615,11 +2615,11 @@ impl Game<'_> {
}
self.swing_arm();
if !self.creative
&& let Some(s) = self.inventory[self.selected].as_mut()
&& let Some(s) = self.held_mut().as_mut()
{
s.count -= 1;
if s.count == 0 {
self.inventory[self.selected] = None;
*self.held_mut() = None;
}
}
Ok(true)
+3 -3
View File
@@ -88,7 +88,7 @@ impl Game<'_> {
} else if (self.projectile_slot(CROSSBOW).is_some() || self.creative)
&& self.using.is_none()
{
self.using = Some((self.selected, 0));
self.using = Some((self.held_slot(), 0));
}
true
}
@@ -135,7 +135,7 @@ impl Game<'_> {
let drawn = (0..shots)
.map(|i| horizon_client::arrows::drawn_ammo(&ammo, self.creative || i > 0))
.collect();
if let Some(bow) = self.inventory[slot].as_mut() {
if let Some(bow) = self.stack_in_mut(slot).as_mut() {
bow.data_mut().charged = drawn;
}
let pitch = 1.0 / (self.world.random.next_float() * 0.5 + 1.0) + 0.2;
@@ -147,7 +147,7 @@ impl Game<'_> {
let Some(eye) = self.eye_position() else {
return;
};
let Some(bow) = self.inventory[self.selected].as_mut() else {
let Some(bow) = self.held_mut().as_mut() else {
return;
};
let charged = std::mem::take(&mut bow.data_mut().charged);
@@ -514,9 +514,15 @@ impl Game<'_> {
}
self.using = None;
self.inventory[self.selected] = stack.clone();
let used_before = stack
.as_ref()
.map_or(0, |s| self.stats.get("used", &s.item));
self.offhand = parse_stack(op["offhand"].as_str().unwrap_or("-"))?;
// The used statistic of each item held, once.
let mut items: Vec<_> = [stack.as_ref(), self.offhand.as_ref()]
.into_iter()
.flatten()
.map(|s| s.item.clone())
.collect();
items.dedup();
let used_before: Vec<_> = items.iter().map(|i| self.stats.get("used", i)).collect();
self.forced_hit = Some(super::Hit {
pos: [pos.x, pos.y, pos.z],
face: [0, 1, 0],
@@ -542,10 +548,10 @@ impl Game<'_> {
out.push(format!("msg {key}"));
}
}
if let Some(s) = &stack {
let used = self.stats.get("used", &s.item) - used_before;
for (item, before) in items.iter().zip(used_before) {
let used = self.stats.get("used", item) - before;
if used != 0 {
out.push(format!("stat {} minecraft:used {used}", s.item));
out.push(format!("stat {item} minecraft:used {used}"));
}
}
let using = self
@@ -553,8 +559,9 @@ impl Game<'_> {
.and_then(|(slot, _)| self.stack_in(slot))
.map_or("-".to_owned(), |s| s.item.to_string());
out.push(format!(
"held {} using {using}",
canon_stack(self.inventory[self.selected].as_ref())
"held {} offhand {} using {using}",
canon_stack(self.inventory[self.selected].as_ref()),
canon_stack(self.offhand.as_ref())
));
out.push(match self.respawn_config {
Some(c) => format!(
@@ -568,6 +575,7 @@ impl Game<'_> {
});
self.player = None;
self.using = None;
self.offhand = None;
Ok(out)
}
+1 -1
View File
@@ -146,7 +146,7 @@ impl Game<'_> {
/// `SpyglassItem.use`: start scoping.
pub(super) fn use_spyglass(&mut self) {
if self.using.is_none() {
self.using = Some((self.selected, 0));
self.using = Some((self.held_slot(), 0));
let at = self.eye_position();
self.audio.play("minecraft:item.spyglass.use", at, 1.0, 1.0);
}
+12 -7
View File
@@ -42,9 +42,9 @@ impl Game<'_> {
self.swings_started += 1;
}
}
/// `swing(InteractionHand.MAIN_HAND)` with the default animation.
/// `swing(hand)` for the hand that acts, with the default animation.
pub(super) fn swing_arm(&mut self) {
self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
self.swing_hand(self.hand, SwingAnimation::DEFAULT);
}
/// `Player.resetAttackStrengthTicker`.
pub(super) fn reset_attack_strength(&mut self) {
@@ -166,18 +166,23 @@ impl Game<'_> {
if self.clicks.destroying.active || self.hands_busy() {
return Ok(());
}
let before = self.held().cloned();
let before = [self.stack_in(self.selected).cloned(), self.offhand.clone()];
let swings = self.swings_started;
let using = self.using.is_some();
self.use_item()?;
let Some(hand) = self.use_item()? else {
return Ok(());
};
let (before, after) = match hand {
Hand::Main => (&before[0], self.stack_in(self.selected).cloned()),
Hand::Off => (&before[1], self.offhand.clone()),
};
let swung = self.swings_started != swings;
let after = self.held().cloned();
let spent = match (&before, &after) {
let spent = match (before, &after) {
(Some(a), Some(b)) => a.count != b.count || a.item != b.item || self.creative,
_ => false,
};
if (swung && spent) || (!using && self.using.is_some() && after.is_some()) {
self.heights.item_used(Hand::Main);
self.heights.item_used(hand);
}
Ok(())
}
+1 -1
View File
@@ -482,7 +482,7 @@ impl Game<'_> {
if self.creative {
self.give_or_drop_stack(filled);
} else if stack.count == 1 {
self.inventory[self.selected] = Some(filled);
*self.held_mut() = Some(filled);
} else {
self.consume_held();
self.give_or_drop_stack(filled);
+7 -7
View File
@@ -89,7 +89,7 @@ impl Game<'_> {
match &*stack.item {
"minecraft:potion" | "minecraft:ominous_bottle" => {
if self.using.is_none() {
self.using = Some((self.selected, 0));
self.using = Some((self.held_slot(), 0));
}
Ok(true)
}
@@ -177,8 +177,8 @@ impl Game<'_> {
return;
}
self.consume_held();
if self.inventory[self.selected].is_none() {
self.inventory[self.selected] = Some(filled);
if self.held().is_none() {
*self.held_mut() = Some(filled);
} else if let Some(rest) = self.give(filled)
&& let Some(eye) = self.eye_position()
{
@@ -218,15 +218,15 @@ impl Game<'_> {
self.apply_effect_action(a);
}
if !self.creative {
if let Some(s) = self.inventory[slot].as_mut() {
if let Some(s) = self.stack_in_mut(slot).as_mut() {
s.count -= 1;
if s.count == 0 {
self.inventory[slot] = None;
*self.stack_in_mut(slot) = None;
}
}
let bottle = ItemStack::new("minecraft:glass_bottle", 1);
if self.inventory[slot].is_none() {
self.inventory[slot] = Some(bottle);
if self.stack_in(slot).is_none() {
*self.stack_in_mut(slot) = Some(bottle);
} else if let Some(rest) = self.give(bottle) {
self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
}
@@ -119,7 +119,7 @@ impl Game<'_> {
}
return;
}
let held = &mut self.inventory[self.selected];
let held = self.held_mut();
let last = held.as_ref().is_none_or(|s| s.count <= 1);
if last {
*held = Some(filled);
+2 -2
View File
@@ -1224,11 +1224,11 @@ impl Game<'_> {
self.audio
.play("minecraft:item.ominous_bottle.dispose", Some(eye), 1.0, 1.0);
if !self.creative
&& let Some(s) = self.inventory[slot].as_mut()
&& let Some(s) = self.stack_in_mut(slot).as_mut()
{
s.count -= 1;
if s.count == 0 {
self.inventory[slot] = None;
*self.stack_in_mut(slot) = None;
}
}
}
@@ -4,6 +4,7 @@
//! (`ServerPlayer.findRespawnAndUseSpawnBlock`, `PlayerList.respawn`),
//! using a charge.
use super::{Dim, Game};
use horizon_client::first_person::Hand;
use horizon_client::{
Result,
blocks::Fluid,
@@ -104,7 +105,7 @@ impl Game<'_> {
.play("minecraft:block.respawn_anchor.charge", Some(at), 1.0, 1.0);
Ok(())
}
/// `RespawnAnchorBlock.useItemOn` with `held` in the main hand.
/// `RespawnAnchorBlock.useItemOn` with `held` in the hand that acts.
pub(super) fn use_respawn_anchor(
&mut self,
pos: [i32; 3],
@@ -126,37 +127,11 @@ impl Game<'_> {
}
return Ok(AnchorUse::Charged);
}
if fuel(self.offhand.as_ref()) && chargeable {
if self.hand == Hand::Main && fuel(self.offhand.as_ref()) && chargeable {
return Ok(AnchorUse::Pass);
}
Ok(AnchorUse::Other)
}
/// The off hand's glowstone on an anchor the main hand passed on.
pub(super) fn charge_anchor_from_offhand(&mut self, pos: [i32; 3]) -> Result<bool> {
let state = self.world.block(pos[0], pos[1], pos[2]);
let fuel = self
.offhand
.as_ref()
.is_some_and(|s| &*s.item == "minecraft:glowstone");
if !self.is_anchor(state) || !fuel || self.anchor_charges(state) >= 4 {
return Ok(false);
}
let used = self.offhand.clone();
self.charge_anchor(pos, state, Some(Who::Player))?;
if !self.creative
&& let Some(s) = self.offhand.as_mut()
{
s.count -= 1;
if s.count == 0 {
self.offhand = None;
}
}
if let Some(stack) = used {
self.trigger_block("minecraft:item_used_on_block", pos, &stack);
}
self.swing_arm();
Ok(true)
}
/// `RespawnAnchorBlock.useWithoutItem` on a charged anchor: outside the
/// Nether it explodes; inside, it becomes the respawn point.
pub(super) fn respawn_anchor_used(&mut self, pos: [i32; 3]) -> Result<()> {
-4
View File
@@ -47,10 +47,6 @@ impl Game<'_> {
}
true
}
/// Main-hand use fell through: try the off hand (Minecraft.startUseItem).
pub(super) fn use_offhand(&mut self) -> bool {
self.raise_shield(OFFHAND_SLOT)
}
/// `LivingEntity.getItemBlockingWith` and the inputs of `applyItemBlocking`
/// for an attack from `from` (`DamageSource.getSourcePosition`).
pub(super) fn player_blocking(
+5 -5
View File
@@ -78,7 +78,7 @@ impl Game<'_> {
return true;
}
if self.using.is_none() {
self.using = Some((self.selected, 0));
self.using = Some((self.held_slot(), 0));
}
true
}
@@ -99,7 +99,7 @@ impl Game<'_> {
if ticks < 10 {
return;
}
let Some(stack) = self.inventory[self.selected].clone() else {
let Some(stack) = self.held().cloned() else {
return;
};
let Some(eye) = self.eye_position() else {
@@ -134,13 +134,13 @@ impl Game<'_> {
}
// hurtWithoutBreaking, then the thrown copy.
if !self.creative
&& let Some(s) = self.inventory[self.selected].as_mut()
&& let Some(s) = self.held_mut().as_mut()
{
s.damage += 1;
}
let thrown = self.inventory[self.selected].clone().unwrap_or(stack);
let thrown = self.held().cloned().unwrap_or(stack);
if !self.creative {
self.inventory[self.selected] = None;
*self.held_mut() = None;
}
let start = Vec3::new(eye[0], eye[1] - 0.1, eye[2]);
let mut projectile = horizon_client::projectiles::Projectile::new(
+2 -2
View File
@@ -71,11 +71,11 @@ impl Game<'_> {
self.stats.add("used", "minecraft:wind_charge", 1);
self.swing_arm();
if !self.creative
&& let Some(s) = self.inventory[self.selected].as_mut()
&& let Some(s) = self.held_mut().as_mut()
{
s.count -= 1;
if s.count == 0 {
self.inventory[self.selected] = None;
*self.held_mut() = None;
}
}
Ok(true)
@@ -470,7 +470,7 @@ public final class VanillaDispenserOracle {
static final class Clicker extends net.minecraft.server.level.ServerPlayer {
VanillaBlockUpdateOracle.World world;
boolean creative, sneaking;
ItemStack hand;
ItemStack hand, offhand;
List<String> stats;
String using;
Clicker() {
@@ -485,12 +485,14 @@ public final class VanillaDispenserOracle {
@Override public boolean isDescending() { return sneaking; }
@Override public EntityType<?> getType() { return EntityTypes.PLAYER; }
@Override public net.minecraft.core.Holder<EntityType<?>> typeHolder() { return EntityTypes.PLAYER.builtInRegistryHolder(); }
@Override public ItemStack getItemBySlot(EquipmentSlot slot) { return slot == EquipmentSlot.MAINHAND ? hand : ItemStack.EMPTY; }
@Override public ItemStack getItemBySlot(EquipmentSlot slot) {
return slot == EquipmentSlot.MAINHAND ? hand : slot == EquipmentSlot.OFFHAND ? offhand : ItemStack.EMPTY;
}
@Override public ItemStack getItemInHand(net.minecraft.world.InteractionHand h) {
return h == net.minecraft.world.InteractionHand.MAIN_HAND ? hand : ItemStack.EMPTY;
return h == net.minecraft.world.InteractionHand.MAIN_HAND ? hand : offhand;
}
@Override public void setItemInHand(net.minecraft.world.InteractionHand h, ItemStack stack) {
if (h == net.minecraft.world.InteractionHand.MAIN_HAND) hand = stack;
if (h == net.minecraft.world.InteractionHand.MAIN_HAND) hand = stack; else offhand = stack;
}
@Override public void startUsingItem(net.minecraft.world.InteractionHand h) {
using = BuiltInRegistries.ITEM.getKey(getItemInHand(h).getItem()).toString();
@@ -515,9 +517,9 @@ public final class VanillaDispenserOracle {
* A right click on the top of the block at `pos` (`ServerPlayerGameMode.useItemOn`
* of the real game mode, survival or creative): the block's `useItemOn` and
* `useWithoutItem`, then the item's `useOn` (`BlockItem.place`, falling back
* to eating a consumable), and `useItem` when that passes, as
* `Minecraft.startUseItem` goes on to. The statistics, the held stack and
* the item the player started using follow.
* to eating a consumable), and `useItem` when that passes, for the main
* hand and then the off hand, as `Minecraft.startUseItem` goes on to. The
* statistics, the held stacks and the item the player started using follow.
*/
static List<String> useItem(VanillaBlockUpdateOracle.World w, BlockPos pos, JsonObject use) throws Exception {
if (VanillaBlockUpdateOracle.Server.players == null) {
@@ -528,6 +530,7 @@ public final class VanillaDispenserOracle {
player.creative = use.get("creative").getAsBoolean();
player.sneaking = use.get("sneaking").getAsBoolean();
player.hand = stack(use.get("item").getAsString());
player.offhand = use.has("offhand") ? stack(use.get("offhand").getAsString()) : ItemStack.EMPTY;
player.stats = new ArrayList<>();
var abilities = new net.minecraft.world.entity.player.Abilities();
abilities.invulnerable = abilities.instabuild = abilities.mayfly = player.creative;
@@ -556,16 +559,18 @@ public final class VanillaDispenserOracle {
player.creative ? net.minecraft.world.level.GameType.CREATIVE : net.minecraft.world.level.GameType.SURVIVAL);
var hit = new net.minecraft.world.phys.BlockHitResult(net.minecraft.world.phys.Vec3.atCenterOf(pos).add(0, 0.5, 0),
net.minecraft.core.Direction.UP, pos, false);
var hand = net.minecraft.world.InteractionHand.MAIN_HAND;
var result = gameMode.useItemOn(player, w, player.getItemInHand(hand), hand, hit);
// Minecraft.startUseItem: a click on a block that neither succeeded nor
// failed goes on to use the item in the same hand.
if (!(result instanceof net.minecraft.world.InteractionResult.Success)
&& !(result instanceof net.minecraft.world.InteractionResult.Fail) && !player.hand.isEmpty()) {
gameMode.useItem(player, w, player.getItemInHand(hand), hand);
// Minecraft.startUseItem: each hand in turn clicks the block, then uses
// its item unless the click succeeded or failed; a success ends it.
for (var hand : net.minecraft.world.InteractionHand.values()) {
ItemStack held = player.getItemInHand(hand);
var result = gameMode.useItemOn(player, w, held, hand, hit);
if (result instanceof net.minecraft.world.InteractionResult.Success
|| result instanceof net.minecraft.world.InteractionResult.Fail) break;
if (!held.isEmpty() && gameMode.useItem(player, w, held, hand) instanceof net.minecraft.world.InteractionResult.Success) break;
}
List<String> out = new ArrayList<>(player.stats);
out.add("held " + ParityData.canon(player.hand) + " using " + (player.using == null ? "-" : player.using));
out.add("held " + ParityData.canon(player.hand) + " offhand " + ParityData.canon(player.offhand)
+ " using " + (player.using == null ? "-" : player.using));
var respawn = player.getRespawnConfig();
out.add("respawn " + (respawn == null ? "-" : respawn.respawnData().dimension().identifier() + " " + VanillaBlockUpdateOracle.pos(respawn.respawnData().pos())));
return out;
+11 -1
View File
@@ -6,7 +6,9 @@ for beds in the Nether and the End.
Every case has a block at the origin, something above it, and a player three
blocks south, survival or creative, hungry or full, sneaking or not, who
right-clicks the top face of the origin holding an item. Vanilla runs the real
right-clicks the top face of the origin holding an item, sometimes with
another (or nothing) in the main hand and the item in the off hand, the
main hand trying first. Vanilla runs the real
`ServerPlayerGameMode.useItemOn` over the headless level of the dispenser
harness (`VanillaDispenserOracle.useItem`): the block's `useItemOn` and
`useWithoutItem` (picking a bush's berries, `SweetBerryBushBlock.useItemOn`
@@ -26,6 +28,7 @@ or fall apart (`AbstractBedBlock.useWithoutItem` under the dimension's
(`HORIZON_DISPENSE_FIXTURE`). Both print block changes, dropped items, level
events, sounds, game events, the used statistic, the held stack, the item the
player started using, spawners' next spawn data, potentials and delay, the
off hand's stack,
player's respawn point, system messages and the level random afterwards.
"""
import json
@@ -144,6 +147,9 @@ def anchor_case(rng, states, case):
'distance': 3 if nether else 12}
if rng.random() < 0.3:
use['respawn'] = rng.choice([[0, 0, 0], [5, 0, 5]])
if rng.random() < 0.4:
# Glowstone in the off hand: the main hand passes it on (PASS).
use['offhand'] = d_plain(rng.choice(['glowstone', 'glowstone', 'apple']), rng.choice([1, 16]))
if rng.random() < 0.2:
case['rules'] = {'block_explosion_drop_decay': False}
case['use_item'] = use
@@ -206,6 +212,10 @@ def cases(facts, count, seed):
held = '-' if item == '-' else d.plain(item, rng.choice([1, 1, 2, 16, 64]))
case['use_item'] = {'item': held, 'creative': rng.random() < 0.2, 'sneaking': rng.random() < 0.2,
'food': rng.choice([20, 20, 19, 10, 0])}
if rng.random() < 0.3:
# The item in the off hand, something else or nothing in the main hand.
main = rng.choice(['-', '-', 'stick', 'apple', 'stone', 'bone_meal', 'shield'])
case['use_item'].update(offhand=held, item='-' if main == '-' else d.plain(main, rng.choice([1, 16])))
case['cells'] = cells
case['items'] = []
case['mode'] = 'dispense'