Files
horizon-airdef/crates/horizon-world/src/datafix/schema.rs
T
2026-10-11 15:53:55 +02:00

861 lines
33 KiB
Rust

//! Where DataFixerUpper finds each type inside the data, schema by schema
//! (`net.minecraft.util.datafix.schemas`), from the 1.20 schemas on.
//!
//! `walk` visits every value of the target type under a root of a given type,
//! children before parents (DataFixerUpper rewrites recursive types bottom-up).
//! Keys are `version * 10 + sub-version` as in `DataFixUtils.makeKey`, and a
//! fix with key K reads its input with the schema just below K.
use super::dynamic::{as_str, namespaced};
use crate::nbt::Tag;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Ty {
Level,
/// `LIGHTWEIGHT_LEVEL`: the level data apart from its typed fields (the same value).
LightweightLevel,
Player,
Chunk,
EntityChunk,
PoiChunk,
BlockEntity,
EntityTree,
Entity,
ItemStack,
DataComponents,
TextComponent,
VillagerTrade,
Particle,
BlockState,
FlatBlockState,
BlockName,
ItemName,
EntityName,
Biome,
Recipe,
StructureFeature,
GameEventName,
Advancements,
Stats,
Hotbar,
Objective,
Team,
WorldGenSettings,
SavedCustomBossEvents,
SavedMapData,
SavedScoreboard,
SavedWorldGenSettings,
SavedStructureFeatureIndices,
/// Saved data that has no typed fields (`DSL.remainder`).
SavedRemainder,
/// Each saved data kind still needs its own identity for fixes that target it.
SavedEnderDragonFight,
SavedGameRules,
SavedTickets,
SavedRaids,
SavedRandomSequences,
SavedWorldBorder,
SavedWeather,
SavedWorldClocks,
SavedWanderingTrader,
SavedScheduledEvents,
SavedMapIndex,
SavedCommandStorage,
SavedStopwatches,
Options,
DebugProfile,
}
/// A schema key: `version * 10 + sub`.
pub type Key = u32;
pub const fn key(version: u32, sub: u32) -> Key {
version * 10 + sub
}
pub struct Walker<'f> {
/// The schema the data is read with.
pub k: Key,
pub target: Ty,
pub f: &'f mut dyn FnMut(&mut Tag),
}
impl Walker<'_> {
pub fn walk(&mut self, ty: Ty, v: &mut Tag) {
self.children(ty, v);
if ty == self.target {
(self.f)(v);
}
}
fn field(&mut self, ty: Ty, v: &mut Tag, name: &str) {
if let Some(child) = v.get_mut(name) {
self.walk(ty, child);
}
}
fn list(&mut self, ty: Ty, v: &mut Tag, name: &str) {
if let Some(Tag::List(items)) = v.get_mut(name) {
for item in items {
self.walk(ty, item);
}
}
}
fn list_in(&mut self, ty: Ty, items: &mut Tag) {
if let Tag::List(items) = items {
for item in items {
self.walk(ty, item);
}
}
}
/// `DSL.compoundList(type)`: every value of a map.
fn values(&mut self, ty: Ty, v: &mut Tag, name: &str) {
if let Some(Tag::Compound(c)) = v.get_mut(name) {
for value in c.values_mut() {
self.walk(ty, value);
}
}
}
/// A list of compounds, each with a typed field.
fn list_of_field(&mut self, ty: Ty, v: &mut Tag, list: &str, field: &str) {
if let Some(Tag::List(items)) = v.get_mut(list) {
for item in items {
self.field(ty, item, field);
}
}
}
/// `DSL.compoundList(keyType, valueType)` with typed string keys: keys are
/// renamed in place by the callback (as a string tag).
fn keys(&mut self, ty: Ty, v: &mut Tag, name: &str) {
if ty != self.target {
return;
}
if let Some(Tag::Compound(c)) = v.get_mut(name) {
let entries: Vec<_> = std::mem::take(c).into_iter().collect();
for (k, value) in entries {
let mut key_tag = Tag::String(k.clone());
(self.f)(&mut key_tag);
let k = match key_tag {
Tag::String(s) => s,
_ => k,
};
c.insert(k, value);
}
}
}
fn children(&mut self, ty: Ty, v: &mut Tag) {
let k = self.k;
match ty {
Ty::Level => {
if k < key(4771, 0) {
if let Some(Tag::Compound(c)) = v.get_mut("CustomBossEvents") {
for e in c.values_mut() {
self.field(Ty::TextComponent, e, "Name");
}
}
}
self.walk(Ty::LightweightLevel, v);
}
Ty::Player => {
if k >= key(4312, 0) {
self.equipment(v);
}
if let Some(rv) = v.get_mut("RootVehicle") {
self.field(Ty::EntityTree, rv, "Entity");
}
self.list(Ty::EntityTree, v, "ender_pearls");
self.list(Ty::ItemStack, v, "Inventory");
self.list(Ty::ItemStack, v, "EnderItems");
self.field(Ty::EntityTree, v, "ShoulderEntityLeft");
self.field(Ty::EntityTree, v, "ShoulderEntityRight");
if let Some(book) = v.get_mut("recipeBook") {
self.list(Ty::Recipe, book, "recipes");
self.list(Ty::Recipe, book, "toBeDisplayed");
}
}
Ty::Chunk => {
self.list(Ty::EntityTree, v, "entities");
if let Some(Tag::List(items)) = v.get_mut("block_entities") {
for be in items {
// DSL.or(BLOCK_ENTITY, remainder): unknown ids stay as they are.
if block_entity_known(be, k) {
self.walk(Ty::BlockEntity, be);
}
}
}
self.list_of_field(Ty::BlockName, v, "block_ticks", "i");
if let Some(Tag::List(sections)) = v.get_mut("sections") {
for s in sections {
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");
}
}
}
if let Some(s) = v.get_mut("structures") {
self.values(Ty::StructureFeature, s, "starts");
}
}
Ty::EntityChunk => self.list(Ty::EntityTree, v, "Entities"),
Ty::EntityTree => {
self.list(Ty::EntityTree, v, "Passengers");
self.walk(Ty::Entity, v);
}
Ty::Entity => self.entity(v),
Ty::BlockEntity => self.block_entity(v),
Ty::ItemStack => self.item_stack(v),
Ty::DataComponents => self.components(v),
Ty::TextComponent => self.text(v),
Ty::VillagerTrade => {
self.field(Ty::ItemStack, v, "buy");
self.field(Ty::ItemStack, v, "buyB");
self.field(Ty::ItemStack, v, "sell");
}
Ty::Particle => {
if k >= key(3818, 4) {
self.field(Ty::ItemStack, v, "item");
self.field(Ty::BlockState, v, "block_state");
}
}
Ty::Hotbar => {
if let Tag::Compound(c) = v {
for row in c.values_mut() {
self.list_in(Ty::ItemStack, row);
}
}
}
Ty::Stats => {
if let Some(stats) = v.get_mut("stats") {
self.keys(Ty::BlockName, stats, "minecraft:mined");
for s in ["crafted", "used", "broken", "picked_up", "dropped"] {
self.keys(Ty::ItemName, stats, &format!("minecraft:{s}"));
}
self.keys(Ty::EntityName, stats, "minecraft:killed");
self.keys(Ty::EntityName, stats, "minecraft:killed_by");
}
}
Ty::Advancements => {
for (adv, kind) in [
("minecraft:adventure/adventuring_time", Ty::Biome),
("minecraft:adventure/kill_a_mob", Ty::EntityName),
("minecraft:adventure/kill_all_mobs", Ty::EntityName),
("minecraft:husbandry/bred_all_animals", Ty::EntityName),
] {
if let Some(a) = v.get_mut(adv) {
self.keys(kind, a, "criteria");
}
}
}
Ty::Objective => {
// The hook unpacked CriteriaName into CriteriaType {type, id}.
if let Some(ct) = v.get_mut("CriteriaType") {
let kind = match as_str(ct.get("type")).as_deref() {
Some("minecraft:mined") => Some(Ty::BlockName),
Some(
"minecraft:crafted"
| "minecraft:used"
| "minecraft:broken"
| "minecraft:picked_up"
| "minecraft:dropped",
) => Some(Ty::ItemName),
Some("minecraft:killed" | "minecraft:killed_by") => Some(Ty::EntityName),
_ => None,
};
if let Some(kind) = kind {
self.field(kind, ct, "id");
}
}
self.field(Ty::TextComponent, v, "DisplayName");
}
Ty::Team => {
for f in ["MemberNamePrefix", "MemberNameSuffix", "DisplayName"] {
self.field(Ty::TextComponent, v, f);
}
}
Ty::SavedCustomBossEvents => {
if let Some(Tag::Compound(c)) = v.get_mut("data") {
for e in c.values_mut() {
self.field(Ty::TextComponent, e, "Name");
}
}
}
Ty::SavedMapData => {
if let Some(d) = v.get_mut("data") {
let name = if k >= key(3813, 0) { "name" } else { "Name" };
self.list_of_field(Ty::TextComponent, d, "banners", name);
}
}
Ty::SavedScoreboard => {
if let Some(d) = v.get_mut("data") {
self.list(Ty::Objective, d, "Objectives");
self.list(Ty::Team, d, "Teams");
self.list_of_field(Ty::TextComponent, d, "PlayerScores", "display");
}
}
Ty::SavedWorldGenSettings => self.field(Ty::WorldGenSettings, v, "data"),
Ty::SavedStructureFeatureIndices => {
if let Some(d) = v.get_mut("data") {
self.values(Ty::StructureFeature, d, "Features");
}
}
Ty::WorldGenSettings => self.world_gen(v),
_ => {}
}
}
fn equipment(&mut self, v: &mut Tag) {
if self.k >= key(4301, 0) {
if let Some(eq) = v.get_mut("equipment") {
for slot in [
"mainhand", "offhand", "feet", "legs", "chest", "head", "body", "saddle",
] {
self.field(Ty::ItemStack, eq, slot);
}
}
} else {
self.list(Ty::ItemStack, v, "ArmorItems");
self.list(Ty::ItemStack, v, "HandItems");
self.field(Ty::ItemStack, v, "body_armor_item");
self.field(Ty::ItemStack, v, "saddle");
}
}
fn entity(&mut self, v: &mut Tag) {
let k = self.k;
self.equipment(v);
self.field(Ty::TextComponent, v, "CustomName");
let id = namespaced(&as_str(v.get("id")).unwrap_or_default());
let id = id.as_str();
let listener = |w: &mut Self, v: &mut Tag| {
if let Some(l) = v.get_mut("listener")
&& let Some(e) = l.get_mut("event")
{
w.field(Ty::GameEventName, e, "game_event");
}
};
match id {
"minecraft:area_effect_cloud" => {
let f = if k >= key(4420, 0) {
"custom_particle"
} else {
"Particle"
};
self.field(Ty::Particle, v, f);
}
"minecraft:arrow" | "minecraft:spectral_arrow" => {
self.field(Ty::BlockState, v, "inBlockState");
if k >= key(3685, 0) {
self.field(Ty::ItemStack, v, "item");
}
if k >= key(3938, 0) {
self.field(Ty::ItemStack, v, "weapon");
}
}
"minecraft:trident" => {
self.field(Ty::BlockState, v, "inBlockState");
let f = if k >= key(3685, 0) { "item" } else { "Trident" };
self.field(Ty::ItemStack, v, f);
}
"minecraft:chest_minecart" | "minecraft:hopper_minecart" => {
self.field(Ty::BlockState, v, "DisplayState");
self.list(Ty::ItemStack, v, "Items");
}
"minecraft:minecart" | "minecraft:furnace_minecart" | "minecraft:tnt_minecart" => {
self.field(Ty::BlockState, v, "DisplayState");
}
"minecraft:command_block_minecart" => {
self.field(Ty::BlockState, v, "DisplayState");
self.field(Ty::TextComponent, v, "LastOutput");
}
"minecraft:spawner_minecart" => {
self.field(Ty::BlockState, v, "DisplayState");
self.spawner(v);
}
"minecraft:donkey" | "minecraft:mule" => {
self.list(Ty::ItemStack, v, "Items");
if k < key(4300, 0) {
self.field(Ty::ItemStack, v, "SaddleItem");
}
}
"minecraft:llama" | "minecraft:trader_llama" => {
self.list(Ty::ItemStack, v, "Items");
if k < key(4300, 0) {
self.field(Ty::ItemStack, v, "SaddleItem");
}
let split = if id == "minecraft:llama" {
key(3808, 1)
} else {
key(3808, 2)
};
if k < split {
self.field(Ty::ItemStack, v, "DecorItem");
}
}
"minecraft:horse" => {
if k < key(4300, 0) {
self.field(Ty::ItemStack, v, "SaddleItem");
}
if k < key(3808, 0) {
self.field(Ty::ItemStack, v, "ArmorItem");
}
}
"minecraft:skeleton_horse" | "minecraft:zombie_horse" => {
if k < key(4300, 0) {
self.field(Ty::ItemStack, v, "SaddleItem");
}
}
"minecraft:enderman" => self.field(Ty::BlockState, v, "carriedBlockState"),
"minecraft:falling_block" => {
self.field(Ty::BlockState, v, "BlockState");
self.field(Ty::BlockEntity, v, "TileEntityData");
}
"minecraft:firework_rocket" => self.field(Ty::ItemStack, v, "FireworksItem"),
"minecraft:item" | "minecraft:item_frame" | "minecraft:glow_item_frame" => {
self.field(Ty::ItemStack, v, "Item");
}
"minecraft:potion" if k < key(4306, 0) => self.field(Ty::ItemStack, v, "Item"),
"minecraft:splash_potion" | "minecraft:lingering_potion" if k >= key(4306, 0) => {
self.field(Ty::ItemStack, v, "Item");
}
"minecraft:villager" | "minecraft:wandering_trader" => {
self.list(Ty::ItemStack, v, "Inventory");
if let Some(o) = v.get_mut("Offers") {
self.list(Ty::VillagerTrade, o, "Recipes");
}
}
"minecraft:zombie_villager" => {
if let Some(o) = v.get_mut("Offers") {
self.list(Ty::VillagerTrade, o, "Recipes");
}
}
"minecraft:pillager" | "minecraft:piglin" => self.list(Ty::ItemStack, v, "Inventory"),
"minecraft:allay" => {
self.list(Ty::ItemStack, v, "Inventory");
listener(self, v);
}
"minecraft:warden" => listener(self, v),
"minecraft:tnt" if k >= key(3683, 0) => self.field(Ty::BlockState, v, "block_state"),
"minecraft:chest_boat" if k < key(4067, 0) => self.list(Ty::ItemStack, v, "Items"),
"minecraft:item_display" => self.field(Ty::ItemStack, v, "item"),
"minecraft:block_display" => self.field(Ty::BlockState, v, "block_state"),
"minecraft:text_display" => self.field(Ty::TextComponent, v, "text"),
"minecraft:ominous_item_spawner" if k >= key(3825, 0) => {
self.field(Ty::ItemStack, v, "item")
}
_ if k >= key(4067, 0)
&& (id.ends_with("_chest_boat") || id == "minecraft:bamboo_chest_raft") =>
{
self.list(Ty::ItemStack, v, "Items");
}
_ => {}
}
}
/// `UNTAGGED_SPAWNER` (V2831).
fn spawner(&mut self, v: &mut Tag) {
if let Some(Tag::List(items)) = v.get_mut("SpawnPotentials") {
for p in items {
if let Some(d) = p.get_mut("data") {
self.field(Ty::EntityTree, d, "entity");
}
}
}
if let Some(d) = v.get_mut("SpawnData") {
self.field(Ty::EntityTree, d, "entity");
}
}
fn block_entity(&mut self, v: &mut Tag) {
let k = self.k;
self.field(Ty::DataComponents, v, "components");
let id = namespaced(&as_str(v.get("id")).unwrap_or_default());
let named_inventory = |w: &mut Self, v: &mut Tag| {
w.list(Ty::ItemStack, v, "Items");
w.field(Ty::TextComponent, v, "CustomName");
};
match id.as_str() {
"minecraft:furnace" | "minecraft:smoker" | "minecraft:blast_furnace" => {
named_inventory(self, v);
self.keys(Ty::Recipe, v, "RecipesUsed");
}
"minecraft:chest"
| "minecraft:trapped_chest"
| "minecraft:dispenser"
| "minecraft:dropper"
| "minecraft:hopper"
| "minecraft:shulker_box"
| "minecraft:brewing_stand"
| "minecraft:barrel" => {
named_inventory(self, v);
}
"minecraft:crafter" if k >= key(3682, 0) => named_inventory(self, v),
"minecraft:jukebox" => self.field(Ty::ItemStack, v, "RecordItem"),
"minecraft:sign" | "minecraft:hanging_sign" => {
for side in ["front_text", "back_text"] {
if let Some(s) = v.get_mut(side) {
self.list(Ty::TextComponent, s, "messages");
self.list(Ty::TextComponent, s, "filtered_messages");
}
}
}
"minecraft:mob_spawner" => self.spawner(v),
"minecraft:piston" => self.field(Ty::BlockState, v, "blockState"),
"minecraft:enchanting_table" | "minecraft:beacon" | "minecraft:banner" => {
self.field(Ty::TextComponent, v, "CustomName");
}
"minecraft:skull" => self.field(Ty::TextComponent, v, "custom_name"),
"minecraft:command_block" => {
self.field(Ty::TextComponent, v, "CustomName");
self.field(Ty::TextComponent, v, "LastOutput");
}
"minecraft:jigsaw" => self.field(Ty::FlatBlockState, v, "final_state"),
"minecraft:campfire" | "minecraft:chiseled_bookshelf" => {
self.list(Ty::ItemStack, v, "Items")
}
"minecraft:shelf" if k >= key(4533, 0) => self.list(Ty::ItemStack, v, "Items"),
"minecraft:lectern" => self.field(Ty::ItemStack, v, "Book"),
"minecraft:beehive" => {
if k >= key(3818, 0) {
self.list_of_field(Ty::EntityTree, v, "bees", "entity_data");
} else {
self.list_of_field(Ty::EntityTree, v, "Bees", "EntityData");
}
}
"minecraft:sculk_sensor" | "minecraft:sculk_shrieker" => {
if let Some(l) = v.get_mut("listener")
&& let Some(e) = l.get_mut("event")
{
self.field(Ty::GameEventName, e, "game_event");
}
}
"minecraft:decorated_pot" => {
if k >= key(4996, 1) {
if let Some(s) = v.get_mut("sherds") {
for side in ["back", "left", "right", "front"] {
self.field(Ty::ItemStack, s, side);
}
}
} else if k >= key(3448, 0) {
self.list(Ty::ItemName, v, "sherds");
} else {
self.list(Ty::ItemName, v, "shards");
}
self.field(Ty::ItemStack, v, "item");
}
"minecraft:brushable_block" | "minecraft:suspicious_sand" => {
self.field(Ty::ItemStack, v, "item")
}
"minecraft:trial_spawner" if k >= key(3689, 0) => {
if let Some(Tag::List(items)) = v.get_mut("spawn_potentials") {
for p in items {
if let Some(d) = p.get_mut("data") {
self.field(Ty::EntityTree, d, "entity");
}
}
}
if let Some(d) = v.get_mut("spawn_data") {
self.field(Ty::EntityTree, d, "entity");
}
}
"minecraft:vault" if k >= key(3807, 0) => {
if let Some(c) = v.get_mut("config") {
self.field(Ty::ItemStack, c, "key_item");
}
if let Some(c) = v.get_mut("server_data") {
self.list(Ty::ItemStack, c, "items_to_eject");
}
if let Some(c) = v.get_mut("shared_data") {
self.field(Ty::ItemStack, c, "display_item");
}
}
"minecraft:test_instance_block" if k >= key(4302, 0) => {
if let Some(d) = v.get_mut("data") {
self.field(Ty::TextComponent, d, "error_message");
}
self.list_of_field(Ty::TextComponent, v, "errors", "text");
}
_ => {}
}
}
fn item_stack(&mut self, v: &mut Tag) {
if self.k >= key(3818, 5) {
self.field(Ty::ItemName, v, "id");
self.field(Ty::DataComponents, v, "components");
return;
}
self.field(Ty::ItemName, v, "id");
let Some(tag) = v.get_mut("tag") else {
return;
};
self.field(Ty::EntityTree, tag, "EntityTag");
self.field(Ty::BlockEntity, tag, "BlockEntityTag");
self.list(Ty::BlockName, tag, "CanDestroy");
self.list(Ty::BlockName, tag, "CanPlaceOn");
self.list(Ty::ItemStack, tag, "Items");
self.list(Ty::ItemStack, tag, "ChargedProjectiles");
self.list(Ty::TextComponent, tag, "pages");
self.values(Ty::TextComponent, tag, "filtered_pages");
if let Some(d) = tag.get_mut("display") {
self.field(Ty::TextComponent, d, "Name");
self.list(Ty::TextComponent, d, "Lore");
}
}
fn components(&mut self, v: &mut Tag) {
let k = self.k;
if k < key(3818, 3) {
return;
}
let Tag::Compound(_) = v else {
return;
};
self.list_of_field(Ty::EntityTree, v, "minecraft:bees", "entity_data");
self.field(Ty::BlockEntity, v, "minecraft:block_entity_data");
self.list(Ty::ItemStack, v, "minecraft:bundle_contents");
for c in ["minecraft:can_break", "minecraft:can_place_on"] {
let Some(p) = v.get_mut(c) else {
continue;
};
if k >= key(4307, 0) {
// A predicate or a list of them.
if let Tag::List(items) = p {
for item in items {
self.blocks_predicate(item);
}
} else {
self.blocks_predicate(p);
}
} else if let Some(Tag::List(items)) = p.get_mut("predicates") {
for item in items {
self.blocks_predicate(item);
}
}
}
self.list(Ty::ItemStack, v, "minecraft:charged_projectiles");
self.list_of_field(Ty::ItemStack, v, "minecraft:container", "item");
self.field(Ty::EntityTree, v, "minecraft:entity_data");
if k >= key(4996, 0) {
if let Some(p) = v.get_mut("minecraft:pot_decorations") {
for side in ["back", "left", "right", "front"] {
self.field(Ty::ItemStack, p, side);
}
}
} else {
self.list(Ty::ItemName, v, "minecraft:pot_decorations");
}
if k < key(4059, 0) {
if let Some(f) = v.get_mut("minecraft:food") {
self.field(Ty::ItemStack, f, "using_converts_to");
}
} else {
self.field(Ty::ItemStack, v, "minecraft:use_remainder");
if let Some(e) = v.get_mut("minecraft:equippable")
&& let Some(a) = e.get_mut("allowed_entities")
{
if let Tag::List(_) = a {
self.list_in(Ty::EntityName, a);
} else {
self.walk(Ty::EntityName, a);
}
}
self.field(Ty::ItemStack, v, "minecraft:sulfur_cube_content");
}
self.field(Ty::TextComponent, v, "minecraft:custom_name");
self.field(Ty::TextComponent, v, "minecraft:item_name");
self.list(Ty::TextComponent, v, "minecraft:lore");
if let Some(b) = v.get_mut("minecraft:written_book_content")
&& let Some(Tag::List(pages)) = b.get_mut("pages")
{
for page in pages {
// DSL.or({raw, filtered}, TEXT_COMPONENT): any compound is the filterable form.
if let Tag::Compound(_) = page {
self.field(Ty::TextComponent, page, "raw");
self.field(Ty::TextComponent, page, "filtered");
} else {
self.walk(Ty::TextComponent, page);
}
}
}
}
fn blocks_predicate(&mut self, p: &mut Tag) {
if let Some(b) = p.get_mut("blocks") {
if let Tag::List(_) = b {
self.list_in(Ty::BlockName, b);
} else {
self.walk(Ty::BlockName, b);
}
}
}
fn text(&mut self, v: &mut Tag) {
let k = self.k;
if k < key(4290, 0) {
return;
}
match v {
Tag::List(_) => self.list_in(Ty::TextComponent, v),
Tag::Compound(_) => {
self.list(Ty::TextComponent, v, "extra");
self.field(Ty::TextComponent, v, "separator");
if k >= key(4292, 0) {
if let Some(h) = v.get_mut("hover_event") {
match as_str(h.get("action")).as_deref() {
Some("show_text") => self.field(Ty::TextComponent, h, "value"),
Some("show_item") => self.walk(Ty::ItemStack, h),
Some("show_entity") => {
self.field(Ty::EntityName, h, "id");
self.field(Ty::TextComponent, h, "name");
}
_ => {}
}
}
} else if let Some(h) = v.get_mut("hoverEvent") {
match as_str(h.get("action")).as_deref() {
Some("show_text") => self.field(Ty::TextComponent, h, "contents"),
Some("show_item") => {
if let Some(c) = h.get_mut("contents") {
// DSL.or(ITEM_STACK, ITEM_NAME)
if let Tag::Compound(_) = c {
self.walk(Ty::ItemStack, c);
} else {
self.walk(Ty::ItemName, c);
}
}
}
Some("show_entity") => {
if let Some(c) = h.get_mut("contents") {
self.field(Ty::EntityName, c, "type");
self.field(Ty::TextComponent, c, "name");
}
}
_ => {}
}
}
}
_ => {}
}
}
/// `WORLD_GEN_SETTINGS` (V2832).
fn world_gen(&mut self, v: &mut Tag) {
let Some(Tag::Compound(dims)) = v.get_mut("dimensions") else {
return;
};
for dim in dims.values_mut() {
let Some(g) = dim.get_mut("generator") else {
continue;
};
match as_str(g.get("type")).as_deref() {
Some("minecraft:flat") => {
if let Some(s) = g.get_mut("settings") {
self.field(Ty::Biome, s, "biome");
self.list_of_field(Ty::BlockName, s, "layers", "block");
}
}
Some("minecraft:noise") => {
if let Some(b) = g.get_mut("biome_source") {
match as_str(b.get("type")).as_deref() {
Some("minecraft:fixed") => self.field(Ty::Biome, b, "biome"),
Some("minecraft:checkerboard") => self.list(Ty::Biome, b, "biomes"),
_ => {}
}
}
if let Some(s) = g.get_mut("settings")
&& let Tag::Compound(_) = s
{
self.field(Ty::BlockName, s, "default_block");
self.field(Ty::BlockName, s, "default_fluid");
}
}
_ => {}
}
}
}
}
/// Block entity ids the schema at `k` knows (others are read as remainder).
pub fn block_entity_known(be: &Tag, k: Key) -> bool {
let id = namespaced(&as_str(be.get("id")).unwrap_or_default());
let since = match id.as_str() {
"minecraft:sculk_catalyst" => key(3076, 0),
"minecraft:sculk_shrieker" => key(3078, 0),
"minecraft:hanging_sign" => key(3202, 0),
"minecraft:chiseled_bookshelf" => key(3204, 0),
"minecraft:decorated_pot" => key(3327, 0),
"minecraft:suspicious_sand" => return (key(3327, 0)..key(3438, 0)).contains(&k),
"minecraft:crafter" => key(3682, 0),
"minecraft:trial_spawner" => key(3689, 0),
"minecraft:vault" => key(3807, 0),
"minecraft:creaking_heart" => key(4071, 0),
"minecraft:test_block" | "minecraft:test_instance_block" => key(4302, 0),
"minecraft:copper_golem_statue" => key(4532, 0),
"minecraft:shelf" => key(4533, 0),
"minecraft:potent_sulfur" => key(4881, 0),
"minecraft:bed" => return k < key(4885, 0),
"minecraft:brushable_block" | "minecraft:calibrated_sculk_sensor" => key(3438, 0),
_ => 0,
};
k >= since && BLOCK_ENTITIES.contains(&id.as_str())
}
/// Block entity types of the schemas from 1.20 on.
const BLOCK_ENTITIES: &[&str] = &[
"minecraft:furnace",
"minecraft:chest",
"minecraft:trapped_chest",
"minecraft:ender_chest",
"minecraft:jukebox",
"minecraft:dispenser",
"minecraft:dropper",
"minecraft:sign",
"minecraft:mob_spawner",
"minecraft:piston",
"minecraft:brewing_stand",
"minecraft:enchanting_table",
"minecraft:end_portal",
"minecraft:beacon",
"minecraft:skull",
"minecraft:daylight_detector",
"minecraft:hopper",
"minecraft:comparator",
"minecraft:banner",
"minecraft:structure_block",
"minecraft:end_gateway",
"minecraft:command_block",
"minecraft:shulker_box",
"minecraft:bed",
"minecraft:conduit",
"minecraft:barrel",
"minecraft:smoker",
"minecraft:blast_furnace",
"minecraft:lectern",
"minecraft:bell",
"minecraft:jigsaw",
"minecraft:campfire",
"minecraft:beehive",
"minecraft:sculk_sensor",
"minecraft:sculk_catalyst",
"minecraft:sculk_shrieker",
"minecraft:hanging_sign",
"minecraft:chiseled_bookshelf",
"minecraft:decorated_pot",
"minecraft:suspicious_sand",
"minecraft:brushable_block",
"minecraft:calibrated_sculk_sensor",
"minecraft:crafter",
"minecraft:trial_spawner",
"minecraft:vault",
"minecraft:creaking_heart",
"minecraft:test_block",
"minecraft:test_instance_block",
"minecraft:copper_golem_statue",
"minecraft:shelf",
"minecraft:potent_sulfur",
];
/// Visit every value of `target` under a `root`-typed value read with schema `k`.
pub fn walk(root: Ty, v: &mut Tag, k: Key, target: Ty, f: &mut dyn FnMut(&mut Tag)) {
Walker { k, target, f }.walk(root, v);
}