From 2c07b5e621805ec33cdc198615be7a25c0a7742f Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:24:54 +0200 Subject: [PATCH 1/2] Wire vaults into the game Vaults are block entities now (loaded from saves and structure templates, so trial chambers keep their ominous configs) and tick every game tick: their state changes, sounds, level events and ejected rewards reach the world, keys go in through VaultBlock.useItemOn before the item's own use, and VaultRenderer draws the display item spinning inside the cage. Part of #223. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/containers.rs | 9 + crates/horizon-client/src/game.rs | 10 + .../horizon-client/src/game/trial_spawner.rs | 6 +- crates/horizon-client/src/game/vault.rs | 242 ++++++++++++++++++ crates/horizon-client/src/save.rs | 2 + crates/horizon-client/src/structure_blocks.rs | 3 + crates/horizon-client/src/vault.rs | 26 ++ 7 files changed, 295 insertions(+), 3 deletions(-) create mode 100644 crates/horizon-client/src/game/vault.rs diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 777e90054..45ecdf07a 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -70,6 +70,8 @@ pub enum BlockEntity { Spawner(Box), /// `TrialSpawnerBlockEntity` (`crate::mobs::trial_spawner`). TrialSpawner(Box), + /// `VaultBlockEntity` (`crate::vault`). + Vault(Box), /// `BeehiveBlockEntity` of beehives and bee nests (`crate::beehive`). Beehive(Box), } @@ -192,6 +194,9 @@ impl BlockEntity { if name == "minecraft:trial_spawner" { return Some(Self::TrialSpawner(Box::default())); } + if name == "minecraft:vault" { + return Some(Self::Vault(Box::default())); + } if name == "minecraft:beehive" || name == "minecraft:bee_nest" { return Some(Self::Beehive(Box::default())); } @@ -272,6 +277,7 @@ impl BlockEntity { Self::CreakingHeart(_) => "minecraft:creaking_heart", Self::Spawner(_) => "minecraft:mob_spawner", Self::TrialSpawner(_) => "minecraft:trial_spawner", + Self::Vault(_) => "minecraft:vault", Self::Beehive(_) => "minecraft:beehive", } } @@ -286,6 +292,7 @@ impl BlockEntity { | Self::CreakingHeart(_) | Self::Spawner(_) | Self::TrialSpawner(_) + | Self::Vault(_) | Self::Beehive(_) => Vec::new(), Self::Lectern(l) => l.book.iter().cloned().collect(), Self::Sculk(_) => Vec::new(), @@ -308,6 +315,7 @@ impl BlockEntity { Self::CreakingHeart(_) | Self::Spawner(_) | Self::TrialSpawner(_) + | Self::Vault(_) | Self::Beehive(_) => &[], } } @@ -326,6 +334,7 @@ impl BlockEntity { Self::CreakingHeart(_) | Self::Spawner(_) | Self::TrialSpawner(_) + | Self::Vault(_) | Self::Beehive(_) => &mut [], } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 69dc63667..8416a624e 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -125,6 +125,7 @@ mod trial_spawner; mod trident; mod tweaks; mod ui_control; +mod vault; mod villagers; mod wandering_trader; mod wind; @@ -2360,6 +2361,10 @@ impl Game<'_> { self.swing_arm(); return Ok(true); } + if self.use_vault(hit.pos, held.as_ref())? { + self.swing_arm(); + return Ok(true); + } match self.use_respawn_anchor(hit.pos, held.as_ref())? { respawn_anchor::AnchorUse::Charged => { self.swing_arm(); @@ -3889,6 +3894,7 @@ impl Game<'_> { | BlockEntity::CreakingHeart(_) | BlockEntity::Spawner(_) | BlockEntity::TrialSpawner(_) + | BlockEntity::Vault(_) | BlockEntity::Beehive(_), ) => {} None => { @@ -4144,6 +4150,7 @@ impl Game<'_> { | BlockEntity::CreakingHeart(_) | BlockEntity::Spawner(_) | BlockEntity::TrialSpawner(_) + | BlockEntity::Vault(_) | BlockEntity::Beehive(_), ) => {} None if self.mount_active() => self.draw_mount_background(batch, ox, oy), @@ -5284,6 +5291,8 @@ impl Game<'_> { } // `ItemEntityRenderer`. self.dropped_item_geometry(camera, alpha, &mut out); + // `VaultRenderer`. + self.vault_geometry(camera, alpha, &mut out); // Mobs and their projectiles. self.mob_geometry(camera, alpha, &mut out); self.player_model_geometry(camera, alpha, &mut out); @@ -5801,6 +5810,7 @@ impl Game<'_> { self.tick_creaking_hearts()?; self.tick_spawners()?; self.tick_trial_spawners()?; + self.tick_vaults()?; self.tick_beehives(); let mut lit_changes = Vec::new(); for (pos, entity) in self.world.block_entities.iter_mut() { diff --git a/crates/horizon-client/src/game/trial_spawner.rs b/crates/horizon-client/src/game/trial_spawner.rs index 6427cbeb1..0d0d726f5 100644 --- a/crates/horizon-client/src/game/trial_spawner.rs +++ b/crates/horizon-client/src/game/trial_spawner.rs @@ -184,7 +184,7 @@ impl Game<'_> { } for event in events { match event { - TrialEvent::BlockUpdated => self.trial_spawner_updated(key), + TrialEvent::BlockUpdated => self.mark_block_entity_updated(key), TrialEvent::LevelEvent(id, at, data) => self.level_event_at(id, at, data), TrialEvent::Sound(name) => { self.audio @@ -220,8 +220,8 @@ impl Game<'_> { let id = self.res.assets.registry.resolve(&block)?; self.level_set([key.0, key.1, key.2], id) } - /// `markUpdated`: the clients load the new update tag. - fn trial_spawner_updated(&mut self, key: Pos) { + /// `sendBlockUpdated` of a block entity: the clients load its new update tag. + pub(super) fn mark_block_entity_updated(&mut self, key: Pos) { if let Some(log) = self.world.block_log.as_mut() { log.push(key); } diff --git a/crates/horizon-client/src/game/vault.rs b/crates/horizon-client/src/game/vault.rs new file mode 100644 index 000000000..0ed008add --- /dev/null +++ b/crates/horizon-client/src/game/vault.rs @@ -0,0 +1,242 @@ +//! Vaults in the game: `VaultBlockEntity.Server.tick` for every vault +//! (`vault`), the block's state as it changes, the rewards it ejects, the +//! keys players insert (`VaultBlock.useItemOn`) and the display item spinning +//! inside (`VaultRenderer`). +use super::Game; +use horizon_assets::item_model::DisplayContext; +use horizon_client::{ + Result, + block_entity_render::vertex_light, + containers::BlockEntity, + item_render, + items::ItemStack, + mesher::Vertex, + vault::{Vault, VaultEvent, VaultLevel, VaultPlayer, VaultState}, +}; +use horizon_core::random::LegacyRandom; + +type Pos = (i32, i32, i32); + +/// What a vault reads: the game time and the player. +struct Players { + time: i64, + players: Vec, +} +impl VaultLevel for Players { + fn game_time(&self) -> i64 { + self.time + } + fn players(&self) -> Vec { + self.players.clone() + } +} + +impl Game<'_> { + fn vault_players(&self) -> Players { + let players = self.player.as_ref().map(|p| VaultPlayer { + uuid: self.level.player_uuid.unwrap_or_default(), + block: [p.position.x, p.position.y, p.position.z].map(|v| v.floor() as i32), + spectator: self.spectator(), + }); + Players { + time: self.world.game_time, + players: players.into_iter().collect(), + } + } + /// The vault at `key` with its block's state and ominous flag. + fn take_vault(&mut self, key: Pos) -> Option<(Box, VaultState, bool)> { + let state = self.world.block(key.0, key.1, key.2); + let block = self.res.assets.registry.state(state)?; + if block.name != "minecraft:vault" { + return None; + } + let current = block + .properties + .get("vault_state") + .and_then(|s| VaultState::from_name(s)) + .unwrap_or_default(); + let ominous = block.properties.get("ominous").is_some_and(|v| v == "true"); + let Some(BlockEntity::Vault(vault)) = self.world.block_entities.remove(&key) else { + return None; + }; + Some((vault, current, ominous)) + } + /// Runs `f` on the vault at `key` with the level random and a loot roll, + /// then applies its events. + fn with_vault( + &mut self, + key: Pos, + f: impl FnOnce( + &mut Vault, + &Players, + &mut LegacyRandom, + VaultState, + bool, + &mut horizon_client::vault::Roll, + &mut Vec, + ) -> T, + ) -> Option> { + let (mut vault, current, ominous) = self.take_vault(key)?; + let players = self.vault_players(); + let mut random = std::mem::replace(&mut self.world.random, LegacyRandom::new(0)); + let mut sequences = std::mem::take(&mut self.rand_sequences); + let loot = horizon_client::structure_blocks::loot_data(&self.options.resources); + let seed = self.level.seed; + let mut events = Vec::new(); + let out = { + // LootTable.getRandomItems, stacks split; the reward rolls with the + // table's random sequence. + let mut roll = |table: &str, random: &mut LegacyRandom, sequence: bool| { + let Some(loot) = &loot else { + return Vec::new(); + }; + let drops = match loot.random_sequence(table).filter(|_| sequence) { + Some(s) => loot.roll_split(table, sequences.get(s, seed)), + None => loot.roll_split(table, random), + }; + drops + .iter() + .map(horizon_client::structure_blocks::loot_item_with_components) + .collect() + }; + f( + &mut vault, + &players, + &mut random, + current, + ominous, + &mut roll, + &mut events, + ) + }; + self.world.random = random; + self.rand_sequences = sequences; + self.world + .block_entities + .insert(key, BlockEntity::Vault(vault)); + Some(self.vault_events(key, events).map(|()| out)) + } + /// Every vault's server tick, then its client tick's spin. + pub(super) fn tick_vaults(&mut self) -> Result<()> { + let keys: Vec = self + .world + .block_entities + .iter() + .filter(|(_, e)| matches!(e, BlockEntity::Vault(_))) + .map(|(k, _)| *k) + .collect(); + for key in keys { + let pos = [key.0, key.1, key.2]; + let ticked = self.with_vault(key, |v, l, random, state, ominous, roll, events| { + v.server_tick(l, random, pos, state, ominous, roll, events); + v.update_display_item_spin(); + }); + if let Some(result) = ticked { + result?; + } + } + Ok(()) + } + /// `VaultBlock.useItemOn` with `held` in the hand that acts: true when the + /// vault took the click (an active vault, with anything in the hand). + pub(super) fn use_vault(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> Result { + let Some(stack) = held.cloned() else { + return Ok(false); + }; + let player = self.level.player_uuid.unwrap_or_default(); + let used = self.with_vault( + (pos[0], pos[1], pos[2]), + |v, l, random, state, ominous, roll, events| { + v.use_item_on( + l, + random, + pos, + state, + ominous, + player, + Some(&stack), + roll, + events, + ) + }, + ); + let Some(taken) = used.transpose()?.flatten() else { + return Ok(false); + }; + if taken > 0 { + // awardStat(ITEM_USED), then stackToInsert.consume(count, player). + self.stats.add("used", &stack.item, 1); + for _ in 0..taken { + self.consume_held(); + } + } + Ok(true) + } + fn vault_events(&mut self, key: Pos, events: Vec) -> Result<()> { + let pos = [key.0, key.1, key.2]; + let center = pos.map(|v| f64::from(v) + 0.5); + for event in events { + match event { + VaultEvent::State(state) => self.set_vault_state(key, state)?, + VaultEvent::BlockUpdated => self.mark_block_entity_updated(key), + VaultEvent::LevelEvent(id, data) => self.level_event_at(id, pos, data), + VaultEvent::Sound(name, volume, pitch) => { + self.audio + .play(&format!("minecraft:{name}"), Some(center), volume, pitch) + } + // Vec3.atBottomCenterOf(pos).relative(UP, 1.2), lowered by spawnItem. + VaultEvent::Eject(stack, v) => { + self.spawn_item(stack, [center[0], center[1] + 0.7 - 0.125, center[2]], v, 0) + } + } + } + Ok(()) + } + /// `setBlockAndUpdate` with the new `vault_state`. + fn set_vault_state(&mut self, key: Pos, state: VaultState) -> Result<()> { + let current = self.world.block(key.0, key.1, key.2); + let Some(mut block) = self.res.assets.registry.state(current).cloned() else { + return Ok(()); + }; + block + .properties + .insert("vault_state".into(), state.name().into()); + let id = self.res.assets.registry.resolve(&block)?; + self.level_set([key.0, key.1, key.2], id) + } + /// `VaultRenderer`: the display item of every vault near the camera that + /// shows one, turning above its floor. + pub(super) fn vault_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { + for (key, entity) in &self.world.block_entities { + let BlockEntity::Vault(vault) = entity else { + continue; + }; + let Some(stack) = &vault.display_item else { + continue; + }; + let at = glam::DVec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2)); + if at.distance_squared(camera) >= 64.0 * 64.0 { + continue; + } + let state = self.resolve_item(stack, DisplayContext::Ground, None, 0); + if state.is_empty() { + continue; + } + let pose = + glam::Mat4::from_translation( + (at - camera).as_vec3() + glam::Vec3::new(0.5, 0.4, 0.5), + ) * glam::Mat4::from_rotation_y(vault.display_spin(alpha as f32).to_radians()); + let light = self.world.light(key.0, key.1, key.2); + let seed = + i64::from(self.res.item_renderer.item_id(&stack.item)) + i64::from(stack.damage); + for copy in item_render::cluster_poses( + &state, + pose, + item_render::rendered_amount(stack.count), + seed, + ) { + self.submit_item_world(&state, copy, vertex_light(light), out); + } + } + } +} diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 94ab7646d..678d3f1f1 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -528,6 +528,7 @@ pub fn encode_block_entity( } BlockEntity::Spawner(s) => entries.extend(s.save()), BlockEntity::TrialSpawner(s) => entries.extend(s.save()), + BlockEntity::Vault(v) => entries.extend(v.save()), BlockEntity::Beehive(h) => entries.extend(h.to_nbt()), } Tag::compound(entries) @@ -658,6 +659,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain | BlockEntity::CreakingHeart(_) => {} BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag), BlockEntity::TrialSpawner(s) => **s = crate::mobs::trial_spawner::TrialSpawner::load(tag), + BlockEntity::Vault(v) => **v = crate::vault::Vault::load(tag), BlockEntity::Beehive(h) => **h = crate::beehive::Beehive::from_nbt(tag), } Some((pos, entity)) diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs index f400522df..1e1906f6d 100644 --- a/crates/horizon-client/src/structure_blocks.rs +++ b/crates/horizon-client/src/structure_blocks.rs @@ -147,6 +147,9 @@ pub fn block_entities( if let BlockEntity::TrialSpawner(s) = &mut entity { **s = crate::mobs::trial_spawner::TrialSpawner::load(&Tag::Compound(nbt.clone())); } + if let BlockEntity::Vault(v) = &mut entity { + **v = crate::vault::Vault::load(&Tag::Compound(nbt.clone())); + } if let (BlockEntity::Chest(slots), Some(table), Some(loot)) = (&mut entity, text(nbt, "LootTable"), loot) { diff --git a/crates/horizon-client/src/vault.rs b/crates/horizon-client/src/vault.rs index deb82682e..38e5d29d7 100644 --- a/crates/horizon-client/src/vault.rs +++ b/crates/horizon-client/src/vault.rs @@ -186,6 +186,9 @@ pub struct Vault { pub connected_particles_range: f64, /// The shared data changed since the last tick sent it. pub shared_dirty: bool, + /// `VaultClientData`: the display item's spin and the previous tick's, in degrees. + pub spin: f32, + pub o_spin: f32, } impl Default for Vault { @@ -201,6 +204,8 @@ impl Default for Vault { connected_players: Vec::new(), connected_particles_range: DEFAULT_DEACTIVATION_RANGE, shared_dirty: false, + spin: 0.0, + o_spin: 0.0, } } } @@ -256,7 +261,28 @@ fn same_set(a: &[Uuid], b: &[Uuid]) -> bool { a.len() == b.len() && a.iter().all(|u| b.contains(u)) } +/// `Mth.wrapDegrees`. +fn wrap_degrees(degrees: f32) -> f32 { + let t = degrees % 360.0; + if t >= 180.0 { + t - 360.0 + } else if t < -180.0 { + t + 360.0 + } else { + t + } +} + impl Vault { + /// `VaultClientData.updateDisplayItemSpin`, every client tick. + pub fn update_display_item_spin(&mut self) { + self.o_spin = self.spin; + self.spin = wrap_degrees(self.spin + 10.0); + } + /// `VaultRenderer`'s spin: `Mth.rotLerp` between the last two ticks. + pub fn display_spin(&self, partial: f32) -> f32 { + self.o_spin + partial * wrap_degrees(self.spin - self.o_spin) + } /// `loadAdditional`. `VaultServerData.set` leaves the total of ejections /// out, so a vault loaded mid-ejection counts from 0. pub fn load(tag: &Tag) -> Self { From 3ac3efe749c8d7cba9a1b768d070290a81d33606 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 04:50:06 +0200 Subject: [PATCH 2/2] Save round-trip: a vault's next state update moves with the clock Vaults tick in the game now, and an idle one pushes state_updating_resumes_at to gameTime + 20 on every update, so Horizon, which saves later than vanilla, stores a later value. Stage 3 already treats it as volatile. Co-Authored-By: Claude Opus 5.5 --- tools/test_save_roundtrip_parity.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/test_save_roundtrip_parity.py b/tools/test_save_roundtrip_parity.py index 068fba3d4..33c8a0776 100644 --- a/tools/test_save_roundtrip_parity.py +++ b/tools/test_save_roundtrip_parity.py @@ -67,7 +67,8 @@ IGNORED = { # chunk generation first), so counters and positions of live things move on. r'^chunk\.block_entities\.\(2, -60, 5\)\.(cooking_time_spent|lit_time_remaining|Items\[\]\.count)$': 'the lit furnace keeps smelting', - r'^chunk\.block_entities\..*\.(ticks_since_song_started|Age|BrewTime|warning_level|ticks_in_hive|last_vibration_frequency|listener\..*|RecipesUsed\..*)$': + r'^chunk\.block_entities\..*\.(ticks_since_song_started|Age|BrewTime|warning_level|ticks_in_hive|last_vibration_frequency|listener\..*|RecipesUsed\..*|' + r'server_data\.state_updating_resumes_at)$': 'block entity timers advance', r'^entity\.(Age|Motion\[\]|Rotation\[\]|Pos\[\]|OnGround|HurtTime|Health|TimeInOverworld|fall_distance|' r'wasOnGround|Fire|Air|DeathTime|Fuse|life|inGround|ticks_in_ground|Time)$': 'entity simulation advances',