Merge pull request #2045 from ESHAYAT102/fix/creative-tool-block-breaking
🤖 Agent: Gate check by Ludovic's AI agent (Claude). Item.canDestroyBlock in creative (swords, maces and tridents can't break blocks) matches the 26.3 bytecode, on the player's prediction and on the server. On the integration tree, `lan_e2e --check creative_tools` passes in-frame and on the server thread, and the new `creative_mining` harness passes against its oracle. I merged main into the branch twice; the second time, lan_e2e.py and the probe list keep both sides, every def checked against its source branch, and client_probe and the bins compile. Fixes #2035 is right. Thanks @ESHAYAT102!
This commit is contained in:
@@ -0,0 +1,48 @@
|
||||
use horizon_client::{
|
||||
Result,
|
||||
item_data::StackData,
|
||||
items::{ItemStack, Items},
|
||||
};
|
||||
use horizon_world::nbt::Tag;
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{BufRead, BufReader, BufWriter, Write},
|
||||
path::Path,
|
||||
};
|
||||
|
||||
pub fn main() -> Result<()> {
|
||||
let args: Vec<_> = crate::args().collect();
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
|
||||
let items = Items::catalog(&root)?;
|
||||
let mut out = BufWriter::new(File::create(&args[2])?);
|
||||
for line in BufReader::new(File::open(&args[1])?).lines() {
|
||||
let row: Value = serde_json::from_str(&line?)?;
|
||||
let mut stack = ItemStack::new(
|
||||
row["item"].as_str().unwrap(),
|
||||
row["count"].as_u64().unwrap() as u32,
|
||||
);
|
||||
match row["tool"].as_str().unwrap() {
|
||||
"default" => {}
|
||||
mode => {
|
||||
let mut data = StackData::default();
|
||||
let tool = if mode == "implicit" {
|
||||
Tag::compound([] as [(&str, Tag); 0])
|
||||
} else {
|
||||
Tag::compound([(
|
||||
"can_destroy_blocks_in_creative",
|
||||
Tag::Byte(i8::from(mode == "allow")),
|
||||
)])
|
||||
};
|
||||
data.set_other("minecraft:tool", Some(tool));
|
||||
stack.extra = Some(Box::new(data));
|
||||
}
|
||||
}
|
||||
writeln!(
|
||||
out,
|
||||
"{}",
|
||||
items.can_destroy_block(Some(&stack), row["creative"].as_bool().unwrap())
|
||||
)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -27,6 +27,7 @@ mod chat_screen_fixture;
|
||||
mod cloud_fixture;
|
||||
mod command_parse_fixture;
|
||||
mod container_screen_probe;
|
||||
mod creative_mining_probe;
|
||||
mod creative_search_fixture;
|
||||
mod cushion_placement_probe;
|
||||
mod emitter_particles_probe;
|
||||
@@ -108,6 +109,7 @@ probes! {
|
||||
block_transform_fixture,
|
||||
breaking_fixture,
|
||||
camera_probe,
|
||||
creative_mining_probe,
|
||||
cushion_placement_probe,
|
||||
cauldron_fixture,
|
||||
chat_screen_fixture,
|
||||
|
||||
@@ -3346,6 +3346,13 @@ impl Game<'_> {
|
||||
self.with_player_actor(|game| game.break_block_as_player(pos))
|
||||
}
|
||||
fn break_block_as_player(&mut self, pos: [i32; 3]) -> Result<()> {
|
||||
if !self
|
||||
.res
|
||||
.items()
|
||||
.can_destroy_block(self.held(), self.creative)
|
||||
{
|
||||
return Ok(());
|
||||
}
|
||||
self.pad_rumble(horizon_client::gamepad::Rumble::BlockBroken);
|
||||
// ServerPlayerGameMode.destroyBlock.
|
||||
let state = self.world.block(pos[0], pos[1], pos[2]);
|
||||
@@ -3971,7 +3978,12 @@ impl Game<'_> {
|
||||
return Ok(());
|
||||
};
|
||||
// GameType.isBlockPlacingRestricted: adventure and spectator.
|
||||
if !self.may_build() {
|
||||
if !self.may_build()
|
||||
|| !self
|
||||
.res
|
||||
.items()
|
||||
.can_destroy_block(self.held(), self.creative)
|
||||
{
|
||||
self.mining = None;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -3751,6 +3751,15 @@ impl Game<'_> {
|
||||
|
||||
/// MultiPlayerGameMode.startDestroyBlock / continueDestroyBlock.
|
||||
fn remote_mining(&mut self, start: bool) {
|
||||
if !self
|
||||
.res
|
||||
.items()
|
||||
.can_destroy_block(self.held(), self.creative)
|
||||
{
|
||||
self.stop_remote_mining();
|
||||
self.mining = None;
|
||||
return;
|
||||
}
|
||||
let Some(r) = self.remote.as_mut() else {
|
||||
return;
|
||||
};
|
||||
|
||||
@@ -71,6 +71,8 @@ pub struct ItemInfo {
|
||||
/// The `tool` component's `damage_per_block`, when the item has the
|
||||
/// component (a mace or trident has one without rules).
|
||||
pub tool_damage_per_block: Option<u32>,
|
||||
/// `tool.can_destroy_blocks_in_creative` (defaults to true).
|
||||
pub can_destroy_blocks_in_creative: bool,
|
||||
pub food: Option<(u32, f32)>,
|
||||
pub can_always_eat: bool,
|
||||
/// `consumable`: its timing, sound, particles and `on_consume_effects`.
|
||||
@@ -558,6 +560,10 @@ impl Items {
|
||||
tool_damage_per_block: c
|
||||
.get("minecraft:tool")
|
||||
.map(|t| t["damage_per_block"].as_u64().unwrap_or(1) as u32),
|
||||
can_destroy_blocks_in_creative:
|
||||
c["minecraft:tool"]["can_destroy_blocks_in_creative"]
|
||||
.as_bool()
|
||||
.unwrap_or(true),
|
||||
food,
|
||||
can_always_eat,
|
||||
// Consumable.CODEC's defaults.
|
||||
@@ -758,6 +764,26 @@ impl Items {
|
||||
None => spec == block,
|
||||
}
|
||||
}
|
||||
/// `Item.canDestroyBlock`: a tool may forbid block destruction with instabuild.
|
||||
pub fn can_destroy_block(&self, held: Option<&ItemStack>, creative: bool) -> bool {
|
||||
if !creative {
|
||||
return true;
|
||||
}
|
||||
let Some(held) = held.filter(|s| s.count > 0 && &*s.item != "minecraft:air") else {
|
||||
return true;
|
||||
};
|
||||
if let Some(tool) = held.data().and_then(|d| d.other("minecraft:tool")) {
|
||||
return tool
|
||||
.get("can_destroy_blocks_in_creative")
|
||||
.and_then(|v| match v {
|
||||
horizon_world::nbt::Tag::Byte(v) => Some(*v),
|
||||
_ => None,
|
||||
})
|
||||
.is_none_or(|v| v != 0);
|
||||
}
|
||||
self.get(&held.item)
|
||||
.is_none_or(|info| info.can_destroy_blocks_in_creative)
|
||||
}
|
||||
/// `Tool.getMiningSpeed` for the held item (1.0 without a tool component).
|
||||
pub fn mining_speed(&self, held: Option<&ItemStack>, block: &str) -> f32 {
|
||||
let Some(info) = held.and_then(|s| self.get(&s.item)) else {
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
package dev.horizonlab.parity;
|
||||
|
||||
import com.google.gson.JsonParser;
|
||||
import java.io.PrintWriter;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
import net.minecraft.core.component.DataComponents;
|
||||
import net.minecraft.core.component.DataComponentMap;
|
||||
import com.mojang.serialization.JsonOps;
|
||||
import net.minecraft.core.registries.BuiltInRegistries;
|
||||
import net.minecraft.resources.Identifier;
|
||||
import net.minecraft.server.level.ServerPlayer;
|
||||
import net.minecraft.world.entity.player.Abilities;
|
||||
import net.minecraft.world.entity.player.Player;
|
||||
import net.minecraft.world.item.ItemStack;
|
||||
import net.minecraft.world.item.component.Tool;
|
||||
|
||||
/** Calls the actual item predicate; its unused block and level arguments are null. */
|
||||
public final class VanillaCreativeMiningOracle {
|
||||
public static void main(String[] args) throws Exception {
|
||||
net.minecraft.SharedConstants.tryDetectVersion();
|
||||
net.minecraft.server.Bootstrap.bootStrap();
|
||||
var defaults = JsonParser.parseString(Files.readString(Path.of(args[0]).getParent()
|
||||
.getParent().resolve("horizon-client/26.3/items.json"))).getAsJsonObject();
|
||||
for (var entry : defaults.entrySet()) {
|
||||
var item = BuiltInRegistries.ITEM.getValue(Identifier.parse(entry.getKey()));
|
||||
var components = DataComponentMap.builder();
|
||||
var tool = entry.getValue().getAsJsonObject().getAsJsonObject("minecraft:tool");
|
||||
if (tool != null) {
|
||||
// Only the restriction is queried here; mining-rule tag resolution is separate.
|
||||
tool = tool.deepCopy();
|
||||
tool.add("rules", new com.google.gson.JsonArray());
|
||||
components.set(DataComponents.TOOL, Tool.CODEC.parse(JsonOps.INSTANCE, tool).getOrThrow());
|
||||
}
|
||||
item.builtInRegistryHolder().bindComponents(components.build());
|
||||
}
|
||||
var unsafeClass = Class.forName("sun.misc.Unsafe");
|
||||
var unsafeField = unsafeClass.getDeclaredField("theUnsafe");
|
||||
unsafeField.setAccessible(true);
|
||||
var unsafe = unsafeField.get(null);
|
||||
var player = (ServerPlayer) unsafeClass.getMethod("allocateInstance", Class.class)
|
||||
.invoke(unsafe, ServerPlayer.class);
|
||||
var abilities = new Abilities();
|
||||
var field = Player.class.getDeclaredField("abilities");
|
||||
field.setAccessible(true);
|
||||
field.set(player, abilities);
|
||||
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1])));
|
||||
var lines = Files.lines(Path.of(args[0]))) {
|
||||
for (var line : (Iterable<String>) lines::iterator) {
|
||||
var row = JsonParser.parseString(line).getAsJsonObject();
|
||||
var item = BuiltInRegistries.ITEM.getValue(Identifier.parse(row.get("item").getAsString()));
|
||||
var stack = new ItemStack(item, row.get("count").getAsInt());
|
||||
var mode = row.get("tool").getAsString();
|
||||
if (!mode.equals("default")) {
|
||||
stack.set(DataComponents.TOOL, new Tool(List.of(), 1.0f, 1, !mode.equals("deny")));
|
||||
}
|
||||
abilities.instabuild = row.get("creative").getAsBoolean();
|
||||
// Use the base Item implementation: special debug-stick interactions are separate.
|
||||
out.println(net.minecraft.world.item.Items.STICK.canDestroyBlock(stack, null, null, null, player));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -18,7 +18,7 @@ ROOT = Path(__file__).resolve().parents[1]
|
||||
class RemoteMiningTests(unittest.TestCase):
|
||||
def test_break_timing_and_packets(self):
|
||||
source = (ROOT / "crates/horizon-client/src/game/remote.rs").read_text()
|
||||
start = source.index(" fn remote_mining(")
|
||||
start = source.index(" pub(super) fn stop_remote_mining(")
|
||||
end = source.index(" /// MultiPlayerGameMode.destroyBlock", start)
|
||||
fixture = r'''
|
||||
#![allow(dead_code)]
|
||||
@@ -33,8 +33,11 @@ struct Player { ground: Ground }
|
||||
struct Sounds { hit: String, volume: f32, pitch: f32 }
|
||||
#[derive(Clone)]
|
||||
struct Facts { hardness: f32, name: String, requires_tool: bool, sounds: Sounds }
|
||||
struct Resources { facts: Facts, speed: f32 }
|
||||
struct Resources { facts: Facts, speed: f32, tool_allows_creative: bool }
|
||||
impl Resources {
|
||||
fn can_destroy_block(&self, _: Option<&()>, creative: bool) -> bool {
|
||||
!creative || self.tool_allows_creative
|
||||
}
|
||||
fn facts(&self) -> &Self { self }
|
||||
fn items(&self) -> &Self { self }
|
||||
fn get(&self, _: u32) -> &Facts { &self.facts }
|
||||
@@ -72,7 +75,7 @@ impl Game {
|
||||
remote: Some(Remote::default()), mining: None, creative,
|
||||
world: World::default(),
|
||||
res: Resources { facts: Facts { hardness, name: "block".into(),
|
||||
requires_tool: false, sounds: Sounds { hit: "hit".into(), volume: 1.0, pitch: 1.0 } }, speed },
|
||||
requires_tool: false, sounds: Sounds { hit: "hit".into(), volume: 1.0, pitch: 1.0 } }, speed, tool_allows_creative: true },
|
||||
player: Some(Player { ground: Ground { on_ground: true } }), audio: Audio,
|
||||
hit: Hit { pos: [0, 64, 0], face: 1 }, sequence: 0, packets: vec![],
|
||||
}
|
||||
@@ -138,8 +141,25 @@ fn main() {
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.world.broken.len(), 2);
|
||||
assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5);
|
||||
// A restricted tool must neither predict a break nor send START in Creative.
|
||||
let mut game = Game::new(1.0, 1.0, true);
|
||||
game.res.tool_allows_creative = false;
|
||||
game.remote_mining(true);
|
||||
game.remote_mining(false);
|
||||
assert!(game.world.broken.is_empty());
|
||||
assert!(game.packets.is_empty());
|
||||
// Survival still mines with the same tool. Switching to Creative aborts the crack.
|
||||
game.creative = false;
|
||||
game.remote_mining(true);
|
||||
assert_eq!(game.packets[0].action, 0);
|
||||
game.creative = true;
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.packets.iter().map(|p| p.action).collect::<Vec<_>>(), [0, 2]);
|
||||
assert!(game.remote.as_ref().unwrap().destroying.is_none());
|
||||
assert!(game.mining.is_none());
|
||||
assert!(game.world.broken.is_empty());
|
||||
}
|
||||
'''.replace("METHOD", source[start:end])
|
||||
'''.replace("METHOD", source[start:end].replace("pub(super) fn", "fn"))
|
||||
with tempfile.TemporaryDirectory(prefix="remote-mining-") as directory:
|
||||
path = Path(directory)
|
||||
(path / "main.rs").write_text(fixture)
|
||||
|
||||
@@ -7103,6 +7103,44 @@ CHECKS += ['sonic']
|
||||
CHECK_FNS['sonic'] = check_sonic
|
||||
|
||||
|
||||
def check_creative_tools(host, guest, out):
|
||||
"""#2035: switching Survival -> Creative cannot mine with a restricted tool.
|
||||
Verify both the player's prediction and the host's authoritative block;
|
||||
an ordinary tool must still break the same block.
|
||||
"""
|
||||
seen = {}
|
||||
for label, player in (('host', host), ('guest', guest)):
|
||||
x, y, z = (int(v // 1) for v in pos_of(player))
|
||||
cell = (x, y + 1, z + 2)
|
||||
host('command', command=f'fill {x - 1} {y} {z + 1} {x + 1} {y + 3} {z + 3} minecraft:air')
|
||||
player('command', command='gamemode survival')
|
||||
player('command', command='item replace entity @s weapon.mainhand with minecraft:netherite_sword')
|
||||
player('command', command='gamemode creative')
|
||||
host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} minecraft:stone')
|
||||
player.wait(10)
|
||||
player.raw('look-at', x + 0.5, y + 1.5, z + 2.5)
|
||||
player.raw('mouse', 'left', 'down')
|
||||
try:
|
||||
player.wait(15)
|
||||
finally:
|
||||
player.raw('mouse', 'left', 'up')
|
||||
seen[label] = {'client': player.raw('block', *cell).get('block'),
|
||||
'server': host.raw('block', *cell).get('block')}
|
||||
player.shot(out, 'creative-sword')
|
||||
assert seen[label]['client'] == seen[label]['server'] == 'minecraft:stone', seen
|
||||
player('command', command='item replace entity @s weapon.mainhand with minecraft:diamond_pickaxe')
|
||||
player.wait(6)
|
||||
player.raw('mouse', 'left', 'click')
|
||||
player.wait(10)
|
||||
seen[label]['ordinary_tool'] = host.raw('block', *cell).get('block')
|
||||
assert seen[label]['ordinary_tool'] == 'minecraft:air', seen
|
||||
return seen
|
||||
|
||||
|
||||
CHECKS += ['creative_tools']
|
||||
CHECK_FNS['creative_tools'] = check_creative_tools
|
||||
|
||||
|
||||
def check_cushions(host, guest, out):
|
||||
"""#1935: place a colored cushion, consume it, track it, sit, dismount and break it."""
|
||||
seen = {}
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compare Creative mining eligibility for every item and tool overrides."""
|
||||
import json
|
||||
|
||||
try:
|
||||
from . import lab, oracle_harness as harness
|
||||
except ImportError:
|
||||
import lab, oracle_harness as harness
|
||||
|
||||
|
||||
def make_input(build):
|
||||
resources = lab.LOCAL / 'horizon-client' / '26.3'
|
||||
items = json.loads((resources / 'items.json').read_text())
|
||||
rows = [dict(item=item, creative=creative, count=count, tool=tool)
|
||||
for item in sorted(items)
|
||||
for creative in (False, True)
|
||||
for count in (0, 1)
|
||||
for tool in ('default', 'allow', 'deny', 'implicit')]
|
||||
path = build / 'inputs.jsonl'
|
||||
path.write_text(''.join(json.dumps(row) + '\n' for row in rows))
|
||||
return path, len(rows)
|
||||
|
||||
|
||||
def main():
|
||||
harness.differential(
|
||||
'rust-creative-mining-parity', 'VanillaCreativeMiningOracle',
|
||||
'creative_mining_probe', make_input,
|
||||
'Item.canDestroyBlock with each vanilla item, empty stacks, Survival/Creative '
|
||||
'abilities, and explicit/implicit tool overrides. Block destruction and network '
|
||||
'prediction call this predicate; end-to-end packet handling is not covered here.',
|
||||
sources=[lab.ROOT / 'crates/horizon-client/src/items.rs'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Reference in New Issue
Block a user