diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index fa0f732dd..0e5dda9d7 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -233,6 +233,9 @@ struct Game<'a> {
/// Item being used (eaten): hotbar slot and ticks used.
using: Option<(usize, u32)>,
title: Option
,
+ /// Armor slots: head, chest, legs, feet.
+ armor: [Option; 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 {
+ 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 {
+ 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 {
+ 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 {
+ 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) => {
diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs
index b5413452c..3caf4b445 100644
--- a/crates/horizon-client/src/items.rs
+++ b/crates/horizon-client/src/items.rs
@@ -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,
+ /// `equippable.slot` (head, chest, legs, feet, ...).
+ pub equip_slot: Option,
+ /// 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"),
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 5703b2906..fb5a835b9 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -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