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:
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user