WIP snapshot: creative inventory tabs and vanilla exporter

Uncommitted work from a finished agent worktree on ludothinkpad (/home/ludovic/.t3/worktrees/2026-10-03-i-want-you-to-retro-e5fa4461/t3code-ec3c613c), saved before the worktree was removed. Not built or verified.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-08 11:20:17 +02:00
parent af747818f1
commit f734f237cf
5 changed files with 444 additions and 3 deletions
+112
View File
@@ -0,0 +1,112 @@
//! Creative inventory (CreativeModeInventoryScreen): vanilla's tabs and their
//! contents as built by the game's own display generators
//! (`creative-tabs.json`), a 9x5 scrolling grid and the search tab.
use crate::Result;
use serde_json::Value;
use std::{collections::HashMap, fs, path::Path};
#[derive(Clone, Debug)]
pub struct Tab {
pub id: String,
pub title: String,
pub icon: String,
pub items: Vec<String>,
pub top: bool,
pub column: u32,
pub search: bool,
pub inventory: bool,
}
pub struct Creative {
pub tabs: Vec<Tab>,
pub selected: usize,
/// Scroll position 0..1.
pub scroll: f32,
pub search: String,
all_items: Vec<String>,
}
/// Display names from the pinned en_us language file.
pub struct Names {
map: HashMap<String, String>,
}
impl Names {
pub fn load(root: &Path) -> Self {
let map = fs::read(root.join("assets/minecraft/lang/en_us.json"))
.ok()
.and_then(|b| serde_json::from_slice::<HashMap<String, String>>(&b).ok())
.unwrap_or_default();
Self { map }
}
pub fn item(&self, id: &str) -> String {
let path = id.trim_start_matches("minecraft:");
self.map
.get(&format!("item.minecraft.{path}"))
.or_else(|| self.map.get(&format!("block.minecraft.{path}")))
.cloned()
.unwrap_or_else(|| path.replace('_', " "))
}
pub fn get(&self, key: &str) -> Option<&str> {
self.map.get(key).map(String::as_str)
}
}
impl Creative {
pub const WIDTH: f32 = 195.0;
pub const HEIGHT: f32 = 136.0;
pub fn load(root: &Path) -> Result<Self> {
let raw: Value = serde_json::from_slice(&fs::read(root.join("creative-tabs.json"))?)?;
let mut tabs = Vec::new();
let mut all_items: Vec<String> = Vec::new();
for t in raw.as_array().into_iter().flatten() {
let items: Vec<String> = t["items"].as_array().into_iter().flatten().filter_map(|v| v.as_str().map(str::to_owned)).collect();
for i in &items {
if !all_items.contains(i) {
all_items.push(i.clone());
}
}
let kind = t["type"].as_str().unwrap_or("");
if t["id"] == "minecraft:hotbar" || t["id"] == "minecraft:op_blocks" {
continue;
}
tabs.push(Tab {
id: t["id"].as_str().unwrap_or("").to_owned(),
title: t["title"].as_str().unwrap_or("").to_owned(),
icon: t["icon"].as_str().unwrap_or("minecraft:stone").to_owned(),
items,
top: t["row"] == "TOP",
column: t["column"].as_u64().unwrap_or(0) as u32,
search: kind == "SEARCH",
inventory: kind == "INVENTORY",
});
}
Ok(Self { tabs, selected: 0, scroll: 0.0, search: String::new(), all_items })
}
pub fn tab(&self) -> &Tab {
&self.tabs[self.selected.min(self.tabs.len() - 1)]
}
/// Items shown by the selected tab (the search tab filters by name).
pub fn items(&self, names: &Names) -> Vec<String> {
let tab = self.tab();
if tab.search {
let query = self.search.to_lowercase();
return self.all_items.iter().filter(|i| query.is_empty() || names.item(i).to_lowercase().contains(&query) || i.contains(&query)).cloned().collect();
}
tab.items.clone()
}
pub fn rows(&self, names: &Names) -> usize {
self.items(names).len().div_ceil(9)
}
/// First visible grid row for the scroll position.
pub fn first_row(&self, names: &Names) -> usize {
let hidden = self.rows(names).saturating_sub(5);
(self.scroll * hidden as f32 + 0.5) as usize
}
/// Tab button position relative to the screen origin (CreativeModeInventoryScreen.getTabX/Y).
pub fn tab_position(tab: &Tab) -> (f32, f32) {
let mut x = tab.column as f32 * 27.0;
if tab.column >= 5 {
// Right-aligned tabs (search, inventory).
x = Self::WIDTH - 27.0 * (7 - tab.column) as f32 + 1.0;
}
let y = if tab.top { -28.0 } else { Self::HEIGHT - 4.0 };
(x, y)
}
}
+230 -3
View File
@@ -12,6 +12,7 @@ use horizon_client::{
mobs::{Mob, MobEvent, MobType, MobTypes, MobWorld},
particles::Particle,
containers::{BlockEntity, Providers},
creative::{Creative, Names},
crafting::Recipes,
collisions,
environment::Environment,
@@ -71,6 +72,8 @@ struct Options {
time: Option<i64>,
weather: Option<String>,
dimension: Option<String>,
/// Options.pauseOnLostFocus off (F3+P), for scripted testing.
no_pause: bool,
}
impl Options {
fn read() -> Result<Option<Self>> {
@@ -98,6 +101,7 @@ impl Options {
time: None,
weather: None,
dimension: None,
no_pause: false,
};
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
@@ -110,6 +114,7 @@ impl Options {
}
"--creative" => o.creative = true,
"--test-terrain" => o.test_terrain = true,
"--no-pause" => o.no_pause = true,
_ => {
let value = args.next().ok_or_else(|| format!("missing value after {arg}"))?;
match arg.as_str() {
@@ -155,6 +160,7 @@ enum Screen {
Playing,
Paused,
Options,
Creative,
Inventory,
Dead,
}
@@ -267,6 +273,7 @@ pub struct Resources {
chest_model: Option<horizon_client::mobs::Part>,
nether_environment: Environment,
behaviours: Behaviours,
names: Names,
/// clouds.png: (width, height, filled cells).
clouds: (u32, u32, Vec<bool>),
context: Arc<WorkerContext>,
@@ -368,6 +375,7 @@ struct Game<'a> {
tick_chunks: HashSet<(i32, i32)>,
level_events: Vec<LevelEvent>,
falling: Vec<FallingBlock>,
creative_screen: Creative,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Dim {
@@ -492,6 +500,22 @@ impl Game<'_> {
Some(stack)
}
/// The block's particle texture (approximated by its first model face) and tint.
/// The `particle` texture of a block's first blockstate model (for models without faces).
fn model_particle(&self, block: &str) -> Option<String> {
let root = &self.options.resources;
let read = |path: String| -> Option<serde_json::Value> { serde_json::from_slice(&std::fs::read(root.join(path)).ok()?).ok() };
let states = read(format!("assets/minecraft/blockstates/{block}.json"))?;
let mut model = states["variants"].as_object()?.values().next().and_then(|v| v["model"].as_str().or_else(|| v[0]["model"].as_str()))?.to_owned();
for _ in 0..8 {
let m = read(format!("assets/minecraft/models/{}.json", model.trim_start_matches("minecraft:")))?;
if let Some(p) = m["textures"]["particle"].as_str() {
let p = if let Some(alias) = p.strip_prefix('#') { m["textures"][alias].as_str()? } else { p };
return Some(p.trim_start_matches("minecraft:").to_owned());
}
model = m["parent"].as_str()?.to_owned();
}
None
}
fn particle_sprite(&self, state: BlockStateId) -> Option<(String, u32)> {
let models = self.res.assets.model_catalog.collect(state, horizon_core::position::BlockPos::new(0, 0, 0)).ok()?;
let face = models.iter().flat_map(|(_, m)| m.faces.iter()).find(|f| f.quad.facing == horizon_assets::model::Direction::Up)
@@ -1418,7 +1442,12 @@ impl Game<'_> {
_ => None,
}
}
let model = first_model(&def["model"])?;
let Some(model) = first_model(&def["model"]) else {
// Special item models (chests, beds, banners...): show the block's particle texture.
let block = self.res.assets.registry.default_state(item).or_else(|| info.and_then(|i| i.block))?;
let (sprite, tint) = self.particle_sprite(block).or_else(|| self.model_particle(name).map(|s| (s, 0xFFFFFF)))?;
return Some(Icon::Cube { top: sprite.clone(), left: sprite.clone(), right: sprite, tint });
};
let path = model.trim_start_matches("minecraft:").to_owned();
let mut current = path.clone();
let mut textures = serde_json::Map::new();
@@ -1670,6 +1699,9 @@ impl Game<'_> {
Screen::Inventory => {
self.draw_inventory(&mut batch);
}
Screen::Creative => {
self.draw_creative(&mut batch);
}
Screen::Playing | Screen::Options => {}
}
batch
@@ -3873,6 +3905,162 @@ impl Game<'_> {
self.sleeping = Some((head, ticks));
}
}
fn creative_origin(batch: &HudBatch) -> (f32, f32) {
((batch.width - Creative::WIDTH) / 2.0, (batch.height - Creative::HEIGHT) / 2.0)
}
/// Vanilla tooltip: dark box with a purple gradient border.
fn tooltip(&self, batch: &mut HudBatch, text: &str, x: f32, y: f32) {
let atlas = &self.res.atlas;
let w = HudBatch::text_width(atlas, text);
let (x, y) = (x + 12.0, y - 12.0);
batch.fill(atlas, x - 3.0, y - 4.0, w + 6.0, 16.0, rgba(16, 0, 16, 240));
batch.fill(atlas, x - 3.0, y - 3.0, w + 6.0, 1.0, rgba(80, 0, 255, 80));
batch.fill(atlas, x - 3.0, y + 10.0, w + 6.0, 1.0, rgba(40, 0, 127, 80));
batch.text(atlas, text, x, y, u32::MAX, true);
}
fn draw_creative(&mut self, batch: &mut HudBatch) {
let (ox, oy) = Self::creative_origin(batch);
let selected = self.creative_screen.selected;
let tabs = self.creative_screen.tabs.clone();
let tab = self.creative_screen.tab().clone();
let tab_sprite = |t: &horizon_client::creative::Tab, on: bool| {
format!("gui/sprites/container/creative_inventory/tab_{}_{}_{}", if t.top { "top" } else { "bottom" }, if on { "selected" } else { "unselected" }, t.column + 1)
};
batch.fill(&self.res.atlas, 0.0, 0.0, batch.width, batch.height, rgba(16, 16, 16, 160));
// Unselected tabs behind the panel, then the panel, then the selected tab.
for (i, t) in tabs.iter().enumerate() {
if i != selected {
let (tx, ty) = Creative::tab_position(t);
batch.sprite(&self.res.atlas, &tab_sprite(t, false), ox + tx, oy + ty);
}
}
let background = if tab.search {
"gui/container/creative_inventory/tab_item_search"
} else if tab.inventory {
"gui/container/creative_inventory/tab_inventory"
} else {
"gui/container/creative_inventory/tab_items"
};
if let Some(mut r) = self.res.atlas.sprites.get(background).copied() {
r.u1 = r.u0 + (r.u1 - r.u0) * Creative::WIDTH / r.w as f32;
r.v1 = r.v0 + (r.v1 - r.v0) * Creative::HEIGHT / r.h as f32;
batch.rect_uv(ox, oy, Creative::WIDTH, Creative::HEIGHT, r, u32::MAX);
}
let (tx, ty) = Creative::tab_position(&tab);
batch.sprite(&self.res.atlas, &tab_sprite(&tab, true), ox + tx, oy + ty);
for t in &tabs {
let (tx, ty) = Creative::tab_position(t);
let stack = ItemStack { item: Arc::from(t.icon.as_str()), count: 1, damage: 0 };
self.draw_item(batch, &stack, ox + tx + 5.0, oy + ty + if t.top { 9.0 } else { 7.0 });
}
let atlas = &self.res.atlas;
batch.text(atlas, &tab.title, ox + 8.0, oy + 6.0, rgba(64, 64, 64, 255), false);
if tab.search {
let shown = format!("{}_", self.creative_screen.search);
batch.text(atlas, &shown, ox + 82.0, oy + 6.0, u32::MAX, true);
}
let items = self.creative_screen.items(&self.res.names);
let first = self.creative_screen.first_row(&self.res.names);
let mut hovered: Option<String> = None;
for r in 0..5 {
for c in 0..9 {
let Some(item) = items.get((first + r) * 9 + c) else { continue };
let (x, y) = (ox + 9.0 + c as f32 * 18.0, oy + 18.0 + r as f32 * 18.0);
let stack = ItemStack { item: Arc::from(item.as_str()), count: 1, damage: 0 };
self.draw_item(batch, &stack, x, y);
if self.cursor.0 >= x && self.cursor.0 < x + 16.0 && self.cursor.1 >= y && self.cursor.1 < y + 16.0 {
batch.fill(&self.res.atlas, x, y, 16.0, 16.0, rgba(255, 255, 255, 128));
hovered = Some(item.clone());
}
}
}
for c in 0..9 {
let (x, y) = (ox + 9.0 + c as f32 * 18.0, oy + 112.0);
if let Some(stack) = self.inventory[c].clone() {
self.draw_item(batch, &stack, x, y);
if self.cursor.0 >= x && self.cursor.0 < x + 16.0 && self.cursor.1 >= y && self.cursor.1 < y + 16.0 {
hovered = Some(stack.item.to_string());
}
}
}
let scrollable = self.creative_screen.rows(&self.res.names) > 5;
let scroller = if scrollable {
"gui/sprites/container/creative_inventory/scroller"
} else {
"gui/sprites/container/creative_inventory/scroller_disabled"
};
batch.sprite(&self.res.atlas, scroller, ox + 175.0, oy + 18.0 + self.creative_screen.scroll * (112.0 - 15.0));
for t in &tabs {
let (tx, ty) = Creative::tab_position(t);
if self.cursor.0 >= ox + tx && self.cursor.0 < ox + tx + 26.0 && self.cursor.1 >= oy + ty && self.cursor.1 < oy + ty + 32.0 {
self.tooltip(batch, &t.title, self.cursor.0, self.cursor.1);
}
}
if let Some(stack) = self.carried.clone() {
self.draw_item(batch, &stack, self.cursor.0 - 8.0, self.cursor.1 - 8.0);
} else if let Some(item) = hovered {
let name = self.res.names.item(&item);
self.tooltip(batch, &name, self.cursor.0, self.cursor.1);
}
}
fn click_creative(&mut self, right: bool) {
let Some(size) = self.renderer.as_ref().map(|r| [r.config.width, r.config.height]) else { return };
let batch = HudBatch::new(size);
let (ox, oy) = Self::creative_origin(&batch);
let (cx, cy) = self.cursor;
let tabs = self.creative_screen.tabs.clone();
for (i, t) in tabs.iter().enumerate() {
let (tx, ty) = Creative::tab_position(t);
if cx >= ox + tx && cx < ox + tx + 26.0 && cy >= oy + ty && cy < oy + ty + 32.0 {
if t.inventory {
self.screen = Screen::Inventory;
return;
}
self.creative_screen.selected = i;
self.creative_screen.scroll = 0.0;
return;
}
}
if cx >= ox + 175.0 && cx < ox + 187.0 && cy >= oy + 18.0 && cy < oy + 130.0 {
self.creative_screen.scroll = ((cy - oy - 18.0 - 7.5) / (112.0 - 15.0)).clamp(0.0, 1.0);
return;
}
let shift = self.keys.contains(&KeyCode::ShiftLeft);
let items = self.creative_screen.items(&self.res.names);
let first = self.creative_screen.first_row(&self.res.names);
for r in 0..5 {
for c in 0..9 {
let (x, y) = (ox + 9.0 + c as f32 * 18.0, oy + 18.0 + r as f32 * 18.0);
if !(cx >= x && cx < x + 16.0 && cy >= y && cy < y + 16.0) {
continue;
}
// Clicking the grid with an item deletes it; otherwise take a stack.
if self.carried.take().is_some() {
return;
}
let Some(item) = items.get((first + r) * 9 + c) else { return };
let max = self.res.items.get(item).map_or(64, |i| i.max_stack);
let stack = ItemStack { item: Arc::from(item.as_str()), count: if right { 1 } else { max }, damage: 0 };
if shift {
let _ = self.give(stack);
} else {
self.carried = Some(stack);
}
return;
}
}
for c in 0..9 {
let (x, y) = (ox + 9.0 + c as f32 * 18.0, oy + 112.0);
if cx >= x && cx < x + 16.0 && cy >= y && cy < y + 16.0 {
std::mem::swap(&mut self.carried, &mut self.inventory[c]);
return;
}
}
// Clicking outside the panel throws the carried stack away.
if !(cx >= ox && cx < ox + Creative::WIDTH && cy >= oy && cy < oy + Creative::HEIGHT) {
self.carried = None;
}
}
fn save_game(&mut self) -> Result<()> {
let keys: Vec<_> = self.world.modified.drain().collect();
let chunks: Vec<_> = keys
@@ -4101,7 +4289,7 @@ impl ApplicationHandler for Game<'_> {
self.left = false;
self.right = false;
self.capture(false);
if self.screen == Screen::Playing && self.player.is_some() {
if self.screen == Screen::Playing && self.player.is_some() && !self.options.no_pause {
self.screen = Screen::Paused;
}
}
@@ -4121,6 +4309,10 @@ impl ApplicationHandler for Game<'_> {
MouseScrollDelta::LineDelta(_, y) => y,
MouseScrollDelta::PixelDelta(p) => p.y as f32,
};
if self.screen == Screen::Creative && d != 0.0 {
let rows = self.creative_screen.rows(&self.res.names).saturating_sub(5).max(1) as f32;
self.creative_screen.scroll = (self.creative_screen.scroll - d.signum() / rows).clamp(0.0, 1.0);
}
if self.screen == Screen::Playing && d != 0.0 {
self.selected = (self.selected as i32 - d.signum() as i32).rem_euclid(9) as usize;
}
@@ -4196,6 +4388,9 @@ impl ApplicationHandler for Game<'_> {
Screen::Inventory if pressed => {
self.click_inventory(button == MouseButton::Right);
}
Screen::Creative if pressed => {
self.click_creative(button == MouseButton::Right);
}
Screen::Paused if pressed => {
let size = self.renderer.as_ref().map(|r| [r.config.width, r.config.height]).unwrap_or([1, 1]);
let b = HudBatch::new(size);
@@ -4223,6 +4418,22 @@ impl ApplicationHandler for Game<'_> {
_ => {}
}
}
WindowEvent::KeyboardInput { event, .. }
if self.screen == Screen::Creative && self.creative_screen.tab().search && event.state == ElementState::Pressed
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
match event.physical_key {
PhysicalKey::Code(KeyCode::Backspace) => {
self.creative_screen.search.pop();
}
_ => {
if let Some(text) = &event.text {
self.creative_screen.search.extend(text.chars().filter(|c| !c.is_control()));
}
}
}
self.creative_screen.scroll = 0.0;
}
WindowEvent::KeyboardInput { event, .. } if self.title.is_some() => {
if event.state == ElementState::Pressed
&& let Some(title) = self.title.as_mut()
@@ -4259,6 +4470,11 @@ impl ApplicationHandler for Game<'_> {
self.screen = Screen::Paused;
self.capture(false);
}
Screen::Creative => {
self.carried = None;
self.screen = Screen::Playing;
self.capture(true);
}
Screen::Paused | Screen::Inventory => {
self.close_container();
self.screen = Screen::Playing;
@@ -4266,11 +4482,19 @@ impl ApplicationHandler for Game<'_> {
}
Screen::Dead => {}
},
KeyCode::KeyE if self.screen == Screen::Creative && self.creative_screen.tab().search => {}
KeyCode::KeyE => match self.screen {
Screen::Playing => {
self.screen = Screen::Inventory;
self.screen = if self.creative { Screen::Creative } else { Screen::Inventory };
self.capture(false);
}
Screen::Creative => {
if let Some(c) = self.carried.take() {
let _ = self.give(c);
}
self.screen = Screen::Playing;
self.capture(true);
}
Screen::Inventory => {
self.close_container();
self.screen = Screen::Playing;
@@ -4438,6 +4662,7 @@ pub fn run() -> Result<()> {
chest_model: horizon_client::mobs::load_model(&root, "minecraft:chest#main"),
nether_environment: Environment::load_dimension(&root, "the_nether", false)?,
behaviours: Behaviours::load(registry_owner.registry, &root)?,
names: Names::load(&root),
clouds: horizon_client::hud::decode(&root.join("assets/minecraft/textures/environment/clouds.png"))
.map(|(w, h, px)| (w, h, px.chunks_exact(4).map(|p| p[3] > 0).collect()))
.unwrap_or((1, 1, vec![false])),
@@ -4450,6 +4675,7 @@ pub fn run() -> Result<()> {
};
let inventory = vec![None; 36];
let now = Instant::now();
let game_root = options.resources.clone();
let mut settings = Settings::load(&std::env::current_dir()?.join("options.txt"));
if let Some(d) = options.distance_override {
settings.render_distance = d;
@@ -4540,6 +4766,7 @@ pub fn run() -> Result<()> {
tick_chunks: HashSet::new(),
level_events: Vec::new(),
falling: Vec::new(),
creative_screen: Creative::load(&game_root)?,
};
match game.options.world.clone() {
Some(folder) => {
+1
View File
@@ -10,6 +10,7 @@ pub mod chunk;
pub mod clock;
pub mod containers;
pub mod crafting;
pub mod creative;
pub mod collisions;
pub mod entities;
pub mod environment;
@@ -0,0 +1,59 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import net.minecraft.SharedConstants;
import net.minecraft.core.RegistryAccess;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.server.Bootstrap;
import net.minecraft.world.flag.FeatureFlags;
import net.minecraft.world.item.CreativeModeTab;
import net.minecraft.world.item.CreativeModeTabs;
/**
* Original exporter of the creative inventory tab contents built by vanilla's own
* CreativeModeTab display generators (built-in registries; tabs needing dynamic
* registries keep whatever they produced before failing).
*/
public final class VanillaCreativeTabsExporter {
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();
Bootstrap.bootStrap();
// Display generators only need ItemStacks to exist: bind minimal components.
for (var item : BuiltInRegistries.ITEM) {
item.builtInRegistryHolder().bindComponents(
net.minecraft.core.component.DataComponentMap.builder()
.set(net.minecraft.core.component.DataComponents.MAX_STACK_SIZE, 64)
.build());
}
var lookup = RegistryAccess.fromRegistryOfRegistries(BuiltInRegistries.REGISTRY);
var parameters = new CreativeModeTab.ItemDisplayParameters(FeatureFlags.DEFAULT_FLAGS, true, lookup);
var out = new JsonArray();
for (CreativeModeTab tab : BuiltInRegistries.CREATIVE_MODE_TAB) {
var o = new JsonObject();
var key = BuiltInRegistries.CREATIVE_MODE_TAB.getKey(tab);
o.addProperty("id", key == null ? "" : key.toString());
o.addProperty("type", tab.getType().name());
o.addProperty("row", tab.row().name());
o.addProperty("column", tab.column());
o.addProperty("title", tab.getDisplayName().getString());
var items = new JsonArray();
try {
tab.buildContents(parameters);
for (var stack : tab.getDisplayItems()) {
items.add(BuiltInRegistries.ITEM.getKey(stack.getItem()).toString());
}
} catch (RuntimeException error) {
o.addProperty("error", error.toString());
}
try {
o.addProperty("icon", BuiltInRegistries.ITEM.getKey(tab.getIconItem().getItem()).toString());
} catch (RuntimeException ignored) {
}
o.add("items", items);
out.add(o);
}
Files.writeString(Path.of(args[0]), new Gson().toJson(out), StandardCharsets.UTF_8);
}
}
+42
View File
@@ -293,6 +293,21 @@ def main():
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaEntityModelExporter', str(entity_models)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
creative = root / 'creative-tabs.json'
creative_oracle = oracle.with_name('VanillaCreativeTabsExporter.java')
creative_sources = base.source_hashes([creative_oracle])
if not (previous.get('creative_exporters_sha256') == creative_sources and creative.exists()
and previous.get('server_sha256') == origin['server_sha256']):
classes = lab.LOCAL / 'creative-tabs' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'creative-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(creative_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaCreativeTabsExporter', str(creative)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
recover_creative_tabs(creative, root)
lab.write_json(manifest, {'schema': 7, **origin,
'health_exporters_sha256': health_sources,
'health_files_sha256': {name: lab.digest(root/name, 'sha256') for name in health_files},
@@ -305,6 +320,7 @@ def main():
'model_state_exporters_sha256': binding_sources,
'gameplay_exporters_sha256': gameplay_sources,
'entity_model_exporters_sha256': entity_sources,
'creative_exporters_sha256': creative_sources,
'behaviour_exporters_sha256': behaviour_sources,
'model_states_sha256': lab.digest(model_states, 'sha256'), 'data_version': version['world_version'],
'facts_sha256': lab.digest(facts, 'sha256'),
@@ -312,5 +328,31 @@ def main():
print(f'Prepared Horizon native-client resources: {root}')
def recover_creative_tabs(path, root):
"""Tabs whose generators need dynamic registries (banner patterns) fail in
the bare bootstrap; recover their item order from the decompiled source."""
import re
tabs = json.loads(path.read_text())
source = lab.LOCAL / 'decompiled/net/minecraft/world/item/CreativeModeTabs.java'
if not source.exists():
return
items = json.loads((root / 'items.json').read_text())
text = source.read_text()
for tab in tabs:
if tab['items'] or tab['type'] != 'CATEGORY':
continue
name = tab['id'].split(':')[1].upper()
start = text.find(f'{name},')
end = text.find('Registry.register(', start + 1)
found = []
for m in re.finditer(r'\b(Items|Blocks)\.([A-Z0-9_]+)(?:\.(\w+)\(\))?', text[start:end]):
base, colour = m.group(2).lower(), m.group(3)
item = 'minecraft:' + (f'{colour}_{base}' if colour and colour not in ('asItem', 'defaultBlockState', 'get') else base)
if item in items and item not in found:
found.append(item)
tab['items'] = found
path.write_text(json.dumps(tabs))
if __name__ == '__main__':
main()