Add armor, buckets and tool block actions

Equippable items swap into armor slots (inventory screen slots with the
empty-slot icons, saved as vanilla slots 100-103) and apply their
attribute modifiers, so the validated vanilla armor and toughness
damage reduction applies; armor loses max(1, damage/4) durability per
hit. Buckets pick up and place water and lava sources; hoes till,
shovels make paths, axes strip logs and wood, flint and steel and fire
charges light fire, with vanilla sounds and tool durability.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-08 02:15:26 +02:00
parent 6dca05a35f
commit 619339dca2
3 changed files with 324 additions and 3 deletions
+279 -3
View File
@@ -233,6 +233,9 @@ struct Game<'a> {
/// Item being used (eaten): hotbar slot and ticks used.
using: Option<(usize, u32)>,
title: Option<Title>,
/// Armor slots: head, chest, legs, feet.
armor: [Option<ItemStack>; 4],
applied_modifiers: Vec<(String, String)>,
}
fn view_vector(yaw: f32, pitch: f32) -> [f64; 3] {
let (y, p) = (f64::from(yaw).to_radians(), f64::from(pitch).to_radians());
@@ -671,6 +674,9 @@ impl Game<'_> {
}
return Ok(());
}
if self.use_tool(&stack)? {
return Ok(());
}
let Some(hit) = self.pick() else { return Ok(()) };
let Some(block) = info.block else { return Ok(()) };
let clicked_state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
@@ -947,6 +953,7 @@ impl Game<'_> {
}
self.previous_position = feet;
self.player = Some(player);
self.apply_equipment();
self.eye = 1.62;
self.previous_eye = 1.62;
self.clock.reset();
@@ -1353,6 +1360,9 @@ impl Game<'_> {
None => {
v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i));
v.push(200);
if self.craft_size == 2 {
v.extend(500..504);
}
}
}
v
@@ -1365,7 +1375,8 @@ impl Game<'_> {
match i {
0..9 => (8.0 + i as f32 * 18.0, 142.0 + shift),
9..36 => (8.0 + ((i - 9) % 9) as f32 * 18.0, 84.0 + shift + ((i - 9) / 9) as f32 * 18.0),
300.. => match self.container_kind() {
500..504 => (8.0, 8.0 + (i - 500) as f32 * 18.0),
300..500 => match self.container_kind() {
Some(BlockEntity::Furnace(_)) => [(56.0, 17.0), (56.0, 53.0), (116.0, 35.0)][(i - 300).min(2)],
_ => (8.0 + ((i - 300) % 9) as f32 * 18.0, 18.0 + ((i - 300) / 9) as f32 * 18.0),
},
@@ -1389,6 +1400,9 @@ impl Game<'_> {
})
}
fn slot_mut(&mut self, i: usize) -> &mut Option<ItemStack> {
if (500..504).contains(&i) {
return &mut self.armor[i - 500];
}
if i >= 300 {
let key = self.container;
return match key.and_then(|k| self.world.block_entities.get_mut(&k)) {
@@ -1467,6 +1481,10 @@ impl Game<'_> {
}
for i in self.slots() {
let (sx, sy) = self.slot_position(i);
if (500..504).contains(&i) && self.armor[i - 500].is_none() {
let icon = ["helmet", "chestplate", "leggings", "boots"][i - 500];
batch.sprite(&self.res.atlas, &format!("gui/sprites/container/slot/{icon}"), ox + sx, oy + sy);
}
let stack = if i == 200 { self.craft_result() } else { self.slot_mut(i).clone() };
if let Some(stack) = stack {
self.draw_item(batch, &stack, ox + sx, oy + sy);
@@ -1586,6 +1604,16 @@ impl Game<'_> {
}
return;
}
if (500..504).contains(&slot) {
let wanted = ["head", "chest", "legs", "feet"][slot - 500];
let fits = self.carried.as_ref().is_none_or(|c| self.res.items.get(&c.item).and_then(|i| i.equip_slot.as_deref()) == Some(wanted));
if !fits {
return;
}
std::mem::swap(&mut self.carried, &mut self.armor[slot - 500]);
self.apply_equipment();
return;
}
let carried = self.carried.take();
let current = self.slot_mut(slot).take();
let items = &self.res.items;
@@ -2049,6 +2077,7 @@ impl Game<'_> {
self.audio.play("minecraft:entity.generic.explode", Some(center), 4.0, (1.0 + (self.world.random.next_float() - self.world.random.next_float()) * 0.2) * 0.7);
// Entity damage by distance (exposure approximated as unobstructed).
let diameter = f64::from(radius) * 2.0;
let mut armor_damage = None;
if let Some(player) = self.player.as_mut() {
let p = [player.position.x, player.position.y, player.position.z];
let dist = ((p[0] - center[0]).powi(2) + (p[1] - center[1]).powi(2) + (p[2] - center[2]).powi(2)).sqrt() / diameter;
@@ -2057,12 +2086,18 @@ impl Game<'_> {
let damage = ((impact * impact + impact) / 2.0 * 7.0 * diameter + 1.0) as f32;
if let Some(id) = self.motion.health.damage.id("minecraft:explosion") {
let _ = player.hurt(&self.motion.health, self.world.health_rules, id, damage);
armor_damage = Some(damage);
}
let (dx, dy, dz) = (p[0] - center[0], p[1] - center[1], p[2] - center[2]);
let l = (dx * dx + dy * dy + dz * dz).sqrt().max(1e-4);
player.velocity = Vec3::new(player.velocity.x + dx / l * impact, player.velocity.y + dy / l * impact, player.velocity.z + dz / l * impact);
}
}
if let Some(d) = armor_damage
&& !self.creative
{
self.hurt_armor(d);
}
for m in &mut self.mobs {
let dist = ((m.position.x - center[0]).powi(2) + (m.position.y - center[1]).powi(2) + (m.position.z - center[2]).powi(2)).sqrt() / diameter;
if dist <= 1.0 && m.alive() {
@@ -2175,6 +2210,7 @@ impl Game<'_> {
player.velocity = Vec3::new(player.velocity.x / 2.0 + dx / l * 0.4, (player.velocity.y / 2.0 + 0.4).min(0.4), player.velocity.z / 2.0 + dz / l * 0.4);
let at = [player.position.x, player.position.y, player.position.z];
self.audio.play("minecraft:entity.player.hurt", Some(at), 1.0, 1.0);
self.hurt_armor(amount);
}
}
MobEvent::Shoot(from, target) => {
@@ -2222,6 +2258,7 @@ impl Game<'_> {
let _ = player.hurt(&self.motion.health, self.world.health_rules, id, d);
let at = [player.position.x, player.position.y, player.position.z];
self.audio.play("minecraft:entity.arrow.hit_player", Some(at), 1.0, 1.0);
self.hurt_armor(d);
}
}
Ok(())
@@ -2373,9 +2410,13 @@ impl Game<'_> {
world.day_time = self.options.time.unwrap_or(level.day_time);
self.creative = level.creative;
let mut inventory = vec![None; 36];
self.armor = [None, None, None, None];
for (slot, id, count, damage) in &level.inventory {
if let Some(cell) = inventory.get_mut(usize::from(*slot)) {
*cell = Some(ItemStack { item: Arc::from(id.as_str()), count: *count, damage: *damage });
let stack = ItemStack { item: Arc::from(id.as_str()), count: *count, damage: *damage };
if (100..104).contains(slot) {
self.armor[usize::from(103 - slot)] = Some(stack);
} else if let Some(cell) = inventory.get_mut(usize::from(*slot)) {
*cell = Some(stack);
}
}
if self.creative && level.inventory.is_empty() && level.position.is_none() {
@@ -2452,6 +2493,233 @@ impl Game<'_> {
}
out
}
/// Equipment attribute modifiers (LivingEntity.collectEquipmentChanges).
fn apply_equipment(&mut self) {
let Some(player) = self.player.as_mut() else { return };
for (attribute, id) in std::mem::take(&mut self.applied_modifiers) {
let _ = player.set_modifier(&attribute, &id, 0.0, "add_value", false);
}
let slots = ["head", "chest", "legs", "feet"];
let mut equipped: Vec<(Option<&ItemStack>, &str)> = self.armor.iter().zip(slots).map(|(s, n)| (s.as_ref(), n)).collect();
equipped.push((self.inventory[self.selected].as_ref(), "mainhand"));
for (stack, slot) in equipped {
let Some(info) = stack.and_then(|s| self.res.items.get(&s.item)) else { continue };
for (attribute, id, amount, op, group) in &info.modifiers {
let matches = group == slot
|| group == "any"
|| (group == "armor" && slot != "mainhand")
|| (group == "hand" && slot == "mainhand");
// Main-hand attack modifiers are read by the attack code directly.
if !matches || slot == "mainhand" {
continue;
}
if player.set_modifier(attribute, id, *amount, op, true).is_ok() {
self.applied_modifiers.push((attribute.clone(), id.clone()));
}
}
}
}
/// Inventory.hurtArmor: each piece loses max(1, damage / 4) durability.
fn hurt_armor(&mut self, damage: f32) {
let amount = ((damage / 4.0) as u32).max(1);
let mut broke = false;
for slot in &mut self.armor {
if let Some(stack) = slot.as_mut()
&& let Some(info) = self.res.items.get(&stack.item)
&& info.max_damage > 0
{
stack.damage += amount;
if stack.damage >= info.max_damage {
*slot = None;
broke = true;
}
}
}
if broke {
if let Some(eye) = self.eye_position() {
self.audio.play("minecraft:entity.item.break", Some(eye), 0.8, 0.8 + self.world.random.next_float() * 0.4);
}
self.apply_equipment();
}
}
/// Voxel traversal that also stops at fluid source blocks (bucket pick).
fn pick_fluid(&self) -> Option<Hit> {
let origin = self.eye_position()?;
let dir = view_vector(self.yaw, self.pitch);
let mut t = 0.0;
let mut last = origin.map(|v| v.floor() as i32);
while t <= self.reach() {
let p = [origin[0] + dir[0] * t, origin[1] + dir[1] * t, origin[2] + dir[2] * t];
let b = p.map(|v| v.floor() as i32);
if b != last {
let state = self.world.block(b[0], b[1], b[2]);
let f = self.res.facts.get(state);
let face = [last[0] - b[0], last[1] - b[1], last[2] - b[2]];
if f.fluid != Fluid::None && f.fluid_level == 8 && !f.fluid_falling && !f.waterlogged && f.render_shape != horizon_client::blocks::RenderShape::Model {
return Some(Hit { pos: b, face, point: p });
}
if !self.res.facts.is_air(state) && f.fluid == Fluid::None {
return Some(Hit { pos: b, face, point: p });
}
last = b;
}
t += 0.05;
}
None
}
fn set_state_named(&mut self, pos: [i32; 3], name: &str, keep: &[&str]) -> Result<bool> {
let registry = &self.res.assets.registry;
let old = self.world.block(pos[0], pos[1], pos[2]);
let Some(default) = registry.default_state(name) else { return Ok(false) };
let mut state = registry.state(default).cloned().ok_or("state")?;
if let Some(previous) = registry.state(old) {
for k in keep {
if let Some(v) = previous.properties.get(*k) {
state.properties.insert((*k).to_owned(), v.clone());
}
}
}
let id = registry.resolve(&state).unwrap_or(default);
self.world.set(pos[0], pos[1], pos[2], id)?;
Ok(true)
}
fn damage_held(&mut self, amount: u32) {
if self.creative {
return;
}
if let Some(stack) = self.inventory[self.selected].as_mut()
&& let Some(info) = self.res.items.get(&stack.item)
&& info.max_damage > 0
{
stack.damage += amount;
if stack.damage >= info.max_damage {
self.inventory[self.selected] = None;
if let Some(eye) = self.eye_position() {
self.audio.play("minecraft:entity.item.break", Some(eye), 0.8, 0.8 + self.world.random.next_float() * 0.4);
}
}
}
}
/// Item use on blocks for tools, buckets and fire starters; returns true if handled.
fn use_tool(&mut self, stack: &ItemStack) -> Result<bool> {
let item = stack.item.trim_start_matches("minecraft:").to_owned();
let at = |p: [i32; 3]| [f64::from(p[0]) + 0.5, f64::from(p[1]) + 0.5, f64::from(p[2]) + 0.5];
if item == "bucket" {
let Some(hit) = self.pick_fluid() else { return Ok(false) };
let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
let f = self.res.facts.get(state).clone();
if f.fluid == Fluid::None || f.fluid_level != 8 || f.fluid_falling {
return Ok(false);
}
let (filled, sound) = match f.fluid {
Fluid::Water => ("minecraft:water_bucket", "minecraft:item.bucket.fill"),
_ => ("minecraft:lava_bucket", "minecraft:item.bucket.fill_lava"),
};
self.world.set(hit.pos[0], hit.pos[1], hit.pos[2], self.world.air)?;
self.audio.play(sound, Some(at(hit.pos)), 1.0, 1.0);
if !self.creative {
self.consume_held();
let filled = ItemStack { item: Arc::from(filled), count: 1, damage: 0 };
if self.inventory[self.selected].is_none() {
self.inventory[self.selected] = Some(filled);
} else if let Some(rest) = self.give(filled)
&& let Some(eye) = self.eye_position()
{
self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
}
}
return Ok(true);
}
let Some(hit) = self.pick() else { return Ok(false) };
let clicked = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
let name = self.res.facts.get(clicked).name.trim_start_matches("minecraft:").to_owned();
let above_air = self.res.facts.is_air(self.world.block(hit.pos[0], hit.pos[1] + 1, hit.pos[2]));
if item == "water_bucket" || item == "lava_bucket" {
let target = if self.res.facts.get(clicked).replaceable { hit.pos } else { [hit.pos[0] + hit.face[0], hit.pos[1] + hit.face[1], hit.pos[2] + hit.face[2]] };
let existing = self.world.block(target[0], target[1], target[2]);
if !self.res.facts.get(existing).replaceable && !self.res.facts.is_air(existing) {
return Ok(true);
}
let fluid = if item == "water_bucket" { "minecraft:water" } else { "minecraft:lava" };
self.set_state_named(target, fluid, &[])?;
let sound = if item == "water_bucket" { "minecraft:item.bucket.empty" } else { "minecraft:item.bucket.empty_lava" };
self.audio.play(sound, Some(at(target)), 1.0, 1.0);
if !self.creative {
self.inventory[self.selected] = Some(ItemStack { item: Arc::from("minecraft:bucket"), count: 1, damage: 0 });
}
return Ok(true);
}
if item.ends_with("_hoe") && hit.face != [0, -1, 0] && above_air {
// HoeItem.TILLABLES
let result = match name.as_str() {
"grass_block" | "dirt_path" | "dirt" => Some("minecraft:farmland"),
"coarse_dirt" | "rooted_dirt" => Some("minecraft:dirt"),
_ => None,
};
if let Some(result) = result {
self.set_state_named(hit.pos, result, &[])?;
if name == "rooted_dirt" {
self.pop_resource([hit.pos[0], hit.pos[1] - 1, hit.pos[2]], ItemStack { item: Arc::from("minecraft:hanging_roots"), count: 1, damage: 0 });
}
self.audio.play("minecraft:item.hoe.till", Some(at(hit.pos)), 1.0, 1.0);
self.damage_held(1);
return Ok(true);
}
}
if item.ends_with("_shovel") && hit.face != [0, -1, 0] && above_air
&& matches!(name.as_str(), "grass_block" | "dirt" | "podzol" | "coarse_dirt" | "mycelium" | "rooted_dirt")
{
// ShovelItem.FLATTENABLES
self.set_state_named(hit.pos, "minecraft:dirt_path", &[])?;
self.audio.play("minecraft:item.shovel.flatten", Some(at(hit.pos)), 1.0, 1.0);
self.damage_held(1);
return Ok(true);
}
if item.ends_with("_axe") && !name.starts_with("stripped_") {
// AxeItem.STRIPPABLES
let strippable = name.ends_with("_log") || name.ends_with("_wood") || name.ends_with("_stem") || name.ends_with("_hyphae") || name == "bamboo_block";
let stripped = format!("minecraft:stripped_{name}");
if strippable && self.res.assets.registry.default_state(&stripped).is_some() {
self.set_state_named(hit.pos, &stripped, &["axis"])?;
self.audio.play("minecraft:item.axe.strip", Some(at(hit.pos)), 1.0, 1.0);
self.damage_held(1);
return Ok(true);
}
}
if item == "flint_and_steel" || item == "fire_charge" {
let target = [hit.pos[0] + hit.face[0], hit.pos[1] + hit.face[1], hit.pos[2] + hit.face[2]];
if self.res.facts.is_air(self.world.block(target[0], target[1], target[2])) {
self.set_state_named(target, "minecraft:fire", &[])?;
let sound = if item == "fire_charge" { "minecraft:item.firecharge.use" } else { "minecraft:item.flintandsteel.use" };
self.audio.play(sound, Some(at(target)), 1.0, self.world.random.next_float() * 0.4 + 0.8);
if item == "fire_charge" {
self.consume_held();
} else {
self.damage_held(1);
}
return Ok(true);
}
}
// Equippable items swap into their armor slot (Equippable.swapWithEquipmentSlot).
if let Some(slot) = self.res.items.get(&stack.item).and_then(|i| i.equip_slot.clone()) {
let index = match slot.as_str() {
"head" => 0,
"chest" => 1,
"legs" => 2,
"feet" => 3,
_ => return Ok(false),
};
let held = self.inventory[self.selected].take();
self.inventory[self.selected] = self.armor[index].take();
self.armor[index] = held;
if let Some(eye) = self.eye_position() {
self.audio.play("minecraft:item.armor.equip_generic", Some(eye), 1.0, 1.0);
}
self.apply_equipment();
return Ok(true);
}
Ok(false)
}
fn save_game(&mut self) -> Result<()> {
let keys: Vec<_> = self.world.modified.drain().collect();
let chunks: Vec<_> = keys
@@ -2478,6 +2746,12 @@ impl Game<'_> {
.enumerate()
.filter_map(|(i, s)| s.as_ref().map(|s| (i as u8, s.item.to_string(), s.count, s.damage)))
.collect();
// Vanilla stores armor in slots 100 (feet) to 103 (head).
for (i, s) in self.armor.iter().enumerate() {
if let Some(s) = s {
level.inventory.push((103 - i as u8, s.item.to_string(), s.count, s.damage));
}
}
level.write(&self.save.root)?;
self.message = Some(("Saved the game".into(), Instant::now()));
Ok(())
@@ -3022,6 +3296,8 @@ pub fn run() -> Result<()> {
chest_open: HashMap::new(),
using: None,
title: None,
armor: [None, None, None, None],
applied_modifiers: Vec::new(),
};
match game.options.world.clone() {
Some(folder) => {
+19
View File
@@ -35,6 +35,10 @@ pub struct ItemInfo {
pub fuel: Option<(Value, Value)>,
/// Item left behind after crafting/fuel use (e.g. bucket).
pub remainder: Option<String>,
/// `equippable.slot` (head, chest, legs, feet, ...).
pub equip_slot: Option<String>,
/// All `attribute_modifiers`: (attribute, id, amount, operation, slot group).
pub modifiers: Vec<(String, String, f64, String, String)>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ItemStack {
@@ -156,6 +160,21 @@ impl Items {
.unwrap_or(1.0) as f32,
food,
model: c["minecraft:item_model"].as_str().unwrap_or(name).to_owned(),
equip_slot: c["minecraft:equippable"]["slot"].as_str().map(str::to_owned),
modifiers: c["minecraft:attribute_modifiers"]
.as_array()
.into_iter()
.flatten()
.filter_map(|m| {
Some((
m["type"].as_str()?.to_owned(),
m["id"].as_str()?.to_owned(),
m["amount"].as_f64()?,
m["operation"].as_str().unwrap_or("add_value").to_owned(),
m["slot"].as_str().unwrap_or("any").to_owned(),
))
})
.collect(),
fuel: c.get("minecraft:cooking_fuel").map(|f| (f["burn_time"].clone(), f["speed_multiplier"].clone())),
remainder: c["minecraft:use_remainder"]["id"].as_str().or(c["minecraft:crafting_remainder"]["id"].as_str()).or(c["minecraft:crafting_remainder"].as_str()).map(str::to_owned),
attack_damage: modifier("minecraft:attack_damage"),
+26
View File
@@ -229,6 +229,32 @@ impl PlayerMotion {
.value(Some(key), ValueKind::Computed)
.map_err(attribute_error)?)
}
/// Add (or remove) a transient attribute modifier, e.g. from equipment
/// (`LivingEntity.collectEquipmentChanges` applying item modifiers).
pub fn set_modifier(&mut self, attribute: &str, id: &str, amount: f64, operation: &str, present: bool) -> Result<()> {
let Some(key) = self.attributes.key(attribute) else {
return Ok(());
};
let Some(handle) = self.attributes.get_instance(Some(key)).map_err(attribute_error)? else {
return Ok(());
};
let operation = match operation {
"add_multiplied_base" => Operation::AddMultipliedBase,
"add_multiplied_total" => Operation::AddMultipliedTotal,
_ => Operation::AddValue,
};
let modifier = Modifier::new(id, amount, operation)?;
self.attributes
.edit(&handle, |value, observer| {
value.remove(modifier.id(), observer)?;
if present {
value.add_transient(modifier, observer)?;
}
Ok(())
})
.map_err(attribute_error)?;
Ok(())
}
pub fn set_sprinting(&mut self, sprinting: bool) -> Result<()> {
self.sprinting = sprinting;
let key = self