Merge remote-tracking branch 'origin/worktree-agent-a2bb16cfb9ff4be19' into t3code/rewrite-minecraft-rust

# Conflicts:
#	tools/prepare_native_client.py
This commit is contained in:
Ludovic Marie
2026-10-08 11:18:39 +02:00
23 changed files with 5942 additions and 6 deletions
+111 -1
View File
@@ -96,7 +96,7 @@ fn verify(data: &std::sync::Arc<GeneratorData>, parity: &Path) -> Result<(), Err
];
let mut expected = Vec::new();
for (seed, x, z) in cases {
let generator = OverworldGenerator::new(data.clone(), seed)?;
let generator = OverworldGenerator::without_structures(data.clone(), seed)?;
let lines = dump(&generator.worker().generate_proto(ChunkPos::new(x, z))?);
if let Ok(path) = std::env::var("HORIZON_VERIFY_DUMP") {
fs::write(format!("{path}{seed}.txt"), lines.join("\n") + "\n")?;
@@ -146,6 +146,82 @@ fn verify(data: &std::sync::Arc<GeneratorData>, parity: &Path) -> Result<(), Err
}
}
/// Structure starts in the oracle's line format (VanillaStructureStartOracle).
fn dump_starts(
generator: &OverworldGenerator,
seed: i64,
[x0, z0, x1, z1]: [i32; 4],
out: &Path,
) -> Result<(), Error> {
use horizon_world::worldgen::structure::{Rotation, start::Piece};
let _ = seed;
let mut worker = generator.worker();
let mut lines = Vec::new();
let start = Instant::now();
for cx in x0..=x1 {
for cz in z0..=z1 {
for s in worker.structure_starts(ChunkPos::new(cx, cz)) {
let b = s.bounding_box;
lines.push(format!(
"start {cx} {cz} {} {} {} {} {} {} {} {}",
s.name,
b.min[0],
b.min[1],
b.min[2],
b.max[0],
b.max[1],
b.max[2],
s.pieces.len()
));
for piece in &s.pieces {
let Piece::Pool(p) = piece else {
let b = piece.bounding_box();
lines.push(format!(
"piece {} {} {} {} {} {} {}",
piece.type_name(),
b.min[0],
b.min[1],
b.min[2],
b.max[0],
b.max[1],
b.max[2]
));
continue;
};
let b = p.bounding_box;
let rotation = match p.rotation {
Rotation::None => "NONE",
Rotation::Clockwise90 => "CLOCKWISE_90",
Rotation::Clockwise180 => "CLOCKWISE_180",
Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90",
};
lines.push(format!(
"piece minecraft:jigsaw {} {} {} {} {} {} {} {} {} {rotation} {} {}",
b.min[0],
b.min[1],
b.min[2],
b.max[0],
b.max[1],
b.max[2],
p.position[0],
p.position[1],
p.position[2],
p.ground_level_delta,
p.junctions.len()
));
}
}
}
}
println!(
"structure starts for {} chunks in {:.2?}",
(x1 - x0 + 1) * (z1 - z0 + 1),
start.elapsed()
);
fs::write(out, lines.join("\n") + "\n")?;
Ok(())
}
/// Process CPU seconds (Linux), robust against other load on shared machines.
fn cpu_seconds() -> f64 {
fs::read_to_string("/proc/self/stat")
@@ -165,6 +241,11 @@ fn glyph(name: &str) -> char {
match name {
"water" => '~',
"lava" => '!',
"dirt_path" => '_',
"cobblestone" | "mossy_cobblestone" => 'o',
"hay_block" => 'h',
_ if name.ends_with("planks") || name.ends_with("stairs") || name.ends_with("slab") => 'P',
_ if name.contains("glass") => 'g',
"grass_block" => '"',
"sand" | "suspicious_sand" => '.',
"red_sand" => ',',
@@ -193,6 +274,7 @@ fn main() -> Result<(), Error> {
let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0));
let mut parity = None;
let mut decorate = true;
let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None;
while let Some(arg) = args.next() {
let mut next = || args.next().expect("argument value");
match arg.as_str() {
@@ -202,6 +284,15 @@ fn main() -> Result<(), Error> {
"--center" => center = (next().parse()?, next().parse()?),
"--verify" => parity = Some(PathBuf::from(next())),
"--no-decorate" => decorate = false,
"--starts" => {
starts = Some((
next().parse()?,
next().parse()?,
next().parse()?,
next().parse()?,
PathBuf::from(next()),
))
}
_ => return Err(format!("unknown argument {arg}").into()),
}
}
@@ -215,6 +306,10 @@ fn main() -> Result<(), Error> {
let start = Instant::now();
let generator = OverworldGenerator::new(data.clone(), seed)?;
println!("seeded generator in {:.2?}", start.elapsed());
if let Some((x0, z0, x1, z1, out)) = starts {
dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?;
return Ok(());
}
let (x0, z0) = (center.0 - size / 2, center.1 - size / 2);
let count = (size * size) as usize;
let next = AtomicUsize::new(0);
@@ -350,6 +445,21 @@ fn main() -> Result<(), Error> {
);
}
}
let mut structures = BTreeMap::<(String, i32, i32), [[i32; 3]; 2]>::new();
for chunk in chunks.iter().flatten() {
for (name, start, min, max) in chunk.structures() {
structures.insert((name.to_owned(), start.x, start.z), [min, max]);
}
}
for ((name, x, z), [min, max]) in &structures {
println!("structure {name} start chunk ({x}, {z}) box {min:?}..{max:?}");
}
let block_entities: usize = chunks
.iter()
.flatten()
.map(|c| c.block_entities.len())
.sum();
println!("block entities: {block_entities}");
let mut legend = BTreeMap::<char, BTreeMap<String, usize>>::new();
let step = (size * 16 / 96).max(1);
for bz in (0..size * 16).step_by(step as usize) {
+2
View File
@@ -40,6 +40,7 @@ pub mod fungus;
pub mod generator;
mod generator_blocks;
mod generator_decoration;
mod generator_structures;
pub mod height_provider;
pub mod iceberg;
pub mod material_condition;
@@ -61,6 +62,7 @@ pub mod speleothem;
pub mod spike;
pub mod spring;
pub mod state_provider;
pub mod structure;
pub mod tags;
pub mod terrain;
pub mod tree;
@@ -30,10 +30,19 @@ pub struct FeatureBlockBindings<'r> {
pub(crate) tags: BTreeMap<String, Arc<BTreeSet<BlockStateId>>>,
pub(crate) air: [BlockStateId; 3],
tree_blocks: std::sync::OnceLock<Arc<super::tree_blocks::TreeBlocks>>,
pub(crate) structures: Option<Arc<super::structure::StructureResources>>,
}
impl<'r> FeatureBlockBindings<'r> {
/// Shared tree/vegetation classifications, built on first use. Requires
/// state-provider and block-property bindings.
/// Bind structure templates and processor lists for template features.
pub fn with_structures(
mut self,
structures: Arc<super::structure::StructureResources>,
) -> Self {
self.structures = Some(structures);
self
}
pub(crate) fn tree_blocks(&self) -> Result<Arc<super::tree_blocks::TreeBlocks>, DecodeError> {
if let Some(blocks) = self.tree_blocks.get() {
return Ok(blocks.clone());
@@ -154,6 +163,7 @@ impl<'r> FeatureBlockBindings<'r> {
.collect(),
tags: bound_tags,
tree_blocks: std::sync::OnceLock::new(),
structures: None,
air: [
get("minecraft:air")?,
get("minecraft:cave_air")?,
@@ -75,6 +75,33 @@ impl FeatureDecorationPlan {
world: &mut W,
chunk: ChunkPos,
world_seed: i64,
place: impl FnMut(
&mut W,
&mut FeaturePlacer,
&mut WorldgenRandom<XoroshiroRandom>,
FeatureIdentity,
[i32; 3],
) -> Result<bool, W::Error>,
) -> Result<(), DecorationError<W::Error>> {
self.decorate(world, chunk, world_seed, 0, |_, _, _, _| Ok(()), place)
}
/// Like `decorate_features`, running `structures` at the start of each of
/// `max(structure_steps, feature steps)` steps, before that step's
/// features (vanilla applyBiomeDecoration). It receives the shared random
/// and decoration seed; it seeds per structure itself.
pub fn decorate<W: DecorationWorld>(
&self,
world: &mut W,
chunk: ChunkPos,
world_seed: i64,
structure_steps: usize,
mut structures: impl FnMut(
&mut W,
&mut WorldgenRandom<XoroshiroRandom>,
i64,
usize,
) -> Result<(), W::Error>,
mut place: impl FnMut(
&mut W,
&mut FeaturePlacer,
@@ -114,7 +141,11 @@ impl FeatureDecorationPlan {
}
}
let mut placer = FeaturePlacer::new();
for (step, data) in self.steps.iter().enumerate() {
for step in 0..structure_steps.max(self.steps.len()) {
structures(world, &mut random, seed, step).map_err(DecorationError::World)?;
let Some(data) = self.steps.get(step) else {
continue;
};
let mut selected = BTreeSet::new();
for biome in &present {
if let Some(features) = self.biomes[biome].get(step) {
@@ -86,6 +86,8 @@ pub enum FeatureDefinition {
SteppedColumnCluster(Box<super::projected::SteppedColumnClusterFeature>),
FallenTree(Box<super::tree::FallenTreeFeature>),
NoOp,
Template(Box<super::structure::features::TemplateFeature>),
Fossil(Box<super::structure::features::FossilFeature>),
WeightedChoice(OptionalWeightedList<PlacedFeatureDefinition>),
Sequence(Vec<PlacedFeatureDefinition>),
Overlay(Vec<PlacedFeatureDefinition>),
@@ -312,6 +314,16 @@ impl FeatureDefinition {
)?)?;
match kind.as_str() {
"minecraft:no_op" => Ok(Self::NoOp),
"minecraft:template" => super::structure::features::TemplateFeature::decode(
json,
blocks.ok_or(DecodeError::Field("template bindings"))?,
)
.map(|f| Self::Template(Box::new(f))),
"minecraft:fossil" => super::structure::features::FossilFeature::decode(
json,
blocks.ok_or(DecodeError::Field("fossil bindings"))?,
)
.map(|f| Self::Fossil(Box::new(f))),
"minecraft:freeze_top_layer" => super::snow_freeze::SnowAndFreezeFeature::new(
blocks.ok_or(DecodeError::Field("snow and freeze bindings"))?,
)
@@ -843,6 +855,12 @@ impl FeatureDefinition {
.place(world, random, origin, run.blocks)
.map_err(FeatureExecutionError::Basic),
Self::NoOp => Ok(true),
Self::Template(feature) => feature
.place(world, random, origin)
.map_err(FeatureExecutionError::Query),
Self::Fossil(feature) => feature
.place(world, random, origin)
.map_err(FeatureExecutionError::Query),
Self::SnowAndFreeze(feature) => feature
.place(world, origin)
.map_err(FeatureExecutionError::SnowAndFreeze),
@@ -147,6 +147,13 @@ pub(super) struct FeatureResources {
pub(super) blocks: Option<super::generator_blocks::BlockBehavior>,
}
/// Raw structure, structure-set and template-pool resources.
pub(super) struct StructureBundles {
pub(super) structures: BTreeMap<String, String>,
pub(super) sets: BTreeMap<String, String>,
pub(super) pools: BTreeMap<String, String>,
}
/// Seed-independent generation resources, loaded once and shared by every
/// generator. Biome identities are indices into the sorted biome registry.
pub struct GeneratorData {
@@ -170,6 +177,9 @@ pub struct GeneratorData {
pub(super) block_tags: BTreeMap<String, Vec<String>>,
pub(super) biome_tags: BTreeMap<String, Vec<String>>,
pub(super) feature_resources: Option<FeatureResources>,
/// Templates, processor lists and per-state template transforms.
pub(super) structures: Option<Arc<super::structure::StructureResources>>,
pub(super) structure_resources: Option<StructureBundles>,
}
type Bundle = BTreeMap<String, String>;
fn read_bundle(dir: &Path, name: &str) -> Result<Bundle, GeneratorError> {
@@ -393,7 +403,31 @@ impl GeneratorData {
}
_ => None,
};
let structures = match fs::read_to_string(dir.join("blocks/structure-blocks.json")) {
Ok(json) => Some(Arc::new(super::structure::StructureResources::new(
registry,
super::structure::StateTransforms::from_json(&json, registry.len())?,
&dir.join("structure"),
read_optional_bundle(dir, "processor_lists")?.unwrap_or_default(),
&block_tags,
))),
Err(_) => None,
};
let structure_resources = match (
read_optional_bundle(dir, "structures")?,
read_optional_bundle(dir, "structure_sets")?,
read_optional_bundle(dir, "template_pools")?,
) {
(Some(structures), Some(sets), Some(pools)) => Some(StructureBundles {
structures,
sets,
pools,
}),
_ => None,
};
Ok(Arc::new(Self {
structure_resources,
structures,
registry,
states: GenBlockStates(states.into()),
integers,
@@ -452,6 +486,11 @@ pub struct ProtoChunk {
biomes: BiomeChunk<BiomeId>,
data: Arc<GeneratorData>,
decorated: bool,
/// Block-entity data placed by structures and template features, in
/// placement order (positions are absolute block coordinates).
pub block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
/// Structure starts referencing this chunk (STRUCTURE_REFERENCES).
pub(super) structure_starts: Vec<Arc<super::structure::start::StructureStart>>,
}
impl ProtoChunk {
pub fn position(&self) -> ChunkPos {
@@ -482,6 +521,21 @@ impl ProtoChunk {
pub fn data(&self) -> &Arc<GeneratorData> {
&self.data
}
/// Structure starts referencing this chunk: (structure id, start chunk,
/// inclusive bounding box min/max).
pub fn structures(&self) -> Vec<(&str, ChunkPos, [i32; 3], [i32; 3])> {
self.structure_starts
.iter()
.map(|s| {
(
s.name.as_str(),
s.chunk,
s.bounding_box.min,
s.bounding_box.max,
)
})
.collect()
}
pub fn is_decorated(&self) -> bool {
self.decorated
}
@@ -527,6 +581,7 @@ struct Pipeline<R: RandomSource> {
biome_cache: BiomeCache,
carver_cache: Mutex<HashMap<(i32, i32), BiomeId>>,
pub(super) decoration: Option<super::generator_decoration::Decoration>,
pub(super) structures: Option<super::generator_structures::StructureState>,
}
const CACHE_LIMIT: usize = 16384;
type BiomeCache = Mutex<HashMap<(i32, i32), Arc<BiomeChunk<BiomeId>>>>;
@@ -567,6 +622,7 @@ where
mut random: R,
generator: &Value,
settings_json: &Value,
with_structures: bool,
) -> Result<Self, GeneratorError> {
let registry = data.registry;
let noise = &settings_json["noise"];
@@ -691,9 +747,20 @@ where
biome_cache: Mutex::new(HashMap::new()),
carver_cache: Mutex::new(HashMap::new()),
decoration: None,
structures: None,
};
pipeline.decoration =
super::generator_decoration::Decoration::new(&pipeline.data, &pipeline.source)?;
if with_structures {
let possible = pipeline
.source
.possible_biomes()
.into_iter()
.filter_map(|name| pipeline.data.biome_id(name))
.collect();
pipeline.structures =
super::generator_structures::StructureState::new(&pipeline.data, &possible)?;
}
Ok(pipeline)
}
fn generation(&self) -> WorldGenerationContext {
@@ -807,7 +874,31 @@ where
let mut chunk = TerrainChunk::new(pos, min, height, data.registry, data.states.clone())
.map_err(stage("noise"))?;
chunk.set_generation_stage(PreLightChunkStage::Biomes);
let references = match &self.structures {
Some(structures) => structures.references(
&mut StructureQueries {
pipeline: self,
worker,
valid: BTreeSet::new(),
},
pos,
),
None => Vec::new(),
};
let mut context = SamplerContext::cached();
if let Some(beard) = self
.structures
.as_ref()
.and_then(|s| s.beardifier(&references, pos))
{
context = context.with_world_fields(
horizon_core::density::WorldFields::default().with_field(
horizon_core::density::WorldField::Beardifier,
Arc::new(beard),
),
);
}
worker.timings.structures += lap(&mut clock);
let volume = DensityVolume::new(
[16, height, 16],
[pos.x.wrapping_shl(4), min, pos.z.wrapping_shl(4)],
@@ -919,10 +1010,135 @@ where
biomes: center,
data: data.clone(),
decorated: false,
block_entities: Vec::new(),
structure_starts: references,
})
}
}
impl<R: RandomSource> Pipeline<R>
where
R::Positional: Clone + Send + Sync,
{
/// ChunkGenerator.getBaseHeight: the first free Y above the noise column
/// (with aquifers, without terrain adaptation) for a heightmap type.
fn base_height(&self, x: i32, z: i32, kind: HeightmapType) -> i32 {
let (min, height) = (self.settings.min_y, self.settings.height);
let Ok(volume) = DensityVolume::new([1, height, 1], [x, min, z], [1; 3]) else {
return min;
};
let mut context = SamplerContext::cached();
let mut aquifer: Box<dyn TerrainAquifer> = match &self.aquifer {
Some(samplers) => match RegistryAquiferBlockStates::new(self.data.registry)
.ok()
.and_then(|blocks| {
NoiseBasedAquifer::new(
AquiferSamplers::new(samplers.clone()),
self.picker,
self.root
.from_hash_of("minecraft:aquifer")
.fork_positional(),
blocks,
volume,
&mut context,
)
.ok()
}) {
Some(aquifer) => Box::new(aquifer),
None => return min,
},
None => Box::new(DisabledAquifer::new(
self.picker,
self.data.registry.default_state("minecraft:air").unwrap(),
)),
};
let mut density = vec![0.; height as usize];
if self
.router
.get(RouterField::FinalDensity)
.sample_volume(&mut context, &mut density, volume)
.is_err()
{
return min;
}
for y in (0..height).rev() {
let state = aquifer
.compute_substance(
&mut context,
[x, min + y, z],
f64::from(density[y as usize]),
)
.ok()
.flatten()
.unwrap_or(self.settings.default_block);
if kind.is_opaque(self.data.states.get(state)) {
return min + y + 1;
}
}
min
}
}
/// Biome and height queries for structure generation on one worker.
pub(super) struct StructureQueries<'a, R: RandomSource> {
pipeline: &'a Pipeline<R>,
worker: &'a mut WorkerState,
valid: BTreeSet<BiomeId>,
}
impl<R: RandomSource> super::structure::jigsaw::JigsawContext for StructureQueries<'_, R>
where
R::Positional: Clone + Send + Sync,
{
fn min_y(&self) -> i32 {
self.pipeline.settings.min_y
}
fn max_y(&self) -> i32 {
self.pipeline.settings.min_y + self.pipeline.settings.height - 1
}
fn base_height(&mut self, x: i32, z: i32, kind: HeightmapType) -> i32 {
if let Some(h) = self.worker.heights.get(&(x, z, kind as u8)) {
return *h;
}
let h = self.pipeline.base_height(x, z, kind);
if self.worker.heights.len() > 65536 {
self.worker.heights.clear();
}
self.worker.heights.insert((x, z, kind as u8), h);
h
}
fn column_has_valid_biome(&mut self, x: i32, z: i32, min_y: i32, max_y: i32) -> bool {
use super::structure::start::StartContext;
((min_y >> 2)..=(max_y >> 2)).any(|qy| {
let id = self.noise_biome([x >> 2, qy, z >> 2]);
self.valid.contains(&id)
})
}
}
impl<R: RandomSource> super::structure::start::StartContext for StructureQueries<'_, R>
where
R::Positional: Clone + Send + Sync,
{
fn seed(&self) -> i64 {
self.pipeline.seed
}
fn generation(&self) -> WorldGenerationContext {
self.pipeline.generation()
}
fn noise_biome(&mut self, quart: [i32; 3]) -> BiomeId {
let mut resolver = self.pipeline.source.resolver(
&self.pipeline.climate,
self.pipeline.router.get(RouterField::Erosion).as_ref(),
);
resolver
.sample(&mut self.worker.carver_context, quart)
.ok()
.and_then(|name| self.pipeline.data.biome_id(name))
.unwrap_or(BiomeId(0))
}
fn set_valid_biomes(&mut self, biomes: &BTreeSet<BiomeId>) {
self.valid = biomes.clone();
}
}
enum Biomes<'a, 'b> {
Region(&'a BiomeRegion<BiomeId>),
Resolver(
@@ -1020,6 +1236,8 @@ pub struct StageTimings {
/// Noise fill including aquifer setup.
pub noise: std::time::Duration,
pub surface: std::time::Duration,
/// Structure starts/references and terrain adaptation.
pub structures: std::time::Duration,
/// Carving mask generation/application and final heightmap priming.
pub carvers: std::time::Duration,
}
@@ -1030,6 +1248,7 @@ pub(super) struct WorkerState {
biome_context: SamplerContext,
carver_context: SamplerContext,
timings: StageTimings,
heights: HashMap<(i32, i32, u8), i32>,
}
trait SeededPipeline: Send + Sync {
@@ -1045,6 +1264,11 @@ trait SeededPipeline: Send + Sync {
) -> Result<DecorateStats, GeneratorError>;
fn data(&self) -> &Arc<GeneratorData>;
fn sea_level(&self) -> i32;
fn structure_starts(
&self,
worker: &mut WorkerState,
pos: ChunkPos,
) -> Vec<Arc<super::structure::start::StructureStart>>;
fn unsupported_features(&self) -> Vec<(String, String)>;
}
impl<R: RandomSource + 'static> SeededPipeline for Pipeline<R>
@@ -1083,6 +1307,7 @@ where
worker,
region,
|| random.next_boolean(),
self.structures.as_ref(),
)
}
None => Err(resource("decoration resources were not loaded")),
@@ -1094,6 +1319,25 @@ where
fn sea_level(&self) -> i32 {
self.settings.sea_level
}
fn structure_starts(
&self,
worker: &mut WorkerState,
pos: ChunkPos,
) -> Vec<Arc<super::structure::start::StructureStart>> {
match &self.structures {
Some(structures) => structures
.starts_at(
&mut StructureQueries {
pipeline: self,
worker,
valid: BTreeSet::new(),
},
pos,
)
.to_vec(),
None => Vec::new(),
}
}
fn unsupported_features(&self) -> Vec<(String, String)> {
self.decoration
.as_ref()
@@ -1126,12 +1370,26 @@ impl OverworldGenerator {
pub fn new(data: Arc<GeneratorData>, seed: i64) -> Result<Self, GeneratorError> {
Self::for_dimension(data, seed, "minecraft:normal", "minecraft:overworld")
}
/// The overworld without structures (no starts, terrain adaptation or
/// structure pieces), as in a world with structure generation disabled.
pub fn without_structures(data: Arc<GeneratorData>, seed: i64) -> Result<Self, GeneratorError> {
Self::build(data, seed, "minecraft:normal", "minecraft:overworld", false)
}
/// Any noise-generator dimension of a bundled world preset.
pub fn for_dimension(
data: Arc<GeneratorData>,
seed: i64,
preset: &str,
dimension: &str,
) -> Result<Self, GeneratorError> {
Self::build(data, seed, preset, dimension, true)
}
fn build(
data: Arc<GeneratorData>,
seed: i64,
preset: &str,
dimension: &str,
with_structures: bool,
) -> Result<Self, GeneratorError> {
let preset_json: Value = serde_json::from_str(
data.world_presets
@@ -1160,6 +1418,7 @@ impl OverworldGenerator {
LegacyRandom::new(seed),
&generator,
&settings_json,
with_structures,
)?)
} else {
Arc::new(Pipeline::new(
@@ -1168,6 +1427,7 @@ impl OverworldGenerator {
XoroshiroRandom::new(seed),
&generator,
&settings_json,
with_structures,
)?)
};
Ok(Self { pipeline })
@@ -1197,6 +1457,7 @@ impl OverworldGenerator {
biome_context: SamplerContext::cached(),
carver_context: SamplerContext::default(),
timings: StageTimings::default(),
heights: HashMap::new(),
},
}
}
@@ -1215,6 +1476,13 @@ impl GeneratorWorker {
self.state.timings.chunks += 1;
result
}
/// STRUCTURE_STARTS: the structure starts owned by a chunk (cached).
pub fn structure_starts(
&mut self,
pos: ChunkPos,
) -> Vec<Arc<super::structure::start::StructureStart>> {
self.pipeline.structure_starts(&mut self.state, pos)
}
pub fn stage_timings(&self) -> StageTimings {
self.state.timings
}
@@ -4,6 +4,10 @@
//! Roots whose algorithm or bindings are not implemented are left out of
//! execution (but keep their place in vanilla's per-step feature ordering, so
//! decoration seeds of the remaining features are unchanged).
use super::structure::{
BoundingBox,
start::{STEPS, place_in_chunk},
};
use super::{
anchor::WorldGenerationContext,
biome::BiomeId,
@@ -41,12 +45,14 @@ use crate::{
heightmap::{HeightmapState, HeightmapType},
registry::BlockStateId,
};
use horizon_core::random::{WorldgenRandom, XoroshiroRandom};
use horizon_core::{
biome::obfuscate_seed,
geometry::{Axis, Direction, VoxelShape},
position::{BlockPos, ChunkPos},
};
use serde_json::Value;
use std::collections::HashMap;
use std::{
collections::{BTreeMap, BTreeSet},
sync::Arc,
@@ -62,6 +68,9 @@ pub(super) struct Decoration {
bindings: FeatureBlockBindings<'static>,
weather: Option<BiomeWeatherBindings>,
blocks: FeatureBlocks,
catalog: FeatureCatalog,
/// Placed features referenced by name (feature pool elements), decoded lazily.
named: std::sync::Mutex<HashMap<String, Option<Arc<PlacedFeatureDefinition>>>>,
}
fn resource(message: impl Into<String>) -> GeneratorError {
GeneratorError::Resource(message.into())
@@ -125,6 +134,9 @@ impl Decoration {
FeatureBlockBindings::with_tags(registry, data.integers().clone(), &data.block_tags)?
.with_fluid_tags(&resources.fluid_tags)?
.with_biomes(biomes.clone());
if let Some(structures) = &data.structures {
bindings = bindings.with_structures(structures.clone());
}
if let Some(blocks) = &resources.blocks {
bindings = bindings
.with_block_properties(&blocks.properties)?
@@ -210,8 +222,22 @@ impl Decoration {
weather,
blocks: FeatureBlocks::from_registry(registry)?,
bindings,
catalog,
named: std::sync::Mutex::new(HashMap::new()),
}))
}
fn named_feature(&self, name: &str) -> Option<Arc<PlacedFeatureDefinition>> {
let mut named = self.named.lock().unwrap();
named
.entry(name.to_owned())
.or_insert_with(|| {
self.catalog
.placed_feature_with_blocks(&Value::from(name).to_string(), &self.bindings)
.ok()
.map(Arc::new)
})
.clone()
}
/// Placed-feature roots that cannot run, with their decode errors.
pub(super) fn unsupported(&self) -> Vec<(String, String)> {
self.names
@@ -228,6 +254,7 @@ impl Decoration {
worker: &mut WorkerState,
region: &mut [ProtoChunk; 9],
next_boolean: impl FnMut() -> bool,
structures: Option<&super::generator_structures::StructureState>,
) -> Result<DecorateStats, GeneratorError> {
let center = region[4].position();
for (i, chunk) in region.iter().enumerate() {
@@ -268,7 +295,12 @@ impl Decoration {
Err(e) => return Err(resource(e.to_string())),
};
let mut next_boolean = next_boolean;
let mut block_entities = Vec::new();
for chunk in region.iter_mut() {
block_entities.append(&mut chunk.block_entities);
}
let mut world = World {
block_entities,
next_boolean: &mut next_boolean,
blocks: data
.feature_resources
@@ -283,10 +315,59 @@ impl Decoration {
};
let mut stats = DecorateStats::default();
let blocks = self.blocks;
let result = self.plan.decorate_features(
let references = region[4].structure_starts.clone();
let chunk_box = BoundingBox::new(
[center.x * 16, generation.min_y + 1, center.z * 16],
[
center.x * 16 + 15,
generation.min_y + generation.height - 1,
center.z * 16 + 15,
],
);
let mut structure_errors = 0;
let result = self.plan.decorate(
&mut world,
center,
seed,
STEPS.len(),
|world, random, decoration_seed, step| {
let Some(structures) = structures else {
return Ok(());
};
let Some(in_step) = structures.by_step.get(step) else {
return Ok(());
};
for (index, &structure) in in_step.iter().enumerate() {
random.set_feature_seed(decoration_seed, index as i32, step as i32);
for start in references.iter().filter(|s| s.structure == structure) {
let mut place_feature =
|world: &mut World<'_>,
random: &mut WorldgenRandom<XoroshiroRandom>,
name: &str,
pos: [i32; 3]| {
match self.named_feature(name) {
Some(feature) => feature
.place(world, random, pos, blocks)
.map_err(|e| PlacementQueryError::Failed(e.to_string())),
None => Ok(false),
}
};
if place_in_chunk(
start,
world,
&structures.resources,
random,
chunk_box,
&mut place_feature,
)
.is_err()
{
structure_errors += 1;
}
}
}
Ok(())
},
|world, placer, random, id, origin| {
let Ok(feature) = &self.features[id.0 as usize] else {
stats.unsupported += 1;
@@ -309,12 +390,21 @@ impl Decoration {
Ok(placed.unwrap_or(false))
},
);
for (pos, nbt) in std::mem::take(&mut world.block_entities) {
let index = ((pos[2] >> 4).wrapping_sub(center.z) + 1) * 3
+ (pos[0] >> 4).wrapping_sub(center.x)
+ 1;
if let Some(chunk) = usize::try_from(index).ok().and_then(|i| region.get_mut(i)) {
chunk.block_entities.push((pos, nbt));
}
}
for terrain in world.region.into_chunks() {
let p = terrain.position();
let index = (p.z.wrapping_sub(center.z) + 1) * 3 + p.x.wrapping_sub(center.x) + 1;
region[index as usize].terrain = terrain;
}
result.map_err(|e| GeneratorError::Stage("features", e.to_string()))?;
stats.failed += structure_errors;
region[4]
.terrain
.set_generation_stage(PreLightChunkStage::Features);
@@ -326,6 +416,7 @@ impl Decoration {
/// WorldGenRegion-style view: reads anywhere in the 3×3 region, writes within
/// the FEATURES step's write radius, biome lookups through the biome zoom.
struct World<'a> {
block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
next_boolean: &'a mut dyn FnMut() -> bool,
blocks: Option<&'a BlockBehavior>,
region: TerrainRegion<'static, GenBlockStates>,
@@ -370,6 +461,7 @@ impl FeatureWorld for World<'_> {
return Ok(false);
}
self.region.set_block_worldgen(position, state)?;
self.block_entities.retain(|(p, _)| *p != position);
Ok(true)
}
}
@@ -497,6 +589,15 @@ impl PlacementContext for World<'_> {
(0..ny).all(|y| (0..nz).all(|z| shape.is_full(x as i32, y as i32, z as i32)))
}))
}
fn set_block_entity(
&mut self,
position: [i32; 3],
nbt: crate::nbt::Compound,
) -> Result<(), PlacementQueryError> {
self.block_entities.retain(|(p, _)| *p != position);
self.block_entities.push((position, nbt));
Ok(())
}
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
self.region.world_seed()
}
@@ -0,0 +1,152 @@
//! STRUCTURE_STARTS / STRUCTURE_REFERENCES for the chunk generator.
use super::{
biome::BiomeId,
block_feature::FeatureBlockBindings,
generator::{GeneratorData, GeneratorError},
structure::{
StructureResources,
start::{StructureRegistry, StructureStart, beardifier, create_starts},
},
};
use horizon_core::{density::Beardifier, position::ChunkPos};
use serde_json::Value;
use std::{
collections::{BTreeSet, HashMap},
sync::{Arc, Mutex},
};
pub(super) type Starts = Arc<Vec<Arc<StructureStart>>>;
pub(super) struct StructureState {
pub(super) registry: StructureRegistry,
pub(super) resources: Arc<StructureResources>,
pub(super) bindings: FeatureBlockBindings<'static>,
possible_sets: Vec<usize>,
/// Structure indices of each decoration step, in registry order.
pub(super) by_step: Vec<Vec<usize>>,
starts: Mutex<HashMap<(i32, i32), Starts>>,
}
const START_CACHE_LIMIT: usize = 65536;
fn biome_set(data: &GeneratorData, value: &Value) -> Result<BTreeSet<BiomeId>, super::DecodeError> {
let names: Vec<&str> = match value {
Value::String(s) => vec![s.as_str()],
Value::Array(a) => a.iter().filter_map(Value::as_str).collect(),
_ => Vec::new(),
};
let mut out = BTreeSet::new();
for name in names {
match name.strip_prefix('#') {
Some(tag) => {
for biome in data.biome_tags.get(tag).into_iter().flatten() {
out.extend(data.biome_id(biome));
}
}
None => out.extend(data.biome_id(name)),
}
}
Ok(out)
}
impl StructureState {
pub(super) fn new(
data: &Arc<GeneratorData>,
possible_biomes: &BTreeSet<BiomeId>,
) -> Result<Option<Self>, GeneratorError> {
let (Some(resources), Some(raw)) = (&data.structures, &data.structure_resources) else {
return Ok(None);
};
let registry =
StructureRegistry::new(&raw.structures, &raw.sets, raw.pools.clone(), &|value| {
biome_set(data, value)
})?;
let possible_sets = registry
.sets
.iter()
.enumerate()
.filter(|(_, set)| {
set.structures
.iter()
.any(|(s, _)| !registry.structures[*s].biomes.is_disjoint(possible_biomes))
})
.map(|(i, _)| i)
.collect();
let mut by_step = vec![Vec::new(); super::structure::start::STEPS.len()];
for (i, def) in registry.structures.iter().enumerate() {
by_step[def.step].push(i);
}
let bindings = FeatureBlockBindings::with_tags(
data.registry(),
data.integers().clone(),
&data.block_tags,
)?;
Ok(Some(Self {
registry,
resources: resources.clone(),
bindings,
possible_sets,
by_step,
starts: Mutex::new(HashMap::new()),
}))
}
/// The (cached) structure starts owned by a chunk.
pub(super) fn starts_at(
&self,
context: &mut impl super::structure::start::StartContext,
chunk: ChunkPos,
) -> Starts {
if let Some(found) = self.starts.lock().unwrap().get(&(chunk.x, chunk.z)) {
return found.clone();
}
let starts: Starts = Arc::new(
create_starts(
&self.registry,
&self.resources,
&self.bindings,
context,
&self.possible_sets,
&[],
chunk,
)
.into_iter()
.map(Arc::new)
.collect(),
);
let mut cache = self.starts.lock().unwrap();
if cache.len() >= START_CACHE_LIMIT {
cache.clear();
}
cache.insert((chunk.x, chunk.z), starts.clone());
starts
}
/// ChunkGenerator.createReferences: starts within 8 chunks whose box
/// intersects this chunk's column.
pub(super) fn references(
&self,
context: &mut impl super::structure::start::StartContext,
chunk: ChunkPos,
) -> Vec<Arc<StructureStart>> {
let (bx, bz) = (chunk.x * 16, chunk.z * 16);
let mut out = Vec::new();
for sx in chunk.x - 8..=chunk.x + 8 {
for sz in chunk.z - 8..=chunk.z + 8 {
for start in self.starts_at(context, ChunkPos::new(sx, sz)).iter() {
let b = start.bounding_box;
if b.max[0] >= bx
&& b.min[0] <= bx + 15
&& b.max[2] >= bz
&& b.min[2] <= bz + 15
{
out.push(start.clone());
}
}
}
}
out
}
pub(super) fn beardifier(
&self,
references: &[Arc<StructureStart>],
chunk: ChunkPos,
) -> Option<Beardifier> {
beardifier(&self.registry, references, chunk)
}
}
@@ -285,6 +285,15 @@ pub trait PlacementContext {
fn layer_block(&mut self, _position: [i32; 3]) -> Result<LayerBlock, PlacementQueryError> {
Err(PlacementQueryError::Unavailable)
}
/// Store block-entity data loaded at a just-placed block (structure
/// templates). Worlds without block-entity storage drop it.
fn set_block_entity(
&mut self,
_position: [i32; 3],
_nbt: crate::nbt::Compound,
) -> Result<(), PlacementQueryError> {
Ok(())
}
fn generation(&self) -> WorldGenerationContext;
/// Recreate the generation bounds for a block-predicate invocation. World
/// adapters may perform fallible level/generator queries here; ordinary
@@ -0,0 +1,345 @@
//! Structure templates, processors and placement shared by template features
//! and structure pieces.
pub mod features;
pub mod jigsaw;
pub mod legacy;
pub mod ocean_ruin;
pub mod processor;
pub mod simple;
pub mod start;
pub mod template;
use crate::{
nbt::{self, Limits},
registry::{BlockRegistry, BlockStateId},
};
use horizon_core::geometry::Direction;
use processor::ProcessorList;
use std::{
collections::{BTreeMap, BTreeSet, HashMap},
io::Read,
path::{Path, PathBuf},
sync::{Arc, RwLock},
};
pub use template::{BlockInfo, JigsawInfo, StructureTemplate};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Rotation {
None,
Clockwise90,
Clockwise180,
Counterclockwise90,
}
impl Rotation {
pub const ALL: [Self; 4] = [
Self::None,
Self::Clockwise90,
Self::Clockwise180,
Self::Counterclockwise90,
];
pub fn from_name(name: &str) -> Option<Self> {
Some(match name {
"none" => Self::None,
"clockwise_90" => Self::Clockwise90,
"180" => Self::Clockwise180,
"counterclockwise_90" => Self::Counterclockwise90,
_ => return None,
})
}
/// Rotation.getRandom: one bounded draw over the four values.
pub fn random(random: &mut impl horizon_core::random::RandomSource) -> Self {
Self::ALL[random.next_int_bound(4).unwrap_or(0) as usize]
}
pub fn rotate_direction(self, direction: Direction) -> Direction {
if matches!(direction, Direction::Up | Direction::Down) {
return direction;
}
let order = [
Direction::North,
Direction::East,
Direction::South,
Direction::West,
];
let index = order.iter().position(|d| *d == direction).unwrap();
order[(index + self as usize) % 4]
}
pub fn get_rotated(self, other: Self) -> Self {
Self::ALL[(self as usize + other as usize) % 4]
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Mirror {
None,
LeftRight,
FrontBack,
}
/// Inclusive integer box (vanilla BoundingBox).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct BoundingBox {
pub min: [i32; 3],
pub max: [i32; 3],
}
impl BoundingBox {
pub fn new(min: [i32; 3], max: [i32; 3]) -> Self {
Self { min, max }
}
pub fn from_corners(a: [i32; 3], b: [i32; 3]) -> Self {
Self {
min: std::array::from_fn(|i| a[i].min(b[i])),
max: std::array::from_fn(|i| a[i].max(b[i])),
}
}
pub fn moved(self, d: [i32; 3]) -> Self {
Self {
min: std::array::from_fn(|i| self.min[i] + d[i]),
max: std::array::from_fn(|i| self.max[i] + d[i]),
}
}
pub fn is_inside(&self, p: [i32; 3]) -> bool {
(0..3).all(|i| p[i] >= self.min[i] && p[i] <= self.max[i])
}
pub fn intersects(&self, other: &Self) -> bool {
(0..3).all(|i| self.max[i] >= other.min[i] && self.min[i] <= other.max[i])
}
pub fn encapsulate(&mut self, other: &Self) {
for i in 0..3 {
self.min[i] = self.min[i].min(other.min[i]);
self.max[i] = self.max[i].max(other.max[i]);
}
}
pub fn inflated(self, xz: i32, y: i32) -> Self {
Self {
min: [self.min[0] - xz, self.min[1] - y, self.min[2] - xz],
max: [self.max[0] + xz, self.max[1] + y, self.max[2] + xz],
}
}
pub fn span(&self) -> [i32; 3] {
std::array::from_fn(|i| self.max[i] - self.min[i] + 1)
}
pub fn center(&self) -> [i32; 3] {
std::array::from_fn(|i| self.min[i] + (self.max[i] - self.min[i] + 1) / 2)
}
pub fn corners(&self) -> [[i32; 3]; 8] {
let (a, b) = (self.min, self.max);
[
[a[0], a[1], a[2]],
[a[0], a[1], b[2]],
[a[0], b[1], a[2]],
[a[0], b[1], b[2]],
[b[0], a[1], a[2]],
[b[0], a[1], b[2]],
[b[0], b[1], a[2]],
[b[0], b[1], b[2]],
]
}
}
/// Per-state BlockState.rotate/mirror results and template ordering flags,
/// exported from vanilla (`blocks/structure-blocks.json`).
#[derive(Debug, Default)]
pub struct StateTransforms {
rotate: Vec<[u32; 3]>,
mirror: Vec<[u32; 2]>,
full: Vec<bool>,
loot: BTreeSet<BlockStateId>,
}
impl StateTransforms {
pub fn from_json(json: &str, states: usize) -> Result<Self, super::DecodeError> {
let value: serde_json::Value = serde_json::from_str(json)?;
let arr = |key: &'static str| {
value[key]
.as_array()
.cloned()
.ok_or(super::DecodeError::Field(key))
};
let ids = |v: &serde_json::Value| -> Vec<u32> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|x| x.as_u64())
.map(|x| x as u32)
.collect()
})
.unwrap_or_default()
};
let rotate = arr("rotate")?
.iter()
.map(|v| {
let v = ids(v);
[v[0], v[1], v[2]]
})
.collect::<Vec<_>>();
let mirror = arr("mirror")?
.iter()
.map(|v| {
let v = ids(v);
[v[0], v[1]]
})
.collect::<Vec<_>>();
let full = arr("full_block")?
.iter()
.map(|v| v.as_bool().unwrap_or(false))
.collect::<Vec<_>>();
if rotate.len() != states || mirror.len() != states || full.len() != states {
return Err(super::DecodeError::Field("structure block table size"));
}
let loot = ids(&value["loot_containers"])
.into_iter()
.map(BlockStateId)
.collect();
Ok(Self {
rotate,
mirror,
full,
loot,
})
}
pub fn rotate(&self, state: BlockStateId, rotation: Rotation) -> BlockStateId {
match rotation {
Rotation::None => state,
r => self
.rotate
.get(state.0 as usize)
.map_or(state, |t| BlockStateId(t[r as usize - 1])),
}
}
pub fn mirror(&self, state: BlockStateId, mirror: Mirror) -> BlockStateId {
match mirror {
Mirror::None => state,
m => self
.mirror
.get(state.0 as usize)
.map_or(state, |t| BlockStateId(t[m as usize - 1])),
}
}
pub fn full_block(&self, state: BlockStateId) -> bool {
self.full.get(state.0 as usize).copied().unwrap_or(false)
}
pub fn loot_container(&self, state: BlockStateId) -> bool {
self.loot.contains(&state)
}
}
/// Lazily loaded templates (`structure/<namespace>/<path>.nbt`, gzip NBT) and
/// processor lists, shared by all generators of one resource bundle.
pub struct StructureResources {
pub registry: &'static BlockRegistry,
pub transforms: StateTransforms,
dir: PathBuf,
templates: RwLock<HashMap<String, Option<Arc<StructureTemplate>>>>,
pub processor_lists: BTreeMap<String, String>,
jigsaw_states: BTreeMap<BlockStateId, bool>,
pub(crate) waterlogged: HashMap<BlockStateId, BlockStateId>,
sources: BTreeSet<BlockStateId>,
/// Block names in each block tag, for processors matching tags by block.
pub block_tags: BTreeMap<String, BTreeSet<String>>,
}
impl std::fmt::Debug for StructureResources {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("StructureResources")
}
}
impl StructureResources {
pub fn new(
registry: &'static BlockRegistry,
transforms: StateTransforms,
dir: &Path,
processor_lists: BTreeMap<String, String>,
block_tags: &BTreeMap<String, Vec<String>>,
) -> Self {
let mut sources = BTreeSet::new();
let fluids = crate::fluid::FluidStateTable::new(registry).ok();
let mut jigsaw_states = BTreeMap::new();
let mut waterlogged = HashMap::new();
for id in 0..registry.len() {
let id = BlockStateId(id as u32);
let state = registry.state(id).unwrap();
if state.name == "minecraft:jigsaw" {
let orientation = state
.properties
.get("orientation")
.cloned()
.unwrap_or_default();
let front = orientation.split('_').next().unwrap_or("");
jigsaw_states.insert(id, !matches!(front, "up" | "down"));
}
if fluids
.as_ref()
.and_then(|table| table.get(id))
.is_some_and(|fluid| fluid.is_source())
{
sources.insert(id);
}
if state.properties.get("waterlogged").map(String::as_str) == Some("false") {
let mut wet = state.clone();
wet.properties.insert("waterlogged".into(), "true".into());
if let Some(wet) = registry.id(&wet) {
waterlogged.insert(id, wet);
}
}
}
Self {
registry,
transforms,
dir: dir.to_owned(),
templates: RwLock::new(HashMap::new()),
processor_lists,
jigsaw_states,
waterlogged,
sources,
block_tags: block_tags
.iter()
.map(|(k, v)| (k.clone(), v.iter().cloned().collect()))
.collect(),
}
}
/// StructureTemplateManager.getOrCreate; missing templates are None.
pub fn template(&self, id: &str) -> Option<Arc<StructureTemplate>> {
let id = if id.contains(':') {
id.to_owned()
} else {
format!("minecraft:{id}")
};
if let Some(found) = self.templates.read().unwrap().get(&id) {
return found.clone();
}
let (namespace, path) = id.split_once(':').unwrap();
let file = self.dir.join(namespace).join(format!("{path}.nbt"));
let loaded = std::fs::read(&file).ok().and_then(|bytes| {
let mut raw = Vec::new();
flate2::read::GzDecoder::new(bytes.as_slice())
.read_to_end(&mut raw)
.ok()?;
let limits = Limits {
max_bytes: 1 << 28,
..Limits::default()
};
let tag = nbt::read_named(&raw, limits).ok()?.0.tag;
Some(Arc::new(StructureTemplate::from_nbt(
&tag,
self.registry,
&self.transforms,
)))
});
self.templates.write().unwrap().insert(id, loaded.clone());
loaded
}
/// Whether the state's fluid is a source (water/lava level 0, waterlogged).
pub fn source_fluid(&self, state: BlockStateId) -> bool {
self.sources.contains(&state)
}
pub fn jigsaw_horizontal(&self, state: BlockStateId) -> Option<bool> {
self.jigsaw_states.get(&state).copied()
}
pub fn processor_list(
&self,
json: &str,
bindings: &super::block_feature::FeatureBlockBindings<'_>,
) -> Result<ProcessorList, super::DecodeError> {
ProcessorList::decode(json, self, bindings)
}
pub fn is_jigsaw(&self, state: BlockStateId) -> bool {
self.jigsaw_states.contains_key(&state)
}
}
@@ -0,0 +1,231 @@
//! The `template` and `fossil` configured features.
use super::{
BoundingBox, Mirror, Rotation, StructureResources, StructureTemplate,
processor::{PlaceSettings, ProcessorList, place_in_world},
};
use crate::{
heightmap::HeightmapType,
worldgen::{
DecodeError,
block_feature::FeatureBlockBindings,
feature::FeatureWorld,
placement::{PlacementContext, PlacementQueryError},
weighted::WeightedList,
},
};
use horizon_core::random::RandomSource;
use serde_json::{Value, value::RawValue};
use std::sync::Arc;
fn resources(bindings: &FeatureBlockBindings<'_>) -> Result<Arc<StructureResources>, DecodeError> {
bindings
.structures
.clone()
.ok_or(DecodeError::Field("structure template bindings"))
}
fn template(
resources: &StructureResources,
id: &str,
) -> Result<Arc<StructureTemplate>, DecodeError> {
resources
.template(id)
.ok_or_else(|| DecodeError::Registry(format!("missing structure template {id}")))
}
#[derive(Clone, Debug)]
pub struct TemplateFeature {
templates: WeightedList<(Arc<StructureTemplate>, Vec<Rotation>)>,
processors: ProcessorList,
resources: Arc<StructureResources>,
}
impl TemplateFeature {
pub fn decode(json: &str, bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
let resources = resources(bindings)?;
let value: Value = serde_json::from_str(json)?;
let raw: Box<RawValue> = serde_json::from_str(&value["templates"].to_string())?;
let templates = WeightedList::decode(&raw, |entry| {
let entry: Value = serde_json::from_str(entry.get())?;
let id = entry["id"]
.as_str()
.ok_or(DecodeError::Field("template id"))?;
let rotations = match entry.get("rotations").and_then(Value::as_array) {
Some(list) => list
.iter()
.map(|r| {
r.as_str()
.and_then(Rotation::from_name)
.ok_or(DecodeError::Field("rotation"))
})
.collect::<Result<Vec<_>, _>>()?,
None => Rotation::ALL.to_vec(),
};
Ok((template(&resources, id)?, rotations))
})?;
let processors = match value.get("processors") {
Some(p) => ProcessorList::decode(&p.to_string(), &resources, bindings)?,
None => ProcessorList::default(),
};
Ok(Self {
templates,
processors,
resources,
})
}
pub fn place<W: FeatureWorld + PlacementContext>(
&self,
world: &mut W,
random: &mut impl RandomSource,
origin: [i32; 3],
) -> Result<bool, PlacementQueryError> {
let invalid = |_| PlacementQueryError::Failed("template weights".into());
let (template, rotations) = self.templates.sample(random).map_err(invalid)?;
let rotation = rotations[random
.next_int_bound(rotations.len() as i32)
.map_err(invalid)? as usize];
// rotation.rotate(axis.getNegative()) * (size along axis / 2), for X then Z.
let mut pos = origin;
for (axis, negative) in [
(0, horizon_core::geometry::Direction::West),
(2, horizon_core::geometry::Direction::North),
] {
let step = rotation.rotate_direction(negative).normal();
let length = template.size[axis] / 2;
for i in 0..3 {
pos[i] += step[i] * length;
}
}
let mut settings = PlaceSettings::new(rotation).add(&self.processors);
settings.random = Some(random);
place_in_world(
world,
&self.resources,
template,
pos,
pos,
&mut settings,
None,
3,
)
}
}
#[derive(Clone, Debug)]
pub struct FossilFeature {
fossils: Vec<(Arc<StructureTemplate>, Arc<StructureTemplate>)>,
fossil_processors: ProcessorList,
overlay_processors: ProcessorList,
max_empty_corners: i32,
resources: Arc<StructureResources>,
}
impl FossilFeature {
pub fn decode(json: &str, bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
let resources = resources(bindings)?;
let value: Value = serde_json::from_str(json)?;
let list = |key: &'static str| -> Result<Vec<Arc<StructureTemplate>>, DecodeError> {
value[key]
.as_array()
.ok_or(DecodeError::Field(key))?
.iter()
.map(|id| template(&resources, id.as_str().unwrap_or_default()))
.collect()
};
let (base, overlay) = (list("fossil_structures")?, list("overlay_structures")?);
if base.is_empty() || base.len() != overlay.len() {
return Err(DecodeError::Field("fossil structure lists"));
}
Ok(Self {
fossils: base.into_iter().zip(overlay).collect(),
fossil_processors: ProcessorList::decode(
&value["fossil_processors"].to_string(),
&resources,
bindings,
)?,
overlay_processors: ProcessorList::decode(
&value["overlay_processors"].to_string(),
&resources,
bindings,
)?,
max_empty_corners: value["max_empty_corners_allowed"].as_i64().unwrap_or(0) as i32,
resources,
})
}
pub fn place<W: FeatureWorld + PlacementContext>(
&self,
world: &mut W,
random: &mut impl RandomSource,
origin: [i32; 3],
) -> Result<bool, PlacementQueryError> {
let invalid = |_| PlacementQueryError::Failed("fossil bounds".into());
let rotation = Rotation::random(random);
let index = random
.next_int_bound(self.fossils.len() as i32)
.map_err(invalid)? as usize;
let (base, overlay) = &self.fossils[index];
let (cx, cz) = (origin[0] >> 4, origin[2] >> 4);
let bounds = BoundingBox::new(
[cx * 16 - 16, world.min_y()?, cz * 16 - 16],
[cx * 16 + 15 + 16, world.max_y()?, cz * 16 + 15 + 16],
);
let size = base.size(rotation);
let low = [origin[0] - size[0] / 2, 0, origin[2] - size[2] / 2];
let mut lowest = origin[1];
for x in 0..size[0] {
for z in 0..size[2] {
lowest = lowest.min(world.height(
HeightmapType::OceanFloorWg,
low[0] + x,
low[2] + z,
)?);
}
}
let y =
(lowest - 15 - random.next_int_bound(10).map_err(invalid)?).max(world.min_y()? + 10);
let target = StructureTemplate::zero_position_with_transform(
[low[0], y, low[2]],
Mirror::None,
rotation,
base.size[0],
base.size[2],
);
let mut empty = 0;
for corner in base
.bounding_box(target, rotation, [0; 3], Mirror::None)
.corners()
{
let state = world.block_state(corner)?;
let name = &self.resources.registry.state(state).unwrap().name;
if matches!(
name.as_str(),
"minecraft:air"
| "minecraft:cave_air"
| "minecraft:void_air"
| "minecraft:lava"
| "minecraft:water"
) {
empty += 1;
}
}
if empty > self.max_empty_corners {
return Ok(false);
}
for (template, processors) in [
(base, &self.fossil_processors),
(overlay, &self.overlay_processors),
] {
let mut settings = PlaceSettings::new(rotation).add(processors);
settings.bounding_box = Some(bounds);
settings.random = Some(&mut *random);
place_in_world(
world,
&self.resources,
template,
target,
target,
&mut settings,
None,
260,
)?;
}
Ok(true)
}
}
@@ -0,0 +1,857 @@
//! Template pools, pool elements and JigsawPlacement.
use super::{
BoundingBox, Mirror, Rotation, StructureResources, StructureTemplate,
processor::{PlaceSettings, Processor, ProcessorList, place_in_world},
};
use crate::{
heightmap::HeightmapType,
worldgen::{
DecodeError,
block_feature::FeatureBlockBindings,
feature::FeatureWorld,
placement::{PlacementContext, PlacementQueryError},
},
};
use horizon_core::{
geometry::Direction,
position::BlockPos,
random::{LegacyRandom, RandomSource, position_seed},
};
use serde_json::Value;
use std::{
cell::RefCell,
collections::{BTreeMap, HashMap, VecDeque},
rc::Rc,
sync::{Arc, OnceLock, RwLock},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Projection {
Rigid,
TerrainMatching,
}
#[derive(Debug)]
pub enum PoolElement {
Empty,
Single {
template: Arc<StructureTemplate>,
processors: ProcessorList,
legacy: bool,
projection: Projection,
waterlogging: Option<bool>,
},
Feature {
feature: String,
projection: Projection,
},
List {
elements: Vec<PoolElement>,
projection: Projection,
},
}
#[derive(Clone, Debug)]
pub struct Jigsaw {
pub pos: [i32; 3],
pub front: Direction,
pub top: Direction,
pub rollable: bool,
pub name: Option<String>,
pub pool: String,
pub target: String,
pub placement_priority: i32,
pub selection_priority: i32,
}
fn direction(name: &str) -> Direction {
match name {
"down" => Direction::Down,
"up" => Direction::Up,
"north" => Direction::North,
"south" => Direction::South,
"west" => Direction::West,
_ => Direction::East,
}
}
fn opposite(d: Direction) -> Direction {
match d {
Direction::Down => Direction::Up,
Direction::Up => Direction::Down,
Direction::North => Direction::South,
Direction::South => Direction::North,
Direction::West => Direction::East,
Direction::East => Direction::West,
}
}
fn step(d: Direction) -> [i32; 3] {
let n = d.normal();
[n[0], n[1], n[2]]
}
fn shuffle<T>(list: &mut [T], random: &mut impl RandomSource) {
for i in (2..=list.len()).rev() {
let swap = random.next_int_bound(i as i32).unwrap_or(0) as usize;
list.swap(i - 1, swap);
}
}
fn projection(value: &Value) -> Result<Projection, DecodeError> {
match value["projection"].as_str() {
Some("rigid") => Ok(Projection::Rigid),
Some("terrain_matching") => Ok(Projection::TerrainMatching),
_ => Err(DecodeError::Field("pool element projection")),
}
}
impl PoolElement {
fn decode(
value: &Value,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
inherited: Option<Projection>,
) -> Result<Self, DecodeError> {
let kind = value["element_type"].as_str().unwrap_or_default();
let projection = || match inherited {
Some(p) => Ok(p),
None => projection(value),
};
Ok(match kind {
"minecraft:empty_pool_element" => Self::Empty,
"minecraft:single_pool_element" | "minecraft:legacy_single_pool_element" => {
let location = value["location"]
.as_str()
.ok_or(DecodeError::Field("location"))?;
Self::Single {
template: resources.template(location).ok_or_else(|| {
DecodeError::Registry(format!("missing template {location}"))
})?,
processors: ProcessorList::decode(
&value["processors"].to_string(),
resources,
bindings,
)?,
legacy: kind == "minecraft:legacy_single_pool_element",
projection: projection()?,
waterlogging: match value
.get("override_liquid_settings")
.and_then(Value::as_str)
{
Some("apply_waterlogging") => Some(true),
Some("ignore_waterlogging") => Some(false),
_ => None,
},
}
}
"minecraft:feature_pool_element" => Self::Feature {
feature: value["feature"].as_str().unwrap_or_default().to_owned(),
projection: projection()?,
},
"minecraft:list_pool_element" => {
let p = projection()?;
Self::List {
elements: value["elements"]
.as_array()
.ok_or(DecodeError::Field("list elements"))?
.iter()
.map(|e| Self::decode(e, resources, bindings, Some(p)))
.collect::<Result<_, _>>()?,
projection: p,
}
}
_ => return Err(DecodeError::Field("pool element type")),
})
}
pub fn projection(&self) -> Projection {
match self {
Self::Empty => Projection::TerrainMatching,
Self::Single { projection, .. }
| Self::Feature { projection, .. }
| Self::List { projection, .. } => *projection,
}
}
pub fn size(&self, rotation: Rotation) -> [i32; 3] {
match self {
Self::Empty | Self::Feature { .. } => [0; 3],
Self::Single { template, .. } => template.size(rotation),
Self::List { elements, .. } => elements.iter().fold([0; 3], |acc, e| {
let s = e.size(rotation);
std::array::from_fn(|i| acc[i].max(s[i]))
}),
}
}
pub fn bounding_box(&self, position: [i32; 3], rotation: Rotation) -> BoundingBox {
match self {
Self::Empty => BoundingBox::new(position, position),
Self::Feature { .. } => BoundingBox::new(position, position),
Self::Single { template, .. } => {
template.bounding_box(position, rotation, [0; 3], Mirror::None)
}
Self::List { elements, .. } => {
let mut boxes = elements
.iter()
.filter(|e| !matches!(e, Self::Empty))
.map(|e| e.bounding_box(position, rotation));
let mut first = boxes.next().unwrap_or(BoundingBox::new(position, position));
for b in boxes {
first.encapsulate(&b);
}
first
}
}
}
/// getShuffledJigsawBlocks.
pub fn shuffled_jigsaws(
&self,
resources: &StructureResources,
position: [i32; 3],
rotation: Rotation,
random: &mut impl RandomSource,
) -> Vec<Jigsaw> {
match self {
Self::Empty => Vec::new(),
Self::Feature { .. } => vec![Jigsaw {
pos: position,
front: Direction::Down,
top: Direction::South,
rollable: true,
name: None,
pool: "minecraft:empty".into(),
target: "minecraft:empty".into(),
placement_priority: 0,
selection_priority: 0,
}],
Self::List { elements, .. } => elements
.first()
.map(|e| e.shuffled_jigsaws(resources, position, rotation, random))
.unwrap_or_default(),
Self::Single { template, .. } => {
let mut jigsaws = template_jigsaws(resources, template, position, rotation);
shuffle(&mut jigsaws, random);
jigsaws.sort_by_key(|j| std::cmp::Reverse(j.selection_priority));
jigsaws
}
}
}
pub fn ground_level_delta(&self) -> i32 {
1
}
}
/// StructureTemplate.getJigsaws: palette chosen by a position-seeded random.
fn template_jigsaws(
resources: &StructureResources,
template: &StructureTemplate,
position: [i32; 3],
rotation: Rotation,
) -> Vec<Jigsaw> {
if template.palettes().is_empty() {
return Vec::new();
}
let palette = LegacyRandom::new(position_seed(BlockPos::new(
position[0],
position[1],
position[2],
)))
.next_int_bound(template.palettes().len() as i32)
.unwrap_or(0) as usize;
template
.jigsaws(palette, &|state| resources.jigsaw_horizontal(state))
.iter()
.map(|j| {
let relative = StructureTemplate::transform(j.info.pos, Mirror::None, rotation, [0; 3]);
let state = resources.transforms.rotate(j.info.state, rotation);
let orientation = resources
.registry
.state(state)
.and_then(|s| s.properties.get("orientation").cloned())
.unwrap_or_default();
let (front, top) = orientation.split_once('_').unwrap_or(("north", "up"));
Jigsaw {
pos: std::array::from_fn(|i| relative[i] + position[i]),
front: direction(front),
top: direction(top),
rollable: j.rollable,
name: Some(j.name.clone()),
pool: j.pool.clone(),
target: j.target.clone(),
placement_priority: j.placement_priority,
selection_priority: j.selection_priority,
}
})
.collect()
}
fn can_attach(source: &Jigsaw, target: &Jigsaw) -> bool {
source.front == opposite(target.front)
&& (source.rollable || source.top == target.top)
&& target
.name
.as_ref()
.is_none_or(|name| *name == source.target)
}
#[derive(Debug)]
pub struct Pool {
templates: Vec<Arc<PoolElement>>,
fallback: String,
max_size: OnceLock<i32>,
}
impl Pool {
fn random_template(&self, random: &mut impl RandomSource) -> Arc<PoolElement> {
if self.templates.is_empty() {
return Arc::new(PoolElement::Empty);
}
self.templates[random
.next_int_bound(self.templates.len() as i32)
.unwrap_or(0) as usize]
.clone()
}
fn shuffled(&self, random: &mut impl RandomSource) -> Vec<Arc<PoolElement>> {
let mut copy = self.templates.clone();
shuffle(&mut copy, random);
copy
}
fn max_size(&self) -> i32 {
*self.max_size.get_or_init(|| {
self.templates
.iter()
.filter(|t| !matches!(t.as_ref(), PoolElement::Empty))
.map(|t| t.bounding_box([0; 3], Rotation::None).span()[1])
.max()
.unwrap_or(0)
})
}
}
/// Lazily decoded template pools.
pub struct Pools {
raw: BTreeMap<String, String>,
decoded: RwLock<HashMap<String, Option<Arc<Pool>>>>,
}
impl std::fmt::Debug for Pools {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("Pools")
}
}
impl Pools {
pub fn new(raw: BTreeMap<String, String>) -> Self {
Self {
raw,
decoded: RwLock::new(HashMap::new()),
}
}
pub fn get(
&self,
name: &str,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
) -> Option<Arc<Pool>> {
if let Some(found) = self.decoded.read().unwrap().get(name) {
return found.clone();
}
let pool = self.raw.get(name).and_then(|json| {
let value: Value = serde_json::from_str(json).ok()?;
let mut templates = Vec::new();
for entry in value["elements"].as_array()? {
let element =
match PoolElement::decode(&entry["element"], resources, bindings, None) {
Ok(element) => Arc::new(element),
Err(error) => {
if std::env::var_os("HORIZON_JIGSAW_DEBUG").is_some() {
eprintln!("pool {name}: {error}");
}
return None;
}
};
for _ in 0..entry["weight"].as_i64().unwrap_or(1) {
templates.push(element.clone());
}
}
Some(Arc::new(Pool {
templates,
fallback: value["fallback"]
.as_str()
.unwrap_or("minecraft:empty")
.to_owned(),
max_size: OnceLock::new(),
}))
});
self.decoded
.write()
.unwrap()
.insert(name.to_owned(), pool.clone());
pool
}
}
#[derive(Clone, Copy, Debug)]
pub struct Junction {
pub source_x: i32,
pub source_ground_y: i32,
pub source_z: i32,
}
#[derive(Debug)]
pub struct PoolPiece {
pub element: Arc<PoolElement>,
pub position: [i32; 3],
pub ground_level_delta: i32,
pub rotation: Rotation,
pub bounding_box: BoundingBox,
pub junctions: Vec<Junction>,
pub waterlogging: bool,
}
impl PoolPiece {
fn moved(&mut self, dy: i32) {
self.position[1] += dy;
self.bounding_box = self.bounding_box.moved([0, dy, 0]);
}
/// PoolElementStructurePiece.postProcess.
#[allow(clippy::too_many_arguments)]
pub fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
&self,
world: &mut W,
resources: &StructureResources,
random: &mut R,
chunk_box: BoundingBox,
reference: [i32; 3],
place_feature: &mut dyn FnMut(
&mut W,
&mut R,
&str,
[i32; 3],
) -> Result<bool, PlacementQueryError>,
) -> Result<bool, PlacementQueryError> {
place_element(
&self.element,
world,
resources,
random,
chunk_box,
self.position,
reference,
self.rotation,
self.waterlogging,
place_feature,
)
}
}
static GRAVITY: OnceLock<Processor> = OnceLock::new();
static IGNORE_STRUCTURE_BLOCK: OnceLock<Processor> = OnceLock::new();
static IGNORE_STRUCTURE_AND_AIR: OnceLock<Processor> = OnceLock::new();
#[allow(clippy::too_many_arguments)]
fn place_element<W: FeatureWorld + PlacementContext, R: RandomSource>(
element: &PoolElement,
world: &mut W,
resources: &StructureResources,
random: &mut R,
chunk_box: BoundingBox,
position: [i32; 3],
reference: [i32; 3],
rotation: Rotation,
waterlogging: bool,
place_feature: &mut dyn FnMut(
&mut W,
&mut R,
&str,
[i32; 3],
) -> Result<bool, PlacementQueryError>,
) -> Result<bool, PlacementQueryError> {
match element {
PoolElement::Empty => Ok(true),
PoolElement::Feature { feature, .. } => place_feature(world, random, feature, position),
PoolElement::List { elements, .. } => {
for e in elements {
if !place_element(
e,
world,
resources,
random,
chunk_box,
position,
reference,
rotation,
waterlogging,
place_feature,
)? {
return Ok(false);
}
}
Ok(true)
}
PoolElement::Single {
template,
processors,
legacy,
projection,
waterlogging: override_liquid,
} => {
let ignore = if *legacy {
IGNORE_STRUCTURE_AND_AIR.get_or_init(|| {
Processor::BlockIgnore(
[
"minecraft:structure_block".to_owned(),
"minecraft:air".to_owned(),
]
.into(),
)
})
} else {
IGNORE_STRUCTURE_BLOCK.get_or_init(|| {
Processor::BlockIgnore(["minecraft:structure_block".to_owned()].into())
})
};
let mut settings = PlaceSettings::new(rotation);
settings.bounding_box = Some(chunk_box);
settings.waterlogging = override_liquid.unwrap_or(waterlogging);
settings.processors.push(ignore);
settings.processors.push(&Processor::JigsawReplacement);
settings.processors.extend(processors.0.iter());
if *projection == Projection::TerrainMatching {
settings
.processors
.push(GRAVITY.get_or_init(|| Processor::Gravity {
heightmap: HeightmapType::WorldSurfaceWg,
offset: -1,
}));
}
place_in_world(
world,
resources,
template,
position,
reference,
&mut settings,
Some(random),
18,
)
}
}
}
/// The world queries jigsaw assembly needs from the chunk generator.
pub trait JigsawContext {
fn min_y(&self) -> i32;
fn max_y(&self) -> i32;
/// ChunkGenerator.getBaseHeight (getFirstFreeHeight).
fn base_height(&mut self, x: i32, z: i32, kind: HeightmapType) -> i32;
/// couldStructureExistInColumn over inclusive block Y bounds.
fn column_has_valid_biome(&mut self, x: i32, z: i32, min_y: i32, max_y: i32) -> bool;
}
pub struct JigsawConfig<'a> {
pub start_pool: &'a str,
pub start_jigsaw: Option<&'a str>,
pub max_depth: i32,
pub use_expansion_hack: bool,
pub project_to: Option<HeightmapType>,
pub max_distance: [i32; 2],
pub aliases: &'a BTreeMap<String, String>,
pub padding: [i32; 2],
pub waterlogging: bool,
}
/// Free space for children: an inclusive container box minus placed boxes.
#[derive(Debug)]
struct Free {
container: BoundingBox,
removed: Vec<BoundingBox>,
}
impl Free {
/// Whether every point of the (0.25-deflated) box lies in free space.
fn fits(&self, b: &BoundingBox) -> bool {
(0..3).all(|i| b.min[i] >= self.container.min[i] && b.max[i] <= self.container.max[i])
&& !self.removed.iter().any(|r| r.intersects(b))
}
}
struct PieceState {
piece: usize,
free: Rc<RefCell<Free>>,
depth: i32,
}
/// JigsawPlacement.addPieces. Returns the structure start position and the
/// pieces, or None when the start is invalid.
pub fn assemble(
config: &JigsawConfig<'_>,
context: &mut impl JigsawContext,
pools: &Pools,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
random: &mut impl RandomSource,
position: [i32; 3],
) -> Option<([i32; 3], Vec<PoolPiece>)> {
let alias = |name: &str| {
config
.aliases
.get(name)
.cloned()
.unwrap_or_else(|| name.to_owned())
};
let rotation = Rotation::random(random);
let center_pool = pools.get(&alias(config.start_pool), resources, bindings)?;
let element = center_pool.random_template(random);
if matches!(element.as_ref(), PoolElement::Empty) {
return None;
}
let anchored = match config.start_jigsaw {
Some(name) => {
element
.shuffled_jigsaws(resources, position, rotation, random)
.into_iter()
.find(|j| j.name.as_deref() == Some(name))?
.pos
}
None => position,
};
let local: [i32; 3] = std::array::from_fn(|i| anchored[i] - position[i]);
let adjusted: [i32; 3] = std::array::from_fn(|i| position[i] - local[i]);
let mut center = PoolPiece {
bounding_box: element.bounding_box(adjusted, rotation),
ground_level_delta: element.ground_level_delta(),
element: element.clone(),
position: adjusted,
rotation,
junctions: Vec::new(),
waterlogging: config.waterlogging,
};
let b = center.bounding_box;
let cx = (b.max[0] + b.min[0]) / 2;
let cz = (b.max[2] + b.min[2]) / 2;
let bottom = match config.project_to {
None => adjusted[1],
Some(kind) => {
if !context.column_has_valid_biome(cx, cz, context.min_y(), context.max_y()) {
return None;
}
position[1] + context.base_height(cx, cz, kind)
}
};
let old_ground = b.min[1] + center.ground_level_delta;
center.moved(bottom - old_ground);
let b = center.bounding_box;
if config.padding != [0, 0]
&& (b.min[1] < context.min_y() + config.padding[0]
|| b.max[1] > context.max_y() - config.padding[1])
{
return None;
}
let cy = bottom + local[1];
let mut pieces = vec![center];
if config.max_depth > 0 {
let [h, v] = config.max_distance;
let low_y = (cy - v).max(context.min_y() + config.padding[0]);
let high_y = (cy + v + 1).min(context.max_y() + 1 - config.padding[1]);
let free = Rc::new(RefCell::new(Free {
container: BoundingBox::new([cx - h, low_y, cz - h], [cx + h, high_y - 1, cz + h]),
removed: vec![pieces[0].bounding_box],
}));
let mut placer = Placer {
config,
pools,
resources,
bindings,
pieces: &mut pieces,
queue: BTreeMap::new(),
};
placer.children(0, free, 0, context, random);
while let Some(state) = placer.next() {
placer.children(state.piece, state.free, state.depth, context, random);
}
}
Some(([cx, cy, cz], pieces))
}
struct Placer<'a, 'p> {
config: &'a JigsawConfig<'a>,
pools: &'a Pools,
resources: &'a StructureResources,
bindings: &'a FeatureBlockBindings<'a>,
pieces: &'p mut Vec<PoolPiece>,
/// SequencedPriorityIterator: highest priority first, FIFO within one.
queue: BTreeMap<i32, VecDeque<PieceState>>,
}
impl Placer<'_, '_> {
fn next(&mut self) -> Option<PieceState> {
let mut entry = self.queue.last_entry()?;
let state = entry.get_mut().pop_front();
if entry.get().is_empty() {
entry.remove();
}
state
}
fn pool(&self, name: &str) -> Option<Arc<Pool>> {
let name = self.config.aliases.get(name).map_or(name, String::as_str);
self.pools.get(name, self.resources, self.bindings)
}
fn children(
&mut self,
source_index: usize,
context_free: Rc<RefCell<Free>>,
depth: i32,
context: &mut impl JigsawContext,
random: &mut impl RandomSource,
) {
let (source_element, source_position, source_rotation, source_box, source_ground) = {
let s = &self.pieces[source_index];
(
s.element.clone(),
s.position,
s.rotation,
s.bounding_box,
s.ground_level_delta,
)
};
let source_rigid = source_element.projection() == Projection::Rigid;
let mut source_free: Option<Rc<RefCell<Free>>> = None;
let source_y = source_box.min[1];
let jigsaws = source_element.shuffled_jigsaws(
self.resources,
source_position,
source_rotation,
random,
);
'jigsaws: for jigsaw in jigsaws {
let direction = jigsaw.front;
let s = step(direction);
let target_pos: [i32; 3] = std::array::from_fn(|i| jigsaw.pos[i] + s[i]);
let local_y = jigsaw.pos[1] - source_y;
let mut base_height = i32::MIN;
let Some(target_pool) = self.pool(&jigsaw.pool) else {
continue;
};
if target_pool.templates.is_empty() && jigsaw.pool != "minecraft:empty" {
continue;
}
let Some(fallback) = self.pool(&target_pool.fallback) else {
continue;
};
if fallback.templates.is_empty() && target_pool.fallback != "minecraft:empty" {
continue;
}
let children_free = if source_box.is_inside(target_pos) {
source_free
.get_or_insert_with(|| {
Rc::new(RefCell::new(Free {
container: source_box,
removed: Vec::new(),
}))
})
.clone()
} else {
context_free.clone()
};
let mut targets = Vec::new();
if depth != self.config.max_depth {
targets.extend(target_pool.shuffled(random));
}
targets.extend(fallback.shuffled(random));
for target in targets {
if matches!(target.as_ref(), PoolElement::Empty) {
break;
}
let mut rotations = Rotation::ALL;
shuffle(&mut rotations, random);
for rotation in rotations {
let target_jigsaws =
target.shuffled_jigsaws(self.resources, [0; 3], rotation, random);
let hack_box = target.bounding_box([0; 3], rotation);
let expand_to = if self.config.use_expansion_hack && hack_box.span()[1] <= 16 {
target_jigsaws
.iter()
.map(|tj| {
let st = step(tj.front);
if !hack_box.is_inside(std::array::from_fn(|i| tj.pos[i] + st[i])) {
return 0;
}
let child = self.pool(&tj.pool);
let child_size = child.as_ref().map_or(0, |p| p.max_size());
let fallback_size = child
.and_then(|p| self.pool(&p.fallback))
.map_or(0, |p| p.max_size());
child_size.max(fallback_size)
})
.max()
.unwrap_or(0)
} else {
0
};
for target_jigsaw in &target_jigsaws {
if !can_attach(&jigsaw, target_jigsaw) {
continue;
}
let target_local = target_jigsaw.pos;
let raw_position: [i32; 3] =
std::array::from_fn(|i| target_pos[i] - target_local[i]);
let raw_box = target.bounding_box(raw_position, rotation);
let raw_y = raw_box.min[1];
let target_rigid = target.projection() == Projection::Rigid;
let target_local_y = target_local[1];
let delta_y = local_y - target_local_y + step(jigsaw.front)[1];
let target_y = if source_rigid && target_rigid {
source_y + delta_y
} else {
if base_height == i32::MIN {
base_height = context.base_height(
jigsaw.pos[0],
jigsaw.pos[2],
HeightmapType::WorldSurfaceWg,
);
}
base_height - target_local_y
};
let offset = target_y - raw_y;
let mut target_box = raw_box.moved([0, offset, 0]);
let target_position =
[raw_position[0], raw_position[1] + offset, raw_position[2]];
if expand_to > 0 {
let size = (expand_to + 1).max(target_box.max[1] - target_box.min[1]);
target_box.max[1] = target_box.max[1].max(target_box.min[1] + size);
}
if !children_free.borrow().fits(&target_box) {
continue;
}
children_free.borrow_mut().removed.push(target_box);
let target_ground = if target_rigid {
source_ground - delta_y
} else {
target.ground_level_delta()
};
let junction_y = if source_rigid {
source_y + local_y
} else if target_rigid {
target_y + target_local_y
} else {
if base_height == i32::MIN {
base_height = context.base_height(
jigsaw.pos[0],
jigsaw.pos[2],
HeightmapType::WorldSurfaceWg,
);
}
base_height + delta_y / 2
};
self.pieces[source_index].junctions.push(Junction {
source_x: target_pos[0],
source_ground_y: junction_y - local_y + source_ground,
source_z: target_pos[2],
});
self.pieces.push(PoolPiece {
element: target.clone(),
position: target_position,
ground_level_delta: target_ground,
rotation,
bounding_box: target_box,
junctions: vec![Junction {
source_x: jigsaw.pos[0],
source_ground_y: junction_y - target_local_y + target_ground,
source_z: jigsaw.pos[2],
}],
waterlogging: self.config.waterlogging,
});
if depth < self.config.max_depth {
self.queue
.entry(jigsaw.placement_priority)
.or_default()
.push_back(PieceState {
piece: self.pieces.len() - 1,
free: children_free.clone(),
depth: depth + 1,
});
}
continue 'jigsaws;
}
}
}
}
}
}
@@ -0,0 +1,818 @@
//! Piece-based ("legacy") structure support: the StructurePiece helpers,
//! object-safe world/random access and template pieces.
use super::{
BlockInfo, BoundingBox, Mirror, Rotation, StructureResources, StructureTemplate,
processor::{PlaceSettings, Processor, ProcessorList, ProcessorRandom, place_in_world},
};
use crate::{
chunk::BlockState,
fluid::FluidState,
heightmap::HeightmapType,
nbt::{Compound, JavaString, Tag},
registry::BlockStateId,
worldgen::{
feature::FeatureWorld,
placement::{PlacementContext, PlacementQueryError},
},
};
use horizon_core::{
geometry::Direction,
position::{BlockPos, ChunkPos},
random::{LegacyRandom, RandomSource, position_seed},
};
use std::sync::{Arc, Mutex};
pub type Result<T> = std::result::Result<T, PlacementQueryError>;
/// The random draws legacy pieces make.
pub trait PieceRandom: ProcessorRandom {
fn boolean(&mut self) -> bool;
fn double(&mut self) -> f64;
}
impl<R: RandomSource> PieceRandom for R {
fn boolean(&mut self) -> bool {
self.next_boolean()
}
fn double(&mut self) -> f64 {
self.next_double()
}
}
/// Object-safe world access for piece post-processing.
pub trait PieceWorld {
fn block(&mut self, pos: [i32; 3]) -> Result<BlockStateId>;
fn set(&mut self, pos: [i32; 3], state: BlockStateId, flags: i32) -> Result<bool>;
fn fluid(&mut self, pos: [i32; 3]) -> Result<FluidState>;
fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result<i32>;
fn min_y(&mut self) -> Result<i32>;
fn max_y(&mut self) -> Result<i32>;
fn block_entity(&mut self, pos: [i32; 3], nbt: Compound) -> Result<()>;
fn post_process(&mut self, pos: [i32; 3]) -> Result<()>;
fn place_template(
&mut self,
resources: &StructureResources,
template: &StructureTemplate,
position: [i32; 3],
reference: [i32; 3],
settings: &mut PlaceSettings<'_>,
random: &mut dyn ProcessorRandom,
flags: i32,
) -> Result<bool>;
}
impl<W: FeatureWorld + PlacementContext> PieceWorld for W {
fn block(&mut self, pos: [i32; 3]) -> Result<BlockStateId> {
self.block_state(pos)
}
fn set(&mut self, pos: [i32; 3], state: BlockStateId, flags: i32) -> Result<bool> {
self.set_block(pos, state, flags)
.map_err(|_| PlacementQueryError::Failed("piece write".into()))
}
fn fluid(&mut self, pos: [i32; 3]) -> Result<FluidState> {
self.fluid_state(pos)
}
fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result<i32> {
PlacementContext::height(self, kind, x, z)
}
fn min_y(&mut self) -> Result<i32> {
PlacementContext::min_y(self)
}
fn max_y(&mut self) -> Result<i32> {
PlacementContext::max_y(self)
}
fn block_entity(&mut self, pos: [i32; 3], nbt: Compound) -> Result<()> {
self.set_block_entity(pos, nbt)
}
fn post_process(&mut self, pos: [i32; 3]) -> Result<()> {
self.mark_postprocessing(pos)
}
fn place_template(
&mut self,
resources: &StructureResources,
template: &StructureTemplate,
position: [i32; 3],
reference: [i32; 3],
settings: &mut PlaceSettings<'_>,
random: &mut dyn ProcessorRandom,
flags: i32,
) -> Result<bool> {
place_in_world(
self,
resources,
template,
position,
reference,
settings,
Some(random),
flags,
)
}
}
/// Everything a piece needs while post-processing one chunk.
pub struct PieceContext<'a> {
pub world: &'a mut dyn PieceWorld,
pub resources: &'a StructureResources,
pub random: &'a mut dyn PieceRandom,
pub chunk_box: BoundingBox,
pub chunk: ChunkPos,
pub reference: [i32; 3],
}
impl PieceContext<'_> {
pub fn state(&self, name: &str) -> BlockStateId {
state(self.resources, name, &[])
}
pub fn state_with(&self, name: &str, properties: &[(&str, &str)]) -> BlockStateId {
state(self.resources, name, properties)
}
pub fn name(&self, state: BlockStateId) -> &str {
self.resources
.registry
.state(state)
.map(|s| s.name.as_str())
.unwrap_or("")
}
pub fn is_block(&mut self, pos: [i32; 3], name: &str) -> Result<bool> {
let state = self.world.block(pos)?;
Ok(self.name(state) == name)
}
pub fn is_air(&self, state: BlockStateId) -> bool {
matches!(
self.name(state),
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
)
}
/// BlockState.liquid(): water and lava blocks.
pub fn is_liquid(&self, state: BlockStateId) -> bool {
matches!(self.name(state), "minecraft:water" | "minecraft:lava")
}
pub fn property<'s>(&'s self, state: BlockStateId, key: &str) -> Option<&'s str> {
self.resources
.registry
.state(state)
.and_then(|s| s.properties.get(key))
.map(String::as_str)
}
pub fn with_property(&self, state: BlockStateId, key: &str, value: &str) -> BlockStateId {
let Some(mut descriptor) = self.resources.registry.state(state).cloned() else {
return state;
};
if let Some(slot) = descriptor.properties.get_mut(key) {
*slot = value.to_owned();
}
self.resources.registry.id(&descriptor).unwrap_or(state)
}
/// Store a loot-table container's block entity (RandomizableContainer.setLootTable).
pub fn loot_table(&mut self, pos: [i32; 3], kind: &str, table: &str) -> Result<()> {
let seed = self.random.long();
let mut nbt = Compound::new();
nbt.insert("id".into(), Tag::String(kind.into()));
nbt.insert("LootTable".into(), Tag::String(table.into()));
nbt.insert("LootTableSeed".into(), Tag::Long(seed));
self.world.block_entity(pos, nbt)
}
}
/// A state by block name and properties (missing properties keep defaults).
pub fn state(
resources: &StructureResources,
name: &str,
properties: &[(&str, &str)],
) -> BlockStateId {
let registry = resources.registry;
let mut descriptor = BlockState {
name: if name.contains(':') {
name.to_owned()
} else {
format!("minecraft:{name}")
},
properties: Default::default(),
};
for (k, v) in properties {
descriptor
.properties
.insert((*k).to_owned(), (*v).to_owned());
}
registry
.resolve(&descriptor)
.ok()
.or_else(|| registry.default_state(&descriptor.name))
.unwrap_or_else(|| registry.default_state("minecraft:air").unwrap())
}
/// A placed structure piece.
pub trait LegacyPiece: std::fmt::Debug + Send + Sync {
fn bounding_box(&self) -> BoundingBox;
/// The vanilla StructurePieceType id, for diagnostics and comparisons.
fn type_name(&self) -> &'static str;
fn post_process(&self, context: &mut PieceContext<'_>) -> Result<()>;
}
/// StructurePiece's orientation transform and block helpers.
#[derive(Clone, Copy, Debug)]
pub struct PieceFrame {
pub bounding_box: BoundingBox,
pub orientation: Option<Direction>,
pub mirror: Mirror,
pub rotation: Rotation,
}
pub const HORIZONTAL: [Direction; 4] = [
Direction::North,
Direction::East,
Direction::South,
Direction::West,
];
/// Direction.Plane.HORIZONTAL.getRandomDirection.
pub fn random_horizontal(random: &mut impl RandomSource) -> Direction {
HORIZONTAL[random.next_int_bound(4).unwrap_or(0) as usize]
}
pub fn make_bounding_box(
x: i32,
y: i32,
z: i32,
direction: Direction,
width: i32,
height: i32,
depth: i32,
) -> BoundingBox {
if matches!(direction, Direction::North | Direction::South) {
BoundingBox::new([x, y, z], [x + width - 1, y + height - 1, z + depth - 1])
} else {
BoundingBox::new([x, y, z], [x + depth - 1, y + height - 1, z + width - 1])
}
}
impl PieceFrame {
pub fn new(bounding_box: BoundingBox, orientation: Option<Direction>) -> Self {
let (mirror, rotation) = match orientation {
Some(Direction::South) => (Mirror::LeftRight, Rotation::None),
Some(Direction::West) => (Mirror::LeftRight, Rotation::Clockwise90),
Some(Direction::East) => (Mirror::None, Rotation::Clockwise90),
_ => (Mirror::None, Rotation::None),
};
Self {
bounding_box,
orientation,
mirror,
rotation,
}
}
pub fn world_x(&self, x: i32, z: i32) -> i32 {
match self.orientation {
Some(Direction::North | Direction::South) => self.bounding_box.min[0] + x,
Some(Direction::West) => self.bounding_box.max[0] - z,
Some(Direction::East) => self.bounding_box.min[0] + z,
_ => x,
}
}
pub fn world_y(&self, y: i32) -> i32 {
if self.orientation.is_none() {
y
} else {
y + self.bounding_box.min[1]
}
}
pub fn world_z(&self, x: i32, z: i32) -> i32 {
match self.orientation {
Some(Direction::North) => self.bounding_box.max[2] - z,
Some(Direction::South) => self.bounding_box.min[2] + z,
Some(Direction::West | Direction::East) => self.bounding_box.min[2] + x,
_ => z,
}
}
pub fn world_pos(&self, x: i32, y: i32, z: i32) -> [i32; 3] {
[self.world_x(x, z), self.world_y(y), self.world_z(x, z)]
}
/// StructurePiece.placeBlock (canBeReplaced is always true here).
pub fn place(
&self,
c: &mut PieceContext<'_>,
state: BlockStateId,
x: i32,
y: i32,
z: i32,
) -> Result<()> {
let pos = self.world_pos(x, y, z);
if !c.chunk_box.is_inside(pos) {
return Ok(());
}
let mut state = state;
if self.mirror != Mirror::None {
state = c.resources.transforms.mirror(state, self.mirror);
}
if self.rotation != Rotation::None {
state = c.resources.transforms.rotate(state, self.rotation);
}
c.world.set(pos, state, 2)?;
let fluid = c.world.fluid(pos)?;
if fluid.kind() != crate::fluid::FluidKind::Empty {
// scheduleTick(pos, fluid, 0) is a no-op for generation output.
}
if matches!(
c.name(state),
"minecraft:nether_brick_fence"
| "minecraft:torch"
| "minecraft:wall_torch"
| "minecraft:oak_fence"
| "minecraft:spruce_fence"
| "minecraft:dark_oak_fence"
| "minecraft:pale_oak_fence"
| "minecraft:acacia_fence"
| "minecraft:birch_fence"
| "minecraft:jungle_fence"
| "minecraft:ladder"
| "minecraft:iron_bars"
) {
c.world.post_process(pos)?;
}
Ok(())
}
pub fn get(&self, c: &mut PieceContext<'_>, x: i32, y: i32, z: i32) -> Result<BlockStateId> {
let pos = self.world_pos(x, y, z);
if c.chunk_box.is_inside(pos) {
c.world.block(pos)
} else {
Ok(c.state("air"))
}
}
pub fn is_interior(&self, c: &mut PieceContext<'_>, x: i32, y: i32, z: i32) -> Result<bool> {
let pos = self.world_pos(x, y + 1, z);
if !c.chunk_box.is_inside(pos) {
return Ok(false);
}
Ok(pos[1]
< c.world
.height(HeightmapType::OceanFloorWg, pos[0], pos[2])?)
}
#[allow(clippy::too_many_arguments)]
pub fn generate_box(
&self,
c: &mut PieceContext<'_>,
[x0, y0, z0]: [i32; 3],
[x1, y1, z1]: [i32; 3],
edge: BlockStateId,
fill: BlockStateId,
skip_air: bool,
) -> Result<()> {
for y in y0..=y1 {
for x in x0..=x1 {
for z in z0..=z1 {
if skip_air {
let s = self.get(c, x, y, z)?;
if c.is_air(s) {
continue;
}
}
let interior = y != y0 && y != y1 && x != x0 && x != x1 && z != z0 && z != z1;
self.place(c, if interior { fill } else { edge }, x, y, z)?;
}
}
}
Ok(())
}
/// generateBox with a block selector called as (random, x, y, z, edge).
pub fn generate_box_selector(
&self,
c: &mut PieceContext<'_>,
[x0, y0, z0]: [i32; 3],
[x1, y1, z1]: [i32; 3],
skip_air: bool,
selector: &mut dyn FnMut(&mut PieceContext<'_>, i32, i32, i32, bool) -> BlockStateId,
) -> Result<()> {
for y in y0..=y1 {
for x in x0..=x1 {
for z in z0..=z1 {
if skip_air {
let s = self.get(c, x, y, z)?;
if c.is_air(s) {
continue;
}
}
let edge = y == y0 || y == y1 || x == x0 || x == x1 || z == z0 || z == z1;
let state = selector(c, x, y, z, edge);
self.place(c, state, x, y, z)?;
}
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub fn generate_maybe_box(
&self,
c: &mut PieceContext<'_>,
probability: f32,
[x0, y0, z0]: [i32; 3],
[x1, y1, z1]: [i32; 3],
edge: BlockStateId,
fill: BlockStateId,
skip_air: bool,
inside: bool,
) -> Result<()> {
for y in y0..=y1 {
for x in x0..=x1 {
for z in z0..=z1 {
if c.random.float() > probability {
continue;
}
if skip_air {
let s = self.get(c, x, y, z)?;
if c.is_air(s) {
continue;
}
}
if inside && !self.is_interior(c, x, y, z)? {
continue;
}
let interior = y != y0 && y != y1 && x != x0 && x != x1 && z != z0 && z != z1;
self.place(c, if interior { fill } else { edge }, x, y, z)?;
}
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub fn maybe_block(
&self,
c: &mut PieceContext<'_>,
probability: f32,
x: i32,
y: i32,
z: i32,
state: BlockStateId,
) -> Result<()> {
if c.random.float() < probability {
self.place(c, state, x, y, z)?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub fn upper_half_sphere(
&self,
c: &mut PieceContext<'_>,
[x0, y0, z0]: [i32; 3],
[x1, y1, z1]: [i32; 3],
fill: BlockStateId,
skip_air: bool,
) -> Result<()> {
let dx = (x1 - x0 + 1) as f32;
let dy = (y1 - y0 + 1) as f32;
let dz = (z1 - z0 + 1) as f32;
let cx = x0 as f32 + dx / 2.;
let cz = z0 as f32 + dz / 2.;
for y in y0..=y1 {
let ny = (y - y0) as f32 / dy;
for x in x0..=x1 {
let nx = (x as f32 - cx) / (dx * 0.5);
for z in z0..=z1 {
let nz = (z as f32 - cz) / (dz * 0.5);
if skip_air {
let s = self.get(c, x, y, z)?;
if c.is_air(s) {
continue;
}
}
if nx * nx + ny * ny + nz * nz <= 1.05 {
self.place(c, fill, x, y, z)?;
}
}
}
}
Ok(())
}
pub fn fill_column_down(
&self,
c: &mut PieceContext<'_>,
state: BlockStateId,
x: i32,
y: i32,
z: i32,
) -> Result<()> {
let mut pos = self.world_pos(x, y, z);
if !c.chunk_box.is_inside(pos) {
return Ok(());
}
let min = c.world.min_y()?;
loop {
let current = c.world.block(pos)?;
let replaceable = c.is_air(current)
|| c.is_liquid(current)
|| matches!(
c.name(current),
"minecraft:glow_lichen" | "minecraft:seagrass" | "minecraft:tall_seagrass"
);
if !replaceable || pos[1] <= min + 1 {
break;
}
c.world.set(pos, state, 2)?;
pos[1] -= 1;
}
Ok(())
}
/// StructurePiece.createChest at piece coordinates.
pub fn create_chest(
&self,
c: &mut PieceContext<'_>,
x: i32,
y: i32,
z: i32,
table: &str,
) -> Result<bool> {
let pos = self.world_pos(x, y, z);
create_chest(c, pos, table, None)
}
#[allow(clippy::too_many_arguments)]
pub fn create_dispenser(
&self,
c: &mut PieceContext<'_>,
x: i32,
y: i32,
z: i32,
facing: Direction,
table: &str,
) -> Result<bool> {
let pos = self.world_pos(x, y, z);
if !c.chunk_box.is_inside(pos) || c.is_block(pos, "minecraft:dispenser")? {
return Ok(false);
}
let state = c.state_with("dispenser", &[("facing", direction_name(facing))]);
self.place(c, state, x, y, z)?;
c.loot_table(pos, "minecraft:dispenser", table)?;
Ok(true)
}
}
pub fn direction_name(d: Direction) -> &'static str {
match d {
Direction::Down => "down",
Direction::Up => "up",
Direction::North => "north",
Direction::South => "south",
Direction::West => "west",
Direction::East => "east",
}
}
pub fn offset(pos: [i32; 3], d: Direction, n: i32) -> [i32; 3] {
let s = d.normal();
[pos[0] + s[0] * n, pos[1] + s[1] * n, pos[2] + s[2] * n]
}
fn solid_render(c: &PieceContext<'_>, state: BlockStateId) -> bool {
c.resources.transforms.full_block(state) && !c.is_liquid(state)
}
/// StructurePiece.createChest with an absolute position.
pub fn create_chest(
c: &mut PieceContext<'_>,
pos: [i32; 3],
table: &str,
state: Option<BlockStateId>,
) -> Result<bool> {
if !c.chunk_box.is_inside(pos) || c.is_block(pos, "minecraft:chest")? {
return Ok(false);
}
let state = match state {
Some(s) => s,
None => reorient(c, pos, c.state("chest"))?,
};
c.world.set(pos, state, 2)?;
c.loot_table(pos, "minecraft:chest", table)?;
Ok(true)
}
/// StructurePiece.reorient for chests (solid-render approximated by the
/// full collision cube of non-liquid blocks).
fn reorient(c: &mut PieceContext<'_>, pos: [i32; 3], state: BlockStateId) -> Result<BlockStateId> {
let mut solid: Option<Direction> = None;
for d in HORIZONTAL {
let n = c.world.block(offset(pos, d, 1))?;
if c.name(n) == "minecraft:chest" {
return Ok(state);
}
if solid_render(c, n) {
if solid.is_some() {
solid = None;
break;
}
solid = Some(d);
}
}
if let Some(d) = solid {
return Ok(c.with_property(state, "facing", direction_name(opposite(d))));
}
let mut facing = match c.property(state, "facing") {
Some("south") => Direction::South,
Some("east") => Direction::East,
Some("west") => Direction::West,
_ => Direction::North,
};
let solid_at = |c: &mut PieceContext<'_>, d: Direction| -> Result<bool> {
let s = c.world.block(offset(pos, d, 1))?;
Ok(solid_render(c, s))
};
if solid_at(c, facing)? {
facing = opposite(facing);
}
if solid_at(c, facing)? {
facing = clockwise(facing);
}
if solid_at(c, facing)? {
facing = opposite(facing);
}
Ok(c.with_property(state, "facing", direction_name(facing)))
}
pub fn opposite(d: Direction) -> Direction {
match d {
Direction::Down => Direction::Up,
Direction::Up => Direction::Down,
Direction::North => Direction::South,
Direction::South => Direction::North,
Direction::West => Direction::East,
Direction::East => Direction::West,
}
}
pub fn clockwise(d: Direction) -> Direction {
match d {
Direction::North => Direction::East,
Direction::East => Direction::South,
Direction::South => Direction::West,
Direction::West => Direction::North,
other => other,
}
}
pub fn counter_clockwise(d: Direction) -> Direction {
match d {
Direction::North => Direction::West,
Direction::West => Direction::South,
Direction::South => Direction::East,
Direction::East => Direction::North,
other => other,
}
}
/// TemplateStructurePiece: one template with fixed settings; data markers
/// are handed to the owning structure.
#[derive(Debug)]
pub struct TemplatePiece {
pub type_name: &'static str,
pub template_name: String,
pub template: Arc<StructureTemplate>,
pub position: [i32; 3],
pub rotation: Rotation,
pub mirror: Mirror,
pub pivot: [i32; 3],
pub processors: Arc<ProcessorList>,
pub waterlogging: bool,
/// Ignore structure blocks (and air, for ocean ruins) before processors.
pub ignore: Vec<String>,
pub bounding_box: BoundingBox,
pub handler: TemplateHandler,
/// Per-piece state mutated by vanilla post-processing (e.g. ruined
/// portals record nothing; shipwrecks/igloos re-place at a height).
pub state: Mutex<Option<i32>>,
}
#[derive(Clone, Copy, Debug)]
pub enum TemplateHandler {
Igloo,
Shipwreck {
beached: bool,
},
OceanRuin {
warm: bool,
large: bool,
integrity: f32,
},
Plain,
}
impl TemplatePiece {
#[allow(clippy::too_many_arguments)]
pub fn new(
type_name: &'static str,
template_name: &str,
template: Arc<StructureTemplate>,
position: [i32; 3],
rotation: Rotation,
mirror: Mirror,
pivot: [i32; 3],
processors: Arc<ProcessorList>,
waterlogging: bool,
ignore: Vec<String>,
handler: TemplateHandler,
) -> Self {
Self {
bounding_box: template.bounding_box(position, rotation, pivot, mirror),
type_name,
template_name: template_name.to_owned(),
template,
position,
rotation,
mirror,
pivot,
processors,
waterlogging,
ignore,
handler,
state: Mutex::new(None),
}
}
pub fn settings(&self) -> PlaceSettings<'_> {
let mut s = PlaceSettings::new(self.rotation);
s.mirror = self.mirror;
s.pivot = self.pivot;
s.waterlogging = self.waterlogging;
s
}
/// TemplateStructurePiece.postProcess at a (possibly shifted) position;
/// returns the data markers (metadata, absolute position) on success.
pub fn place_at(
&self,
c: &mut PieceContext<'_>,
position: [i32; 3],
extra: &[Processor],
) -> Result<Option<Vec<(String, [i32; 3])>>> {
let ignore = Processor::BlockIgnore(self.ignore.iter().cloned().collect());
let mut settings = self.settings();
settings.bounding_box = Some(c.chunk_box);
settings.processors.push(&ignore);
settings.processors.extend(extra.iter());
settings.processors.extend(self.processors.0.iter());
let resources = c.resources;
let reference = c.reference;
if !c.world.place_template(
resources,
&self.template,
position,
reference,
&mut settings,
&mut *c.random,
2,
)? {
return Ok(None);
}
let mut markers = Vec::new();
let mut jigsaws = Vec::new();
for info in filter_blocks(resources, &self.template, position, &settings) {
let name = c.name(info.state).to_owned();
let Some(nbt) = &info.nbt else { continue };
let text = |key: &str| match nbt.get(&JavaString::from(key)) {
Some(Tag::String(s)) => s.to_string_lossy(),
_ => String::new(),
};
if name == "minecraft:structure_block" && text("mode").eq_ignore_ascii_case("data") {
markers.push((text("metadata"), info.pos));
} else if name == "minecraft:jigsaw" {
let final_state = nbt
.get(&JavaString::from("final_state"))
.map(|_| text("final_state"))
.unwrap_or_else(|| "minecraft:air".into());
jigsaws.push((info.pos, final_state));
}
}
for (pos, final_state) in jigsaws {
let state = super::template::parse_state_string(resources.registry, &final_state)
.unwrap_or_else(|| c.state("air"));
c.world.set(pos, state, 3)?;
}
Ok(Some(markers))
}
}
/// StructureTemplate.filterBlocks for structure and jigsaw blocks (palette
/// chosen by settings' random or a position seed), within the settings box.
fn filter_blocks(
resources: &StructureResources,
template: &StructureTemplate,
position: [i32; 3],
settings: &PlaceSettings<'_>,
) -> Vec<BlockInfo> {
if template.palettes().is_empty() {
return Vec::new();
}
let palette = LegacyRandom::new(position_seed(BlockPos::new(
position[0],
position[1],
position[2],
)))
.next_int_bound(template.palettes().len() as i32)
.unwrap_or(0) as usize;
template.palettes()[palette]
.blocks()
.iter()
.filter(|b| {
let name = resources
.registry
.state(b.state)
.map(|s| s.name.as_str())
.unwrap_or("");
name == "minecraft:structure_block" || name == "minecraft:jigsaw"
})
.filter_map(|b| {
let relative = StructureTemplate::transform(
b.pos,
settings.mirror,
settings.rotation,
settings.pivot,
);
let pos: [i32; 3] = std::array::from_fn(|i| relative[i] + position[i]);
settings
.bounding_box
.is_none_or(|bb| bb.is_inside(pos))
.then(|| BlockInfo {
pos,
state: resources.transforms.rotate(b.state, settings.rotation),
nbt: b.nbt.clone(),
})
})
.collect()
}
@@ -0,0 +1,353 @@
//! Ocean ruins (OceanRuinPieces).
use super::{
BoundingBox, Mirror, Rotation, StructureResources, StructureTemplate,
legacy::{PieceContext, Result, TemplateHandler, TemplatePiece},
processor::ProcessorList,
};
use crate::{
fluid::FluidKind,
heightmap::HeightmapType,
worldgen::{DecodeError, block_feature::FeatureBlockBindings},
};
use horizon_core::random::RandomSource;
use std::sync::Arc;
const WARM: [&str; 8] = [
"warm_1", "warm_2", "warm_3", "warm_4", "warm_5", "warm_6", "warm_7", "warm_8",
];
const BIG_WARM: [&str; 4] = ["big_warm_4", "big_warm_5", "big_warm_6", "big_warm_7"];
const BRICK: [&str; 8] = [
"brick_1", "brick_2", "brick_3", "brick_4", "brick_5", "brick_6", "brick_7", "brick_8",
];
const CRACKED: [&str; 8] = [
"cracked_1",
"cracked_2",
"cracked_3",
"cracked_4",
"cracked_5",
"cracked_6",
"cracked_7",
"cracked_8",
];
const MOSSY: [&str; 8] = [
"mossy_1", "mossy_2", "mossy_3", "mossy_4", "mossy_5", "mossy_6", "mossy_7", "mossy_8",
];
const BIG_BRICK: [&str; 4] = ["big_brick_1", "big_brick_2", "big_brick_3", "big_brick_8"];
const BIG_CRACKED: [&str; 4] = [
"big_cracked_1",
"big_cracked_2",
"big_cracked_3",
"big_cracked_8",
];
const BIG_MOSSY: [&str; 4] = ["big_mossy_1", "big_mossy_2", "big_mossy_3", "big_mossy_8"];
/// Mth.nextInt(random, min, max).
pub fn next_int(random: &mut impl RandomSource, min: i32, max: i32) -> i32 {
if min >= max {
min
} else {
random.next_int_bound(max - min + 1).unwrap_or(0) + min
}
}
pub struct OceanRuinConfig {
pub warm: bool,
pub large_probability: f32,
pub cluster_probability: f32,
}
fn processors(
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
integrity: f32,
warm: bool,
) -> std::result::Result<Arc<ProcessorList>, DecodeError> {
let (candidate, replacement, table) = if warm {
(
"minecraft:sand",
"minecraft:suspicious_sand",
"minecraft:archaeology/ocean_ruin_warm",
)
} else {
(
"minecraft:gravel",
"minecraft:suspicious_gravel",
"minecraft:archaeology/ocean_ruin_cold",
)
};
let json = serde_json::json!({"processors": [
{"processor_type": "minecraft:block_rot", "integrity": integrity},
{"processor_type": "minecraft:block_ignore", "blocks": [{"id": "minecraft:structure_block"}, {"id": "minecraft:air"}]},
{"processor_type": "minecraft:capped", "limit": 5, "delegate": {"processor_type": "minecraft:rule", "rules": [{
"input_predicate": {"predicate_type": "minecraft:block_match", "block": candidate},
"location_predicate": {"predicate_type": "minecraft:always_true"},
"output_state": {"id": replacement},
"block_entity_modifier": {"type": "minecraft:append_loot", "loot_table": table}
}]}}
]});
Ok(Arc::new(ProcessorList::decode(
&json.to_string(),
resources,
bindings,
)?))
}
#[allow(clippy::too_many_arguments)]
fn piece(
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
name: &str,
position: [i32; 3],
rotation: Rotation,
integrity: f32,
warm: bool,
large: bool,
) -> Option<TemplatePiece> {
let name = format!("minecraft:underwater_ruin/{name}");
Some(TemplatePiece::new(
"minecraft:orp",
&name,
resources.template(&name)?,
position,
rotation,
Mirror::None,
[0; 3],
processors(resources, bindings, integrity, warm).ok()?,
true,
Vec::new(),
TemplateHandler::OceanRuin {
warm,
large,
integrity,
},
))
}
#[allow(clippy::too_many_arguments)]
fn add_piece(
out: &mut Vec<TemplatePiece>,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
position: [i32; 3],
rotation: Rotation,
random: &mut impl RandomSource,
config: &OceanRuinConfig,
large: bool,
integrity: f32,
) -> Option<()> {
if config.warm {
let names: &[&str] = if large { &BIG_WARM } else { &WARM };
let name = names[random.next_int_bound(names.len() as i32).ok()? as usize];
out.push(piece(
resources, bindings, name, position, rotation, integrity, true, large,
)?);
} else {
let (bricks, cracked, mossy): (&[&str], &[&str], &[&str]) = if large {
(&BIG_BRICK, &BIG_CRACKED, &BIG_MOSSY)
} else {
(&BRICK, &CRACKED, &MOSSY)
};
let idx = random.next_int_bound(bricks.len() as i32).ok()? as usize;
out.push(piece(
resources,
bindings,
bricks[idx],
position,
rotation,
integrity,
false,
large,
)?);
out.push(piece(
resources,
bindings,
cracked[idx],
position,
rotation,
0.7,
false,
large,
)?);
out.push(piece(
resources, bindings, mossy[idx], position, rotation, 0.5, false, large,
)?);
}
Some(())
}
/// OceanRuinPieces.addPieces.
pub fn pieces(
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
position: [i32; 3],
rotation: Rotation,
random: &mut impl RandomSource,
config: &OceanRuinConfig,
) -> Option<Vec<TemplatePiece>> {
let mut out = Vec::new();
let large = random.next_float() <= config.large_probability;
let integrity = if large { 0.9 } else { 0.8 };
add_piece(
&mut out, resources, bindings, position, rotation, random, config, large, integrity,
)?;
if large && random.next_float() <= config.cluster_probability {
let parent = [position[0], 90, position[2]];
let corner = StructureTemplate::transform([15, 0, 15], Mirror::None, rotation, [0; 3]);
let corner = [
corner[0] + parent[0],
corner[1] + parent[1],
corner[2] + parent[2],
];
let parent_box = BoundingBox::from_corners(parent, corner);
let origin = [
parent[0].min(corner[0]),
parent[1],
parent[2].min(corner[2]),
];
let mut all = vec![
[
origin[0] - 16 + next_int(random, 1, 8),
origin[1],
origin[2] + 16 + next_int(random, 1, 7),
],
[
origin[0] - 16 + next_int(random, 1, 8),
origin[1],
origin[2] + next_int(random, 1, 7),
],
[
origin[0] - 16 + next_int(random, 1, 8),
origin[1],
origin[2] - 16 + next_int(random, 4, 8),
],
[
origin[0] + next_int(random, 1, 7),
origin[1],
origin[2] + 16 + next_int(random, 1, 7),
],
[
origin[0] + next_int(random, 1, 7),
origin[1],
origin[2] - 16 + next_int(random, 4, 6),
],
[
origin[0] + 16 + next_int(random, 1, 7),
origin[1],
origin[2] + 16 + next_int(random, 3, 8),
],
[
origin[0] + 16 + next_int(random, 1, 7),
origin[1],
origin[2] + next_int(random, 1, 7),
],
[
origin[0] + 16 + next_int(random, 1, 7),
origin[1],
origin[2] - 16 + next_int(random, 4, 8),
],
];
let ruins = next_int(random, 4, 8);
for _ in 0..ruins {
if all.is_empty() {
continue;
}
let idx = random.next_int_bound(all.len() as i32).ok()? as usize;
let pos = all.remove(idx);
let next_rotation = Rotation::random(random);
let c = StructureTemplate::transform([5, 0, 6], Mirror::None, next_rotation, [0; 3]);
let next_box =
BoundingBox::from_corners(pos, [c[0] + pos[0], c[1] + pos[1], c[2] + pos[2]]);
if !next_box.intersects(&parent_box) {
add_piece(
&mut out,
resources,
bindings,
pos,
next_rotation,
random,
config,
false,
0.8,
)?;
}
}
}
Some(out)
}
fn is_water(c: &mut PieceContext<'_>, pos: [i32; 3]) -> Result<bool> {
Ok(matches!(
c.world.fluid(pos)?.kind(),
FluidKind::Water | FluidKind::FlowingWater
))
}
/// OceanRuinPiece.postProcess.
pub fn post_process(piece: &TemplatePiece, c: &mut PieceContext<'_>) -> Result<()> {
let TemplateHandler::OceanRuin { large, .. } = piece.handler else {
return Ok(());
};
let [x, _, z] = piece.position;
let mut position = [x, c.world.height(HeightmapType::OceanFloorWg, x, z)?, z];
let size = piece.template.size;
let r = StructureTemplate::transform(
[size[0] - 1, 0, size[2] - 1],
Mirror::None,
piece.rotation,
[0; 3],
);
let corner = [r[0] + position[0], r[1] + position[1], r[2] + position[2]];
// getHeight over the footprint.
let mut new_y = position[1];
let mut min_y = 512;
let top_y = new_y - 1;
let mut area = 0;
let min_world = c.world.min_y()?;
for px in position[0].min(corner[0])..=position[0].max(corner[0]) {
for pz in position[2].min(corner[2])..=position[2].max(corner[2]) {
let mut floor = position[1] - 1;
loop {
let state = c.world.block([px, floor, pz])?;
let ice = c
.resources
.block_tags
.get("minecraft:ice")
.is_some_and(|t| t.contains(c.name(state)));
let open = c.is_air(state) || is_water(c, [px, floor, pz])? || ice;
if !(open && floor > min_world + 1) {
break;
}
floor -= 1;
}
min_y = min_y.min(floor);
if floor < top_y - 2 {
area += 1;
}
}
}
let width = (position[0] - corner[0]).abs();
if top_y - min_y > 2 && area > width - 2 {
new_y = min_y + 1;
}
position[1] = new_y;
if let Some(markers) = piece.place_at(c, position, &[])? {
for (marker, pos) in markers {
if marker == "chest" {
let water = if is_water(c, pos)? { "true" } else { "false" };
let chest = c.state_with("chest", &[("waterlogged", water)]);
c.world.set(pos, chest, 2)?;
let table = if large {
"minecraft:chests/underwater_ruin_big"
} else {
"minecraft:chests/underwater_ruin_small"
};
c.loot_table(pos, "minecraft:chest", table)?;
} else if marker == "drowned" {
// The drowned entity is not created; its marker block is cleared.
let sea = 63;
let state = if pos[1] > sea {
c.state("air")
} else {
c.state("water")
};
c.world.set(pos, state, 2)?;
}
}
}
Ok(())
}
@@ -0,0 +1,788 @@
//! Structure processors (`worldgen/processor_list`) and template placement.
use super::{BlockInfo, BoundingBox, Mirror, Rotation, StructureResources, StructureTemplate};
use crate::{
fluid::FluidKind,
heightmap::HeightmapType,
nbt::{Compound, JavaString, Tag},
registry::BlockStateId,
worldgen::{
DecodeError,
block_feature::FeatureBlockBindings,
feature::FeatureWorld,
placement::{PlacementContext, PlacementQueryError},
rule_test::RuleTest,
value_provider::IntProvider,
},
};
use horizon_core::{
position::BlockPos,
random::{LegacyRandom, PositionalRandom, RandomSource, position_seed},
};
use serde_json::Value;
use std::{collections::BTreeSet, sync::Arc};
/// The draws processors make from StructurePlaceSettings' random.
pub trait ProcessorRandom {
fn float(&mut self) -> f32;
fn int(&mut self, bound: i32) -> i32;
fn long(&mut self) -> i64;
}
impl<R: RandomSource> ProcessorRandom for R {
fn float(&mut self) -> f32 {
self.next_float()
}
fn int(&mut self, bound: i32) -> i32 {
self.next_int_bound(bound).unwrap_or(0)
}
fn long(&mut self) -> i64 {
self.next_long()
}
}
#[derive(Clone, Debug)]
enum PosRule {
Always,
Linear {
min_chance: f32,
max_chance: f32,
min_dist: i32,
max_dist: i32,
axis: Option<usize>,
},
}
#[derive(Clone, Debug)]
enum Modifier {
Passthrough,
Clear,
AppendLoot(String),
AppendStatic(Compound),
}
#[derive(Clone, Debug)]
pub struct Rule {
input: RuleTest,
location: RuleTest,
position: PosRule,
output: BlockStateId,
modifier: Modifier,
}
#[derive(Clone, Debug)]
pub enum Processor {
Nop,
BlockIgnore(BTreeSet<String>),
BlockRot {
rottable: Option<Arc<BTreeSet<BlockStateId>>>,
integrity: f32,
},
Gravity {
heightmap: HeightmapType,
offset: i32,
},
Rule(Vec<Rule>),
Protected(Arc<BTreeSet<BlockStateId>>),
Capped {
delegate: Box<Processor>,
limit: IntProvider,
},
JigsawReplacement,
BlockAge(f32),
LavaSubmerged,
}
#[derive(Clone, Debug, Default)]
pub struct ProcessorList(pub Vec<Processor>);
fn holder_set(
value: &Value,
bindings: &FeatureBlockBindings<'_>,
) -> Result<Arc<BTreeSet<BlockStateId>>, DecodeError> {
let names: Vec<&str> = match value {
Value::String(s) => vec![s.as_str()],
Value::Array(a) => a.iter().filter_map(Value::as_str).collect(),
_ => return Err(DecodeError::Field("block holder set")),
};
let mut out = BTreeSet::new();
for name in names {
if let Some(tag) = name.strip_prefix('#') {
let tag = super::super::tags::identifier(tag)?;
out.extend(
bindings
.tags
.get(&tag)
.map(|s| s.iter().copied())
.into_iter()
.flatten(),
);
} else {
let name = super::super::tags::identifier(name)?;
out.extend(
bindings
.blocks
.get(&name)
.ok_or_else(|| DecodeError::Registry(format!("unknown block {name}")))?
.iter()
.copied(),
);
}
}
Ok(Arc::new(out))
}
fn json_to_nbt(value: &Value) -> Tag {
match value {
Value::Bool(b) => Tag::Byte(i8::from(*b)),
Value::Number(n) => match n.as_i64() {
Some(i) if i32::try_from(i).is_ok() => Tag::Int(i as i32),
Some(i) => Tag::Long(i),
None => Tag::Double(n.as_f64().unwrap_or(0.).to_bits()),
},
Value::String(s) => Tag::String(s.as_str().into()),
Value::Array(a) => Tag::List(a.iter().map(json_to_nbt).collect()),
Value::Object(o) => Tag::Compound(
o.iter()
.map(|(k, v)| (JavaString::from(k.as_str()), json_to_nbt(v)))
.collect(),
),
Value::Null => Tag::End,
}
}
fn float(value: &Value, key: &'static str) -> Result<f32, DecodeError> {
value[key]
.as_f64()
.map(|v| v as f32)
.ok_or(DecodeError::Field(key))
}
impl Processor {
fn decode(
value: &Value,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
) -> Result<Self, DecodeError> {
let kind = value["processor_type"]
.as_str()
.ok_or(DecodeError::Field("processor_type"))?;
let state = |v: &Value| -> Result<BlockStateId, DecodeError> {
bindings
.codec
.decode(&v.to_string(), false)
.map_err(|e| DecodeError::Registry(e.to_string()))
};
Ok(match super::super::tags::identifier(kind)?.as_str() {
"minecraft:nop" => Self::Nop,
"minecraft:block_ignore" => Self::BlockIgnore(
value["blocks"]
.as_array()
.ok_or(DecodeError::Field("block_ignore blocks"))?
.iter()
.map(|b| state(b).map(|id| resources.registry.state(id).unwrap().name.clone()))
.collect::<Result<_, _>>()?,
),
"minecraft:block_rot" => Self::BlockRot {
rottable: match value.get("rottable_blocks") {
Some(v) => Some(holder_set(v, bindings)?),
None => None,
},
integrity: float(value, "integrity")?,
},
"minecraft:gravity" => Self::Gravity {
heightmap: match value.get("heightmap").and_then(Value::as_str) {
Some(name) => HeightmapType::ALL
.into_iter()
.find(|k| k.name() == name)
.ok_or(DecodeError::Field("gravity heightmap"))?,
None => HeightmapType::WorldSurfaceWg,
},
offset: value.get("offset").and_then(Value::as_i64).unwrap_or(0) as i32,
},
"minecraft:protected_blocks" => Self::Protected(holder_set(&value["value"], bindings)?),
"minecraft:jigsaw_replacement" => Self::JigsawReplacement,
"minecraft:block_age" => Self::BlockAge(float(value, "mossiness")?),
"minecraft:lava_submerged_block" => Self::LavaSubmerged,
"minecraft:capped" => Self::Capped {
delegate: Box::new(Self::decode(&value["delegate"], resources, bindings)?),
limit: IntProvider::from_json(&value["limit"].to_string())?,
},
"minecraft:rule" => Self::Rule(
value["rules"]
.as_array()
.ok_or(DecodeError::Field("rules"))?
.iter()
.map(|rule| {
let test = |key| RuleTest::from_json(&rule[key].to_string(), bindings);
let position = match rule.get("position_predicate") {
Some(p) => match p["predicate_type"]
.as_str()
.unwrap_or("minecraft:always_true")
{
"minecraft:always_true" => PosRule::Always,
kind @ ("minecraft:linear_pos"
| "minecraft:axis_aligned_linear_pos") => PosRule::Linear {
min_chance: p
.get("min_chance")
.and_then(Value::as_f64)
.unwrap_or(0.)
as f32,
max_chance: p
.get("max_chance")
.and_then(Value::as_f64)
.unwrap_or(0.)
as f32,
min_dist: p.get("min_dist").and_then(Value::as_i64).unwrap_or(0)
as i32,
max_dist: p.get("max_dist").and_then(Value::as_i64).unwrap_or(0)
as i32,
axis: (kind == "minecraft:axis_aligned_linear_pos").then(
|| match p.get("axis").and_then(Value::as_str) {
Some("x") => 0,
Some("z") => 2,
_ => 1,
},
),
},
_ => return Err(DecodeError::Field("position predicate")),
},
None => PosRule::Always,
};
let modifier = match rule.get("block_entity_modifier") {
None => Modifier::Passthrough,
Some(m) => match m["type"].as_str().unwrap_or("") {
"minecraft:passthrough" => Modifier::Passthrough,
"minecraft:clear" => Modifier::Clear,
"minecraft:append_loot" => Modifier::AppendLoot(
m["loot_table"].as_str().unwrap_or_default().to_owned(),
),
"minecraft:append_static" => match json_to_nbt(&m["data"]) {
Tag::Compound(c) => Modifier::AppendStatic(c),
_ => Modifier::AppendStatic(Compound::new()),
},
_ => return Err(DecodeError::Field("block entity modifier")),
},
};
Ok(Rule {
input: test("input_predicate")?,
location: test("location_predicate")?,
position,
output: state(&rule["output_state"])?,
modifier,
})
})
.collect::<Result<_, DecodeError>>()?,
),
_ => return Err(DecodeError::Field("structure processor type")),
})
}
fn evaluates_entire_piece(&self) -> bool {
matches!(self, Self::Capped { .. })
}
}
impl ProcessorList {
/// A processor list holder: a registry name, `{"processors": [...]}` or a list.
pub fn decode(
json: &str,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
) -> Result<Self, DecodeError> {
let value: Value = serde_json::from_str(json)?;
let value = match &value {
Value::String(name) => {
let name = super::super::tags::identifier(name)?;
let raw = resources.processor_lists.get(&name).ok_or_else(|| {
DecodeError::Registry(format!("unknown processor list {name}"))
})?;
serde_json::from_str(raw)?
}
other => other.clone(),
};
let list = match &value {
Value::Array(a) => a.clone(),
Value::Object(_) => value["processors"].as_array().cloned().unwrap_or_default(),
_ => return Err(DecodeError::Field("processor list")),
};
Ok(Self(
list.iter()
.map(|p| Processor::decode(p, resources, bindings))
.collect::<Result<_, _>>()?,
))
}
}
/// StructurePlaceSettings without entity options.
pub struct PlaceSettings<'a> {
pub mirror: Mirror,
pub rotation: Rotation,
pub pivot: [i32; 3],
pub bounding_box: Option<BoundingBox>,
pub processors: Vec<&'a Processor>,
pub waterlogging: bool,
pub random: Option<&'a mut dyn ProcessorRandom>,
}
impl<'a> PlaceSettings<'a> {
pub fn new(rotation: Rotation) -> Self {
Self {
mirror: Mirror::None,
rotation,
pivot: [0; 3],
bounding_box: None,
processors: Vec::new(),
waterlogging: true,
random: None,
}
}
pub fn add(mut self, list: &'a ProcessorList) -> Self {
self.processors.extend(list.0.iter());
self
}
/// settings.getRandom(pos): the shared random, else a position-seeded one.
fn with_random<T>(
&mut self,
pos: [i32; 3],
f: impl FnOnce(&mut dyn ProcessorRandom) -> T,
) -> T {
match self.random.as_deref_mut() {
Some(random) => f(random),
None => f(&mut LegacyRandom::new(position_seed(BlockPos::new(
pos[0], pos[1], pos[2],
)))),
}
}
}
type ProcessResult = Result<Option<BlockInfo>, PlacementQueryError>;
#[allow(clippy::too_many_arguments)]
fn process_block<W: PlacementContext>(
processor: &Processor,
world: &mut W,
resources: &StructureResources,
reference: [i32; 3],
relative: [i32; 3],
info: BlockInfo,
settings: &mut PlaceSettings<'_>,
) -> ProcessResult {
let registry = resources.registry;
let name = |id: BlockStateId| registry.state(id).map(|s| s.name.as_str()).unwrap_or("");
Ok(match processor {
Processor::Nop => Some(info),
Processor::BlockIgnore(blocks) => (!blocks.contains(name(info.state))).then_some(info),
Processor::BlockRot {
rottable,
integrity,
} => {
let candidate = rottable
.as_ref()
.is_none_or(|set| set.contains(&info.state));
let keep = settings.with_random(info.pos, |r| !candidate || r.float() <= *integrity);
keep.then_some(info)
}
Processor::Gravity { heightmap, offset } => {
let height = world.height(*heightmap, info.pos[0], info.pos[2])? + offset;
Some(BlockInfo {
pos: [info.pos[0], height + relative[1], info.pos[2]],
..info
})
}
Processor::Protected(set) => (!set.contains(&world.block_state(info.pos)?)).then_some(info),
Processor::JigsawReplacement => {
if !resources.is_jigsaw(info.state) {
return Ok(Some(info));
}
let Some(nbt) = &info.nbt else {
return Ok(Some(info));
};
let text = match nbt.get(&JavaString::from("final_state")) {
Some(Tag::String(s)) => s.to_string_lossy(),
_ => "minecraft:air".to_owned(),
};
let Some(state) = super::template::parse_state_string(registry, &text) else {
return Ok(None);
};
(name(state) != "minecraft:structure_void").then_some(BlockInfo {
pos: info.pos,
state,
nbt: None,
})
}
Processor::LavaSubmerged => {
let lava = name(world.block_state(info.pos)?) == "minecraft:lava";
if lava && !resources.transforms.full_block(info.state) {
Some(BlockInfo {
state: registry.default_state("minecraft:lava").unwrap(),
..info
})
} else {
Some(info)
}
}
Processor::BlockAge(mossiness) => block_age(*mossiness, info, settings, resources),
Processor::Rule(rules) => {
let mut random = LegacyRandom::new(position_seed(BlockPos::new(
info.pos[0],
info.pos[1],
info.pos[2],
)));
for rule in rules {
if !rule.input.test(info.state, info.pos, &mut random) {
continue;
}
let located = world.block_state(info.pos)?;
if !rule.location.test(located, info.pos, &mut random) {
continue;
}
let position_ok = match &rule.position {
PosRule::Always => true,
PosRule::Linear {
min_chance,
max_chance,
min_dist,
max_dist,
axis,
} => {
let dist = match axis {
None => (0..3)
.map(|i| (info.pos[i] - reference[i]).abs())
.sum::<i32>(),
Some(a) => {
let d: [f32; 3] = std::array::from_fn(|i| {
if i == *a {
((info.pos[i] - reference[i]) as f32).abs()
} else {
0.
}
});
(d[0] + d[1] + d[2]) as i32
}
};
let roll = random.next_float();
let t = (dist - min_dist) as f32 / (max_dist - min_dist) as f32;
let chance = if t < 0. {
*min_chance
} else if t > 1. {
*max_chance
} else {
min_chance + t * (max_chance - min_chance)
};
roll <= chance
}
};
if !position_ok {
continue;
}
let nbt = match &rule.modifier {
Modifier::Passthrough => info.nbt.clone(),
Modifier::Clear => Some(Compound::new()),
Modifier::AppendLoot(table) => {
let mut nbt = info.nbt.clone().unwrap_or_default();
nbt.insert("LootTable".into(), Tag::String(table.as_str().into()));
nbt.insert("LootTableSeed".into(), Tag::Long(random.next_long()));
Some(nbt)
}
Modifier::AppendStatic(data) => {
let mut nbt = info.nbt.clone().unwrap_or_default();
nbt.extend(data.clone());
Some(nbt)
}
};
return Ok(Some(BlockInfo {
pos: info.pos,
state: rule.output,
nbt,
}));
}
Some(info)
}
Processor::Capped { .. } => Some(info),
})
}
fn block_age(
mossiness: f32,
info: BlockInfo,
settings: &mut PlaceSettings<'_>,
resources: &StructureResources,
) -> Option<BlockInfo> {
let registry = resources.registry;
let state = registry.state(info.state)?.clone();
let default = |n: &str| registry.default_state(n).unwrap();
let with_props = |n: &str| {
let mut target = registry.state(default(n)).unwrap().clone();
for (k, v) in &state.properties {
if target.properties.contains_key(k) {
target.properties.insert(k.clone(), v.clone());
}
}
registry.id(&target).unwrap_or(default(n))
};
let random_stairs = |r: &mut dyn ProcessorRandom, n: &str| {
let facing = ["north", "east", "south", "west"][r.int(4) as usize];
let half = ["top", "bottom"][r.int(2) as usize];
let mut target = registry.state(default(n)).unwrap().clone();
target.properties.insert("facing".into(), facing.into());
target.properties.insert("half".into(), half.into());
registry.id(&target).unwrap()
};
let name = state.name.as_str();
let is_tag = |tag: &str| {
// Tags are matched by block name through the template resources' bindings.
resources
.block_tags
.get(tag)
.is_some_and(|set| set.contains(name))
};
let new_state = settings.with_random(info.pos, |r| -> Option<BlockStateId> {
let pick = |r: &mut dyn ProcessorRandom, non: &[BlockStateId], mossy: &[BlockStateId]| {
if r.float() < mossiness {
mossy[r.int(mossy.len() as i32) as usize]
} else {
non[r.int(non.len() as i32) as usize]
}
};
if matches!(
name,
"minecraft:stone_bricks" | "minecraft:stone" | "minecraft:chiseled_stone_bricks"
) {
if r.float() >= 0.5 {
return None;
}
let non = [
default("minecraft:cracked_stone_bricks"),
random_stairs(r, "minecraft:stone_brick_stairs"),
];
let mossy = [
default("minecraft:mossy_stone_bricks"),
random_stairs(r, "minecraft:mossy_stone_brick_stairs"),
];
Some(pick(r, &non, &mossy))
} else if is_tag("minecraft:stairs") {
if r.float() >= 0.5 {
return None;
}
let non = [
default("minecraft:stone_slab"),
default("minecraft:stone_brick_slab"),
];
let mossy = [
with_props("minecraft:mossy_stone_brick_stairs"),
default("minecraft:mossy_stone_brick_slab"),
];
Some(pick(r, &non, &mossy))
} else if is_tag("minecraft:slabs") {
(r.float() < mossiness).then(|| with_props("minecraft:mossy_stone_brick_slab"))
} else if is_tag("minecraft:walls") {
(r.float() < mossiness).then(|| with_props("minecraft:mossy_stone_brick_wall"))
} else if name == "minecraft:obsidian" {
(r.float() < 0.15).then(|| default("minecraft:crying_obsidian"))
} else {
None
}
});
Some(match new_state {
Some(state) => BlockInfo { state, ..info },
None => info,
})
}
/// StructureTemplate.processBlockInfos.
fn process_infos<W: PlacementContext>(
world: &mut W,
resources: &StructureResources,
template: &StructureTemplate,
palette: usize,
position: [i32; 3],
reference: [i32; 3],
settings: &mut PlaceSettings<'_>,
) -> Result<Vec<BlockInfo>, PlacementQueryError> {
let whole = settings
.processors
.iter()
.any(|p| p.evaluates_entire_piece());
let mut original = Vec::new();
let mut processed = Vec::new();
for info in template.palettes()[palette].blocks() {
let relative = StructureTemplate::transform(
info.pos,
settings.mirror,
settings.rotation,
settings.pivot,
);
let pos = std::array::from_fn(|i| relative[i] + position[i]);
if !whole && settings.bounding_box.is_some_and(|b| !b.is_inside(pos)) {
continue;
}
let mut current = Some(BlockInfo {
pos,
state: info.state,
nbt: info.nbt.clone(),
});
let processors = settings.processors.clone();
for processor in processors {
let Some(value) = current.take() else { break };
current = process_block(
processor, world, resources, reference, info.pos, value, settings,
)?;
}
if let Some(value) = current {
processed.push(value);
original.push(info.clone());
}
}
let processors = settings.processors.clone();
for processor in processors {
let Processor::Capped { delegate, limit } = processor else {
continue;
};
if limit.bounds()[1] == 0 || processed.is_empty() || original.len() != processed.len() {
continue;
}
let seed = world.world_seed()?;
let mut random = LegacyRandom::new(seed).fork_positional().at(BlockPos::new(
position[0],
position[1],
position[2],
));
let max = limit
.sample(&mut random)
.unwrap_or(0)
.min(processed.len() as i32);
if max < 1 {
continue;
}
let mut indices: Vec<usize> = (0..processed.len()).collect();
for i in (2..=indices.len()).rev() {
let swap = random.next_int_bound(i as i32).unwrap_or(0) as usize;
indices.swap(i - 1, swap);
}
let mut replaced = 0;
for index in indices {
if replaced >= max {
break;
}
let before = processed[index].clone();
let altered = process_block(
delegate,
world,
resources,
reference,
original[index].pos,
before.clone(),
settings,
)?;
if let Some(altered) = altered {
if altered != before {
replaced += 1;
processed[index] = altered;
}
}
}
}
Ok(processed)
}
/// StructureTemplate.placeInWorld without entities or neighbor shape updates.
/// Returns false for empty templates.
#[allow(clippy::too_many_arguments)]
pub fn place_in_world<W: FeatureWorld + PlacementContext>(
world: &mut W,
resources: &StructureResources,
template: &StructureTemplate,
position: [i32; 3],
reference: [i32; 3],
settings: &mut PlaceSettings<'_>,
mut loot_random: Option<&mut dyn ProcessorRandom>,
flags: i32,
) -> Result<bool, PlacementQueryError> {
if template.palettes().is_empty() {
return Ok(false);
}
let palette = match settings.random.as_deref_mut() {
Some(r) => r.int(template.palettes().len() as i32) as usize,
None => LegacyRandom::new(position_seed(BlockPos::new(
position[0],
position[1],
position[2],
)))
.next_int_bound(template.palettes().len() as i32)
.unwrap_or(0) as usize,
};
if template.palettes()[palette].blocks().is_empty() || template.size.iter().any(|s| *s < 1) {
return Ok(false);
}
let infos = process_infos(
world, resources, template, palette, position, reference, settings,
)?;
let barrier = resources
.registry
.default_state("minecraft:barrier")
.unwrap();
let mut to_fill = Vec::new();
let mut locked = Vec::new();
let world_err = |_| PlacementQueryError::Failed("template write".into());
for info in infos {
if settings
.bounding_box
.is_some_and(|b| !b.is_inside(info.pos))
{
continue;
}
let previous = if settings.waterlogging {
Some(world.fluid_state(info.pos)?)
} else {
None
};
let state = resources.transforms.rotate(
resources.transforms.mirror(info.state, settings.mirror),
settings.rotation,
);
if info.nbt.is_some() {
world.set_block(info.pos, barrier, 820).map_err(world_err)?;
}
if !world.set_block(info.pos, state, flags).map_err(world_err)? {
continue;
}
if let Some(mut nbt) = info.nbt {
if resources.transforms.loot_container(state) {
let seed = match loot_random.as_deref_mut() {
Some(random) => random.long(),
None => settings.random.as_deref_mut().map_or(0, |r| r.long()),
};
nbt.insert("LootTableSeed".into(), Tag::Long(seed));
}
world.set_block_entity(info.pos, nbt)?;
}
if let Some(previous) = previous {
if resources.source_fluid(state) {
locked.push(info.pos);
} else if let Some(wet) = resources.waterlogged.get(&state) {
if previous.kind() == FluidKind::Water {
world.set_block(info.pos, *wet, 3).map_err(world_err)?;
world.schedule_fluid_tick(info.pos, previous.kind(), 5).ok();
} else if !previous.is_source() {
to_fill.push(info.pos);
}
}
}
}
let mut filled = true;
while filled && !to_fill.is_empty() {
filled = false;
let mut remaining = Vec::new();
for pos in std::mem::take(&mut to_fill) {
let mut fluid = world.fluid_state(pos)?;
for d in [[0, 1, 0], [0, 0, -1], [1, 0, 0], [0, 0, 1], [-1, 0, 0]] {
if fluid.is_source() {
break;
}
let n = [pos[0] + d[0], pos[1] + d[1], pos[2] + d[2]];
let neighbor = world.fluid_state(n)?;
if neighbor.is_source() && !locked.contains(&n) {
fluid = neighbor;
}
}
let state = world.block_state(pos)?;
match resources.waterlogged.get(&state) {
Some(wet) if fluid.is_source() && fluid.kind() == FluidKind::Water => {
world.set_block(pos, *wet, 3).map_err(world_err)?;
world.schedule_fluid_tick(pos, fluid.kind(), 5).ok();
filled = true;
}
_ => remaining.push(pos),
}
}
to_fill = remaining;
}
Ok(true)
}
@@ -0,0 +1,486 @@
//! Small piece-based structures: buried treasure, igloo, swamp hut, shipwreck.
use super::{
BoundingBox, Mirror, Rotation, StructureResources, StructureTemplate,
legacy::{
LegacyPiece, PieceContext, PieceFrame, Result, TemplateHandler, TemplatePiece,
create_chest, make_bounding_box, offset, random_horizontal,
},
processor::ProcessorList,
};
use crate::heightmap::HeightmapType;
use horizon_core::{geometry::Direction, random::RandomSource};
use std::sync::{Arc, Mutex};
fn empty_processors() -> Arc<ProcessorList> {
Arc::new(ProcessorList::default())
}
#[derive(Debug)]
pub struct BuriedTreasurePiece {
pub position: [i32; 3],
}
impl LegacyPiece for BuriedTreasurePiece {
fn bounding_box(&self) -> BoundingBox {
BoundingBox::new(self.position, self.position)
}
fn type_name(&self) -> &'static str {
"minecraft:btp"
}
fn post_process(&self, c: &mut PieceContext<'_>) -> Result<()> {
let [x, _, z] = self.position;
let mut pos = [x, c.world.height(HeightmapType::OceanFloorWg, x, z)?, z];
let min = c.world.min_y()?;
while pos[1] > min {
let current = c.world.block(pos)?;
let below = c.world.block(offset(pos, Direction::Down, 1))?;
if matches!(
c.name(below),
"minecraft:sandstone"
| "minecraft:stone"
| "minecraft:andesite"
| "minecraft:granite"
| "minecraft:diorite"
) {
let soft = if !c.is_air(current) && !c.is_liquid(current) {
current
} else {
c.state("sand")
};
for d in Direction::ALL {
let relative = offset(pos, d, 1);
let state = c.world.block(relative)?;
if c.is_air(state) || c.is_liquid(state) {
let under = c.world.block(offset(relative, Direction::Down, 1))?;
if (c.is_air(under) || c.is_liquid(under)) && d != Direction::Up {
c.world.set(relative, below, 3)?;
} else {
c.world.set(relative, soft, 3)?;
}
}
}
create_chest(c, pos, "minecraft:chests/buried_treasure", None)?;
return Ok(());
}
pos[1] -= 1;
}
Ok(())
}
}
pub const IGLOO_TOP: &str = "minecraft:igloo/top";
const IGLOO_MIDDLE: &str = "minecraft:igloo/middle";
const IGLOO_BOTTOM: &str = "minecraft:igloo/bottom";
fn igloo_pivot(name: &str) -> [i32; 3] {
match name {
IGLOO_TOP => [3, 5, 5],
IGLOO_MIDDLE => [1, 3, 1],
_ => [3, 6, 7],
}
}
fn igloo_offset(name: &str) -> [i32; 3] {
match name {
IGLOO_TOP => [0, 0, 0],
IGLOO_MIDDLE => [2, -3, 4],
_ => [0, -3, -2],
}
}
/// IglooPieces.addPieces.
pub fn igloo_pieces(
resources: &StructureResources,
position: [i32; 3],
rotation: Rotation,
random: &mut impl RandomSource,
) -> Option<Vec<TemplatePiece>> {
let piece = |name: &str, depth: i32| -> Option<TemplatePiece> {
let o = igloo_offset(name);
Some(TemplatePiece::new(
"minecraft:iglu",
name,
resources.template(name)?,
[
position[0] + o[0],
position[1] + o[1] - depth,
position[2] + o[2],
],
rotation,
Mirror::None,
igloo_pivot(name),
empty_processors(),
false,
vec!["minecraft:structure_block".into()],
TemplateHandler::Igloo,
))
};
let mut pieces = Vec::new();
if random.next_double() < 0.5 {
let depth = random.next_int_bound(8).unwrap_or(0) + 4;
pieces.push(piece(IGLOO_BOTTOM, depth * 3)?);
for i in 0..depth - 1 {
pieces.push(piece(IGLOO_MIDDLE, i * 3)?);
}
}
pieces.push(piece(IGLOO_TOP, 0)?);
Some(pieces)
}
const SHIPWRECK_BEACHED: [&str; 11] = [
"with_mast",
"sideways_full",
"sideways_fronthalf",
"sideways_backhalf",
"rightsideup_full",
"rightsideup_fronthalf",
"rightsideup_backhalf",
"with_mast_degraded",
"rightsideup_full_degraded",
"rightsideup_fronthalf_degraded",
"rightsideup_backhalf_degraded",
];
const SHIPWRECK_OCEAN: [&str; 20] = [
"with_mast",
"upsidedown_full",
"upsidedown_fronthalf",
"upsidedown_backhalf",
"sideways_full",
"sideways_fronthalf",
"sideways_backhalf",
"rightsideup_full",
"rightsideup_fronthalf",
"rightsideup_backhalf",
"with_mast_degraded",
"upsidedown_full_degraded",
"upsidedown_fronthalf_degraded",
"upsidedown_backhalf_degraded",
"sideways_full_degraded",
"sideways_fronthalf_degraded",
"sideways_backhalf_degraded",
"rightsideup_full_degraded",
"rightsideup_fronthalf_degraded",
"rightsideup_backhalf_degraded",
];
/// ShipwreckPieces.addRandomPiece.
pub fn shipwreck_piece(
resources: &StructureResources,
position: [i32; 3],
rotation: Rotation,
random: &mut impl RandomSource,
beached: bool,
) -> Option<TemplatePiece> {
let names: &[&str] = if beached {
&SHIPWRECK_BEACHED
} else {
&SHIPWRECK_OCEAN
};
let name = format!(
"minecraft:shipwreck/{}",
names[random.next_int_bound(names.len() as i32).ok()? as usize]
);
Some(TemplatePiece::new(
"minecraft:shipwreck",
&name,
resources.template(&name)?,
position,
rotation,
Mirror::None,
[4, 0, 15],
empty_processors(),
true,
vec!["minecraft:structure_block".into(), "minecraft:air".into()],
TemplateHandler::Shipwreck { beached },
))
}
pub fn shipwreck_too_big(template: &StructureTemplate) -> bool {
template.size[0] > 32 || template.size[1] > 32
}
impl LegacyPiece for TemplatePiece {
fn bounding_box(&self) -> BoundingBox {
self.bounding_box
}
fn type_name(&self) -> &'static str {
self.type_name
}
fn post_process(&self, c: &mut PieceContext<'_>) -> Result<()> {
match self.handler {
TemplateHandler::Plain => {
self.place_at(c, self.position, &[])?;
}
TemplateHandler::Igloo => {
let o = igloo_offset(&self.template_name);
let entrance_relative = StructureTemplate::transform(
[3 - o[0], 0, -o[2]],
Mirror::None,
self.rotation,
self.pivot,
);
let entrance = [
self.position[0] + entrance_relative[0],
0,
self.position[2] + entrance_relative[2],
];
let height =
c.world
.height(HeightmapType::WorldSurfaceWg, entrance[0], entrance[2])?;
let position = [
self.position[0],
self.position[1] + height - 90 - 1,
self.position[2],
];
if let Some(markers) = self.place_at(c, position, &[])? {
for (marker, pos) in markers {
if marker == "chest" {
c.world.set(pos, c.state("air"), 3)?;
let below = offset(pos, Direction::Down, 1);
if c.is_block(below, "minecraft:chest")? {
c.loot_table(
below,
"minecraft:chest",
"minecraft:chests/igloo_chest",
)?;
}
}
}
}
if self.template_name == IGLOO_TOP {
let r = StructureTemplate::transform(
[3, 0, 5],
Mirror::None,
self.rotation,
self.pivot,
);
let trapdoor = [position[0] + r[0], position[1] + r[1], position[2] + r[2]];
let below = c.world.block(offset(trapdoor, Direction::Down, 1))?;
if !c.is_air(below) && c.name(below) != "minecraft:ladder" {
c.world.set(trapdoor, c.state("snow_block"), 3)?;
}
}
}
TemplateHandler::Shipwreck { beached } => {
let adjusted = *self.state.lock().unwrap();
let y = match adjusted {
Some(y) => y,
None if shipwreck_too_big(&self.template) => self.position[1],
None => {
let kind = if beached {
HeightmapType::WorldSurfaceWg
} else {
HeightmapType::OceanFloorWg
};
let size = self.template.size;
let mut min = c.world.max_y()? + 1;
let mut mean = 0;
let base = size[0] * size[2];
if base == 0 {
mean = c.world.height(kind, self.position[0], self.position[2])?;
} else {
for x in self.position[0]..self.position[0] + size[0] {
for z in self.position[2]..self.position[2] + size[2] {
let h = c.world.height(kind, x, z)?;
mean += h;
min = min.min(h);
}
}
mean /= base;
}
let y = if beached {
min - size[1] / 2 - c.random.int(3)
} else {
mean
};
*self.state.lock().unwrap() = Some(y);
y
}
};
let position = [self.position[0], y, self.position[2]];
if let Some(markers) = self.place_at(c, position, &[])? {
for (marker, pos) in markers {
let table = match marker.as_str() {
"map_chest" => "minecraft:chests/shipwreck_map",
"treasure_chest" => "minecraft:chests/shipwreck_treasure",
"supply_chest" => "minecraft:chests/shipwreck_supply",
_ => continue,
};
let below = offset(pos, Direction::Down, 1);
let state = c.world.block(below)?;
if c.resources.transforms.loot_container(state) {
let kind = c.name(state).to_owned();
c.loot_table(below, &kind, table)?;
}
}
}
}
TemplateHandler::OceanRuin { .. } => {
super::ocean_ruin::post_process(self, c)?;
}
}
Ok(())
}
}
/// ScatteredFeaturePiece: an oriented box whose height is fixed on first use.
#[derive(Debug)]
pub struct Scattered {
pub frame: Mutex<PieceFrame>,
pub width: i32,
pub height: i32,
pub depth: i32,
pub height_position: Mutex<i32>,
}
impl Scattered {
pub fn new(
west: i32,
floor: i32,
north: i32,
width: i32,
height: i32,
depth: i32,
direction: Direction,
) -> Self {
Self {
frame: Mutex::new(PieceFrame::new(
make_bounding_box(west, floor, north, direction, width, height, depth),
Some(direction),
)),
width,
height,
depth,
height_position: Mutex::new(-1),
}
}
pub fn frame(&self) -> PieceFrame {
*self.frame.lock().unwrap()
}
/// updateAverageGroundHeight over the part of the box inside the chunk.
pub fn average_ground(&self, c: &mut PieceContext<'_>, offset: i32) -> Result<bool> {
if *self.height_position.lock().unwrap() >= 0 {
return Ok(true);
}
let b = self.frame().bounding_box;
let (mut total, mut count) = (0, 0);
for z in b.min[2]..=b.max[2] {
for x in b.min[0]..=b.max[0] {
if c.chunk_box.is_inside([x, 64, z]) {
total += c
.world
.height(HeightmapType::MotionBlockingNoLeaves, x, z)?;
count += 1;
}
}
}
if count == 0 {
return Ok(false);
}
let h = total / count;
*self.height_position.lock().unwrap() = h;
let mut frame = self.frame.lock().unwrap();
frame.bounding_box =
frame
.bounding_box
.moved([0, h - frame.bounding_box.min[1] + offset, 0]);
Ok(true)
}
/// updateHeightPositionToLowestGroundHeight over the whole box.
pub fn lowest_ground(&self, c: &mut PieceContext<'_>, offset: i32) -> Result<bool> {
if *self.height_position.lock().unwrap() >= 0 {
return Ok(true);
}
let b = self.frame().bounding_box;
let mut lowest = c.world.max_y()? + 1;
for z in b.min[2]..=b.max[2] {
for x in b.min[0]..=b.max[0] {
lowest = lowest.min(
c.world
.height(HeightmapType::MotionBlockingNoLeaves, x, z)?,
);
}
}
*self.height_position.lock().unwrap() = lowest;
let mut frame = self.frame.lock().unwrap();
frame.bounding_box =
frame
.bounding_box
.moved([0, lowest - frame.bounding_box.min[1] + offset, 0]);
Ok(true)
}
}
#[derive(Debug)]
pub struct SwampHutPiece {
pub base: Scattered,
}
impl SwampHutPiece {
pub fn new(random: &mut impl RandomSource, west: i32, north: i32) -> Self {
let direction = random_horizontal(random);
Self {
base: Scattered::new(west, 64, north, 7, 7, 9, direction),
}
}
}
impl LegacyPiece for SwampHutPiece {
fn bounding_box(&self) -> BoundingBox {
self.base.frame().bounding_box
}
fn type_name(&self) -> &'static str {
"minecraft:tesh"
}
fn post_process(&self, c: &mut PieceContext<'_>) -> Result<()> {
if !self.base.average_ground(c, 0)? {
return Ok(());
}
let f = self.base.frame();
let planks = c.state("spruce_planks");
let log = c.state("oak_log");
for (a, b) in [
([1, 1, 1], [5, 1, 7]),
([1, 4, 2], [5, 4, 7]),
([2, 1, 0], [4, 1, 0]),
([2, 2, 2], [3, 3, 2]),
([1, 2, 3], [1, 3, 6]),
([5, 2, 3], [5, 3, 6]),
([2, 2, 7], [4, 3, 7]),
] {
f.generate_box(c, a, b, planks, planks, false)?;
}
for (a, b) in [
([1, 0, 2], [1, 3, 2]),
([5, 0, 2], [5, 3, 2]),
([1, 0, 7], [1, 3, 7]),
([5, 0, 7], [5, 3, 7]),
] {
f.generate_box(c, a, b, log, log, false)?;
}
let fence = c.state("oak_fence");
let air = c.state("air");
f.place(c, fence, 2, 3, 2)?;
f.place(c, fence, 3, 3, 7)?;
f.place(c, air, 1, 3, 4)?;
f.place(c, air, 5, 3, 4)?;
f.place(c, air, 5, 3, 5)?;
f.place(c, c.state("potted_red_mushroom"), 1, 3, 5)?;
f.place(c, c.state("crafting_table"), 3, 2, 6)?;
f.place(c, c.state("cauldron"), 4, 2, 6)?;
f.place(c, fence, 1, 2, 1)?;
f.place(c, fence, 5, 2, 1)?;
let stairs = |c: &PieceContext<'_>, facing: &str, shape: &str| {
c.state_with("spruce_stairs", &[("facing", facing), ("shape", shape)])
};
let north = stairs(c, "north", "straight");
let east = stairs(c, "east", "straight");
let west = stairs(c, "west", "straight");
let south = stairs(c, "south", "straight");
f.generate_box(c, [0, 4, 1], [6, 4, 1], north, north, false)?;
f.generate_box(c, [0, 4, 2], [0, 4, 7], east, east, false)?;
f.generate_box(c, [6, 4, 2], [6, 4, 7], west, west, false)?;
f.generate_box(c, [0, 4, 8], [6, 4, 8], south, south, false)?;
f.place(c, stairs(c, "north", "outer_right"), 0, 4, 1)?;
f.place(c, stairs(c, "north", "outer_left"), 6, 4, 1)?;
f.place(c, stairs(c, "south", "outer_left"), 0, 4, 8)?;
f.place(c, stairs(c, "south", "outer_right"), 6, 4, 8)?;
for z in [2, 7] {
for x in [1, 5] {
f.fill_column_down(c, log, x, -1, z)?;
}
}
Ok(())
}
}
@@ -0,0 +1,775 @@
//! Structures, structure sets and their placements, structure starts,
//! references, terrain adaptation and per-chunk piece placement.
use super::{
BoundingBox, StructureResources,
jigsaw::{JigsawConfig, JigsawContext, PoolPiece, Pools, Projection, assemble},
legacy::{LegacyPiece, PieceContext},
};
use crate::{
heightmap::HeightmapType,
worldgen::{
DecodeError,
anchor::WorldGenerationContext,
biome::BiomeId,
block_feature::FeatureBlockBindings,
feature::FeatureWorld,
height_provider::HeightProvider,
placement::{PlacementContext, PlacementQueryError},
weighted::WeightedList,
},
};
use horizon_core::{
density::{Beardifier, JigsawJunction, RigidPiece, StructureBounds, TerrainAdjustment},
position::{BlockPos, ChunkPos},
random::{LegacyRandom, PositionalRandom, RandomSource, WorldgenRandom},
};
use serde_json::{Value, value::RawValue};
use std::{
collections::{BTreeMap, BTreeSet},
sync::Arc,
};
pub const STEPS: [&str; 11] = [
"raw_generation",
"lakes",
"local_modifications",
"underground_structures",
"surface_structures",
"strongholds",
"underground_ores",
"underground_decoration",
"fluid_springs",
"vegetal_decoration",
"top_layer_modification",
];
#[derive(Debug)]
pub struct JigsawDef {
start_pool: String,
start_jigsaw: Option<String>,
max_depth: i32,
start_height: HeightProvider,
use_expansion_hack: bool,
project_to: Option<HeightmapType>,
max_distance: [i32; 2],
aliases: Vec<Value>,
padding: [i32; 2],
waterlogging: bool,
}
#[derive(Debug)]
pub enum StructureKind {
Jigsaw(JigsawDef),
BuriedTreasure,
Igloo,
SwampHut,
Shipwreck {
beached: bool,
},
OceanRuin {
warm: bool,
large: f32,
cluster: f32,
},
/// A structure type whose generator is not implemented yet.
Unsupported(String),
}
#[derive(Debug)]
pub struct StructureDef {
pub name: String,
pub kind: StructureKind,
pub biomes: BTreeSet<BiomeId>,
pub step: usize,
pub terrain: TerrainAdjustment,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Reduction {
Default,
Legacy1,
Legacy2,
Legacy3,
}
#[derive(Debug)]
enum Placement {
RandomSpread {
spacing: i32,
separation: i32,
triangular: bool,
},
ConcentricRings,
Unsupported,
}
#[derive(Debug)]
pub struct StructureSet {
pub name: String,
pub structures: Vec<(usize, i32)>,
placement: Placement,
salt: i32,
frequency: f32,
reduction: Reduction,
exclusion: Option<(String, i32)>,
}
fn heightmap(name: &str) -> Option<HeightmapType> {
HeightmapType::ALL.into_iter().find(|k| k.name() == name)
}
fn terrain(name: Option<&str>) -> TerrainAdjustment {
match name {
Some("bury") => TerrainAdjustment::Bury,
Some("beard_thin") => TerrainAdjustment::BeardThin,
Some("beard_box") => TerrainAdjustment::BeardBox,
Some("encapsulate") => TerrainAdjustment::Encapsulate,
_ => TerrainAdjustment::None,
}
}
fn pair(value: Option<&Value>, a: &str, b: &str, default: i32) -> [i32; 2] {
match value {
Some(Value::Number(n)) => [n.as_i64().unwrap_or(0) as i32; 2],
Some(Value::Object(o)) => {
let get = |k: &str| o.get(k).and_then(Value::as_i64).unwrap_or(0) as i32;
let first = get(a);
[
first,
o.get(b).and_then(Value::as_i64).map_or(first, |v| v as i32),
]
}
_ => [default; 2],
}
}
/// All structures and structure sets of a resource bundle, in registry
/// (identifier) order.
#[derive(Debug)]
pub struct StructureRegistry {
pub structures: Vec<StructureDef>,
pub sets: Vec<StructureSet>,
pub pools: Pools,
}
impl StructureRegistry {
pub fn new(
structures: &BTreeMap<String, String>,
sets: &BTreeMap<String, String>,
pools: BTreeMap<String, String>,
biome_set: &dyn Fn(&Value) -> Result<BTreeSet<BiomeId>, DecodeError>,
) -> Result<Self, DecodeError> {
let mut defs = Vec::new();
for (name, json) in structures {
let v: Value = serde_json::from_str(json)?;
let kind = match v["type"].as_str().unwrap_or_default() {
"minecraft:jigsaw" => StructureKind::Jigsaw(JigsawDef {
start_pool: v["start_pool"].as_str().unwrap_or_default().to_owned(),
start_jigsaw: v["start_jigsaw_name"].as_str().map(str::to_owned),
max_depth: v["size"].as_i64().unwrap_or(0) as i32,
start_height: HeightProvider::from_json(&v["start_height"].to_string())?,
use_expansion_hack: v["use_expansion_hack"].as_bool().unwrap_or(false),
project_to: v["project_start_to_heightmap"].as_str().and_then(heightmap),
max_distance: pair(
v.get("max_distance_from_center"),
"horizontal",
"vertical",
80,
),
aliases: v["pool_aliases"].as_array().cloned().unwrap_or_default(),
padding: pair(v.get("dimension_padding"), "bottom", "top", 0),
waterlogging: v["liquid_settings"].as_str() != Some("ignore_waterlogging"),
}),
"minecraft:buried_treasure" => StructureKind::BuriedTreasure,
"minecraft:igloo" => StructureKind::Igloo,
"minecraft:swamp_hut" => StructureKind::SwampHut,
"minecraft:shipwreck" => StructureKind::Shipwreck {
beached: v["is_beached"].as_bool().unwrap_or(false),
},
"minecraft:ocean_ruin" => StructureKind::OceanRuin {
warm: v["biome_temp"].as_str() == Some("warm"),
large: v["large_probability"].as_f64().unwrap_or(0.) as f32,
cluster: v["cluster_probability"].as_f64().unwrap_or(0.) as f32,
},
other => StructureKind::Unsupported(other.to_owned()),
};
defs.push(StructureDef {
name: name.clone(),
kind,
biomes: biome_set(&v["biomes"])?,
step: STEPS
.iter()
.position(|s| Some(*s) == v["step"].as_str())
.unwrap_or(4),
terrain: terrain(v["terrain_adaptation"].as_str()),
});
}
let index = |name: &str| defs.iter().position(|d| d.name == name);
let mut out = Vec::new();
for (name, json) in sets {
let v: Value = serde_json::from_str(json)?;
let p = &v["placement"];
let placement = match p["type"].as_str().unwrap_or_default() {
"minecraft:random_spread" => Placement::RandomSpread {
spacing: p["spacing"].as_i64().unwrap_or(1) as i32,
separation: p["separation"].as_i64().unwrap_or(0) as i32,
triangular: p["spread_type"].as_str() == Some("triangular"),
},
"minecraft:concentric_rings" => Placement::ConcentricRings,
_ => Placement::Unsupported,
};
out.push(StructureSet {
name: name.clone(),
structures: v["structures"]
.as_array()
.into_iter()
.flatten()
.filter_map(|e| {
Some((
index(e["structure"].as_str()?)?,
e["weight"].as_i64().unwrap_or(1) as i32,
))
})
.collect(),
placement,
salt: p["salt"].as_i64().unwrap_or(0) as i32,
frequency: p["frequency"].as_f64().unwrap_or(1.) as f32,
reduction: match p["frequency_reduction_method"].as_str() {
Some("legacy_type_1") => Reduction::Legacy1,
Some("legacy_type_2") => Reduction::Legacy2,
Some("legacy_type_3") => Reduction::Legacy3,
_ => Reduction::Default,
},
exclusion: p.get("exclusion_zone").map(|z| {
(
z["other_set"].as_str().unwrap_or_default().to_owned(),
z["chunk_count"].as_i64().unwrap_or(0) as i32,
)
}),
});
}
Ok(Self {
structures: defs,
sets: out,
pools: Pools::new(pools),
})
}
/// RandomSpreadStructurePlacement.getPotentialStructureChunk et al.
pub fn is_structure_chunk(
&self,
set: &StructureSet,
seed: i64,
x: i32,
z: i32,
rings: &[ChunkPos],
) -> bool {
let placed = match set.placement {
Placement::RandomSpread {
spacing,
separation,
triangular,
} => {
let (gx, gz) = (x.div_euclid(spacing), z.div_euclid(spacing));
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
random.set_large_feature_with_salt(seed, gx, gz, set.salt);
let limit = spacing - separation;
let spread = |r: &mut WorldgenRandom<LegacyRandom>| {
if triangular {
(r.next_int_bound(limit).unwrap_or(0)
+ r.next_int_bound(limit).unwrap_or(0))
/ 2
} else {
r.next_int_bound(limit).unwrap_or(0)
}
};
let sx = spread(&mut random);
let sz = spread(&mut random);
gx * spacing + sx == x && gz * spacing + sz == z
}
Placement::ConcentricRings => rings.contains(&ChunkPos::new(x, z)),
Placement::Unsupported => false,
};
if !placed {
return false;
}
if set.frequency < 1. && !reduce(set.reduction, seed, set.salt, x, z, set.frequency) {
return false;
}
match &set.exclusion {
Some((other, range)) => {
let Some(other) = self.sets.iter().find(|s| s.name == *other) else {
return true;
};
for tx in x - range..=x + range {
for tz in z - range..=z + range {
if self.is_structure_chunk(other, seed, tx, tz, rings) {
return false;
}
}
}
true
}
None => true,
}
}
}
fn reduce(method: Reduction, seed: i64, salt: i32, x: i32, z: i32, probability: f32) -> bool {
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
match method {
Reduction::Default => {
random.set_large_feature_with_salt(seed, salt, x, z);
random.next_float() < probability
}
Reduction::Legacy1 => {
let (cx, cz) = (x >> 4, z >> 4);
random.set_seed(i64::from(cx ^ (cz << 4)) ^ seed);
random.next_int();
random
.next_int_bound((1. / probability) as i32)
.unwrap_or(1)
== 0
}
Reduction::Legacy2 => {
random.set_large_feature_with_salt(seed, x, z, 10_387_320);
random.next_float() < probability
}
Reduction::Legacy3 => {
random.set_large_feature_seed(seed, x, z);
random.next_double() < f64::from(probability)
}
}
}
#[derive(Debug)]
pub enum Piece {
Pool(PoolPiece),
Legacy(Box<dyn LegacyPiece>),
}
impl Piece {
pub fn bounding_box(&self) -> BoundingBox {
match self {
Self::Pool(p) => p.bounding_box,
Self::Legacy(p) => p.bounding_box(),
}
}
pub fn type_name(&self) -> &'static str {
match self {
Self::Pool(_) => "minecraft:jigsaw",
Self::Legacy(p) => p.type_name(),
}
}
}
fn legacy(pieces: Vec<impl LegacyPiece + 'static>) -> Vec<Piece> {
pieces
.into_iter()
.map(|p| Piece::Legacy(Box::new(p)))
.collect()
}
/// Structure.onTopOfChunkCenter: the start position, or None when no valid
/// biome can exist in the chunk-center column.
fn top_of_chunk_center(
context: &mut impl StartContext,
chunk: ChunkPos,
kind: HeightmapType,
) -> Option<[i32; 3]> {
let (x, z) = (chunk.x * 16 + 8, chunk.z * 16 + 8);
let (min, max) = (context.min_y(), context.max_y());
if !context.column_has_valid_biome(x, z, min - 1, max) {
return None;
}
Some([x, context.base_height(x, z, kind) - 1, z])
}
fn first_occupied(context: &mut impl StartContext, x: i32, z: i32) -> i32 {
context.base_height(x, z, HeightmapType::WorldSurfaceWg) - 1
}
fn corner_heights(context: &mut impl StartContext, x: i32, sx: i32, z: i32, sz: i32) -> [i32; 4] {
[
first_occupied(context, x, z),
first_occupied(context, x, z + sz),
first_occupied(context, x + sx, z),
first_occupied(context, x + sx, z + sz),
]
}
#[derive(Debug)]
pub struct StructureStart {
pub structure: usize,
pub name: String,
pub chunk: ChunkPos,
pub pieces: Vec<Piece>,
/// Piece union, inflated by 12 for terrain-adapting structures.
pub bounding_box: BoundingBox,
}
/// Biome and height queries for one structure generation attempt.
pub trait StartContext: JigsawContext {
fn seed(&self) -> i64;
fn generation(&self) -> WorldGenerationContext;
/// Noise biome at a quart position (caching resolver, no zoom).
fn noise_biome(&mut self, quart: [i32; 3]) -> BiomeId;
fn set_valid_biomes(&mut self, biomes: &BTreeSet<BiomeId>);
}
/// ChunkGenerator.createStructures for one chunk: the starts it owns.
pub fn create_starts(
registry: &StructureRegistry,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
context: &mut impl StartContext,
possible_sets: &[usize],
rings: &[ChunkPos],
chunk: ChunkPos,
) -> Vec<StructureStart> {
let seed = context.seed();
let mut starts = Vec::new();
for &set_index in possible_sets {
let set = &registry.sets[set_index];
if !registry.is_structure_chunk(set, seed, chunk.x, chunk.z, rings) {
continue;
}
if set.structures.len() == 1 {
if let Some(start) = try_generate(
registry,
resources,
bindings,
context,
set.structures[0].0,
chunk,
) {
starts.push(start);
}
continue;
}
let mut options = set.structures.clone();
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
random.set_large_feature_seed(seed, chunk.x, chunk.z);
let mut total: i32 = options.iter().map(|o| o.1).sum();
while !options.is_empty() {
let mut choice = random.next_int_bound(total).unwrap_or(0);
let mut index = 0;
for option in &options {
choice -= option.1;
if choice < 0 {
break;
}
index += 1;
}
let selected = options[index];
if let Some(start) =
try_generate(registry, resources, bindings, context, selected.0, chunk)
{
starts.push(start);
break;
}
options.remove(index);
total -= selected.1;
}
}
starts
}
fn try_generate(
registry: &StructureRegistry,
resources: &StructureResources,
bindings: &FeatureBlockBindings<'_>,
context: &mut impl StartContext,
structure: usize,
chunk: ChunkPos,
) -> Option<StructureStart> {
let def = &registry.structures[structure];
context.set_valid_biomes(&def.biomes);
let seed = context.seed();
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
random.set_large_feature_seed(seed, chunk.x, chunk.z);
let (position, pieces) = match &def.kind {
StructureKind::Jigsaw(jigsaw) => {
let height = jigsaw
.start_height
.sample(&mut random, context.generation())
.ok()?;
let start = [chunk.x * 16, height, chunk.z * 16];
let aliases = resolve_aliases(&jigsaw.aliases, start, seed);
let config = JigsawConfig {
start_pool: &jigsaw.start_pool,
start_jigsaw: jigsaw.start_jigsaw.as_deref(),
max_depth: jigsaw.max_depth,
use_expansion_hack: jigsaw.use_expansion_hack,
project_to: jigsaw.project_to,
max_distance: jigsaw.max_distance,
aliases: &aliases,
padding: jigsaw.padding,
waterlogging: jigsaw.waterlogging,
};
let (position, mut pieces) = assemble(
&config,
context,
&registry.pools,
resources,
bindings,
&mut random,
start,
)?;
if jigsaw.max_depth <= 0 {
pieces.clear();
}
(
position,
pieces.into_iter().map(Piece::Pool).collect::<Vec<_>>(),
)
}
StructureKind::BuriedTreasure => {
let stub = top_of_chunk_center(context, chunk, HeightmapType::OceanFloorWg)?;
let piece = super::simple::BuriedTreasurePiece {
position: [chunk.x * 16 + 9, 90, chunk.z * 16 + 9],
};
(stub, legacy(vec![piece]))
}
StructureKind::Igloo => {
let stub = top_of_chunk_center(context, chunk, HeightmapType::WorldSurfaceWg)?;
let rotation = super::Rotation::random(&mut random);
let pieces = super::simple::igloo_pieces(
resources,
[chunk.x * 16, 90, chunk.z * 16],
rotation,
&mut random,
)?;
(stub, legacy(pieces))
}
StructureKind::SwampHut => {
let stub = top_of_chunk_center(context, chunk, HeightmapType::WorldSurfaceWg)?;
let piece = super::simple::SwampHutPiece::new(&mut random, chunk.x * 16, chunk.z * 16);
(stub, legacy(vec![piece]))
}
StructureKind::Shipwreck { beached } => {
let kind = if *beached {
HeightmapType::WorldSurfaceWg
} else {
HeightmapType::OceanFloorWg
};
let stub = top_of_chunk_center(context, chunk, kind)?;
let rotation = super::Rotation::random(&mut random);
let piece = super::simple::shipwreck_piece(
resources,
[chunk.x * 16, 90, chunk.z * 16],
rotation,
&mut random,
*beached,
)?;
if super::simple::shipwreck_too_big(&piece.template) {
let b = piece.bounding_box;
let [sx, _, sz] = b.span();
let heights = corner_heights(context, b.min[0], sx, b.min[2], sz);
let height = if *beached {
let min = heights.into_iter().min().unwrap_or(0);
min - piece.template.size[1] / 2 - random.next_int_bound(3).unwrap_or(0)
} else {
heights.iter().sum::<i32>() / 4
};
*piece.state.lock().unwrap() = Some(height);
}
(stub, legacy(vec![piece]))
}
StructureKind::OceanRuin {
warm,
large,
cluster,
} => {
let stub = top_of_chunk_center(context, chunk, HeightmapType::OceanFloorWg)?;
let rotation = super::Rotation::random(&mut random);
let config = super::ocean_ruin::OceanRuinConfig {
warm: *warm,
large_probability: *large,
cluster_probability: *cluster,
};
let pieces = super::ocean_ruin::pieces(
resources,
bindings,
[chunk.x * 16, 90, chunk.z * 16],
rotation,
&mut random,
&config,
)?;
(stub, legacy(pieces))
}
StructureKind::Unsupported(_) => return None,
};
let quart = position.map(|v| v >> 2);
if !def.biomes.contains(&context.noise_biome(quart)) || pieces.is_empty() {
return None;
}
let mut bounding_box = pieces[0].bounding_box();
for piece in &pieces[1..] {
bounding_box.encapsulate(&piece.bounding_box());
}
if def.terrain != TerrainAdjustment::None {
bounding_box = bounding_box.inflated(12, 12);
}
Some(StructureStart {
structure,
name: def.name.clone(),
chunk,
pieces,
bounding_box,
})
}
/// PoolAliasLookup.create.
fn resolve_aliases(bindings: &[Value], position: [i32; 3], seed: i64) -> BTreeMap<String, String> {
let mut map = BTreeMap::new();
if bindings.is_empty() {
return map;
}
let mut random = LegacyRandom::new(seed).fork_positional().at(BlockPos::new(
position[0],
position[1],
position[2],
));
fn visit(binding: &Value, random: &mut LegacyRandom, map: &mut BTreeMap<String, String>) {
let weighted = |key: &str| -> Option<WeightedList<Value>> {
let raw: Box<RawValue> = serde_json::from_str(&binding[key].to_string()).ok()?;
WeightedList::decode(&raw, |v| Ok(serde_json::from_str::<Value>(v.get())?)).ok()
};
match binding["type"].as_str().unwrap_or_default() {
"minecraft:direct" => {
map.insert(
binding["alias"].as_str().unwrap_or_default().to_owned(),
binding["target"].as_str().unwrap_or_default().to_owned(),
);
}
"minecraft:random" => {
if let Some(target) =
weighted("targets").and_then(|w| w.sample(random).ok().cloned())
{
map.insert(
binding["alias"].as_str().unwrap_or_default().to_owned(),
target.as_str().unwrap_or_default().to_owned(),
);
}
}
"minecraft:random_group" => {
if let Some(group) = weighted("groups").and_then(|w| w.sample(random).ok().cloned())
{
for b in group.as_array().into_iter().flatten() {
visit(b, random, map);
}
}
}
_ => {}
}
}
for binding in bindings {
visit(binding, &mut random, &mut map);
}
map
}
/// Beardifier.forStructuresInChunk over the starts referencing a chunk.
pub fn beardifier(
registry: &StructureRegistry,
starts: &[Arc<StructureStart>],
chunk: ChunkPos,
) -> Option<Beardifier> {
let (bx, bz) = (chunk.x * 16, chunk.z * 16);
let mut rigids = Vec::new();
let mut junctions = Vec::new();
let mut any: Option<BoundingBox> = None;
let include = |b: BoundingBox, any: &mut Option<BoundingBox>| match any {
Some(a) => a.encapsulate(&b),
None => *any = Some(b),
};
for start in starts {
let adjustment = registry.structures[start.structure].terrain;
if adjustment == TerrainAdjustment::None {
continue;
}
for piece in &start.pieces {
let b = piece.bounding_box();
let near = b.max[0] >= bx - 12
&& b.min[0] <= bx + 15 + 12
&& b.max[2] >= bz - 12
&& b.min[2] <= bz + 15 + 12;
if !near {
continue;
}
let Piece::Pool(pool) = piece else {
rigids.push(RigidPiece {
bounds: StructureBounds::new(b.min, b.max)?,
adjustment,
ground_level_delta: 0,
});
include(b, &mut any);
continue;
};
if pool.element.projection() == Projection::Rigid {
rigids.push(RigidPiece {
bounds: StructureBounds::new(b.min, b.max)?,
adjustment,
ground_level_delta: pool.ground_level_delta,
});
include(b, &mut any);
}
for j in &pool.junctions {
if j.source_x > bx - 12
&& j.source_z > bz - 12
&& j.source_x < bx + 15 + 12
&& j.source_z < bz + 15 + 12
{
junctions.push(JigsawJunction {
source_x: j.source_x,
source_ground_y: j.source_ground_y,
source_z: j.source_z,
});
let p = [j.source_x, j.source_ground_y, j.source_z];
include(BoundingBox::new(p, p), &mut any);
}
}
}
}
let any = any?;
let affected = any.inflated(24, 24);
Some(Beardifier::new(
rigids,
junctions,
StructureBounds::new(affected.min, affected.max),
))
}
/// StructureStart.placeInChunk for pieces intersecting the chunk's writable box.
#[allow(clippy::too_many_arguments)]
pub fn place_in_chunk<W: FeatureWorld + PlacementContext, R: RandomSource + 'static>(
start: &StructureStart,
world: &mut W,
resources: &StructureResources,
random: &mut R,
chunk_box: BoundingBox,
place_feature: &mut dyn FnMut(
&mut W,
&mut R,
&str,
[i32; 3],
) -> Result<bool, PlacementQueryError>,
) -> Result<(), PlacementQueryError> {
let Some(first) = start.pieces.first() else {
return Ok(());
};
let center_box = first.bounding_box();
let center = center_box.center();
let reference = [center[0], center_box.min[1], center[2]];
for piece in &start.pieces {
if piece.bounding_box().intersects(&chunk_box) {
match piece {
Piece::Pool(p) => {
p.place(
world,
resources,
random,
chunk_box,
reference,
place_feature,
)?;
}
Piece::Legacy(p) => {
let mut context = PieceContext {
world,
resources,
random,
chunk_box,
chunk: ChunkPos::new(chunk_box.min[0] >> 4, chunk_box.min[2] >> 4),
reference,
};
p.post_process(&mut context)?;
}
}
}
}
Ok(())
}
@@ -0,0 +1,305 @@
//! StructureTemplate: NBT loading, palettes, transforms and bounding boxes.
use super::{BoundingBox, Mirror, Rotation, StateTransforms};
use crate::{
chunk::BlockState,
nbt::{Compound, Tag},
registry::{BlockRegistry, BlockStateId},
};
use std::sync::OnceLock;
#[derive(Clone, Debug, PartialEq)]
pub struct BlockInfo {
pub pos: [i32; 3],
pub state: BlockStateId,
pub nbt: Option<Compound>,
}
#[derive(Clone, Debug)]
pub struct JigsawInfo {
pub info: BlockInfo,
pub rollable: bool,
pub name: String,
pub pool: String,
pub target: String,
pub placement_priority: i32,
pub selection_priority: i32,
}
#[derive(Debug)]
pub struct Palette {
blocks: Vec<BlockInfo>,
jigsaws: OnceLock<Vec<JigsawInfo>>,
}
impl Palette {
pub fn blocks(&self) -> &[BlockInfo] {
&self.blocks
}
}
#[derive(Debug)]
pub struct StructureTemplate {
pub size: [i32; 3],
palettes: Vec<Palette>,
}
fn int_list(tag: Option<&Tag>) -> [i32; 3] {
let mut out = [0; 3];
if let Some(Tag::List(values)) = tag {
for (slot, value) in out.iter_mut().zip(values) {
if let Tag::Int(v) = value {
*slot = *v;
}
}
}
out
}
fn string(tag: Option<&Tag>) -> Option<String> {
match tag {
Some(Tag::String(s)) => Some(s.to_string_lossy()),
_ => None,
}
}
fn get<'a>(compound: &'a Compound, key: &str) -> Option<&'a Tag> {
compound.get(&crate::nbt::JavaString::from(key))
}
/// NbtUtils.readBlockState: unknown blocks read as air; missing or invalid
/// properties keep the block's defaults.
pub(super) fn read_state(registry: &BlockRegistry, tag: &Tag) -> BlockStateId {
let air = registry.default_state("minecraft:air").expect("air");
let Tag::Compound(compound) = tag else {
return air;
};
// 26.3 writes `id`/`properties`; older templates use `Name`/`Properties`.
let Some(name) = string(get(compound, "id")).or_else(|| string(get(compound, "Name"))) else {
return air;
};
let Some(default) = registry.default_state(&name) else {
return air;
};
let mut state = registry.state(default).unwrap().clone();
if let Some(Tag::Compound(properties)) =
get(compound, "properties").or_else(|| get(compound, "Properties"))
{
for (key, value) in properties {
let (Tag::String(value), key) = (value, key.to_string_lossy()) else {
continue;
};
let value = value.to_string_lossy();
if let Some(slot) = state.properties.get_mut(&key) {
let previous = std::mem::replace(slot, value);
if registry.id(&state).is_none() {
*state.properties.get_mut(&key).unwrap() = previous;
}
}
}
}
registry.id(&state).unwrap_or(default)
}
/// Parse `name[key=value,...]` (BlockStateParser without NBT); None if invalid.
pub(super) fn parse_state_string(registry: &BlockRegistry, text: &str) -> Option<BlockStateId> {
let text = text.split('{').next().unwrap_or(text).trim();
let (name, properties) = match text.split_once('[') {
Some((name, rest)) => (name, rest.strip_suffix(']')?),
None => (text, ""),
};
let name = if name.contains(':') {
name.to_owned()
} else {
format!("minecraft:{name}")
};
let mut descriptor = BlockState {
name,
properties: Default::default(),
};
for pair in properties.split(',').filter(|p| !p.trim().is_empty()) {
let (k, v) = pair.split_once('=')?;
descriptor
.properties
.insert(k.trim().to_owned(), v.trim().to_owned());
}
registry.resolve(&descriptor).ok()
}
impl StructureTemplate {
/// StructureTemplate.load. Blocks are ordered as vanilla orders them:
/// full collision blocks, then other blocks, then block entities, each
/// sorted by Y, X, Z.
pub fn from_nbt(tag: &Tag, registry: &BlockRegistry, transforms: &StateTransforms) -> Self {
let empty = Compound::new();
let root = match tag {
Tag::Compound(c) => c,
_ => &empty,
};
let size = int_list(get(root, "size"));
let blocks = match get(root, "blocks") {
Some(Tag::List(list)) => list.as_slice(),
_ => &[],
};
let mut palettes = Vec::new();
let mut load = |palette: &[Tag]| {
let states: Vec<BlockStateId> =
palette.iter().map(|t| read_state(registry, t)).collect();
let air = registry.default_state("minecraft:air").unwrap();
let mut lists: [Vec<BlockInfo>; 3] = Default::default();
for block in blocks {
let Tag::Compound(block) = block else {
continue;
};
let index = match get(block, "state") {
Some(Tag::Int(i)) => *i,
_ => 0,
};
let state = usize::try_from(index)
.ok()
.and_then(|i| states.get(i))
.copied()
.unwrap_or(air);
let nbt = match get(block, "nbt") {
Some(Tag::Compound(c)) => Some(c.clone()),
_ => None,
};
let class = if nbt.is_some() {
2
} else if transforms.full_block(state) {
0
} else {
1
};
lists[class].push(BlockInfo {
pos: int_list(get(block, "pos")),
state,
nbt,
});
}
let mut result = Vec::with_capacity(blocks.len());
for mut list in lists {
list.sort_by_key(|b| (b.pos[1], b.pos[0], b.pos[2]));
result.extend(list);
}
palettes.push(Palette {
blocks: result,
jigsaws: OnceLock::new(),
});
};
match get(root, "palettes") {
Some(Tag::List(lists)) => {
for list in lists {
match list {
Tag::List(p) => load(p),
_ => load(&[]),
}
}
}
_ => match get(root, "palette") {
Some(Tag::List(p)) => load(p),
_ => load(&[]),
},
}
Self { size, palettes }
}
pub fn palettes(&self) -> &[Palette] {
&self.palettes
}
pub fn size(&self, rotation: Rotation) -> [i32; 3] {
match rotation {
Rotation::Clockwise90 | Rotation::Counterclockwise90 => {
[self.size[2], self.size[1], self.size[0]]
}
_ => self.size,
}
}
pub fn transform(
pos: [i32; 3],
mirror: Mirror,
rotation: Rotation,
pivot: [i32; 3],
) -> [i32; 3] {
let [mut x, y, mut z] = pos;
match mirror {
Mirror::LeftRight => z = z.wrapping_neg(),
Mirror::FrontBack => x = x.wrapping_neg(),
Mirror::None => {}
}
let (px, pz) = (pivot[0], pivot[2]);
match rotation {
Rotation::Counterclockwise90 => [px - pz + z, y, px + pz - x],
Rotation::Clockwise90 => [px + pz - z, y, pz - px + x],
Rotation::Clockwise180 => [px + px - x, y, pz + pz - z],
Rotation::None => [x, y, z],
}
}
pub fn zero_position_with_transform(
zero: [i32; 3],
mirror: Mirror,
rotation: Rotation,
size_x: i32,
size_z: i32,
) -> [i32; 3] {
let (sx, sz) = (size_x - 1, size_z - 1);
let mx = if mirror == Mirror::FrontBack { sx } else { 0 };
let mz = if mirror == Mirror::LeftRight { sz } else { 0 };
let d = match rotation {
Rotation::Counterclockwise90 => [mz, 0, sx - mx],
Rotation::Clockwise90 => [sz - mz, 0, mx],
Rotation::Clockwise180 => [sx - mx, 0, sz - mz],
Rotation::None => [mx, 0, mz],
};
[zero[0] + d[0], zero[1], zero[2] + d[2]]
}
pub fn bounding_box(
&self,
position: [i32; 3],
rotation: Rotation,
pivot: [i32; 3],
mirror: Mirror,
) -> BoundingBox {
let delta = [self.size[0] - 1, self.size[1] - 1, self.size[2] - 1];
let a = Self::transform([0; 3], mirror, rotation, pivot);
let b = Self::transform(delta, mirror, rotation, pivot);
BoundingBox::from_corners(a, b).moved(position)
}
/// The palette selected by StructurePlaceSettings.getRandomPalette.
pub fn palette_index(&self, random: &mut impl horizon_core::random::RandomSource) -> usize {
random
.next_int_bound(self.palettes.len().max(1) as i32)
.unwrap_or(0) as usize
}
/// Jigsaw blocks of a palette, parsed from their block-entity data.
pub fn jigsaws(
&self,
palette: usize,
jigsaw_states: &dyn Fn(BlockStateId) -> Option<bool>,
) -> &[JigsawInfo] {
let Some(palette) = self.palettes.get(palette) else {
return &[];
};
palette.jigsaws.get_or_init(|| {
palette
.blocks
.iter()
.filter_map(|info| {
let horizontal = jigsaw_states(info.state)?;
let nbt = info.nbt.clone().unwrap_or_default();
let joint = string(get(&nbt, "joint"));
let text = |key: &str, default: &str| {
string(get(&nbt, key)).unwrap_or_else(|| default.to_owned())
};
let int = |key: &str| match get(&nbt, key) {
Some(Tag::Int(v)) => *v,
_ => 0,
};
Some(JigsawInfo {
rollable: match joint.as_deref() {
Some("rollable") => true,
Some("aligned") => false,
_ => !horizontal,
},
name: text("name", "minecraft:empty"),
pool: text("pool", "minecraft:empty"),
target: text("target", "minecraft:empty"),
placement_priority: int("placement_priority"),
selection_priority: int("selection_priority"),
info: info.clone(),
})
})
.collect()
})
}
}
@@ -0,0 +1,40 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import net.minecraft.SharedConstants;
import net.minecraft.core.BlockPos;
import net.minecraft.server.Bootstrap;
import net.minecraft.world.RandomizableContainer;
import net.minecraft.world.level.EmptyBlockGetter;
import net.minecraft.world.level.block.*;
import net.minecraft.world.level.block.state.BlockState;
/**
* Original exporter of per-state structure-template behavior: BlockState.rotate
* and BlockState.mirror results, StructureTemplate's full-block ordering class
* and whether the state's block entity is a RandomizableContainer.
*/
public final class VanillaStructureBlockExporter {
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();Bootstrap.bootStrap();
var rotate=new JsonArray();var mirror=new JsonArray();var full=new JsonArray();var loot=new JsonArray();
Rotation[] rotations={Rotation.CLOCKWISE_90,Rotation.CLOCKWISE_180,Rotation.COUNTERCLOCKWISE_90};
Mirror[] mirrors={Mirror.LEFT_RIGHT,Mirror.FRONT_BACK};
for(BlockState state:Block.BLOCK_STATE_REGISTRY) {
var r=new JsonArray();for(var rotation:rotations)r.add(Block.getId(state.rotate(rotation)));rotate.add(r);
var m=new JsonArray();for(var value:mirrors)m.add(Block.getId(state.mirror(value)));mirror.add(m);
full.add(!state.getBlock().hasDynamicShape()&&state.isCollisionShapeFullBlock(EmptyBlockGetter.INSTANCE,BlockPos.ZERO));
boolean container=false;
if(state.getBlock() instanceof EntityBlock entityBlock) {
try{container=entityBlock.newBlockEntity(BlockPos.ZERO,state) instanceof RandomizableContainer;}catch(Throwable ignored){}
}
if(container)loot.add(Block.getId(state));
}
var result=new JsonObject();
result.addProperty("states",Block.BLOCK_STATE_REGISTRY.size());
result.add("rotate",rotate);result.add("mirror",mirror);result.add("full_block",full);result.add("loot_containers",loot);
Files.writeString(Path.of(args[0]),new Gson().toJson(result),StandardCharsets.UTF_8);
}
}
@@ -0,0 +1,111 @@
package dev.horizonlab.parity;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.core.*;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.RegistryDataLoader;
import net.minecraft.server.Bootstrap;
import net.minecraft.server.RegistryLayer;
import net.minecraft.server.packs.PackType;
import net.minecraft.server.packs.repository.ServerPacksSource;
import net.minecraft.server.packs.resources.MultiPackResourceManager;
import net.minecraft.tags.TagLoader;
import net.minecraft.util.datafix.DataFixers;
import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelHeightAccessor;
import net.minecraft.world.level.biome.MultiNoiseBiomeSource;
import net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterLists;
import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
import net.minecraft.world.level.levelgen.*;
import net.minecraft.world.level.levelgen.structure.*;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
import net.minecraft.world.level.storage.LevelStorageSource;
/**
* Original oracle: runs vanilla structure placement checks, start selection
* and Structure.generate (as ChunkGenerator.createStructures does for a fresh
* chunk) for a rectangle of overworld chunks and prints every valid start.
*/
public final class VanillaStructureStartOracle {
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();Bootstrap.bootStrap();
Path out=Path.of(args[0]);long seed=Long.parseLong(args[1]);
int x0=Integer.parseInt(args[2]),z0=Integer.parseInt(args[3]),x1=Integer.parseInt(args[4]),z1=Integer.parseInt(args[5]);
var repo=ServerPacksSource.createVanillaTrustedRepository();repo.reload();repo.setSelected(List.of("vanilla"));
var resources=new MultiPackResourceManager(PackType.SERVER_DATA,repo.openAllSelected());
var layers=RegistryLayer.createRegistryAccess();
var staticTags=TagLoader.loadTagsForExistingRegistries(resources,layers.getLayer(RegistryLayer.STATIC));
var context=TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD),staticTags);
RegistryAccess.Frozen world=RegistryDataLoader.load(resources,context,RegistryDataLoader.WORLD_REGISTRIES,Runnable::run).join();
staticTags.forEach(Registry.PendingTags::apply);
RegistryAccess access=layers.replaceFrom(RegistryLayer.WORLD,world).compositeAccess();
var settings=world.lookupOrThrow(Registries.NOISE_SETTINGS).getOrThrow(NoiseGeneratorSettings.OVERWORLD);
var randomState=RandomState.create(world.lookupOrThrow(Registries.NOISE),seed,settings.value());
var biomeSource=MultiNoiseBiomeSource.createFromPreset(world.lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST).getOrThrow(MultiNoiseBiomeSourceParameterLists.OVERWORLD));
var generator=new NoiseBasedChunkGenerator(biomeSource,settings);
var state=ChunkGeneratorStructureState.createForNormal(randomState,seed,new ChunkPos(0,0),biomeSource,world.lookupOrThrow(Registries.STRUCTURE_SET));
Path tmp=Files.createTempDirectory("horizon-structures");
var storage=LevelStorageSource.createDefault(tmp).createAccess("oracle");
var templates=new StructureTemplateManager(resources,storage,DataFixers.getDataFixer(),BuiltInRegistries.BLOCK);
LevelHeightAccessor height=LevelHeightAccessor.create(-64,384);
var climate=randomState.createClimateSampler(net.minecraft.world.level.levelgen.densityfunction.SamplerContext.builder().enableCaches().build());
var structures=world.lookupOrThrow(Registries.STRUCTURE);
try(var w=new PrintWriter(Files.newBufferedWriter(out,StandardCharsets.UTF_8))) {
structures.listElements().forEach(h->w.println("registry "+h.key().identifier()+" "+h.value().step().ordinal()));
if(System.getenv("HORIZON_HEIGHTS")!=null)for(String p:System.getenv("HORIZON_HEIGHTS").split(";")){
String[] xz=p.split(",");int x=Integer.parseInt(xz[0]),z=Integer.parseInt(xz[1]);
int floor=generator.getBaseHeight(x,z,Heightmap.Types.OCEAN_FLOOR_WG,height,randomState),surface=generator.getBaseHeight(x,z,Heightmap.Types.WORLD_SURFACE_WG,height,randomState);
var resolver=biomeSource.createResolver(climate);
StringBuilder biomes=new StringBuilder();
for(int qy=(floor-12)>>2;qy<=(floor+8)>>2;qy++)biomes.append(" "+qy+":"+resolver.getNoiseBiome(x>>2,qy,z>>2).unwrapKey().get().identifier().getPath());
w.println("height "+x+" "+z+" "+floor+" "+surface+biomes);
}
for(int cx=x0;cx<=x1;cx++)for(int cz=z0;cz<=z1;cz++) {
ChunkPos pos=new ChunkPos(cx,cz);
for(var set:state.possibleStructureSets()) {
var placement=set.value().placement();var entries=set.value().structures();
if(!placement.isStructureChunk(state,cx,cz))continue;
if(System.getenv("HORIZON_PLACED")!=null)w.println("placed "+cx+" "+cz+" "+set.unwrapKey().get().identifier());
var options=new ArrayList<>(entries);
WorldgenRandom random=new WorldgenRandom(new LegacyRandomSource(0L));random.setLargeFeatureSeed(seed,cx,cz);
int total=0;for(var o:options)total+=o.weight();
while(!options.isEmpty()) {
StructureSet.StructureSelectionEntry selected;int index=0;
if(entries.size()==1){selected=options.get(0);}
else{int choice=random.nextInt(total);for(var o:options){choice-=o.weight();if(choice<0)break;index++;}selected=options.get(index);}
var structure=selected.structure();
StructureStart start=structure.value().generate(structure,Level.OVERWORLD,access,generator,biomeSource,climate,randomState,templates,seed,pos,0,height,structure.value().biomes()::contains);
if(System.getenv("HORIZON_PLACED")!=null){
w.println("generate "+structure.unwrapKey().get().identifier()+" "+start.isValid());
var ctx=new Structure.GenerationContext(access,generator,biomeSource,climate,randomState,templates,seed,pos,height,structure.value().biomes()::contains);
try{var m=Structure.class.getDeclaredMethod("findGenerationPoint",Structure.GenerationContext.class);m.setAccessible(true);
var stub=(java.util.Optional<?>)m.invoke(structure.value(),ctx);
stub.ifPresent(st->{var sp=((Structure.GenerationStub)st).position();w.println("stub "+sp+" "+ctx.biomeResolver().getNoiseBiome(sp.getX()>>2,sp.getY()>>2,sp.getZ()>>2).unwrapKey().get().identifier());});}catch(Exception e){w.println("err "+e);}
}
if(start.isValid()) {
var b=start.getBoundingBox();
w.println("start "+cx+" "+cz+" "+structure.unwrapKey().get().identifier()+" "+b.minX()+" "+b.minY()+" "+b.minZ()+" "+b.maxX()+" "+b.maxY()+" "+b.maxZ()+" "+start.getPieces().size());
for(var piece:start.getPieces()) {
var pb=piece.getBoundingBox();
String extra="";
if(piece instanceof PoolElementStructurePiece pool)extra=" "+pool.getPosition().getX()+" "+pool.getPosition().getY()+" "+pool.getPosition().getZ()+" "+pool.getRotation()+" "+pool.getGroundLevelDelta()+" "+pool.getJunctions().size()+" "+pool.getElement();
w.println("piece "+BuiltInRegistries.STRUCTURE_PIECE.getKey(piece.getType())+" "+pb.minX()+" "+pb.minY()+" "+pb.minZ()+" "+pb.maxX()+" "+pb.maxY()+" "+pb.maxZ()+extra);
}
break;
}
if(entries.size()==1)break;
options.remove(index);total-=selected.weight();
}
}
}
}
storage.close();
System.exit(0);
}
}
+55
View File
@@ -0,0 +1,55 @@
#!/usr/bin/env python3
"""Compare Rust structure starts (chunkgen_bench --starts) with the vanilla oracle.
usage: compare_structure_starts.py VANILLA RUST [--all]
Pieces are compared by type, bounding box and (for jigsaw pieces) position,
rotation, ground level delta and junction count. Without --all, vanilla
starts of structure types Rust does not generate yet are only counted.
"""
import collections
import sys
def load(path):
starts = {}
current = None
for line in open(path):
t = line.split()
if not t:
continue
if t[0] == 'start':
current = (int(t[1]), int(t[2]), t[3])
starts[current] = [' '.join(t[4:])]
elif t[0] == 'piece' and current:
starts[current].append(' '.join(t[1:14]))
return starts
def main():
vanilla, rust = load(sys.argv[1]), load(sys.argv[2])
generated = {k[2] for k in rust}
matched = 0
missing = collections.Counter()
for key in sorted(vanilla):
if key not in rust:
missing[key[2]] += 1
if key[2] in generated or '--all' in sys.argv:
print('missing', key)
continue
if vanilla[key] == rust[key]:
matched += 1
continue
v, r = vanilla[key], rust[key]
print('DIFF', key, 'pieces', len(v) - 1, len(r) - 1)
for i, (a, b) in enumerate(zip(v, r)):
if a != b:
print(' first difference at line', i, '\n vanilla', a, '\n rust ', b)
break
for key in sorted(set(rust) - set(vanilla)):
print('extra', key)
print(f'{matched} of {len(vanilla)} vanilla starts match exactly; not generated by Rust:', dict(missing))
return 0 if matched == len(rust) == sum(1 for k in vanilla if k[2] in generated) else 1
if __name__ == '__main__':
sys.exit(main())
+37 -3
View File
@@ -21,13 +21,44 @@ WORLDGEN_BUNDLES = {
'biomes': 'worldgen/biome', 'world_presets': 'worldgen/world_preset', 'features': 'worldgen/feature',
'placed_features': 'worldgen/placed_feature', 'state_providers': 'worldgen/block_state_provider',
'biome_tags': 'tags/worldgen/biome', 'feature_tags': 'tags/worldgen/feature', 'block_tags': 'tags/block',
'fluid_tags': 'tags/fluid'}
'fluid_tags': 'tags/fluid', 'processor_lists': 'worldgen/processor_list',
'template_pools': 'worldgen/template_pool', 'structures': 'worldgen/structure',
'structure_sets': 'worldgen/structure_set'}
def prepare_worldgen(root, jars, local):
def export_structure_blocks(target, jars, libraries):
"""Run the vanilla exporter of per-state rotate/mirror results and template flags."""
lock = json.loads((lab.ROOT/'research-lock.json').read_text())
source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStructureBlockExporter.java'
export = lab.LOCAL/'horizon-client-structures'
classes = export/'classes'
classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies,
'-d', str(classes), str(source)], check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaStructureBlockExporter', str(target)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
def prepare_worldgen(root, jars, local, libraries=None):
"""Write the chunk generator's resource bundle to root/worldgen (see GeneratorData::load)."""
out = root / 'worldgen'
out.mkdir(exist_ok=True)
# Structure templates: gzip NBT files under structure/<namespace>/<path>.nbt.
with zipfile.ZipFile(jars['server']) as server:
prefix = 'data/minecraft/structure/'
for name in server.namelist():
if name.startswith(prefix) and name.endswith('.nbt'):
relative = Path(name[len(prefix):])
if relative.is_absolute() or '..' in relative.parts:
raise ValueError('Invalid structure path')
target = out/'structure'/'minecraft'/relative
data = server.read(name)
if not target.exists() or target.read_bytes() != data:
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(data)
with zipfile.ZipFile(jars['server']) as server, zipfile.ZipFile(jars['client']) as client:
for name, path in WORLDGEN_BUNDLES.items():
prefix = f'data/minecraft/{path}/'
@@ -60,6 +91,9 @@ def prepare_worldgen(root, jars, local):
blocks.mkdir(exist_ok=True)
for name in names:
(blocks/name).write_bytes((behavior/name).read_bytes())
if libraries is not None:
blocks.mkdir(exist_ok=True)
export_structure_blocks(blocks/'structure-blocks.json', jars, libraries)
else:
print('Feature block behavior exports missing; run tools/test_simple_block_parity.py for full decoration')
if presets is None:
@@ -294,7 +328,7 @@ def main():
for f in (reports / 'biome_parameters' / 'minecraft').glob('*.json'):
(root / 'biome-parameters' / f.name).write_bytes(f.read_bytes())
# Biome parameter tables come from the data generator reports above.
prepare_worldgen(root, jars, lab.LOCAL)
prepare_worldgen(root, jars, lab.LOCAL, libraries)
entity_models = root / 'entity-models.json'
entity_oracle = oracle.with_name('VanillaEntityModelExporter.java')
entity_sources = base.source_hashes([entity_oracle])
+37
View File
@@ -0,0 +1,37 @@
#!/usr/bin/env python3
"""Run the vanilla structure-start oracle for a seed and chunk rectangle.
usage: structure_start_oracle.py OUT SEED X0 Z0 X1 Z1
"""
import os
import subprocess
import sys
try:
from . import lab, test_rust_parity as base
except ImportError:
import lab
import test_rust_parity as base
def main():
out, seed, x0, z0, x1, z1 = sys.argv[1:7]
lock, jars, libraries = base.verify_artifacts()
source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStructureStartOracle.java'
build = lab.LOCAL/'structure-start-oracle'
classes = build/'classes'
classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
compiled = subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies,
'-d', str(classes), str(source)], capture_output=True, text=True)
if compiled.returncode:
raise SystemExit('javac failed:\n' + compiled.stderr[-3000:])
result = subprocess.run(['java', '-Xmx2G', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaStructureStartOracle', out, seed, x0, z0, x1, z1],
capture_output=True, text=True)
if result.returncode:
lines = [line for line in (result.stdout + result.stderr).splitlines() if 'Exception' in line or 'Caused' in line]
raise SystemExit('oracle failed: ' + ' | '.join(lines[:5]))
if __name__ == '__main__':
main()