Dedicated server: level-type, generator-settings and generate-structures for a new world

DedicatedServerProperties.WorldDimensionData: a world that doesn't exist
yet gets level-type's preset (flat or normal; an unknown name warns and
falls back to minecraft:normal), a flat world's generator-settings
(FlatLevelGeneratorSettings: layers, biome, lakes, features; a layer that
doesn't parse is logged and left out, and settings without layers use the
preset's classic ones) and generate-structures, written to
world_gen_settings.dat before the world opens, with vanilla's log lines.
Horizon ignored all three and always made a normal world.

New harness server_world_gen compares world_gen_settings.dat and the lines
logged with vanilla's for five server.properties.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-17 16:15:30 +02:00
parent 002f14ce53
commit 3cae8d1d73
4 changed files with 414 additions and 25 deletions
+169
View File
@@ -44,6 +44,105 @@ impl FlatTerrain {
crate::chunk::MIN_Y + self.layers.len().min(crate::chunk::HEIGHT as usize) as i32
}
}
/// DimensionType.Y_SIZE: the most layers FlatLevelGeneratorSettings takes.
const Y_SIZE: i64 = 4064;
/// FlatLevelGeneratorSettings.CODEC reading a dedicated server's
/// `generator-settings` (DedicatedServerProperties.WorldDimensionData for
/// the `minecraft:flat` preset): the settings as `world_gen_settings` stores
/// them, and the error vanilla logs (`resultOrPartial`). No settings means
/// the preset's own layers; a layer that doesn't parse is left out, as the
/// codec's partial result leaves it.
/// `is_block` says whether a block id is registered; `biome` resolves a biome
/// id the way the lenient codec does (Plains when it isn't known).
pub fn settings_from_json(
json: &crate::server::json::Json,
is_block: impl Fn(&str) -> bool,
biome: impl Fn(&str) -> String,
) -> (Option<Tag>, Option<String>) {
use crate::server::json::Json;
let id = |s: &str| {
if s.contains(':') {
s.to_owned()
} else {
format!("minecraft:{s}")
}
};
let Some(Json::Array(list)) = json.get("layers") else {
let error = match json.get("layers") {
None => format!("No key layers in MapLike[{}]", json.compact()),
Some(v) => format!("Not a list: {}", v.compact()),
};
return (None, Some(error));
};
let mut errors = Vec::new();
let mut layers = Vec::new();
let mut total = 0;
for layer in list {
let height = layer.get("height").and_then(Json::as_string);
let height = height.as_deref().and_then(|h| h.parse::<i64>().ok());
let block = layer.get("block").and_then(Json::as_string).map(|b| id(&b));
match (height, block) {
(Some(h), _) if !(0..=Y_SIZE).contains(&h) => {
errors.push(format!("Value {h} outside of range [0:{Y_SIZE}]"));
}
(Some(h), Some(b)) if is_block(&b) => {
total += h;
layers.push(Tag::compound([
("height", Tag::Int(h as i32)),
("block", Tag::String(b.as_str().into())),
]));
}
(Some(_), Some(b)) => errors.push(format!(
"Unknown registry key in ResourceKey[minecraft:root / minecraft:block]: {b}"
)),
(None, _) => errors.push(format!("No key height in MapLike[{}]", layer.compact())),
(_, None) => errors.push(format!("No key block in MapLike[{}]", layer.compact())),
}
}
// validateHeight.
if total > Y_SIZE {
errors.push(format!("Sum of layer heights is > {Y_SIZE}"));
return (None, Some(errors.join("; ")));
}
let flag = |key: &str| match json.get(key) {
Some(Json::Bool(b)) => *b,
Some(Json::Number(n)) => n.parse::<f64>().is_ok_and(|v| v != 0.0),
_ => false,
};
let biome = biome(
&json
.get("biome")
.and_then(Json::as_string)
.map_or_else(|| "minecraft:plains".to_owned(), |b| id(&b)),
);
let mut settings = Vec::new();
// RegistryCodecs.holderSet, lenient too: a tag or a list of ids.
match json.get("structure_overrides") {
Some(Json::String(s)) => {
settings.push(("structure_overrides", Tag::String(s.as_str().into())))
}
Some(Json::Array(ids)) if ids.iter().all(|i| matches!(i, Json::String(_))) => settings
.push((
"structure_overrides",
Tag::List(
ids.iter()
.filter_map(Json::as_string)
.map(|i| Tag::String(id(&i).as_str().into()))
.collect(),
),
)),
_ => {}
}
settings.extend([
("layers", Tag::List(layers)),
("lakes", Tag::Byte(i8::from(flag("lakes")))),
("features", Tag::Byte(i8::from(flag("features")))),
("biome", Tag::String(biome.as_str().into())),
]);
let error = (!errors.is_empty()).then(|| errors.join("; "));
(Some(Tag::compound(settings)), error)
}
impl ChunkGenerator for FlatTerrain {
type Worker = ();
fn worker(&self) {}
@@ -75,3 +174,73 @@ impl ChunkGenerator for FlatTerrain {
*proto.downcast::<Chunk>().expect("flat terrain proto")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::server::json::{self, Json};
fn read(text: &str) -> (Option<Tag>, Option<String>) {
let json: Json = json::parse(text, false).unwrap();
settings_from_json(
&json,
|b| ["minecraft:stone", "minecraft:bedrock"].contains(&b),
|b| {
if b == "minecraft:desert" {
b
} else {
"minecraft:plains"
}
.to_owned()
},
)
}
#[test]
fn generator_settings_read_as_flat_level_generator_settings() {
// server.properties' default: the preset's own layers, and the codec's error.
assert_eq!(
read("{}"),
(None, Some("No key layers in MapLike[{}]".into()))
);
let (settings, error) = read(
r#"{"layers":[{"block":"bedrock","height":1},{"block":"minecraft:stone","height":3}],"biome":"desert","features":true}"#,
);
assert_eq!(error, None);
let settings = settings.unwrap();
let Some(Tag::List(layers)) = settings.get("layers") else {
panic!("{settings:?}")
};
assert_eq!(layers.len(), 2);
assert_eq!(
crate::save::text(layers[0].get("block")).as_deref(),
Some("minecraft:bedrock")
);
assert_eq!(crate::save::number(layers[1].get("height")), Some(3));
assert_eq!(
crate::save::text(settings.get("biome")).as_deref(),
Some("minecraft:desert")
);
assert_eq!(crate::save::number(settings.get("features")), Some(1));
assert_eq!(crate::save::number(settings.get("lakes")), Some(0));
// A layer that doesn't parse is left out; an unknown biome is Plains.
let (settings, error) = read(
r#"{"layers":[{"block":"nope","height":2},{"block":"stone","height":2}],"biome":"x"}"#,
);
assert!(error.unwrap().contains("minecraft:nope"));
let settings = settings.unwrap();
let Some(Tag::List(layers)) = settings.get("layers") else {
panic!()
};
assert_eq!(layers.len(), 1);
assert_eq!(
crate::save::text(settings.get("biome")).as_deref(),
Some("minecraft:plains")
);
// validateHeight.
assert_eq!(
read(r#"{"layers":[{"block":"stone","height":4000},{"block":"stone","height":100}]}"#),
(None, Some("Sum of layer heights is > 4064".into()))
);
}
}
+79 -2
View File
@@ -290,6 +290,78 @@ impl Lists {
}
}
/// The world presets of 26.3's `worldgen/world_preset`.
const WORLD_PRESETS: [&str; 6] = [
"minecraft:normal",
"minecraft:flat",
"minecraft:large_biomes",
"minecraft:amplified",
"minecraft:single_biome_surface",
"minecraft:debug_all_block_states",
];
/// Identifier.tryParse: `namespace:path`, or a path in `minecraft`.
fn parse_identifier(text: &str) -> Option<String> {
let (namespace, path) = text.split_once(':').unwrap_or(("minecraft", text));
let valid = |s: &str, extra: &[char]| {
s.chars()
.all(|c| matches!(c, 'a'..='z' | '0'..='9' | '_' | '.' | '-') || extra.contains(&c))
};
(valid(namespace, &[]) && valid(path, &['/'])).then(|| format!("{namespace}:{path}"))
}
impl Game<'_> {
/// DedicatedServerProperties.createDimensions for a world that doesn't
/// exist yet: `level-type`'s preset, a flat world's `generator-settings`
/// and `generate-structures`, written before the world opens so that
/// streaming reads them. Horizon generates the normal and flat presets.
fn write_world_gen(&self, dir: &std::path::Path, props: &ServerProperties) -> Result<()> {
let level_type = &props.level_type;
let preset = parse_identifier(level_type)
.filter(|id| WORLD_PRESETS.contains(&id.as_str()))
.unwrap_or_else(|| {
log_from(
"Worker-Main-1",
"WARN",
&format!(
"Failed to parse level-type {level_type}, defaulting to minecraft:normal"
),
);
"minecraft:normal".to_owned()
});
let flat = preset == "minecraft:flat";
if !flat && preset != "minecraft:normal" {
log_from(
"Worker-Main-1",
"WARN",
&format!(
"Horizon doesn't generate the {preset} world preset yet: using minecraft:normal"
),
);
}
let settings = if flat {
let biomes = &self.res.biomes;
let (settings, error) = horizon_client::flatgen::settings_from_json(
&props.generator_settings,
|b| self.pack.assets.registry.default_state(b).is_some(),
|b| biomes.get(biomes.id(b)).name.clone(),
);
if let Some(e) = error {
log_from("Worker-Main-1", "ERROR", &e);
}
settings
} else {
None
};
let options = horizon_client::save::WorldGen {
flat,
structures: props.generate_structures,
bonus_chest: false,
};
horizon_client::save::write_world_gen_settings_with(dir, props.seed, options, settings)
}
}
/// PlayerList.BAN_DATE_FORMAT ("yyyy-MM-dd 'at' HH:mm:ss z"), in UTC.
fn ban_date(millis: i64) -> String {
let s = format_date(millis);
@@ -345,6 +417,13 @@ impl Game<'_> {
.get()
.and_then(|m| m.lock().unwrap().take())
.ok_or("dedicated server not prepared")?;
// Main's WorldLoader: a new world's dimensions come from
// server.properties before the server starts.
let world_dir = std::env::current_dir()?.join(&universe).join(&level_name);
let new_world = !world_dir.join("level.dat").exists();
if new_world {
self.write_world_gen(&world_dir, &props)?;
}
// The console thread starts first, as in initServer.
let (tx, console) = mpsc::channel();
std::thread::Builder::new()
@@ -425,9 +504,7 @@ impl Game<'_> {
lists.enforce_whitelist = props.enforce_whitelist;
let lists = Arc::new(Mutex::new(lists));
log("INFO", &format!("Preparing level \"{level_name}\""));
let world_dir = std::env::current_dir()?.join(&universe).join(&level_name);
let folder = world_dir.to_string_lossy().into_owned();
let new_world = !world_dir.join("level.dat").exists();
self.open_world(
&folder,
Some(&level_name),
+34 -23
View File
@@ -1980,40 +1980,51 @@ impl Default for WorldGen {
}
/// Writes a new world's `world_gen_settings` (seed, options and dimensions).
pub fn write_world_gen_settings(dir: &Path, seed: i64, options: WorldGen) -> Result<()> {
write_world_gen_settings_with(dir, seed, options, None)
}
/// [`write_world_gen_settings`] with a flat overworld's own generator
/// settings (FlatLevelGeneratorSettings, as `flatgen::settings_from_json`
/// reads them) instead of the Superflat preset's classic layers.
pub fn write_world_gen_settings_with(
dir: &Path,
seed: i64,
options: WorldGen,
flat_settings: Option<Tag>,
) -> Result<()> {
fs::create_dir_all(dir)?;
// worldgen/world_preset/flat.json's overworld: the classic flat layers.
let layer = |block: &str, height: i32| {
Tag::compound([("block", string(block)), ("height", Tag::Int(height))])
};
let classic = || {
Tag::compound([
("biome", string("minecraft:plains")),
("features", Tag::Byte(0)),
("lakes", Tag::Byte(0)),
(
"layers",
Tag::List(vec![
layer("minecraft:bedrock", 1),
layer("minecraft:dirt", 2),
layer("minecraft:grass_block", 1),
]),
),
(
"structure_overrides",
Tag::List(vec![
string("minecraft:strongholds"),
string("minecraft:villages"),
]),
),
])
};
let flat = Tag::compound([
("type", string("minecraft:overworld")),
(
"generator",
Tag::compound([
("type", string("minecraft:flat")),
(
"settings",
Tag::compound([
("biome", string("minecraft:plains")),
("features", Tag::Byte(0)),
("lakes", Tag::Byte(0)),
(
"layers",
Tag::List(vec![
layer("minecraft:bedrock", 1),
layer("minecraft:dirt", 2),
layer("minecraft:grass_block", 1),
]),
),
(
"structure_overrides",
Tag::List(vec![
string("minecraft:strongholds"),
string("minecraft:villages"),
]),
),
]),
),
("settings", flat_settings.unwrap_or_else(classic)),
]),
),
]);
+132
View File
@@ -0,0 +1,132 @@
#!/usr/bin/env python3
"""A new world's generator settings from server.properties, against vanilla's dedicated server.
DedicatedServerProperties.WorldDimensionData makes a world that doesn't exist yet from `level-type` (a world
preset: `flat`, `minecraft:normal`, or a name it can't find, which it warns about and replaces with
`minecraft:normal`), a flat world's `generator-settings` (FlatLevelGeneratorSettings: its layers, biome,
lakes and features; a layer that doesn't parse is left out and logged, and settings without layers fall back
to the preset's classic ones) and `generate-structures`.
Each case starts vanilla's server and Horizon's (`horizon-client --dedicated --nogui`) in a new folder, waits
for `Done` and stops them. Compared exactly: the world's `data/minecraft/world_gen_settings.dat`, tag types
included, and the warnings and errors logged while the world's settings are read (the `Worker-Main` lines;
the worker's number is left out).
Horizon generates the normal and flat presets only: `large_biomes`, `amplified`, `single_biome_surface` and
`debug_all_block_states` aren't tested.
"""
import json
import os
from pathlib import Path
import platform
import re
import shutil
import subprocess
import sys
try:
from . import anvil_dump, lab, test_rust_parity as base
from .test_dedicated_server_parity import Server, free_port
except ImportError:
import anvil_dump
import lab
import test_rust_parity as base
from test_dedicated_server_parity import Server, free_port
NAME = 'server-world-gen-parity'
PROPERTIES = {
'online-mode': 'false',
'view-distance': '2',
'simulation-distance': '2',
'spawn-protection': '0',
}
CASES = {
# server.properties' default generator-settings ({}) has no layers: the preset's classic ones.
'flat': {'level-type': 'flat', 'level-seed': '1'},
'flat-layers': {
'level-type': 'minecraft:flat',
'level-seed': '-7',
'generator-settings': json.dumps({
'layers': [{'block': 'minecraft:bedrock', 'height': 1}, {'block': 'stone', 'height': 10},
{'block': 'minecraft:no_such_block', 'height': 2}, {'block': 'sand', 'height': 3}],
'biome': 'minecraft:desert', 'lakes': True, 'features': True}, separators=(',', ':')),
},
'flat-biome': {
'level-type': 'FLAT',
'level-seed': 'flat',
'generator-settings': '{"layers":[{"block":"minecraft:glass","height":5}],"biome":"nowhere"}',
},
'normal': {'level-type': 'minecraft:normal', 'level-seed': 'abc', 'generate-structures': 'false'},
'unknown': {'level-type': 'Some Type', 'level-seed': '42'},
}
WORKER = re.compile(r'\[Worker-Main-\d+/(WARN|ERROR)\]: (.*)')
def escape(value):
"""java.util.Properties.store's escaping of a value."""
return value.replace('\\', '\\\\').replace(':', '\\:').replace('=', '\\=').replace('#', '\\#')
def run_case(label, command, build, case):
directory = build / label / case
if directory.exists():
shutil.rmtree(directory)
directory.mkdir(parents=True)
props = dict(PROPERTIES, **CASES[case], **{'server-port': str(free_port())})
(directory / 'server.properties').write_text(''.join(f'{k}={escape(v)}\n' for k, v in props.items()),
encoding='iso-8859-1')
(directory / 'eula.txt').write_text('eula=true\n')
server = Server(command, directory, f'{label}-{case}')
try:
server.wait_for(r'Done \(')
finally:
server.stop()
out = [f'# {case}']
out += [f'{m.group(1)}: {m.group(2)}' for l in server.lines if (m := WORKER.search(l))]
settings = anvil_dump.plain(anvil_dump.read_dat(directory / 'world/data/minecraft/world_gen_settings.dat'),
True, typed=True)
out += json.dumps(settings, indent=1, sort_keys=True).splitlines()
return out
def main():
lock, jars, libraries = base.verify_artifacts()
build = lab.LOCAL / NAME
build.mkdir(parents=True, exist_ok=True)
report = build / 'report.json'
report.unlink(missing_ok=True)
subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
check=True, capture_output=True)
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
cwd=lab.ROOT, text=True))
binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main',
'nogui']
horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
vanilla, horizon = [], []
for case in CASES:
vanilla += run_case('vanilla', vanilla_server, build, case)
horizon += run_case('horizon', horizon_server, build, case)
(build / 'vanilla.txt').write_text('\n'.join(vanilla) + '\n', encoding='utf-8')
(build / 'horizon.txt').write_text('\n'.join(horizon) + '\n', encoding='utf-8')
if vanilla != horizon:
import difflib
diff = '\n'.join(difflib.unified_diff(vanilla, horizon, 'vanilla', 'horizon', n=2, lineterm=''))
raise AssertionError(f'world settings differ (see {build}/vanilla.txt and horizon.txt):\n' + diff[:6000])
if not any('minecraft:flat' in l for l in vanilla) or not any(l.startswith('ERROR: ') for l in vanilla):
raise AssertionError(f'vanilla made no flat world or logged no error (see {build})')
lab.write_json(report, dict(
schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(),
java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
cases=list(CASES), lines=len(vanilla), output_sha256=lab.digest(build / 'horizon.txt', 'sha256'),
scope='a new dedicated-server world: level-type (flat, normal, unknown), a flat world\'s '
'generator-settings, generate-structures, as world_gen_settings.dat and the lines logged.'))
print(f'server world gen: {len(CASES)} cases, {len(vanilla)} lines identical')
if __name__ == '__main__':
try:
main()
except AssertionError as error:
sys.exit(f'{NAME}: {error}')