Match vanilla structure placement block for block
- Legacy jigsaw elements apply STRUCTURE_AND_AIR last, after jigsaw replacement (outposts no longer carve air where jigsaws sat). - Templates without a known shape run StructureTemplate's neighbor shape updates (updateShapeAtEdge, then updateFromNeighbourShapes) through level::Behaviours: snowy grass under igloos, stair shapes and fence connections in shipwrecks. - The placement oracle keeps going through structure entities (a level stand-in with no enabled features) and compares brushable-block loot. With block behavior exports present, 18 chunks of seed 1 covering villages, igloo, outpost, mineshafts, shipwreck, warm ocean ruin, buried treasure, ruined portal, trial chambers, monument, mansion, stronghold, ancient city, trail ruins and a jungle temple match vanilla exactly, blocks and block-entity loot seeds. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -61,7 +61,17 @@ fn main() -> Result<(), Error> {
|
||||
}
|
||||
}
|
||||
let mut region: [ProtoChunk; 9] = region.try_into().map_err(|_| "region size")?;
|
||||
worker.decorate(&mut region)?;
|
||||
let stats = if std::env::var_os("HORIZON_TERRAIN_ONLY").is_some() {
|
||||
Default::default()
|
||||
} else {
|
||||
worker.decorate(&mut region)?
|
||||
};
|
||||
if stats.failed > 0 {
|
||||
eprintln!(
|
||||
"chunk {cx} {cz}: {} structure placements failed",
|
||||
stats.failed
|
||||
);
|
||||
}
|
||||
let chunk = ®ion[4];
|
||||
println!("chunk {cx} {cz}");
|
||||
let (min, height) = (chunk.terrain.min_y(), chunk.terrain.height());
|
||||
|
||||
@@ -180,6 +180,9 @@ pub struct GeneratorData {
|
||||
/// Templates, processor lists and per-state template transforms.
|
||||
pub(super) structures: Option<Arc<super::structure::StructureResources>>,
|
||||
pub(super) structure_resources: Option<StructureBundles>,
|
||||
/// Block shape-update behaviour (`block-behaviours.json` next to the
|
||||
/// worldgen directory) for template placement's neighbor updates.
|
||||
pub(super) behaviours: Option<Arc<crate::level::Behaviours>>,
|
||||
}
|
||||
type Bundle = BTreeMap<String, String>;
|
||||
fn read_bundle(dir: &Path, name: &str) -> Result<Bundle, GeneratorError> {
|
||||
@@ -425,7 +428,13 @@ impl GeneratorData {
|
||||
}),
|
||||
_ => None,
|
||||
};
|
||||
let behaviours = dir
|
||||
.parent()
|
||||
.filter(|root| root.join("block-behaviours.json").exists())
|
||||
.and_then(|root| crate::level::Behaviours::load(registry, root).ok())
|
||||
.map(Arc::new);
|
||||
Ok(Arc::new(Self {
|
||||
behaviours,
|
||||
structure_resources,
|
||||
structures,
|
||||
registry,
|
||||
|
||||
@@ -313,6 +313,8 @@ impl Decoration {
|
||||
zone: GenerationWriteZone::new(center, 1),
|
||||
decoration: self,
|
||||
temperatures: &mut worker.temperatures,
|
||||
behaviours: data.behaviours.as_deref(),
|
||||
build: (generation.min_y, generation.min_y + generation.height),
|
||||
};
|
||||
let mut stats = DecorateStats::default();
|
||||
let blocks = self.blocks;
|
||||
@@ -428,6 +430,68 @@ struct World<'a> {
|
||||
zone: GenerationWriteZone,
|
||||
decoration: &'a Decoration,
|
||||
temperatures: &'a mut [BiomeTemperature],
|
||||
behaviours: Option<&'a crate::level::Behaviours>,
|
||||
/// Inclusive minimum and exclusive maximum build height.
|
||||
build: (i32, i32),
|
||||
}
|
||||
/// Read-only `LevelAccess` view of the decoration region for
|
||||
/// `BlockState.updateShape` (writes go through `World::set_block`).
|
||||
struct ShapeLevel<'w, 'a> {
|
||||
world: &'w World<'a>,
|
||||
random: horizon_core::random::LegacyRandom,
|
||||
}
|
||||
impl crate::level::LevelAccess for ShapeLevel<'_, '_> {
|
||||
fn block_state(&self, pos: BlockPos) -> BlockStateId {
|
||||
self.world
|
||||
.region
|
||||
.block([pos.x, pos.y, pos.z])
|
||||
.unwrap_or(BlockStateId(0))
|
||||
}
|
||||
fn set_raw(&mut self, _: BlockPos, _: BlockStateId) -> Option<BlockStateId> {
|
||||
None
|
||||
}
|
||||
fn is_loaded(&self, pos: BlockPos) -> bool {
|
||||
self.world.region.block([pos.x, pos.y, pos.z]).is_ok()
|
||||
}
|
||||
fn min_y(&self) -> i32 {
|
||||
self.world.build.0
|
||||
}
|
||||
fn max_y(&self) -> i32 {
|
||||
self.world.build.1
|
||||
}
|
||||
fn random(&mut self) -> &mut horizon_core::random::LegacyRandom {
|
||||
&mut self.random
|
||||
}
|
||||
fn game_time(&self) -> i64 {
|
||||
0
|
||||
}
|
||||
}
|
||||
impl World<'_> {
|
||||
/// `BlockState.updateShape` of the state at `pos` against `neighbor`.
|
||||
fn shape_update(
|
||||
&self,
|
||||
behaviours: &crate::level::Behaviours,
|
||||
state: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
direction: Direction,
|
||||
neighbor_pos: [i32; 3],
|
||||
neighbor: BlockStateId,
|
||||
) -> BlockStateId {
|
||||
let mut level = ShapeLevel {
|
||||
world: self,
|
||||
random: horizon_core::random::LegacyRandom::new(0),
|
||||
};
|
||||
let mut ticks = crate::level::Ticks::new(0);
|
||||
behaviours.update_shape(
|
||||
&mut level,
|
||||
&mut ticks,
|
||||
state,
|
||||
BlockPos::new(pos[0], pos[1], pos[2]),
|
||||
direction,
|
||||
BlockPos::new(neighbor_pos[0], neighbor_pos[1], neighbor_pos[2]),
|
||||
neighbor,
|
||||
)
|
||||
}
|
||||
}
|
||||
impl DecorationWorld for World<'_> {
|
||||
type Error = RegionError;
|
||||
@@ -622,6 +686,81 @@ impl PlacementContext for World<'_> {
|
||||
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
self.region.world_seed()
|
||||
}
|
||||
fn update_shape_at_face(
|
||||
&mut self,
|
||||
position: [i32; 3],
|
||||
direction: Direction,
|
||||
flags: i32,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
let Some(behaviours) = self.behaviours else {
|
||||
return Ok(());
|
||||
};
|
||||
let n = direction.normal();
|
||||
let neighbor_pos = [position[0] + n[0], position[1] + n[1], position[2] + n[2]];
|
||||
let state = self.region.block(position).map_err(query)?;
|
||||
let neighbor = self.region.block(neighbor_pos).map_err(query)?;
|
||||
let new_state = self.shape_update(
|
||||
behaviours,
|
||||
state,
|
||||
position,
|
||||
direction,
|
||||
neighbor_pos,
|
||||
neighbor,
|
||||
);
|
||||
if new_state != state {
|
||||
self.set_block(position, new_state, flags & !1)
|
||||
.map_err(query)?;
|
||||
}
|
||||
let new_neighbor = self.shape_update(
|
||||
behaviours,
|
||||
neighbor,
|
||||
neighbor_pos,
|
||||
direction.opposite(),
|
||||
position,
|
||||
new_state,
|
||||
);
|
||||
if new_neighbor != neighbor {
|
||||
self.set_block(neighbor_pos, new_neighbor, flags & !1)
|
||||
.map_err(query)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn update_from_neighbour_shapes(
|
||||
&mut self,
|
||||
position: [i32; 3],
|
||||
flags: i32,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
let Some(behaviours) = self.behaviours else {
|
||||
return Ok(());
|
||||
};
|
||||
let state = self.region.block(position).map_err(query)?;
|
||||
// Block.UPDATE_SHAPE_ORDER.
|
||||
let mut new_state = state;
|
||||
for direction in [
|
||||
Direction::West,
|
||||
Direction::East,
|
||||
Direction::North,
|
||||
Direction::South,
|
||||
Direction::Down,
|
||||
Direction::Up,
|
||||
] {
|
||||
let n = direction.normal();
|
||||
let neighbor_pos = [position[0] + n[0], position[1] + n[1], position[2] + n[2]];
|
||||
let neighbor = self.region.block(neighbor_pos).map_err(query)?;
|
||||
new_state = self.shape_update(
|
||||
behaviours,
|
||||
new_state,
|
||||
position,
|
||||
direction,
|
||||
neighbor_pos,
|
||||
neighbor,
|
||||
);
|
||||
}
|
||||
if new_state != state {
|
||||
self.set_block(position, new_state, flags).map_err(query)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn ensure_can_write(&mut self, position: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
Ok(self
|
||||
.zone
|
||||
|
||||
@@ -39,6 +39,16 @@ pub trait PlacementContext {
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// Block.updateFromNeighbourShapes for the state at `position`, written
|
||||
/// with `flags` when it changes. Worlds without block shape-update
|
||||
/// behavior accept this as a no-op.
|
||||
fn update_from_neighbour_shapes(
|
||||
&mut self,
|
||||
_position: [i32; 3],
|
||||
_flags: i32,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// WorldGenRegion.ensureCanWrite: horizontal write radius and upgrade height.
|
||||
fn ensure_can_write(&mut self, _position: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
Ok(true)
|
||||
|
||||
@@ -483,9 +483,12 @@ fn place_element<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
})
|
||||
};
|
||||
let mut settings = PlaceSettings::new(rotation);
|
||||
settings.known_shape = true;
|
||||
settings.bounding_box = Some(chunk_box);
|
||||
settings.waterlogging = override_liquid.unwrap_or(waterlogging);
|
||||
settings.processors.push(ignore);
|
||||
if !*legacy {
|
||||
settings.processors.push(ignore);
|
||||
}
|
||||
settings.processors.push(&Processor::JigsawReplacement);
|
||||
settings.processors.extend(processors.0.iter());
|
||||
if *projection == Projection::TerrainMatching {
|
||||
@@ -496,6 +499,11 @@ fn place_element<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
offset: -1,
|
||||
}));
|
||||
}
|
||||
// LegacySinglePoolElement pops the structure-block ignore and
|
||||
// appends STRUCTURE_AND_AIR last, after jigsaw replacement.
|
||||
if *legacy {
|
||||
settings.processors.push(ignore);
|
||||
}
|
||||
place_in_world(
|
||||
world,
|
||||
resources,
|
||||
|
||||
@@ -314,6 +314,9 @@ pub struct PlaceSettings<'a> {
|
||||
pub processors: Vec<&'a Processor>,
|
||||
pub waterlogging: bool,
|
||||
pub random: Option<&'a mut dyn ProcessorRandom>,
|
||||
/// StructurePlaceSettings.knownShape: skip the neighbor shape updates
|
||||
/// after placement (jigsaw pieces).
|
||||
pub known_shape: bool,
|
||||
}
|
||||
impl<'a> PlaceSettings<'a> {
|
||||
pub fn new(rotation: Rotation) -> Self {
|
||||
@@ -325,6 +328,7 @@ impl<'a> PlaceSettings<'a> {
|
||||
processors: Vec::new(),
|
||||
waterlogging: true,
|
||||
random: None,
|
||||
known_shape: false,
|
||||
}
|
||||
}
|
||||
pub fn with_processors(mut self, list: &'a ProcessorList) -> Self {
|
||||
@@ -746,6 +750,7 @@ pub fn place_in_world<W: FeatureWorld + PlacementContext>(
|
||||
.unwrap();
|
||||
let mut to_fill = Vec::new();
|
||||
let mut locked = Vec::new();
|
||||
let mut placed = Vec::new();
|
||||
let world_err = |_| PlacementQueryError::Failed("template write".into());
|
||||
for info in infos {
|
||||
if settings
|
||||
@@ -769,6 +774,7 @@ pub fn place_in_world<W: FeatureWorld + PlacementContext>(
|
||||
if !world.set_block(info.pos, state, flags).map_err(world_err)? {
|
||||
continue;
|
||||
}
|
||||
placed.push(info.pos);
|
||||
if let Some(mut nbt) = info.nbt {
|
||||
if resources.transforms.loot_container(state) {
|
||||
let seed = match loot_random.as_deref_mut() {
|
||||
@@ -820,5 +826,87 @@ pub fn place_in_world<W: FeatureWorld + PlacementContext>(
|
||||
}
|
||||
to_fill = remaining;
|
||||
}
|
||||
if !settings.known_shape && !placed.is_empty() {
|
||||
update_shape_at_edge(world, &placed, flags)?;
|
||||
for &pos in &placed {
|
||||
world.update_from_neighbour_shapes(pos, flags & !1 | 16)?;
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// StructureTemplate.updateShapeAtEdge over the placed positions' voxel
|
||||
/// shape (DiscreteVoxelShape.forAllFaces order: X-Y rows along Z, then
|
||||
/// Z-X rows along Y, then Y-Z rows along X).
|
||||
fn update_shape_at_edge<W: PlacementContext>(
|
||||
world: &mut W,
|
||||
placed: &[[i32; 3]],
|
||||
flags: i32,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
use horizon_core::geometry::Direction;
|
||||
let mut min = placed[0];
|
||||
let mut max = placed[0];
|
||||
for p in placed {
|
||||
for i in 0..3 {
|
||||
min[i] = min[i].min(p[i]);
|
||||
max[i] = max[i].max(p[i]);
|
||||
}
|
||||
}
|
||||
let size: [i32; 3] = std::array::from_fn(|i| max[i] - min[i] + 1);
|
||||
let index = |[x, y, z]: [i32; 3]| ((x * size[1] + y) * size[2] + z) as usize;
|
||||
let mut bits = vec![false; size.iter().map(|v| *v as usize).product()];
|
||||
for p in placed {
|
||||
bits[index(std::array::from_fn(|i| p[i] - min[i]))] = true;
|
||||
}
|
||||
let full = |p: [i32; 3]| (0..3).all(|i| (0..size[i]).contains(&p[i])) && bits[index(p)];
|
||||
type Map = fn(i32, i32, i32) -> [i32; 3];
|
||||
let passes: [(Direction, Direction, i32, i32, i32, Map); 3] = [
|
||||
(
|
||||
Direction::North,
|
||||
Direction::South,
|
||||
size[0],
|
||||
size[1],
|
||||
size[2],
|
||||
|a, b, c| [a, b, c],
|
||||
),
|
||||
(
|
||||
Direction::Down,
|
||||
Direction::Up,
|
||||
size[2],
|
||||
size[0],
|
||||
size[1],
|
||||
|a, b, c| [b, c, a],
|
||||
),
|
||||
(
|
||||
Direction::West,
|
||||
Direction::East,
|
||||
size[1],
|
||||
size[2],
|
||||
size[0],
|
||||
|a, b, c| [c, a, b],
|
||||
),
|
||||
];
|
||||
for (negative, positive, a_size, b_size, c_size, map) in passes {
|
||||
for a in 0..a_size {
|
||||
for b in 0..b_size {
|
||||
let mut last = false;
|
||||
for c in 0..=c_size {
|
||||
let here = c != c_size && full(map(a, b, c));
|
||||
let face = if !last && here {
|
||||
Some((negative, map(a, b, c)))
|
||||
} else if last && !here {
|
||||
Some((positive, map(a, b, c - 1)))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some((direction, local)) = face {
|
||||
let p = std::array::from_fn(|i| min[i] + local[i]);
|
||||
world.update_shape_at_face(p, direction, flags)?;
|
||||
}
|
||||
last = here;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
+25
-1
@@ -45,6 +45,26 @@ import net.minecraft.world.level.storage.LevelStorageSource;
|
||||
public final class VanillaStructurePlacementOracle {
|
||||
private static final class Ignored extends RuntimeException {}
|
||||
|
||||
/**
|
||||
* Allocated without a constructor: no feature flags are enabled, so
|
||||
* EntityType.create returns null and structure entities are skipped as
|
||||
* Horizon skips them, while block placement continues.
|
||||
*/
|
||||
private static final class NoEntityLevel extends net.minecraft.server.level.ServerLevel {
|
||||
private NoEntityLevel() {
|
||||
super(null, null, null, null, null, null, false, 0L, null, false);
|
||||
}
|
||||
static long seed;
|
||||
@Override
|
||||
public net.minecraft.world.flag.FeatureFlagSet enabledFeatures() {
|
||||
return net.minecraft.world.flag.FeatureFlagSet.of();
|
||||
}
|
||||
@Override
|
||||
public long getSeed() {
|
||||
return seed;
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
SharedConstants.tryDetectVersion();Bootstrap.bootStrap();
|
||||
Path out=Path.of(args[0]);long seed=Long.parseLong(args[1]);String dimension=args[2];
|
||||
@@ -76,6 +96,9 @@ public final class VanillaStructurePlacementOracle {
|
||||
var climate=randomState.createClimateSampler(net.minecraft.world.level.levelgen.densityfunction.SamplerContext.builder().enableCaches().build());
|
||||
var structures=world.lookupOrThrow(Registries.STRUCTURE);
|
||||
var factory=PalettedContainerFactory.create(access);
|
||||
var unsafeField=Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe");unsafeField.setAccessible(true);Object unsafe=unsafeField.get(null);
|
||||
NoEntityLevel.seed=seed;
|
||||
var noEntities=(net.minecraft.server.level.ServerLevel)unsafe.getClass().getMethod("allocateInstance",Class.class).invoke(unsafe,NoEntityLevel.class);
|
||||
try(var w=new PrintWriter(Files.newBufferedWriter(out,StandardCharsets.UTF_8))) {
|
||||
for(int t=3;t<args.length;t++) {
|
||||
String[] xz=args[t].split(",");int cx=Integer.parseInt(xz[0]),cz=Integer.parseInt(xz[1]);
|
||||
@@ -168,7 +191,7 @@ public final class VanillaStructurePlacementOracle {
|
||||
case "setCurrentlyGenerating","scheduleTick","blockUpdated","updateNeighborsAt","gameEvent","playSound","levelEvent","addParticle":return null;
|
||||
case "addFreshEntity":return true;
|
||||
case "addFreshEntityWithPassengers":return null;
|
||||
case "getLevel":throw new Ignored();
|
||||
case "getLevel":return noEntities;
|
||||
case "isClientSide":return false;
|
||||
case "enabledFeatures":return net.minecraft.world.flag.FeatureFlags.DEFAULT_FLAGS;
|
||||
case "dimensionType":return world.lookupOrThrow(Registries.DIMENSION_TYPE).getOrThrow(switch(dimension){case "the_nether"->net.minecraft.world.level.dimension.BuiltinDimensionTypes.NETHER;case "the_end"->net.minecraft.world.level.dimension.BuiltinDimensionTypes.END;default->net.minecraft.world.level.dimension.BuiltinDimensionTypes.OVERWORLD;}).value();
|
||||
@@ -223,6 +246,7 @@ public final class VanillaStructurePlacementOracle {
|
||||
for(var e:entities.values()) {
|
||||
var p=e.getBlockPos();String table="-",lootSeed="-";
|
||||
if(e instanceof RandomizableContainer rc&&rc.getLootTable()!=null){table=rc.getLootTable().identifier().toString();lootSeed=Long.toString(rc.getLootTableSeed());}
|
||||
if(e instanceof net.minecraft.world.level.block.entity.BrushableBlockEntity){try{var f=e.getClass().getDeclaredField("lootTable");f.setAccessible(true);var key=(net.minecraft.resources.ResourceKey<?>)f.get(e);var s=e.getClass().getDeclaredField("lootTableSeed");s.setAccessible(true);if(key!=null){table=key.identifier().toString();lootSeed=Long.toString(s.getLong(e));}}catch(ReflectiveOperationException ex){throw new RuntimeException(ex);}}
|
||||
w.println("be "+p.getX()+" "+p.getY()+" "+p.getZ()+" "+BuiltInRegistries.BLOCK_ENTITY_TYPE.getKey(e.getType())+" "+table+" "+lootSeed);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -52,7 +52,9 @@ def parse(lines):
|
||||
elif t[0] == 'y' and current:
|
||||
chunks[current]['rows'][int(t[1])] = t[2:]
|
||||
elif t[0] == 'be' and current:
|
||||
chunks[current]['be'].append(' '.join(t[1:]))
|
||||
# Position, loot table and seed; the block entity type follows
|
||||
# from the (separately compared) block state.
|
||||
chunks[current]['be'].append(' '.join(t[1:4] + t[5:]))
|
||||
return chunks
|
||||
|
||||
|
||||
@@ -77,6 +79,7 @@ def main():
|
||||
check=True, cwd=lab.ROOT)
|
||||
rust_out = subprocess.run([str(lab.ROOT/'target/fast/examples/structure_blocks'), resources, seed, dimension, *targets],
|
||||
check=True, capture_output=True, text=True).stdout
|
||||
(build_dir()/'rust.txt').write_text(rust_out)
|
||||
rust = parse(rust_out.splitlines())
|
||||
names = state_names(resources)
|
||||
failed = 0
|
||||
|
||||
Reference in New Issue
Block a user