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:
@@ -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(§ions)) {
|
||||
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(¤t.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"),
|
||||
];
|
||||
|
||||
@@ -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)> {
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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']
|
||||
|
||||
Reference in New Issue
Block a user