From be85b81d136d81054da2b370a3f138752d671f63 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 19 Oct 2026 02:50:14 +0200 Subject: [PATCH] YUNG's assembler: modifiers, piece_in_range and dead-end pools Better Nether Fortresses relies on three parts of YUNG's API the game did not have: - piece_in_range: another piece (of some templates, or any) inside the piece's box grown sideways, below and above. - Modifiers, applied once the layout is done, in piece order and with the assembler's random: a condition, then actions on the piece itself. transform swaps its template for one picked by setFeatureSeed(x, y, x) and moves it by an offset turned with the piece; delay_generation moves it to the end of the piece list. - Dead-end pools: a piece that got no child though it has other jigsaws is taken out (its parent's junction, its room and its count given back) and a piece of its dead-end pool is chosen for the same parent jigsaw. Co-Authored-By: Claude Opus 5.5 --- .../src/worldgen/structure/jigsaw.rs | 4 +- .../src/worldgen/structure/yung.rs | 447 ++++++++++++++++-- 2 files changed, 422 insertions(+), 29 deletions(-) diff --git a/crates/horizon-world/src/worldgen/structure/jigsaw.rs b/crates/horizon-world/src/worldgen/structure/jigsaw.rs index 34a2728f4..27651268d 100644 --- a/crates/horizon-world/src/worldgen/structure/jigsaw.rs +++ b/crates/horizon-world/src/worldgen/structure/jigsaw.rs @@ -30,7 +30,7 @@ pub enum Projection { Rigid, TerrainMatching, } -#[derive(Debug)] +#[derive(Clone, Debug)] pub enum PoolElement { Empty, Single { @@ -400,7 +400,7 @@ impl Pools { } } -#[derive(Clone, Copy, Debug)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Junction { pub source_x: i32, pub source_ground_y: i32, diff --git a/crates/horizon-world/src/worldgen/structure/yung.rs b/crates/horizon-world/src/worldgen/structure/yung.rs index 07b363cfb..8298dfb4a 100644 --- a/crates/horizon-world/src/worldgen/structure/yung.rs +++ b/crates/horizon-world/src/worldgen/structure/yung.rs @@ -9,7 +9,10 @@ //! priority piece first), lays pieces out breadth first, caps pieces by name //! (`max_count`), limits them by depth, lets some ignore the bounds, checks //! each piece's condition, and keeps every piece between `min_y` and -//! `max_y`. Pieces fit the same free space as vanilla's. +//! `max_y`. Pieces fit the same free space as vanilla's. A piece that ends +//! up with no child can be swapped for one of a dead-end pool, and once the +//! layout is done each piece's modifiers can turn it into another template +//! or place it last. use super::{ BoundingBox, Rotation, StructureResources, StructureTemplate, jigsaw::{ @@ -21,7 +24,7 @@ use crate::{ heightmap::HeightmapType, worldgen::{DecodeError, block_feature::FeatureBlockBindings}, }; -use horizon_core::random::RandomSource; +use horizon_core::random::{LegacyRandom, RandomSource, WorldgenRandom}; use serde_json::Value; use std::{ cell::RefCell, @@ -48,7 +51,7 @@ impl Config { } /// A piece's rules (`"horizon:yungsapi"` on a pool element). -#[derive(Debug, Default)] +#[derive(Clone, Debug, Default)] pub struct Rules { /// Pieces sharing a name share the cap `max_count`. name: Option, @@ -60,6 +63,10 @@ pub struct Rules { /// Placed even where it overlaps other pieces or leaves the bounds. ignore_bounds: bool, condition: Condition, + /// The pool a piece that got no child is swapped for. + deadend_pool: Option, + /// Applied to the piece once the layout is done. + modifiers: Vec, } impl Rules { pub fn decode(v: &Value, resources: &StructureResources) -> Result { @@ -75,6 +82,13 @@ impl Rules { Some(c) => Condition::decode(c, resources)?, None => Condition::True, }, + deadend_pool: v["deadend_pool"].as_str().map(str::to_owned), + modifiers: v["modifiers"] + .as_array() + .into_iter() + .flatten() + .map(|m| Modifier::decode(m, resources)) + .collect::>()?, }) } /// YungJigsawPoolElement.isAtValidDepth. @@ -88,8 +102,79 @@ impl Rules { } } +/// A StructureModifier: when its condition holds for the piece, its actions +/// apply to the piece (the `self` target, the only one YUNG's API has). +#[derive(Clone, Debug)] +struct Modifier { + condition: Condition, + actions: Vec, +} +impl Modifier { + fn decode(v: &Value, resources: &StructureResources) -> Result { + Ok(Self { + condition: match v.get("condition") { + Some(c) => Condition::decode(c, resources)?, + None => Condition::True, + }, + actions: v["actions"] + .as_array() + .ok_or(DecodeError::Field("modifier actions"))? + .iter() + .map(|a| Action::decode(a, resources)) + .collect::>()?, + }) + } +} + +#[derive(Clone, Debug)] +enum Action { + /// TransformAction: the piece becomes one of these templates, moved by + /// `offset` turned with the piece. + Transform { + output: Vec>, + offset: [i32; 3], + }, + /// DelayGenerationAction: the piece is placed after every other. + DelayGeneration, +} +impl Action { + fn decode(v: &Value, resources: &StructureResources) -> Result { + Ok(match v["type"].as_str().unwrap_or_default() { + "transform" => { + let output = v["output"] + .as_array() + .into_iter() + .flatten() + .map(|t| { + let id = t.as_str().ok_or(DecodeError::Field("transform output"))?; + resources + .template(id) + .ok_or_else(|| DecodeError::Registry(format!("missing template {id}"))) + }) + .collect::, _>>()?; + if output.is_empty() { + return Err(DecodeError::Field("transform output")); + } + let offset = v["offset"].as_array(); + let at = |i: usize| { + offset + .and_then(|o| o.get(i)) + .and_then(Value::as_i64) + .unwrap_or(0) as i32 + }; + Self::Transform { + output, + offset: [at(0), at(1), at(2)], + } + } + "delay_generation" => Self::DelayGeneration, + _ => return Err(DecodeError::Field("YUNG modifier action type")), + }) + } +} + /// YUNG's structure conditions, as carry writes them. -#[derive(Debug, Default)] +#[derive(Clone, Debug, Default)] enum Condition { #[default] True, @@ -114,6 +199,14 @@ enum Condition { range: i32, rotation: Rotation, }, + /// Another piece (of these templates, or any when None) within the + /// piece's box grown by these ranges, not overlapping the piece. + PieceInRange { + templates: Option>>, + horizontal: i32, + above: i32, + below: i32, + }, } impl Condition { fn decode(v: &Value, resources: &StructureResources) -> Result { @@ -163,6 +256,26 @@ impl Condition { range: int("range").unwrap_or(0), rotation: rotation(&v["rotation"])?, }, + "piece_in_range" => { + let pieces = v["pieces"] + .as_array() + .map(Vec::as_slice) + .unwrap_or_default(); + let any = pieces.is_empty() || pieces.iter().any(|p| p == "yungsapi:all"); + Self::PieceInRange { + // An unknown template matches nothing, as YUNG's API's + // empty stand-in does. + templates: (!any).then(|| { + pieces + .iter() + .filter_map(|p| resources.template(p.as_str()?)) + .collect() + }), + horizontal: int("horizontal_range").unwrap_or(0), + above: int("above_range").unwrap_or(0), + below: int("below_range").unwrap_or(0), + } + } _ => return Err(DecodeError::Field("YUNG condition type")), }) } @@ -179,7 +292,7 @@ impl Condition { min.is_none_or(|d| d <= at.depth) && max.is_none_or(|d| d >= at.depth) } Self::Altitude { bottom, top } => { - let [low, high] = at.piece.map_or([0, 0], |b| [b.min[1], b.max[1]]); + let [low, high] = at.span; bottom.is_none_or(|y| f64::from(low) >= y) && top.is_none_or(|y| f64::from(high) <= y) } @@ -200,16 +313,35 @@ impl Condition { Rotation::Clockwise180 => search.max[2] += range, Rotation::Counterclockwise90 => search.min[0] -= range, } - at.pieces.iter().any(|other| { - let PoolElement::Single { template, .. } = other.element.as_ref() else { - return false; - }; - let b = other.bounding_box; - b != piece - && (templates.is_empty() - || templates.iter().any(|t| Arc::ptr_eq(t, template))) - && b.intersects(&search) - && !b.intersects(&piece) + at.near(piece, &search, |template| { + templates.is_empty() || templates.iter().any(|t| Arc::ptr_eq(t, template)) + }) + } + Self::PieceInRange { + templates, + horizontal, + above, + below, + } => { + let Some(piece) = at.piece else { + return false; + }; + let search = BoundingBox::new( + [ + piece.min[0] - horizontal, + piece.min[1] - below, + piece.min[2] - horizontal, + ], + [ + piece.max[0] + horizontal, + piece.max[1] + above, + piece.max[2] + horizontal, + ], + ); + at.near(piece, &search, |template| { + templates + .as_ref() + .is_none_or(|ts| ts.iter().any(|t| Arc::ptr_eq(t, template))) }) } } @@ -226,12 +358,38 @@ impl JigsawContextDyn for C { } } -/// What a condition sees of the piece being placed. +/// What a condition sees of the piece being placed (or modified). struct At<'a> { depth: i32, rotation: Rotation, piece: Option, + /// The piece's lowest and highest Y when the condition was set up. + span: [i32; 2], pieces: &'a [PoolPiece], + /// Pieces taken out by a dead end, by index; the rest are kept. + gone: &'a [bool], +} +impl At<'_> { + /// Whether another single piece whose template matches lies in `search` + /// without overlapping `piece` (nor being exactly it). + fn near( + &self, + piece: BoundingBox, + search: &BoundingBox, + matches: impl Fn(&Arc) -> bool, + ) -> bool { + self.pieces.iter().enumerate().any(|(i, other)| { + let PoolElement::Single { template, .. } = other.element.as_ref() else { + return false; + }; + let b = other.bounding_box; + !self.gone.get(i).copied().unwrap_or(false) + && b != piece + && matches(template) + && b.intersects(search) + && !b.intersects(&piece) + }) + } } /// The index of the entry to try: the first priority piece, else one drawn @@ -300,7 +458,9 @@ pub fn assemble( depth: 0, rotation, piece: None, + span: [0, 0], pieces: &[], + gone: &[], }; if element .yung() @@ -342,6 +502,8 @@ pub fn assemble( bindings, pieces: vec![start], states: vec![(free, 0)], + origins: vec![None], + gone: vec![false], counts: HashMap::new(), }; if config.max_depth > 0 { @@ -350,7 +512,7 @@ pub fn assemble( assembler.children(piece, &mut queue, context, random); } } - Some(([cx, cy, cz], assembler.pieces)) + Some(([cx, cy, cz], assembler.modified(random))) } /// JigsawStructureAssembler. @@ -363,14 +525,20 @@ struct Assembler<'a> { pieces: Vec, /// Per piece: the free space it was placed in, and its depth. states: Vec<(Rc>, i32)>, + /// Per piece: where it was placed and the junction it left on its + /// parent (none for the start piece), for a dead end to undo. + origins: Vec>, + /// Per piece: taken out by a dead end. + gone: Vec, /// Pieces placed per capped name. counts: HashMap, } /// Where a child goes: the parent's jigsaw and what it needs. -struct Slot<'s> { +#[derive(Clone)] +struct Slot { source: usize, - jigsaw: &'s super::jigsaw::Jigsaw, + jigsaw: super::jigsaw::Jigsaw, target_pos: [i32; 3], free: Rc>, depth: i32, @@ -403,7 +571,10 @@ impl Assembler<'_> { }; let (context_free, depth) = self.states[source].clone(); let mut source_free: Option>> = None; - for jigsaw in element.shuffled_jigsaws(self.resources, position, rotation, random) { + let jigsaws = element.shuffled_jigsaws(self.resources, position, rotation, random); + let count = jigsaws.len(); + let mut any = false; + for jigsaw in jigsaws { let Some(target) = self.pool(&jigsaw.pool) else { continue; }; @@ -432,28 +603,119 @@ impl Assembler<'_> { }; let slot = Slot { source, - jigsaw: &jigsaw, + jigsaw, target_pos, free, depth, }; let placed = depth != self.config.max_depth && self.choose(&slot, target.raw.clone(), queue, context, random); - if !placed { - self.choose(&slot, fallback.raw.clone(), queue, context, random); + any |= placed || self.choose(&slot, fallback.raw.clone(), queue, context, random); + } + if let Some(pool) = element.yung().and_then(|r| r.deadend_pool.as_deref()) + && !any + && count > 1 + { + self.dead_end(source, pool, queue, context, random); + } + } + /// A piece with a dead-end pool that got no child though it has other + /// jigsaws is taken out, its parent's junction and its room freed and its + /// count given back, and a piece of that pool is chosen in its place for + /// the same parent jigsaw. The start piece stays. + fn dead_end( + &mut self, + piece: usize, + pool: &str, + queue: &mut VecDeque, + context: &mut impl JigsawContext, + random: &mut impl RandomSource, + ) { + let Some(pool) = self.pool(pool) else { + return; + }; + let Some((slot, junction)) = self.origins[piece].clone() else { + return; + }; + let parent = &mut self.pieces[slot.source].junctions; + if let Some(i) = parent.iter().position(|j| *j == junction) { + parent.remove(i); + } + let bounds = self.pieces[piece].bounding_box; + { + let mut free = slot.free.borrow_mut(); + if let Some(i) = free.removed.iter().position(|b| *b == bounds) { + free.removed.remove(i); } } + self.gone[piece] = true; + let element = self.pieces[piece].element.clone(); + if let Some((name, _)) = element.yung().and_then(Rules::capped) + && let Some(count) = self.counts.get_mut(name) + { + *count -= 1; + } + self.choose(&slot, pool.raw.clone(), queue, context, random); + } + /// applyModifications: each piece's modifiers, in piece order, then the + /// delayed pieces moved last. Returns the pieces kept. + fn modified(mut self, random: &mut impl RandomSource) -> Vec { + let mut delayed = vec![false; self.pieces.len()]; + for (i, delay) in delayed.iter_mut().enumerate() { + let element = self.pieces[i].element.clone(); + let Some(rules) = element + .yung() + .filter(|r| !self.gone[i] && !r.modifiers.is_empty()) + else { + continue; + }; + let b = self.pieces[i].bounding_box; + let (depth, rotation, span) = ( + self.states[i].1, + self.pieces[i].rotation, + [b.min[1], b.max[1]], + ); + for modifier in &rules.modifiers { + let at = At { + depth, + rotation, + piece: Some(self.pieces[i].bounding_box), + span, + pieces: &self.pieces, + gone: &self.gone, + }; + if !modifier.condition.passes(&at, random) { + continue; + } + for action in &modifier.actions { + match action { + Action::Transform { output, offset } => { + transform(&mut self.pieces[i], output, *offset); + } + Action::DelayGeneration => *delay = true, + } + } + } + } + let (mut kept, mut last) = (Vec::new(), Vec::new()); + for ((piece, gone), delay) in self.pieces.into_iter().zip(self.gone).zip(delayed) { + if !gone { + if delay { &mut last } else { &mut kept }.push(piece); + } + } + kept.extend(last); + kept } /// chooseCandidateFromPool: whether a piece was placed. fn choose( &mut self, - slot: &Slot<'_>, + slot: &Slot, mut candidates: Vec<(Arc, i32)>, queue: &mut VecDeque, context: &mut impl JigsawContext, random: &mut impl RandomSource, ) -> bool { - let jigsaw = slot.jigsaw; + let jigsaw = &slot.jigsaw; let (source_rigid, source_y, source_ground) = { let s = &self.pieces[slot.source]; ( @@ -561,16 +823,19 @@ impl Assembler<'_> { depth: slot.depth + 1, rotation, piece: Some(target_box), + span: [target_box.min[1], target_box.max[1]], pieces: &self.pieces, + gone: &self.gone, }; if rules.is_some_and(|r| !r.condition.passes(&at, random)) { continue; } - self.pieces[slot.source].junctions.push(Junction { + let on_parent = Junction { source_x: slot.target_pos[0], source_ground_y: junction_y - local_y + source_ground, source_z: slot.target_pos[2], - }); + }; + self.pieces[slot.source].junctions.push(on_parent); slot.free.borrow_mut().removed.push(target_box); self.pieces.push(PoolPiece { element: target.clone(), @@ -586,6 +851,8 @@ impl Assembler<'_> { waterlogging: self.config.waterlogging, }); self.states.push((slot.free.clone(), slot.depth + 1)); + self.origins.push(Some((slot.clone(), on_parent))); + self.gone.push(false); if slot.depth < self.config.max_depth { queue.push_back(self.pieces.len() - 1); } @@ -602,6 +869,39 @@ impl Assembler<'_> { } } +/// TransformAction: the piece takes one of `output`'s templates, picked by a +/// random seeded with setFeatureSeed(x, y, x) of its position, and moves by +/// `offset` turned with it. Like YUNG's API's new piece, it loses its +/// junctions and takes its own liquid setting (else waterlogging). +fn transform(piece: &mut PoolPiece, output: &[Arc], offset: [i32; 3]) { + let [x, y, _] = piece.position; + let mut random = WorldgenRandom::new(LegacyRandom::new(0)); + random.set_feature_seed(i64::from(x), y, x); + let chosen = random.next_int_bound(output.len() as i32).unwrap_or(0) as usize; + let mut element = (*piece.element).clone(); + let PoolElement::Single { + template, + waterlogging, + .. + } = &mut element + else { + return; + }; + *template = output[chosen].clone(); + piece.waterlogging = waterlogging.unwrap_or(true); + let [dx, dy, dz] = offset; + let [dx, dz] = match piece.rotation { + Rotation::None => [dx, dz], + Rotation::Clockwise90 => [-dz, dx], + Rotation::Clockwise180 => [-dx, -dz], + Rotation::Counterclockwise90 => [dz, -dx], + }; + piece.position = [x + dx, y + dy, piece.position[2] + dz]; + piece.bounding_box = element.bounding_box(piece.position, piece.rotation); + piece.element = Arc::new(element); + piece.junctions.clear(); +} + #[cfg(test)] mod tests { use super::*; @@ -680,7 +980,9 @@ mod tests { depth, rotation, piece: Some(BoundingBox::new([0, 10, 0], [4, 14, 4])), + span: [10, 14], pieces: &pieces, + gone: &[], }; let mut random = LegacyRandom::new(1); let depth = Condition::Depth { @@ -704,6 +1006,7 @@ mod tests { assert!(!north(Vec::new(), Rotation::None).passes(&at(Rotation::None, 1), &mut random)); let low = At { piece: Some(BoundingBox::new([0, 0, 0], [4, 4, 4])), + span: [0, 4], ..at(Rotation::None, 1) }; assert!(north(Vec::new(), Rotation::None).passes(&low, &mut random)); @@ -724,4 +1027,94 @@ mod tests { assert!(all.passes(&turned, &mut random)); assert!(!Condition::AnyOf(vec![Condition::False]).passes(&turned, &mut random)); } + + #[test] + fn piece_in_range_searches_a_grown_box() { + let t = Arc::new(StructureTemplate::empty()); + let other = Arc::new(StructureTemplate::empty()); + let piece = BoundingBox::new([0, 0, 0], [4, 4, 4]); + let above = |gone: &'static [bool]| { + let pieces = vec![PoolPiece { + element: single(&t, None), + position: [0, 30, 0], + ground_level_delta: 1, + rotation: Rotation::None, + bounding_box: BoundingBox::new([0, 30, 0], [4, 34, 4]), + junctions: Vec::new(), + waterlogging: true, + }]; + (pieces, gone) + }; + let range = |templates, above| Condition::PieceInRange { + templates, + horizontal: 0, + above, + below: 0, + }; + let mut random = LegacyRandom::new(1); + let (pieces, gone) = above(&[]); + let at = At { + depth: 1, + rotation: Rotation::None, + piece: Some(piece), + span: [0, 4], + pieces: &pieces, + gone, + }; + // 26 blocks above the piece's top: in a 40-block search, not 20. + assert!(range(None, 40).passes(&at, &mut random)); + assert!(!range(None, 20).passes(&at, &mut random)); + assert!(range(Some(vec![t.clone()]), 40).passes(&at, &mut random)); + assert!(!range(Some(vec![other]), 40).passes(&at, &mut random)); + // An unknown template matches nothing; a piece taken out by a dead + // end is not seen. + assert!(!range(Some(Vec::new()), 40).passes(&at, &mut random)); + let (pieces, gone) = above(&[true]); + let at = At { + pieces: &pieces, + gone, + ..at + }; + assert!(!range(None, 40).passes(&at, &mut random)); + } + + #[test] + fn transform_picks_by_position_and_turns_its_offset() { + let (a, b) = ( + Arc::new(StructureTemplate::empty()), + Arc::new(StructureTemplate::empty()), + ); + let rules = Rules { + name: Some("pillar".into()), + ..Rules::default() + }; + let mut piece = PoolPiece { + element: single(&a, Some(rules)), + position: [100, 40, -7], + ground_level_delta: 1, + rotation: Rotation::Clockwise90, + bounding_box: BoundingBox::new([100, 40, -7], [104, 44, -3]), + junctions: vec![Junction { + source_x: 0, + source_ground_y: 0, + source_z: 0, + }], + waterlogging: false, + }; + transform(&mut piece, &[a.clone(), b.clone()], [-1, 2, 0]); + // setFeatureSeed(x, y, x): seed x + y + 10000 * x, then nextInt(2). + let mut java = LegacyRandom::new(100 + 40 + 10000 * 100); + let chosen = [&a, &b][java.next_int_bound(2).unwrap() as usize]; + let PoolElement::Single { template, yung, .. } = piece.element.as_ref() else { + panic!("not a single element"); + }; + assert!(Arc::ptr_eq(template, chosen)); + assert_eq!( + yung.as_ref().and_then(|r| r.name.as_deref()), + Some("pillar") + ); + // (-1, 2, 0) turned 90° clockwise is (0, 2, -1). + assert_eq!(piece.position, [100, 42, -8]); + assert!(piece.junctions.is_empty() && piece.waterlogging); + } }