Merge remote-tracking branch 'origin/worktree-agent-a2bb16cfb9ff4be19' into t3code/rewrite-minecraft-rust
# Conflicts: # tools/prepare_native_client.py
This commit is contained in:
@@ -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) {
|
||||
|
||||
@@ -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 = ®istry.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 = ®istry.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,
|
||||
®istry.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);
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
@@ -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])
|
||||
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user