From fbbed63f04094038e076f127c5995b72f2b85d31 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 18:02:34 +0100 Subject: [PATCH] setblock and data keep a container's loot table A command's tag went through decode_block_entity, which has nowhere to put LootTable, so `setblock ... chest{LootTable:...}` made an empty chest (`data get` showed `Items: []`). An empty container given a LootTable is now rolled as a loaded chunk's are, and the roll is kept with its chunk (RolledLoot), so it saves, and `data get` shows, LootTable and LootTableSeed until its items change (tryLoadLootTable / trySaveLootTable). `data merge` and `data modify` go through the same path. command_exec: setblock a seeded loot chest, then data get it whole and its LootTableSeed (870/870 match the 26.3 oracle). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/commands.rs | 78 ++++++++++++++++++- .../horizon-client/src/game/commands/data.rs | 4 +- tools/command_exec_corpus.py | 6 ++ 3 files changed, 85 insertions(+), 3 deletions(-) diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 38a5cddd3..8f934ad8a 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1885,11 +1885,12 @@ impl Game<'_> { } } } - let Some((_, new)) = horizon_client::save::decode_block_entity(&tag) else { + let Some((_, mut new)) = horizon_client::save::decode_block_entity(&tag) else { return false; }; + let rolled = self.take_loot_table(key, &tag, &mut new); let after = horizon_client::save::encode_block_entity(key, &new, &name); - if after == before { + if after == before && !rolled { return false; } self.world.block_entities.insert(key, new); @@ -1897,6 +1898,79 @@ impl Game<'_> { let _ = self.world.set(pos[0], pos[1], pos[2], state); true } + /// RandomizableContainer.tryLoadLootTable for a tag a command gives a + /// container (`setblock`, `data`): an empty container with a `LootTable` + /// is rolled now, as a loaded chunk's are (`save::roll_loaded_loot`), and + /// the roll is kept with its chunk, so that the container saves, and + /// `data get` shows, its table and seed until its items change. A tag + /// without one drops what the container had. True when it had a table. + pub(super) fn take_loot_table( + &mut self, + key: (i32, i32, i32), + tag: &horizon_world::nbt::Tag, + entity: &mut horizon_client::containers::BlockEntity, + ) -> bool { + use horizon_client::{containers::BlockEntity, save, structure_blocks}; + let table = save::text(tag.get("LootTable")); + let rolled = match (table, entity) { + (Some(table), BlockEntity::Chest(slots)) if slots.iter().all(Option::is_none) => { + let loot = structure_blocks::loot_data(&self.options.resources); + let at = Vec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2)); + let biome = self.biome_name_at(at).unwrap_or_default(); + Some(structure_blocks::roll_container( + slots, + loot.as_deref(), + table, + structure_blocks::loot_seed(tag), + key, + &biome, + )) + } + _ => None, + }; + let Some(chunk) = self.world.chunks.get_mut(&(key.0 >> 4, key.2 >> 4)) else { + return false; + }; + let held = |c: &horizon_client::chunk::Chunk| { + c.saved + .as_ref() + .is_some_and(|s| s.rolled_loot.iter().any(|r| r.pos == key)) + }; + if rolled.is_none() && !held(chunk) { + return false; + } + let chunk = std::sync::Arc::make_mut(chunk); + let mut extras = chunk + .saved + .take() + .map(std::sync::Arc::unwrap_or_clone) + .unwrap_or_default(); + extras.rolled_loot.retain(|r| r.pos != key); + let taken = rolled.is_some(); + extras.rolled_loot.extend(rolled); + chunk.saved = Some(std::sync::Arc::new(extras)); + taken + } + /// The loot table and seed a container still holding its roll saves + /// (`RolledLoot::restore`), in place of its items. + pub(super) fn restore_loot_table( + &self, + key: (i32, i32, i32), + tag: &mut horizon_world::nbt::Tag, + ) { + let horizon_world::nbt::Tag::Compound(map) = tag else { + return; + }; + let rolled = self + .world + .chunks + .get(&(key.0 >> 4, key.2 >> 4)) + .and_then(|c| c.saved.as_ref()) + .and_then(|s| s.rolled_loot.iter().find(|r| r.pos == key)); + if let Some(r) = rolled { + r.restore(map); + } + } fn cmd_fill(&mut self, ctx: &Context) -> R { let a = self.block_pos_arg(ctx, "from")?; let b = self.block_pos_arg(ctx, "to")?; diff --git a/crates/horizon-client/src/game/commands/data.rs b/crates/horizon-client/src/game/commands/data.rs index 18035ddd7..ac16c5e7c 100644 --- a/crates/horizon-client/src/game/commands/data.rs +++ b/crates/horizon-client/src/game/commands/data.rs @@ -286,6 +286,7 @@ impl Game<'_> { if let Tag::Compound(c) = &mut tag { c.remove(&"keepPacked".into()); } + self.restore_loot_table(key, &mut tag); Ok(tag) } DataRef::Storage(id) => Ok(self.score.storage.get(id)), @@ -296,7 +297,8 @@ impl Game<'_> { DataRef::Entity(t) => self.apply_entity_nbt(*t, tag), DataRef::Block(p) => { let key = (p[0], p[1], p[2]); - if let Some((_, new)) = save::decode_block_entity(&tag) { + if let Some((_, mut new)) = save::decode_block_entity(&tag) { + self.take_loot_table(key, &tag, &mut new); self.world.block_entities.insert(key, new); let state = self.world.block(p[0], p[1], p[2]); // Redraw what shows the block entity (signs, banners). diff --git a/tools/command_exec_corpus.py b/tools/command_exec_corpus.py index 0e3a7f92e..d8f925ef0 100644 --- a/tools/command_exec_corpus.py +++ b/tools/command_exec_corpus.py @@ -241,6 +241,12 @@ def world_blocks(): cmd('/clone 0 205 0 4 207 4 6 205 6 masked'), cmd('/execute if blocks 0 205 0 4 207 4 6 205 6 all'), cmd('/setblock 3 206 3 minecraft:air'), + # A container keeps its loot table and seed until its items change + # (RandomizableContainer.tryLoadLootTable / trySaveLootTable). + cmd('/setblock 7 206 7 minecraft:chest{LootTable:"minecraft:chests/simple_dungeon",LootTableSeed:42L}'), + cmd('/data get block 7 206 7'), + cmd('/data get block 7 206 7 LootTableSeed'), + cmd('/setblock 7 206 7 minecraft:air'), # A hopper placed into power turns `enabled=false` and keeps its block entity. cmd('/setblock 5 205 5 minecraft:redstone_block'), cmd('/setblock 5 206 5 minecraft:hopper'),