Merge pull request #2037 from levzzz5154/fix/loot-enchant-functions
🤖 Agent: Gate check by Ludovic's AI agent (Claude). I checked the loot functions against vanilla 26.3 directly. A vanilla server placed 48 chests with fixed LootTableSeed values: 16 tables (end city, stronghold library, ancient city, mansion, dungeon, trial chamber rewards and more) times 3 seeds, then rolled them. Horizon then opened the same world. Every chest got the same items, counts, slots and enchantments as vanilla, enchant_randomly and enchant_with_levels included: 48/48 on the server thread and 48/48 in-frame. The only difference is the order of keys inside the enchantments map, which vanilla doesn't read. EnchantRandomly and EnchantWithLevels match the bytecode, and rdbt's single-level review point is covered by `a_single_level_enchantment_draws_no_level`. It is also built and run in an integration tree with the other open PRs. Thanks @levzzz5154!
This commit is contained in:
@@ -251,6 +251,10 @@ pub struct Items {
|
||||
loot: HashMap<String, Value>,
|
||||
/// The `jukebox_song` registry.
|
||||
pub songs: HashMap<String, Song>,
|
||||
/// The enchantment registry: loot functions enchant the items they roll
|
||||
/// (`EnchantWithLevelsFunction`, `EnchantRandomlyFunction`), and the
|
||||
/// station menus share this copy.
|
||||
pub enchantments: Arc<crate::enchant::Enchantments>,
|
||||
}
|
||||
/// A `JukeboxSong`.
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -701,12 +705,15 @@ impl Items {
|
||||
item_tag_order: load_tag_lists(root, "item")?,
|
||||
loot,
|
||||
songs: load_songs(root),
|
||||
enchantments: Arc::new(crate::enchant::Enchantments::load(root)),
|
||||
})
|
||||
}
|
||||
pub fn get(&self, id: &str) -> Option<&ItemInfo> {
|
||||
self.items.get(id)
|
||||
}
|
||||
/// Only the block and item tags, for tools that need tag membership.
|
||||
/// Only the block and item tags (and the enchantment registry, which the
|
||||
/// station rules and loot functions are built from), for tools that need
|
||||
/// tag membership.
|
||||
pub fn tags_only(root: &Path) -> Result<Self> {
|
||||
Ok(Self {
|
||||
items: HashMap::new(),
|
||||
@@ -717,6 +724,7 @@ impl Items {
|
||||
item_tag_order: load_tag_lists(root, "item")?,
|
||||
loot: HashMap::new(),
|
||||
songs: HashMap::new(),
|
||||
enchantments: Arc::new(crate::enchant::Enchantments::load(root)),
|
||||
})
|
||||
}
|
||||
/// An item table with only tags, for unit tests of item rules.
|
||||
@@ -734,6 +742,7 @@ impl Items {
|
||||
item_tags,
|
||||
loot: HashMap::new(),
|
||||
songs: HashMap::new(),
|
||||
enchantments: Arc::new(crate::enchant::Enchantments::default()),
|
||||
}
|
||||
}
|
||||
/// Whether `block` is in the block tag `tag` (`minecraft:fire`, no `#`).
|
||||
@@ -1371,6 +1380,16 @@ impl LootContext<'_> {
|
||||
self.modifiers(&modifiers, &mut stack, random);
|
||||
produced.push(stack);
|
||||
}
|
||||
/// An enchantment function's `options` (`HolderSet`): a tag, a list or
|
||||
/// one id; every enchantment when absent (`registryAccess().listElements`).
|
||||
fn enchant_pool(e: &crate::enchant::Enchantments, options: &Value) -> Vec<Arc<str>> {
|
||||
match options {
|
||||
Value::String(s) if s.starts_with('#') => e.tag(s).to_vec(),
|
||||
Value::String(s) => vec![Arc::from(s.as_str())],
|
||||
Value::Array(a) => a.iter().filter_map(|x| x.as_str().map(Arc::from)).collect(),
|
||||
_ => e.list.iter().map(|x| Arc::clone(&x.id)).collect(),
|
||||
}
|
||||
}
|
||||
fn modifiers<R: RandomSource>(&self, m: &Value, stack: &mut ItemStack, random: &mut R) {
|
||||
let list: Vec<&Value> = match m {
|
||||
Value::Array(a) => a.iter().collect(),
|
||||
@@ -1449,6 +1468,54 @@ impl LootContext<'_> {
|
||||
.with_potion(id);
|
||||
}
|
||||
}
|
||||
// EnchantWithLevelsFunction: EnchantmentHelper.enchantItem on
|
||||
// the context's random (the End cities' gear).
|
||||
"minecraft:enchant_with_levels" => {
|
||||
let cost = Self::int_number(&f["levels"], random);
|
||||
let e = &self.items.enchantments;
|
||||
let pool = Self::enchant_pool(e, &f["options"]);
|
||||
let chosen = e.select(self.items, random, &stack.item, cost, &pool);
|
||||
// EnchantmentHelper.enchantItem: a book becomes one
|
||||
// enchanted book (the fresh stack's count).
|
||||
if &*stack.item == "minecraft:book" {
|
||||
*stack = ItemStack::new("minecraft:enchanted_book", 1);
|
||||
}
|
||||
for (id, level) in chosen {
|
||||
stack.enchant(&id, level);
|
||||
}
|
||||
}
|
||||
// EnchantRandomlyFunction: one enchantment the item accepts,
|
||||
// at a level between its min and max.
|
||||
"minecraft:enchant_randomly" => {
|
||||
let e = &self.items.enchantments;
|
||||
let book = &*stack.item == "minecraft:book";
|
||||
let only_compatible = f["only_compatible"].as_bool().unwrap_or(true);
|
||||
let options: Vec<Arc<str>> = Self::enchant_pool(e, &f["options"])
|
||||
.into_iter()
|
||||
.filter(|id| {
|
||||
book || !only_compatible || e.can_enchant(self.items, id, &stack.item)
|
||||
})
|
||||
.collect();
|
||||
if options.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let id = options
|
||||
[random.next_int_bound(options.len() as i32).unwrap_or(0) as usize]
|
||||
.clone();
|
||||
let max = e.get(&id).map_or(1, |d| d.max_level).max(1);
|
||||
// `Mth.nextInt(random, 1, max)`: a single-level
|
||||
// enchantment (Mending) returns 1 without drawing, so the
|
||||
// rolls after this one keep vanilla's sequence.
|
||||
let level = if max <= 1 {
|
||||
1
|
||||
} else {
|
||||
1 + random.next_int_bound(max as i32).unwrap_or(0) as u32
|
||||
};
|
||||
if book {
|
||||
*stack = ItemStack::new("minecraft:enchanted_book", 1);
|
||||
}
|
||||
stack.enchant(&id, level);
|
||||
}
|
||||
"minecraft:limit_count" => {
|
||||
let limit = &f["limit"];
|
||||
if let Some(min) = limit["min"].as_i64() {
|
||||
@@ -1658,6 +1725,102 @@ mod tests {
|
||||
assert_eq!(drops[0].potion(), Some("minecraft:fire_resistance"));
|
||||
}
|
||||
|
||||
/// `/loot give` and every other table this dispatcher rolls: the two
|
||||
/// enchantment functions (`EnchantWithLevelsFunction`,
|
||||
/// `EnchantRandomlyFunction`) put their enchantments on the stack.
|
||||
#[test]
|
||||
fn loot_enchant_functions_enchant_the_rolled_item() {
|
||||
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../.local/horizon-client/26.3");
|
||||
if !root.join("items.json").exists() {
|
||||
return;
|
||||
}
|
||||
let assets = crate::assets::Assets::load(&root).unwrap();
|
||||
let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap();
|
||||
let items = Items::load(&root, assets.registry, &facts).unwrap();
|
||||
let props = BTreeMap::new();
|
||||
let mut random = LegacyRandom::new(11);
|
||||
// A sword at levels 20..39 comes out enchanted, as in an End city.
|
||||
let levels = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item",
|
||||
"name":"minecraft:diamond_sword","modifier":[
|
||||
{"type":"minecraft:enchant_with_levels","levels":{"type":"minecraft:uniform","min":20.0,"max":39.0}}]}]}]});
|
||||
let mut enchanted = 0;
|
||||
for _ in 0..40 {
|
||||
let drops = ctx(&items, None, &props, "").evaluate(&levels, &mut random);
|
||||
if drops[0].enchantments().is_empty() {
|
||||
continue;
|
||||
}
|
||||
enchanted += 1;
|
||||
assert_eq!(&*drops[0].item, "minecraft:diamond_sword");
|
||||
// Levels stay within the enchantment's range.
|
||||
for (id, level) in drops[0].enchantments() {
|
||||
let max = items
|
||||
.enchantments
|
||||
.get(id)
|
||||
.expect("a known enchantment")
|
||||
.max_level;
|
||||
assert!((1..=max).contains(level), "{id} at {level}");
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
enchanted > 30,
|
||||
"only {enchanted} of 40 rolls were enchanted"
|
||||
);
|
||||
// `enchant_randomly` on a book makes one enchanted book, its levels
|
||||
// stored; the pool is the enchantment tag it names.
|
||||
let book = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item",
|
||||
"name":"minecraft:book","modifier":[
|
||||
{"type":"minecraft:enchant_randomly","options":"#minecraft:on_random_loot"}]}]}]});
|
||||
let drops = ctx(&items, None, &props, "").evaluate(&book, &mut random);
|
||||
assert_eq!(&*drops[0].item, "minecraft:enchanted_book");
|
||||
assert_eq!(drops[0].count, 1);
|
||||
assert!(drops[0].enchantments().is_empty());
|
||||
let stored = drops[0].stored_enchantments();
|
||||
assert_eq!(stored.len(), 1, "{stored:?}");
|
||||
assert!(
|
||||
items
|
||||
.enchantments
|
||||
.in_tag("minecraft:on_random_loot", &stored[0].0)
|
||||
);
|
||||
// An item no enchantment accepts keeps none of them.
|
||||
let dirt = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item",
|
||||
"name":"minecraft:dirt","modifier":[
|
||||
{"type":"minecraft:enchant_with_levels","levels":{"type":"minecraft:constant","value":30.0}}]}]}]});
|
||||
let drops = ctx(&items, None, &props, "").evaluate(&dirt, &mut random);
|
||||
assert!(drops[0].enchantments().is_empty());
|
||||
}
|
||||
|
||||
/// `Mth.nextInt(random, 1, max)` returns `1` without drawing when the
|
||||
/// enchantment has one level (`EnchantRandomlyFunction.enchantItem`), so
|
||||
/// the rolls after it must not shift. Vanilla with `LegacyRandom(11)`: a
|
||||
/// Mending book, then `set_count` uniform 1..64, is 46.
|
||||
#[test]
|
||||
fn a_single_level_enchantment_draws_no_level() {
|
||||
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../.local/horizon-client/26.3");
|
||||
if !root.join("items.json").exists() {
|
||||
return;
|
||||
}
|
||||
let assets = crate::assets::Assets::load(&root).unwrap();
|
||||
let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap();
|
||||
let items = Items::load(&root, assets.registry, &facts).unwrap();
|
||||
let props = BTreeMap::new();
|
||||
let table = json!({"pools":[{"rolls":1,"entries":[{"type":"minecraft:item",
|
||||
"name":"minecraft:book","modifier":[
|
||||
{"type":"minecraft:enchant_randomly","options":"minecraft:mending"},
|
||||
{"type":"minecraft:set_count","count":{"type":"minecraft:uniform","min":1.0,"max":64.0}}]}]}]});
|
||||
let drops = ctx(&items, None, &props, "").evaluate(&table, &mut LegacyRandom::new(11));
|
||||
assert_eq!(drops.len(), 1);
|
||||
assert_eq!(&*drops[0].item, "minecraft:enchanted_book");
|
||||
assert_eq!(
|
||||
drops[0].stored_enchantments(),
|
||||
[("minecraft:mending".to_owned().into(), 1)],
|
||||
"the book keeps its single-level enchantment"
|
||||
);
|
||||
// 46 is vanilla's count for this seed; an extra level draw gives 28.
|
||||
assert_eq!(drops[0].count, 46);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn always_edible_and_consume_effects_loaded() {
|
||||
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
|
||||
@@ -14,7 +14,8 @@ use std::{fs, path::Path, sync::Arc};
|
||||
|
||||
/// Everything the workstation menus read, loaded once with the resources.
|
||||
pub struct StationData {
|
||||
pub enchantments: Enchantments,
|
||||
/// The same registry `Items` carries (`Items::enchantments`).
|
||||
pub enchantments: std::sync::Arc<Enchantments>,
|
||||
pub recipes: StationRecipes,
|
||||
pub brewing: crate::brewing::Brewing,
|
||||
pub trades: crate::merchant::Trades,
|
||||
@@ -25,7 +26,7 @@ pub struct StationData {
|
||||
impl StationData {
|
||||
pub fn load(root: &Path, items: &Items) -> Self {
|
||||
Self {
|
||||
enchantments: Enchantments::load(root),
|
||||
enchantments: std::sync::Arc::clone(&items.enchantments),
|
||||
recipes: StationRecipes::load(root, items),
|
||||
brewing: crate::brewing::Brewing::load(root, items),
|
||||
trades: crate::merchant::Trades::load(root),
|
||||
|
||||
Reference in New Issue
Block a user