Port the 1.17 to 1.18 chunk height, biome and tick fixes (2825 to 2846)

ChunkHeightAndBiomeFix, ChunkProtoTickListFix, ChunkRenamesFix,
OverreachingTickFix, SpawnerDataFix, the world generation settings fixes
and the Caves & Cliffs biome and advancement renames, with the chunk's
Level tag and UNTAGGED_SPAWNER in the schema walker. A 1.17.1 sample
world upgrades as vanilla's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-12 17:42:59 +02:00
parent 82eda1d8bf
commit b0ce83dd2d
6 changed files with 1046 additions and 7 deletions
@@ -239,3 +239,47 @@ pub fn namespaced(id: &str) -> String {
None => id.to_owned(),
}
}
/// `Dynamic.asLongStreamOpt` over `NbtOps`: a long array, or a list or array
/// whose elements are all numbers.
pub fn as_long_stream(tag: Option<&Tag>) -> Option<Vec<i64>> {
match tag? {
Tag::LongArray(v) => Some(v.clone()),
t if is_list(Some(t)) => stream(Some(t))
.iter()
.map(|e| as_number(e).map(Number::long_value))
.collect(),
_ => None,
}
}
/// `Dynamic.asIntStreamOpt` over `NbtOps`.
pub fn as_int_stream(tag: Option<&Tag>) -> Option<Vec<i32>> {
match tag? {
Tag::IntArray(v) => Some(v.clone()),
t if is_list(Some(t)) => stream(Some(t))
.iter()
.map(|e| as_number(e).map(Number::int_value))
.collect(),
_ => None,
}
}
/// `Dynamic.asByteBufferOpt` over `NbtOps`.
pub fn as_byte_buffer(tag: Option<&Tag>) -> Option<Vec<u8>> {
match tag? {
Tag::ByteArray(v) => Some(v.clone()),
t if is_list(Some(t)) => stream(Some(t))
.iter()
.map(|e| as_number(e).map(|n| n.byte_value() as u8))
.collect(),
_ => None,
}
}
/// `ChunkHeightAndBiomeFix.ceillog2` (`Math.ceil(Math.log(n) / Math.log(2))`,
/// which is exact for every palette size).
pub fn ceillog2(n: usize) -> u32 {
if n <= 1 {
0
} else {
usize::BITS - (n - 1).leading_zeros()
}
}
@@ -1,11 +1,54 @@
//! Fixes of 1.17 and 1.18, Caves & Cliffs (keys 2679 to 2970): what worlds
//! saved by 1.16.5 to 1.18.1 need before the fixes of [`super::fixes_old`].
use super::dynamic::{as_str, empty_map, set, stream, string};
use super::dynamic::{
as_bool, as_byte_buffer, as_int, as_int_stream, as_long_stream, as_number, as_str, ceillog2,
empty_map, remove, rename, set, stream, string,
};
use super::fixes_b::advancements_rename;
use super::schema::{Key, Ty, key};
use super::{Cx, FixFn};
use super::{Cx, FixFn, renamer};
use crate::nbt::{Compound, JavaString, Tag};
pub(super) fn register(out: &mut Vec<(Key, FixFn)>) {
out.push((key(2825, 0), |cx| {
add_flag(cx, "has_increased_height_already", false)
}));
out.push((key(2831, 0), spawner_data));
out.push((key(2832, 0), world_gen_height_and_biome));
out.push((key(2832, 0), chunk_height_and_biome));
// 2833 and 2852: `WorldGenSettingsDisallowOldCustomWorldsFix` refuses a
// world whose dimension has no type; it changes nothing.
out.push((key(2838, 0), |cx| {
cx.rename(Ty::Biome, renamer(CAVES_AND_CLIFFS))
}));
out.push((key(2841, 0), chunk_proto_tick_list));
out.push((key(2842, 0), chunk_renames));
out.push((key(2843, 0), overreaching_ticks));
out.push((key(2843, 0), |cx| {
cx.rename(
Ty::Biome,
renamer(&[("minecraft:deep_warm_ocean", "minecraft:warm_ocean")]),
)
}));
out.push((key(2846, 0), |cx| {
advancements_rename(cx, &|id| {
renamer(&[
(
"minecraft:husbandry/play_jukebox_in_meadows",
"minecraft:adventure/play_jukebox_in_meadows",
),
(
"minecraft:adventure/caves_and_cliff",
"minecraft:adventure/fall_from_world_height",
),
(
"minecraft:adventure/ride_strider_in_overworld_lava",
"minecraft:nether/ride_strider_in_overworld_lava",
),
])(id)
.map(str::to_owned)
})
}));
out.push((key(2967, 0), structure_settings_flatten));
out.push((key(2970, 0), structures_become_configured));
}
@@ -264,3 +307,895 @@ fn structures_become_configured(cx: &mut Cx) {
set(chunk, "structures", structures);
});
}
// ------------------------------------------------------------------ 2825 to 2843
/// `AddFlagIfNotPresentFix` over the world generation settings.
pub(super) fn add_flag(cx: &mut Cx, flag: &str, value: bool) {
cx.each(Ty::WorldGenSettings, |v| {
if let Tag::Compound(_) = v
&& v.get(flag).is_none()
{
set(v, flag, Tag::Byte(i8::from(value)));
}
});
}
/// `SpawnerDataFix`: spawn data and potentials wrapped as weighted entries.
fn spawner_data(cx: &mut Cx) {
cx.each(Ty::UntaggedSpawner, |v| {
if let Some(data) = remove(v, "SpawnData") {
set(v, "SpawnData", Tag::compound([("entity", data)]));
}
if let Some(potentials) = v.get("SpawnPotentials").cloned() {
let entries = stream(Some(&potentials))
.into_iter()
.map(|mut entry| {
let weight = entry
.get("Weight")
.and_then(as_number)
.map_or(1, |n| n.int_value());
let entity = remove(&mut entry, "Entity");
remove(&mut entry, "Weight");
if let Some(e) = entity {
set(&mut entry, "entity", e);
}
Tag::compound([("weight", Tag::Int(weight)), ("data", entry)])
})
.collect();
set(v, "SpawnPotentials", Tag::List(entries));
}
});
}
/// `WorldGenSettingsHeightAndBiomeFix`.
fn world_gen_height_and_biome(cx: &mut Cx) {
cx.each(Ty::WorldGenSettings, |v| {
let flag = v.get("has_increased_height_already").cloned();
let was_exp_snap = flag.is_none();
let was_previously_increased = flag.as_ref().map_or(true, |f| as_bool(Some(f), true));
remove(v, "has_increased_height_already");
let Some(generator) = v
.get_mut("dimensions")
.and_then(|d| d.get_mut("minecraft:overworld"))
.and_then(|o| o.get_mut("generator"))
else {
return;
};
match as_str(generator.get("type")).as_deref() {
Some("minecraft:noise") => {
let mut large = false;
if let Some(source) = generator.get_mut("biome_source") {
let ty = as_str(source.get("type")).unwrap_or_default();
if ty == "minecraft:vanilla_layered"
|| (was_exp_snap && ty == "minecraft:multi_noise")
{
large = as_bool(source.get("large_biomes"), false);
*source = Tag::compound([
("preset", string("minecraft:overworld")),
("type", string("minecraft:multi_noise")),
]);
}
}
if large
&& let Some(settings) = generator.get_mut("settings")
&& as_str(Some(settings)).as_deref() == Some("minecraft:overworld")
{
*settings = string("minecraft:large_biomes");
}
}
Some("minecraft:flat") if !was_previously_increased => {
if let Some(layers) = generator
.get_mut("settings")
.and_then(|s| s.get_mut("layers"))
{
let air = Tag::compound([
("height", Tag::Int(64)),
("block", string("minecraft:air")),
]);
let mut list = vec![air];
list.extend(stream(Some(layers)));
*layers = Tag::List(list);
}
}
_ => {}
}
});
}
const STATUS_IS_OR_AFTER_SURFACE: &[&str] = &[
"surface",
"carvers",
"liquid_carvers",
"features",
"light",
"spawn",
"heightmaps",
"full",
];
const STATUS_IS_OR_AFTER_NOISE: &[&str] = &[
"noise",
"surface",
"carvers",
"liquid_carvers",
"features",
"light",
"spawn",
"heightmaps",
"full",
];
const BLOCKS_BEFORE_FEATURE_STATUS: &[&str] = &[
"minecraft:air",
"minecraft:basalt",
"minecraft:bedrock",
"minecraft:blackstone",
"minecraft:calcite",
"minecraft:cave_air",
"minecraft:coarse_dirt",
"minecraft:crimson_nylium",
"minecraft:dirt",
"minecraft:end_stone",
"minecraft:grass_block",
"minecraft:gravel",
"minecraft:ice",
"minecraft:lava",
"minecraft:mycelium",
"minecraft:nether_wart_block",
"minecraft:netherrack",
"minecraft:orange_terracotta",
"minecraft:packed_ice",
"minecraft:podzol",
"minecraft:powder_snow",
"minecraft:red_sand",
"minecraft:red_sandstone",
"minecraft:sand",
"minecraft:sandstone",
"minecraft:snow_block",
"minecraft:soul_sand",
"minecraft:soul_soil",
"minecraft:stone",
"minecraft:terracotta",
"minecraft:warped_nylium",
"minecraft:warped_wart_block",
"minecraft:water",
"minecraft:white_terracotta",
];
const HEIGHTMAP_TYPES: &[&str] = &[
"WORLD_SURFACE_WG",
"WORLD_SURFACE",
"WORLD_SURFACE_IGNORE_SNOW",
"OCEAN_FLOOR_WG",
"OCEAN_FLOOR",
"MOTION_BLOCKING",
"MOTION_BLOCKING_NO_LEAVES",
];
/// `ChunkHeightAndBiomeFix.BIOMES_BY_ID`.
fn biome_by_id(id: i32) -> &'static str {
match id {
0 => "minecraft:ocean",
1 => "minecraft:plains",
2 => "minecraft:desert",
3 => "minecraft:mountains",
4 => "minecraft:forest",
5 => "minecraft:taiga",
6 => "minecraft:swamp",
7 => "minecraft:river",
8 => "minecraft:nether_wastes",
9 => "minecraft:the_end",
10 => "minecraft:frozen_ocean",
11 => "minecraft:frozen_river",
12 => "minecraft:snowy_tundra",
13 => "minecraft:snowy_mountains",
14 => "minecraft:mushroom_fields",
15 => "minecraft:mushroom_field_shore",
16 => "minecraft:beach",
17 => "minecraft:desert_hills",
18 => "minecraft:wooded_hills",
19 => "minecraft:taiga_hills",
20 => "minecraft:mountain_edge",
21 => "minecraft:jungle",
22 => "minecraft:jungle_hills",
23 => "minecraft:jungle_edge",
24 => "minecraft:deep_ocean",
25 => "minecraft:stone_shore",
26 => "minecraft:snowy_beach",
27 => "minecraft:birch_forest",
28 => "minecraft:birch_forest_hills",
29 => "minecraft:dark_forest",
30 => "minecraft:snowy_taiga",
31 => "minecraft:snowy_taiga_hills",
32 => "minecraft:giant_tree_taiga",
33 => "minecraft:giant_tree_taiga_hills",
34 => "minecraft:wooded_mountains",
35 => "minecraft:savanna",
36 => "minecraft:savanna_plateau",
37 => "minecraft:badlands",
38 => "minecraft:wooded_badlands_plateau",
39 => "minecraft:badlands_plateau",
40 => "minecraft:small_end_islands",
41 => "minecraft:end_midlands",
42 => "minecraft:end_highlands",
43 => "minecraft:end_barrens",
44 => "minecraft:warm_ocean",
45 => "minecraft:lukewarm_ocean",
46 => "minecraft:cold_ocean",
47 => "minecraft:deep_warm_ocean",
48 => "minecraft:deep_lukewarm_ocean",
49 => "minecraft:deep_cold_ocean",
50 => "minecraft:deep_frozen_ocean",
127 => "minecraft:the_void",
129 => "minecraft:sunflower_plains",
130 => "minecraft:desert_lakes",
131 => "minecraft:gravelly_mountains",
132 => "minecraft:flower_forest",
133 => "minecraft:taiga_mountains",
134 => "minecraft:swamp_hills",
140 => "minecraft:ice_spikes",
149 => "minecraft:modified_jungle",
151 => "minecraft:modified_jungle_edge",
155 => "minecraft:tall_birch_forest",
156 => "minecraft:tall_birch_hills",
157 => "minecraft:dark_forest_hills",
158 => "minecraft:snowy_taiga_mountains",
160 => "minecraft:giant_spruce_taiga",
161 => "minecraft:giant_spruce_taiga_hills",
162 => "minecraft:modified_gravelly_mountains",
163 => "minecraft:shattered_savanna",
164 => "minecraft:shattered_savanna_plateau",
165 => "minecraft:eroded_badlands",
166 => "minecraft:modified_wooded_badlands_plateau",
167 => "minecraft:modified_badlands_plateau",
168 => "minecraft:bamboo_jungle",
169 => "minecraft:bamboo_jungle_hills",
170 => "minecraft:soul_sand_valley",
171 => "minecraft:crimson_forest",
172 => "minecraft:warped_forest",
173 => "minecraft:basalt_deltas",
174 => "minecraft:dripstone_caves",
175 => "minecraft:lush_caves",
177 => "minecraft:meadow",
178 => "minecraft:grove",
179 => "minecraft:snowy_slopes",
180 => "minecraft:snowcapped_peaks",
181 => "minecraft:lofty_peaks",
182 => "minecraft:stony_peaks",
_ => "minecraft:plains",
}
}
fn paletted(palette: Tag, data: Option<Tag>) -> Tag {
let mut out = Tag::compound([("palette", palette)]);
if let Some(d) = data {
set(&mut out, "data", d);
}
out
}
/// `ChunkHeightAndBiomeFix.makeBiomeContainer`.
fn biome_container(source: impl Fn(usize) -> i32) -> Tag {
let mut ids: Vec<i32> = Vec::new();
for i in 0..64 {
let id = source(i);
if !ids.contains(&id) {
ids.push(id);
}
}
let palette = Tag::List(ids.iter().map(|&id| string(biome_by_id(id))).collect());
let bits = ceillog2(ids.len()) as usize;
if bits == 0 {
return paletted(palette, None);
}
let per_long = 64 / bits;
let mut storage = vec![0i64; 64_usize.div_ceil(per_long)];
let (mut cell, mut bit) = (0, 0);
for i in 0..64 {
let index = ids.iter().position(|&x| x == source(i)).unwrap_or(0) as i64;
storage[cell] |= index << bit;
bit += bits;
if bit + bits > 64 {
cell += 1;
bit = 0;
}
}
paletted(palette, Some(Tag::LongArray(storage)))
}
/// `ChunkHeightAndBiomeFix.getBiomeContainers`: the containers and whether the
/// chunk was already saved with the increased height.
fn biome_containers(level: &Tag, overworld: bool, min_section: i32) -> (Vec<Tag>, bool) {
let count = if overworld { 24 } else { 16 };
let old = as_int_stream(level.get("Biomes"));
let get = |old: &[i32], i: usize| old[i] & 0xFF;
match old {
Some(old) if old.len() == 1536 => {
let containers = (0..24)
.map(|y| biome_container(|i| get(&old, y * 64 + i)))
.collect();
(containers, true)
}
Some(old) if old.len() == 1024 => {
let mut containers = vec![Tag::End; count];
for y in 0..16 {
containers[(y - min_section) as usize] =
biome_container(|i| get(&old, y as usize * 64 + i));
}
if overworld {
let below = biome_container(|i| get(&old, i % 16));
let above = biome_container(|i| get(&old, i % 16 + 1008));
for c in containers.iter_mut().take(4) {
*c = below.clone();
}
for c in containers.iter_mut().skip(20) {
*c = above.clone();
}
}
(containers, false)
}
_ => {
let plains = paletted(Tag::List(vec![string("minecraft:plains")]), None);
(vec![plains; count], false)
}
}
}
/// `ChunkProtoTickListFix.PoorMansPalettedContainer`.
struct PoorMansContainer {
palette: Vec<Tag>,
data: Vec<i64>,
}
impl PoorMansContainer {
fn get(&self, x: usize, y: usize, z: usize) -> Option<&Tag> {
match self.palette.len() {
0 => None,
1 => self.palette.first(),
n => {
let bits = ceillog2(n).max(4) as usize;
let per_long = 64 / bits;
let index = (((y << 4) | z) << 4) | x;
let cell = index / per_long;
let value = *self.data.get(cell)?;
let bit = (index - cell * per_long) * bits;
let i = ((value >> bit) & ((1i64 << bits) - 1)) as usize;
self.palette.get(i)
}
}
}
fn of(container: &Tag) -> Self {
Self {
palette: stream(container.get("palette")),
data: as_long_stream(container.get("data")).unwrap_or_default(),
}
}
}
fn block_name(state: Option<&Tag>, default: &str) -> String {
state.map_or_else(
|| default.to_owned(),
|s| as_str(s.get("Name")).unwrap_or_else(|| default.to_owned()),
)
}
/// `ChunkHeightAndBiomeFix.makeOptimizedPalettedContainer`.
fn optimized_container(palette: &Tag, data: &Tag) -> Tag {
let mut list = stream(Some(palette));
if list.len() == 1 {
return paletted(palette.clone(), None);
}
let bits = as_long_stream(Some(data)).map_or(0, |d| d.len() as i64) * 64 / 4096;
let expected = i64::from(ceillog2(list.len()));
if bits <= expected {
return paletted(palette.clone(), Some(data.clone()));
}
let air = Tag::compound([("Name", string("minecraft:air"))]);
let minimum = (1i64 << (bits - 1)) + 1;
for _ in 0..(minimum - list.len() as i64) {
list.push(air.clone());
}
paletted(Tag::List(list), Some(data.clone()))
}
/// `ChunkHeightAndBiomeFix`.
fn chunk_height_and_biome(cx: &mut Cx) {
cx.each(Ty::Chunk, |chunk| {
let context = chunk.get("__context");
let dimension = context
.and_then(|c| as_str(c.get("dimension")))
.unwrap_or_default();
let generator = context
.and_then(|c| as_str(c.get("generator")))
.unwrap_or_default();
let Some(level) = chunk.get_mut("Level") else {
return;
};
let overworld = dimension == "minecraft:overworld";
let min_section = if overworld { -4 } else { 0 };
let (biomes, was_increased) = biome_containers(level, overworld, min_section);
let air = paletted(
Tag::List(vec![Tag::compound([("Name", string("minecraft:air"))])]),
None,
);
let mut blocks_in_chunk: Vec<String> = Vec::new();
let mut bedrock: Option<PoorMansContainer> = None;
if let Some(sections) = level.get("Sections").cloned() {
let mut done: Vec<i32> = Vec::new();
let mut out = Vec::new();
for mut section in stream(Some(&sections)) {
let y = as_int(section.get("Y"), 0);
let container = match section.get("Palette") {
Some(palette) => {
for state in stream(Some(palette)) {
let name = block_name(Some(&state), "minecraft:air");
if !blocks_in_chunk.contains(&name) {
blocks_in_chunk.push(name);
}
}
match section.get("BlockStates") {
Some(data) => optimized_container(palette, data),
None => air.clone(),
}
}
None => air.clone(),
};
let index = y - min_section;
if index >= 0 && (index as usize) < biomes.len() {
set(&mut section, "biomes", biomes[index as usize].clone());
}
if !done.contains(&y) {
done.push(y);
}
if section.get("Y").and_then(as_number).map(|n| n.int_value()) == Some(0) {
bedrock = Some(PoorMansContainer::of(&container));
}
set(&mut section, "block_states", container);
remove(&mut section, "Palette");
remove(&mut section, "BlockStates");
out.push(section);
}
for (i, b) in biomes.iter().enumerate() {
let y = i as i32 + min_section;
if !done.contains(&y) {
done.push(y);
out.push(Tag::compound([
("Y", Tag::Int(y)),
("block_states", air.clone()),
("biomes", b.clone()),
]));
}
}
set(level, "Sections", Tag::List(out));
}
if overworld {
predict_status_before_surface(level, &mut blocks_in_chunk);
}
update_chunk_tag(
level,
overworld,
was_increased,
generator == "minecraft:noise",
bedrock.as_ref(),
);
});
}
fn predict_status_before_surface(level: &mut Tag, blocks: &mut Vec<String>) {
let Some(status) = level.get("Status") else {
return;
};
let current = as_str(Some(status)).unwrap_or_else(|| "empty".into());
if STATUS_IS_OR_AFTER_SURFACE.contains(&current.as_str()) {
return;
}
blocks.retain(|b| b != "minecraft:air");
let has_non_air = !blocks.is_empty();
blocks.retain(|b| !BLOCKS_BEFORE_FEATURE_STATUS.contains(&b.as_str()));
let has_feature_blocks = !blocks.is_empty();
let new = if has_feature_blocks {
Some("liquid_carvers")
} else if current == "noise" || has_non_air {
Some("noise")
} else if current == "biomes" {
Some("structure_references")
} else {
None
};
if let Some(new) = new {
set(level, "Status", string(new));
}
}
fn update_chunk_tag(
level: &mut Tag,
overworld: bool,
was_increased: bool,
blending: bool,
bedrock: Option<&PoorMansContainer>,
) {
remove(level, "Biomes");
if !overworld {
return update_carving_masks(level, 16, 0);
}
if was_increased {
return update_carving_masks(level, 24, 0);
}
if let Some(Tag::Compound(maps)) = level.get_mut("Heightmaps") {
for ty in HEIGHTMAP_TYPES {
if let Some(h) = maps.get_mut(&super::dynamic::key(ty)) {
let values = as_long_stream(Some(h)).unwrap_or_default();
*h = Tag::LongArray(values.into_iter().map(fixed_heightmap_long).collect());
}
}
}
for key in ["LiquidsToBeTicked", "PostProcessing", "ToBeTicked"] {
let mut list = stream(level.get(key));
if list.len() != 24 {
for _ in 0..4 {
list.insert(0, Tag::List(Vec::new()));
list.push(Tag::List(Vec::new()));
}
set(level, key, Tag::List(list));
}
}
update_carving_masks(level, 24, 4);
if let Some(upgrade) = level.get_mut("UpgradeData")
&& let Some(indices) = upgrade.get("Indices")
{
let mut shifted = Compound::new();
if let Tag::Compound(c) = indices {
for (k, v) in c {
if let Ok(i) = k.to_string_lossy().parse::<i32>() {
shifted.insert(JavaString::from((i + 4).to_string().as_str()), v.clone());
}
}
}
set(upgrade, "Indices", Tag::Compound(shifted));
}
if !blending {
return;
}
let Some(status) = level.get("Status").cloned() else {
return;
};
let last = as_str(Some(&status)).unwrap_or_default();
if last == "empty" {
return;
}
set(
level,
"blending_data",
Tag::compound([(
"old_noise",
Tag::Byte(i8::from(STATUS_IS_OR_AFTER_NOISE.contains(&last.as_str()))),
)]),
);
let Some(container) = bedrock else {
return;
};
let mut missing = [0u64; 4];
let mut any_bedrock = last == "noise";
for z in 0..16 {
for x in 0..16 {
let state = container.get(x, 0, z);
let name = state.map(|s| as_str(s.get("Name")).unwrap_or_default());
if name.as_deref() == Some("minecraft:air") {
let bit = z * 16 + x;
missing[bit / 64] |= 1 << (bit % 64);
}
any_bedrock |= name.as_deref() == Some("minecraft:bedrock");
}
}
let cardinality: u32 = missing.iter().map(|w| w.count_ones()).sum();
if any_bedrock && cardinality != 256 {
let target = if last == "full" {
string("heightmaps")
} else {
status.clone()
};
// `BitSet.toLongArray`: trailing zero words dropped.
let used = missing.iter().rposition(|&w| w != 0).map_or(0, |i| i + 1);
let words = missing[..used].iter().map(|&w| w as i64).collect();
set(
level,
"below_zero_retrogen",
Tag::compound([
("target_status", target),
("missing_bedrock", Tag::LongArray(words)),
]),
);
set(level, "Status", string("empty"));
}
set(level, "isLightOn", Tag::Byte(0));
}
fn fixed_heightmap_long(value: i64) -> i64 {
let mut out = 0i64;
let mut bit = 0;
while bit + 9 <= 64 {
let old = (value >> bit) & 511;
let new = if old == 0 { 0 } else { (old + 64).min(511) };
out |= new << bit;
bit += 9;
}
out
}
fn update_carving_masks(level: &mut Tag, sections: usize, below: usize) {
let mut masks = match level.get("CarvingMasks") {
Some(m) => m.clone(),
None => empty_map(),
};
if let Tag::Compound(c) = &mut masks {
for v in c.values_mut() {
let bytes = as_byte_buffer(Some(v)).unwrap_or_default();
// `BitSet.valueOf(bytes).toLongArray()`: little-endian words,
// trailing zero words dropped.
let mut words: Vec<i64> = bytes
.chunks(8)
.map(|c| {
let mut b = [0u8; 8];
b[..c.len()].copy_from_slice(c);
i64::from_le_bytes(b)
})
.collect();
while words.last() == Some(&0) {
words.pop();
}
let mut out = vec![0i64; 64 * sections];
out[64 * below..64 * below + words.len()].copy_from_slice(&words);
*v = Tag::LongArray(out);
}
}
// `updateMapValues` of something that is not a map leaves it unchanged.
set(level, "CarvingMasks", masks);
}
fn liquid(state: Option<&Tag>) -> &'static str {
let Some(state) = state else {
return "minecraft:empty";
};
let block = as_str(state.get("Name")).unwrap_or_default();
let props = state.get("Properties");
let level = || as_int(props.and_then(|p| p.get("level")), 0);
match block.as_str() {
"minecraft:water" => {
if level() == 0 {
"minecraft:water"
} else {
"minecraft:flowing_water"
}
}
"minecraft:lava" => {
if level() == 0 {
"minecraft:lava"
} else {
"minecraft:flowing_lava"
}
}
_ => {
let always = matches!(
block.as_str(),
"minecraft:bubble_column"
| "minecraft:kelp"
| "minecraft:kelp_plant"
| "minecraft:seagrass"
| "minecraft:tall_seagrass"
);
if always || as_bool(props.and_then(|p| p.get("waterlogged")), false) {
"minecraft:water"
} else {
"minecraft:empty"
}
}
}
}
/// `ChunkProtoTickListFix`.
fn chunk_proto_tick_list(cx: &mut Cx) {
cx.each(Ty::Chunk, |chunk| {
let Some(level) = chunk.get_mut("Level") else {
return;
};
if let Some(t) = remove(level, "LiquidTicks") {
set(level, "fluid_ticks", t);
}
let mut lowest = 0i32;
let mut containers: Vec<(i32, PoorMansContainer)> = Vec::new();
for section in stream(level.get("Sections")) {
let y = as_int(section.get("Y"), i32::MAX);
if y == i32::MAX {
continue;
}
if section.get("biomes").is_some() {
lowest = lowest.min(y);
}
if let Some(container) = section.get("block_states") {
match containers.iter_mut().find(|(sy, _)| *sy == y) {
Some((_, c)) => *c = PoorMansContainer::of(container),
None => containers.push((y, PoorMansContainer::of(container))),
}
}
}
let min_y = lowest as i8;
if level.get("yPos").is_some() {
set(level, "yPos", Tag::Byte(min_y));
}
if level.get("TileTicks").is_some() || level.get("fluid_ticks").is_some() {
return;
}
let x = as_int(level.get("xPos"), 0);
let z = as_int(level.get("zPos"), 0);
let make = |level: &Tag, key: &str, liquid_list: bool| {
let mut out = Vec::new();
for (index, positions) in stream(level.get(key)).iter().enumerate() {
let section_y = index as i32 + i32::from(min_y);
let container = containers
.iter()
.find(|(y, _)| *y == section_y)
.map(|(_, c)| c);
for pos in stream(Some(positions)) {
let pos = as_number(&pos).map_or(-1, |n| i32::from(n.int_value() as i16));
if pos <= 0 {
continue;
}
let (rx, ry, rz) = (pos & 15, (pos >> 4) & 15, (pos >> 8) & 15);
let state =
container.and_then(|c| c.get(rx as usize, ry as usize, rz as usize));
let ty = if liquid_list {
liquid(state).to_owned()
} else {
block_name(state, "minecraft:air")
};
out.push(Tag::compound([
("i", string(&ty)),
("x", Tag::Int(x * 16 + rx)),
("y", Tag::Int(section_y * 16 + ry)),
("z", Tag::Int(z * 16 + rz)),
("t", Tag::Int(0)),
("p", Tag::Int(0)),
]));
}
}
Tag::List(out)
};
let fluid_ticks = make(level, "LiquidsToBeTicked", true);
let block_ticks = make(level, "ToBeTicked", false);
set(level, "TileTicks", block_ticks);
remove(level, "ToBeTicked");
remove(level, "LiquidsToBeTicked");
set(level, "fluid_ticks", fluid_ticks);
});
}
/// `ChunkRenamesFix`: the Level tag merged into the chunk, fields renamed.
fn chunk_renames(cx: &mut Cx) {
cx.each(Ty::Chunk, |chunk| {
let Some(Tag::Compound(level)) = remove(chunk, "Level") else {
return;
};
for (k, v) in level {
if let Tag::Compound(c) = chunk {
c.insert(k, v);
}
}
for (from, to) in [
("TileEntities", "block_entities"),
("TileTicks", "block_ticks"),
("Entities", "entities"),
("Sections", "sections"),
] {
rename(chunk, from, to);
}
if let Some(s) = chunk.get_mut("Structures") {
rename(s, "Starts", "starts");
}
rename(chunk, "Structures", "structures");
});
}
/// `OverreachingTickFix`.
fn overreaching_ticks(cx: &mut Cx) {
cx.each(Ty::Chunk, |chunk| {
let x = as_int(chunk.get("xPos"), 0);
let z = as_int(chunk.get("zPos"), 0);
for (list, name) in [
("block_ticks", "neighbor_block_ticks"),
("fluid_ticks", "neighbor_fluid_ticks"),
] {
let Some(ticks) = chunk.get(list) else {
continue;
};
let over: Vec<Tag> = stream(Some(ticks))
.into_iter()
.filter(|t| {
let dx = (x - (as_int(t.get("x"), 0) >> 4)).abs();
let dz = (z - (as_int(t.get("z"), 0) >> 4)).abs();
(dx != 0 || dz != 0) && dx <= 1 && dz <= 1
})
.collect();
if !over.is_empty() {
let mut upgrade = chunk.get("UpgradeData").cloned().unwrap_or_else(empty_map);
set(&mut upgrade, name, Tag::List(over));
set(chunk, "UpgradeData", upgrade);
}
}
});
}
/// `CavesAndCliffsRenames`.
const CAVES_AND_CLIFFS: &[(&str, &str)] = &[
("minecraft:badlands_plateau", "minecraft:badlands"),
("minecraft:bamboo_jungle_hills", "minecraft:bamboo_jungle"),
("minecraft:birch_forest_hills", "minecraft:birch_forest"),
("minecraft:dark_forest_hills", "minecraft:dark_forest"),
("minecraft:desert_hills", "minecraft:desert"),
("minecraft:desert_lakes", "minecraft:desert"),
(
"minecraft:giant_spruce_taiga_hills",
"minecraft:old_growth_spruce_taiga",
),
(
"minecraft:giant_spruce_taiga",
"minecraft:old_growth_spruce_taiga",
),
(
"minecraft:giant_tree_taiga_hills",
"minecraft:old_growth_pine_taiga",
),
(
"minecraft:giant_tree_taiga",
"minecraft:old_growth_pine_taiga",
),
(
"minecraft:gravelly_mountains",
"minecraft:windswept_gravelly_hills",
),
("minecraft:jungle_edge", "minecraft:sparse_jungle"),
("minecraft:jungle_hills", "minecraft:jungle"),
("minecraft:modified_badlands_plateau", "minecraft:badlands"),
(
"minecraft:modified_gravelly_mountains",
"minecraft:windswept_gravelly_hills",
),
("minecraft:modified_jungle_edge", "minecraft:sparse_jungle"),
("minecraft:modified_jungle", "minecraft:jungle"),
(
"minecraft:modified_wooded_badlands_plateau",
"minecraft:wooded_badlands",
),
("minecraft:mountain_edge", "minecraft:windswept_hills"),
("minecraft:mountains", "minecraft:windswept_hills"),
(
"minecraft:mushroom_field_shore",
"minecraft:mushroom_fields",
),
("minecraft:shattered_savanna", "minecraft:windswept_savanna"),
(
"minecraft:shattered_savanna_plateau",
"minecraft:windswept_savanna",
),
("minecraft:snowy_mountains", "minecraft:snowy_plains"),
("minecraft:snowy_taiga_hills", "minecraft:snowy_taiga"),
("minecraft:snowy_taiga_mountains", "minecraft:snowy_taiga"),
("minecraft:snowy_tundra", "minecraft:snowy_plains"),
("minecraft:stone_shore", "minecraft:stony_shore"),
("minecraft:swamp_hills", "minecraft:swamp"),
("minecraft:taiga_hills", "minecraft:taiga"),
("minecraft:taiga_mountains", "minecraft:taiga"),
(
"minecraft:tall_birch_forest",
"minecraft:old_growth_birch_forest",
),
(
"minecraft:tall_birch_hills",
"minecraft:old_growth_birch_forest",
),
(
"minecraft:wooded_badlands_plateau",
"minecraft:wooded_badlands",
),
("minecraft:wooded_hills", "minecraft:forest"),
("minecraft:wooded_mountains", "minecraft:windswept_forest"),
("minecraft:lofty_peaks", "minecraft:jagged_peaks"),
("minecraft:snowcapped_peaks", "minecraft:frozen_peaks"),
];
+3 -3
View File
@@ -27,9 +27,9 @@ use schema::{Key, Ty, key, walk};
/// The DataVersion of the game.
pub const CURRENT: i32 = crate::DATA_VERSION;
/// Data saved before this DataVersion (1.18 is 2860) needs fixes that are not
/// ported (2852 and everything before).
pub const OLDEST_SUPPORTED: i32 = 2852;
/// Data saved before this DataVersion (1.17 is 2724) needs fixes that are not
/// ported (2717 and everything before).
pub const OLDEST_SUPPORTED: i32 = 2724;
/// `Identifier.tryParse` validity, as `NamespacedSchema.ensureNamespaced` uses it.
pub fn identifier(id: &str) -> Option<(String, String)> {
+57 -1
View File
@@ -24,6 +24,8 @@ pub enum Ty {
DataComponents,
TextComponent,
VillagerTrade,
/// `UNTAGGED_SPAWNER`: the spawner fields of a spawner block entity or minecart.
UntaggedSpawner,
Particle,
BlockState,
FlatBlockState,
@@ -170,6 +172,11 @@ impl Walker<'_> {
self.list(Ty::Recipe, book, "toBeDisplayed");
}
}
Ty::Chunk if k < key(2842, 0) => {
if let Some(level) = v.get_mut("Level") {
self.level_chunk(level);
}
}
Ty::Chunk => {
self.list(Ty::EntityTree, v, "entities");
if let Some(Tag::List(items)) = v.get_mut("block_entities") {
@@ -201,6 +208,7 @@ impl Walker<'_> {
self.walk(Ty::Entity, v);
}
Ty::Entity => self.entity(v),
Ty::UntaggedSpawner => self.untagged_spawner(v),
Ty::BlockEntity => self.block_entity(v),
Ty::ItemStack => self.item_stack(v),
Ty::DataComponents => self.components(v),
@@ -450,8 +458,53 @@ impl Walker<'_> {
}
}
/// `UNTAGGED_SPAWNER` (V2831).
/// The `Level` of a chunk before 1.18 (V99, V1451_1, V1466, V2832).
fn level_chunk(&mut self, v: &mut Tag) {
let k = self.k;
self.list(Ty::EntityTree, v, "Entities");
if let Some(Tag::List(items)) = v.get_mut("TileEntities") {
for be in items {
if block_entity_known(be, k) {
self.walk(Ty::BlockEntity, be);
}
}
}
self.list_of_field(Ty::BlockName, v, "TileTicks", "i");
if let Some(Tag::List(sections)) = v.get_mut("Sections") {
for s in sections {
if k >= key(2832, 0) {
if let Some(b) = s.get_mut("biomes") {
self.list(Ty::Biome, b, "palette");
}
if let Some(b) = s.get_mut("block_states") {
self.list(Ty::BlockState, b, "palette");
}
} else if k >= key(1451, 1) {
self.list(Ty::BlockState, s, "Palette");
}
}
}
if k >= key(1466, 0)
&& let Some(s) = v.get_mut("Structures")
{
self.values(Ty::StructureFeature, s, "Starts");
}
}
fn spawner(&mut self, v: &mut Tag) {
self.walk(Ty::UntaggedSpawner, v);
}
/// `UNTAGGED_SPAWNER` (V106, V2831).
fn untagged_spawner(&mut self, v: &mut Tag) {
if self.k < key(106, 0) {
return;
}
if self.k < key(2831, 0) {
self.list_of_field(Ty::EntityTree, v, "SpawnPotentials", "Entity");
self.field(Ty::EntityTree, v, "SpawnData");
return;
}
if let Some(Tag::List(items)) = v.get_mut("SpawnPotentials") {
for p in items {
if let Some(d) = p.get_mut("data") {
@@ -739,6 +792,9 @@ impl Walker<'_> {
/// `WORLD_GEN_SETTINGS` (V2832).
fn world_gen(&mut self, v: &mut Tag) {
if self.k < key(2551, 0) {
return;
}
let Some(Tag::Compound(dims)) = v.get_mut("dimensions") else {
return;
};
+4
View File
@@ -232,6 +232,10 @@ def block_entities(e, version):
('structure_block', '{name:"x:y",posX:1,posY:2,posZ:3,sizeX:4,sizeY:5,sizeZ:6,mode:"SAVE"}'),
('skeleton_skull', '{}'),
]
if version < 2831: # 1.18: spawn data became weighted entries
out = [(b, '{SpawnData:{id:"minecraft:zombie",ArmorItems:[{},{},{},{id:"minecraft:iron_helmet",Count:1b}]},'
'SpawnPotentials:[{Weight:1,Entity:{id:"minecraft:skeleton"}}]}') if b == 'spawner' else (b, nbt)
for b, nbt in out]
if version >= 3682:
out.append(('crafter', '{Items:[{Slot:0b,id:"minecraft:stone",Count:1b}],triggered:1,crafting_ticks_remaining:2}'))
# Blocks the 1.20 experiment brought in 1.19.3 and 1.19.4.
+1 -1
View File
@@ -37,7 +37,7 @@ LOCAL = ROOT / '.local' / 'datafix'
# Old server jars and their worlds are inputs, not outputs: keep them beside the
# vanilla data, which parallel worktrees share (.local/minecraft links there).
SHARED = (ROOT / '.local' / 'minecraft').resolve().parent / 'datafix'
VERSIONS = ['1.18.1', '1.18.2', '1.19', '1.19.2', '1.19.3', '1.19.4', '1.20.1', '1.20.2', '1.20.4', '1.20.5', '1.20.6', '1.21.1',
VERSIONS = ['1.17.1', '1.18.1', '1.18.2', '1.19', '1.19.2', '1.19.3', '1.19.4', '1.20.1', '1.20.2', '1.20.4', '1.20.5', '1.20.6', '1.21.1',
'1.21.3', '1.21.4', '1.21.5', '1.21.6', '1.21.8', '1.21.9', '1.21.10', '1.21.11', '26.1', '26.1.2', '26.2']
MANIFEST = 'https://piston-meta.mojang.com/mc/game/version_manifest_v2.json'
LOCK = json.loads((ROOT / 'research-lock.json').read_text())['java_runtimes']