diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs index 8ac450bcb..db39f67b8 100644 --- a/crates/horizon-client/src/items.rs +++ b/crates/horizon-client/src/items.rs @@ -251,6 +251,10 @@ pub struct Items { loot: HashMap, /// The `jukebox_song` registry. pub songs: HashMap, + /// The enchantment registry: loot functions enchant the items they roll + /// (`EnchantWithLevelsFunction`, `EnchantRandomlyFunction`), and the + /// station menus share this copy. + pub enchantments: Arc, } /// 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 { 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> { + 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(&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> = 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")) diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs index 715c2663e..c24d8b39f 100644 --- a/crates/horizon-client/src/stations.rs +++ b/crates/horizon-client/src/stations.rs @@ -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, 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),