Generate superflat worlds with their layers (FlatLevelSource)

Horizon generated noise terrain in minecraft:flat worlds. Since chunk
streaming finishes the corners of the spawn neighbourhood, save_roundtrip's
flat test world got four noise chunks where vanilla had saved flat proto
chunks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-13 03:54:23 +02:00
parent 9ac6d665fb
commit 4078118c71
4 changed files with 107 additions and 2 deletions
+73
View File
@@ -0,0 +1,73 @@
//! FlatLevelSource: superflat worlds (`minecraft:flat` generator).
use crate::{chunk::Chunk, streaming::ChunkGenerator};
use horizon_world::{nbt::Tag, registry::BlockRegistry};
/// The layers of a flat generator, bottom up from the world's minimum Y.
pub struct FlatTerrain {
layers: Vec<u16>,
biome: u16,
}
impl FlatTerrain {
/// The overworld generator of `world_gen_settings` (`data.dimensions`), if it
/// is flat. Its `features` and `lakes` decorate the world; a world without
/// them (the default) gets only its layers, as FlatLevelSource places them.
pub fn from_settings(
settings: &Tag,
registry: &BlockRegistry,
biomes: &crate::biome::Biomes,
) -> Option<Self> {
let generator = settings
.get("dimensions")?
.get("minecraft:overworld")?
.get("generator")?;
if crate::save::text(generator.get("type"))?.trim_start_matches("minecraft:") != "flat" {
return None;
}
let s = generator.get("settings")?;
let biome = crate::save::text(s.get("biome")).unwrap_or_else(|| "minecraft:plains".into());
let mut layers = Vec::new();
if let Some(Tag::List(list)) = s.get("layers") {
for layer in list {
let block = crate::save::text(layer.get("block"))?;
let height = crate::save::number(layer.get("height")).unwrap_or(0).max(0);
let state = registry.default_state(&block)?.0 as u16;
layers.extend(std::iter::repeat_n(state, height as usize));
}
}
Some(Self {
layers,
biome: biomes.id(&biome),
})
}
}
impl ChunkGenerator for FlatTerrain {
type Worker = ();
fn worker(&self) {}
fn proto(&self, _: &mut (), cx: i32, cz: i32) -> crate::streaming::Proto {
let mut chunk = Chunk::empty(cx, cz);
for s in &mut chunk.sections {
std::sync::Arc::make_mut(s).biomes = horizon_core::paletted::PalettedContainer::new(
crate::chunk::BIOME_STRATEGY,
u32::from(self.biome),
);
}
for (i, &block) in self.layers.iter().enumerate().take(384) {
if block == 0 {
continue;
}
for z in 0..16 {
for x in 0..16 {
chunk.set(x, -64 + i as i32, z, block);
}
}
}
for s in &mut chunk.sections {
std::sync::Arc::make_mut(s).compact();
}
Box::new(chunk)
}
/// FlatLevelSource.spawnOriginalMobs is empty: no generation-time spawns.
fn finish(&self, proto: crate::streaming::Proto) -> Chunk {
*proto.downcast::<Chunk>().expect("flat terrain proto")
}
}
+22 -1
View File
@@ -5236,7 +5236,28 @@ impl Game<'_> {
dim.id(),
)));
let res = &*self.res;
let mut streaming = if self.options.test_terrain && dim == Dim::Overworld {
let flat = (dim == Dim::Overworld)
.then(|| horizon_client::save::world_gen_settings(world_root))
.flatten()
.and_then(|s| {
horizon_client::flatgen::FlatTerrain::from_settings(
&s,
res.assets.registry,
&res.biomes,
)
});
let mut streaming = if let Some(inner) = flat {
Streaming::new(
Arc::new(Persistent {
inner: Arc::new(inner),
save: save.clone(),
registry: res.assets.clone(),
biomes: res.biomes.clone(),
}),
res.context.clone(),
res.threads,
)
} else if self.options.test_terrain && dim == Dim::Overworld {
let inner = Arc::new(TestTerrain::new(res.assets.registry, &res.biomes)?);
Streaming::new(
Arc::new(Persistent {
+1
View File
@@ -41,6 +41,7 @@ pub mod entities;
pub mod entity_nbt;
pub mod environment;
pub mod fastutil_order;
pub mod flatgen;
pub mod fog;
pub mod font;
pub mod gamerules;
+11 -1
View File
@@ -46,7 +46,7 @@ pub const VERSION_NAME: &str = "26.3";
fn string(s: &str) -> Tag {
Tag::String(s.into())
}
pub(crate) fn text(tag: Option<&Tag>) -> Option<String> {
pub fn text(tag: Option<&Tag>) -> Option<String> {
match tag {
Some(Tag::String(s)) => Some(s.to_string_lossy()),
_ => None,
@@ -1340,6 +1340,16 @@ fn read_saved_data(world: &Path, name: &str) -> Option<Tag> {
.get("data")
.cloned()
}
/// The world's generator settings: world_gen_settings.dat (26.3) or
/// level.dat's Data.WorldGenSettings.
pub fn world_gen_settings(world: &Path) -> Option<Tag> {
read_saved_data(world, "world_gen_settings").or_else(|| {
read_dat(&world.join("level.dat"))?
.get("Data")?
.get("WorldGenSettings")
.cloned()
})
}
fn write_saved_data(world: &Path, name: &str, data: Tag) -> Result<()> {
write_dat(
&saved_data_path(world, name),