Merge main into #1268: keep the End shortcut around the cached surface pass
#1264 wrapped build_surface in `if !self.identity_end_surface(pos)` where this branch adds the uniform_biomes field to the same SurfaceQueries. Kept the condition with the new field inside it; both tests are kept. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -1,7 +1,7 @@
|
||||
//! Firework tooltip companion for tools/test_firework_tooltip_parity.py: the
|
||||
//! lines `item_tooltip::firework_lines` gives each stack (SNBT, one per line;
|
||||
//! the `#resources` line names the prepared resources for en_us).
|
||||
use horizon_client::{item_data::parse_stack, item_tooltip::firework_lines, lang::Language};
|
||||
use horizon_client::{enchant::Enchantments, item_data::parse_stack, item_tooltip::firework_lines};
|
||||
use std::{error::Error, fmt::Write, path::PathBuf};
|
||||
|
||||
fn main() -> Result<(), Box<dyn Error>> {
|
||||
@@ -12,8 +12,9 @@ fn main() -> Result<(), Box<dyn Error>> {
|
||||
.find_map(|l| l.strip_prefix("#resources "))
|
||||
.map(PathBuf::from)
|
||||
.ok_or("no #resources line")?;
|
||||
let language = Language::load(&[&root], "en_us");
|
||||
let translate = |key: &str| language.get(key).map(str::to_owned);
|
||||
// Use the inventory's filtered translations so missing tooltip keys are caught.
|
||||
let enchantments = Enchantments::load(&root);
|
||||
let translate = |key: &str| enchantments.translate(key).map(str::to_owned);
|
||||
let mut output = String::new();
|
||||
for line in input.lines().filter(|l| !l.starts_with('#')) {
|
||||
let stack = parse_stack(line)?.ok_or("empty stack")?;
|
||||
|
||||
@@ -14,13 +14,22 @@ fn main() {
|
||||
for count in [0, 1, 4, 64] {
|
||||
let mut slot = Some(ItemStack::new("minecraft:stone", count));
|
||||
let mut dropped = 0;
|
||||
let mut swings = 0;
|
||||
let mut packets = 0;
|
||||
for _ in 0..2 {
|
||||
if let Some(stack) =
|
||||
take_held_drop(&mut slot, all, mode == GameMode::Spectator)
|
||||
{
|
||||
dropped += stack.count;
|
||||
swings += 1;
|
||||
}
|
||||
println!("{} {}", slot.as_ref().map_or(0, |s| s.count), dropped);
|
||||
if mode != GameMode::Spectator {
|
||||
packets += 1;
|
||||
}
|
||||
println!(
|
||||
"{} {dropped} {swings} {packets}",
|
||||
slot.as_ref().map_or(0, |s| s.count),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
//! what the render thread pays for it in `Streaming::update`.
|
||||
//!
|
||||
//! streaming_bench RESOURCES [--threads N] [--radius R] [--seed S] [--fly CHUNKS_PER_S] [--seconds T] [--hz F]
|
||||
//! [--dimension overworld|the_nether|the_end] [--center-x X] [--center-z Z]
|
||||
//!
|
||||
//! First the area around (0, 0) fills; then, with `--fly`, the centre moves along +x
|
||||
//! at that speed for T seconds while frames run at F per second. Each phase reports
|
||||
@@ -72,14 +73,33 @@ static ALLOCATOR: CountingAllocator = CountingAllocator;
|
||||
|
||||
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
|
||||
|
||||
fn cpu_seconds() -> f64 {
|
||||
std::fs::read_to_string("/proc/self/stat")
|
||||
.ok()
|
||||
.and_then(|stat| {
|
||||
let fields = stat
|
||||
.rsplit_once(')')?
|
||||
.1
|
||||
.split_whitespace()
|
||||
.collect::<Vec<_>>();
|
||||
Some((fields[11].parse::<f64>().ok()? + fields[12].parse::<f64>().ok()?) / 100.0)
|
||||
})
|
||||
.unwrap_or(0.0)
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Phase {
|
||||
updates: Vec<f64>,
|
||||
local: (u64, u64),
|
||||
uploads: usize,
|
||||
stage_samples: [u64; 7],
|
||||
cpu_start: f64,
|
||||
}
|
||||
impl Phase {
|
||||
fn update(&mut self, streaming: &mut Streaming, world: &mut World) {
|
||||
if self.updates.is_empty() {
|
||||
self.cpu_start = cpu_seconds();
|
||||
}
|
||||
let before = LOCAL.with(Cell::get);
|
||||
let started = Instant::now();
|
||||
let (uploads, _) = streaming.update(world);
|
||||
@@ -89,6 +109,9 @@ impl Phase {
|
||||
self.local.1 += after.1 - before.1;
|
||||
self.uploads += uploads.len();
|
||||
drop(uploads);
|
||||
for (sum, (_, count)) in self.stage_samples.iter_mut().zip(streaming.stages()) {
|
||||
*sum += count as u64;
|
||||
}
|
||||
}
|
||||
fn report(&self, name: &str, wall: Duration, streaming: &Streaming, generated: u64) {
|
||||
let mut sorted = self.updates.clone();
|
||||
@@ -106,6 +129,16 @@ impl Phase {
|
||||
at(0.99),
|
||||
sorted.last().copied().unwrap_or(0.0),
|
||||
);
|
||||
println!(
|
||||
"BENCH {}",
|
||||
serde_json::json!({
|
||||
"phase": name, "wall_s": wall.as_secs_f64(),
|
||||
"cpu_s": cpu_seconds() - self.cpu_start,
|
||||
"chunks": streaming.generated_total - generated, "sections": self.uploads,
|
||||
"updates": self.updates.len(), "update_ms": total,
|
||||
"mean_stages": self.stage_samples.map(|n| n as f64 / self.updates.len() as f64),
|
||||
})
|
||||
);
|
||||
if TRACK {
|
||||
println!(
|
||||
" update allocations: {} ({:.1} MiB)",
|
||||
@@ -142,6 +175,22 @@ fn main() -> Result<()> {
|
||||
let fly = flag("--fly", 0.0);
|
||||
let seconds = flag("--seconds", 10.0);
|
||||
let hz = flag("--hz", 240.0);
|
||||
let dimension = args
|
||||
.iter()
|
||||
.position(|a| a == "--dimension")
|
||||
.and_then(|i| args.get(i + 1))
|
||||
.map(|d| {
|
||||
if d.contains(':') {
|
||||
d.clone()
|
||||
} else {
|
||||
format!("minecraft:{d}")
|
||||
}
|
||||
})
|
||||
.unwrap_or_else(|| "minecraft:overworld".into());
|
||||
let center = (
|
||||
flag("--center-x", 0.0) as i32,
|
||||
flag("--center-z", 0.0) as i32,
|
||||
);
|
||||
|
||||
let assets = Arc::new(Assets::load(&root)?);
|
||||
let render = Arc::new(assets.reload(&root)?);
|
||||
@@ -154,11 +203,12 @@ fn main() -> Result<()> {
|
||||
models::load_visibility(&root, assets.registry)?,
|
||||
)?);
|
||||
let light = Arc::new(LightTables::load(&root, assets.registry, &facts)?);
|
||||
let terrain = Arc::new(VanillaTerrain::new(
|
||||
let terrain = Arc::new(VanillaTerrain::for_dimension(
|
||||
&root.join("worldgen"),
|
||||
assets.registry,
|
||||
&biomes,
|
||||
seed,
|
||||
&dimension,
|
||||
)?);
|
||||
let context = Arc::new(WorkerContext {
|
||||
assets,
|
||||
@@ -170,8 +220,12 @@ fn main() -> Result<()> {
|
||||
let mut world = World::new(facts.air, seed);
|
||||
let mut streaming = Streaming::new(terrain, context, threads);
|
||||
streaming.radius = radius;
|
||||
streaming.center = (0, 0);
|
||||
println!("{threads} workers, radius {radius}, seed {seed}");
|
||||
streaming.center = center;
|
||||
streaming.nether_shading = dimension == "minecraft:the_nether";
|
||||
streaming.sky_light = dimension != "minecraft:the_nether";
|
||||
println!(
|
||||
"{threads} workers, radius {radius}, seed {seed}, dimension {dimension}, center {center:?}"
|
||||
);
|
||||
let (allocations, bytes) = (ALLOCATIONS.load(Relaxed), BYTES.load(Relaxed));
|
||||
|
||||
// Fill: update as often as the game would uncapped, until settled.
|
||||
@@ -198,12 +252,12 @@ fn main() -> Result<()> {
|
||||
let mut behind = Vec::new();
|
||||
while started.elapsed().as_secs_f64() < seconds {
|
||||
let next = Instant::now() + frame;
|
||||
let x = (started.elapsed().as_secs_f64() * fly) as i32;
|
||||
streaming.center = (x, 0);
|
||||
let x = center.0 + (started.elapsed().as_secs_f64() * fly) as i32;
|
||||
streaming.center = (x, center.1);
|
||||
phase.update(&mut streaming, &mut world);
|
||||
// Columns within 2 chunks of the player still missing their meshes.
|
||||
let near = (-2..=2)
|
||||
.flat_map(|dz| (-2..=2).map(move |dx| (x + dx, dz)))
|
||||
.flat_map(|dz| (-2..=2).map(move |dx| (x + dx, center.1 + dz)))
|
||||
.filter(|&(cx, cz)| !streaming.is_lit(cx, cz))
|
||||
.count();
|
||||
behind.push(near);
|
||||
|
||||
@@ -193,6 +193,8 @@ impl Enchantments {
|
||||
|| k.starts_with("item.minecraft.splash_potion")
|
||||
|| k.starts_with("item.minecraft.lingering_potion")
|
||||
|| k.starts_with("item.minecraft.tipped_arrow")
|
||||
|| k.starts_with("item.minecraft.firework_rocket.")
|
||||
|| k.starts_with("item.minecraft.firework_star.")
|
||||
|| k.starts_with("trim_")
|
||||
|| k.starts_with("potion.")
|
||||
|| k.starts_with("container.")
|
||||
|
||||
@@ -4849,6 +4849,9 @@ impl Game<'_> {
|
||||
self.draw_chat(&mut batch);
|
||||
self.draw_tab_list(&mut batch);
|
||||
}
|
||||
// Screen.extractBlurredBackground blurs the world and HUD, while the
|
||||
// screen's background, widgets, toasts and debug overlay stay sharp.
|
||||
batch.blur_at = batch.vertices.len() as u32;
|
||||
match self.screen {
|
||||
Screen::Paused if self.pause_menu => self.draw_pause_menu(&mut batch),
|
||||
// PauseScreen(false): only its title, at the top.
|
||||
@@ -10018,9 +10021,8 @@ impl Game<'_> {
|
||||
};
|
||||
level_loading::draw(batch, atlas, Some(&status), Some(self.loading_progress));
|
||||
}
|
||||
/// `Screen.extractBlurredBackground` over the panorama: every classic
|
||||
/// screen of the title menus but the title itself (`TitleScreen`
|
||||
/// doesn't blur), when `menuBackgroundBlurriness` is at least 1.
|
||||
/// `Screen.extractBlurredBackground` over the panorama or the world and
|
||||
/// HUD, when `menuBackgroundBlurriness` is at least 1.
|
||||
fn menu_blur(&self) -> Option<f32> {
|
||||
let loading = self.loading_reason() == Some(horizon_client::level_loading::Reason::Other);
|
||||
let blurred = !horizon_client::ui_theme::horizon()
|
||||
@@ -10028,7 +10030,10 @@ impl Game<'_> {
|
||||
|| self.title.as_ref().is_some_and(|t| {
|
||||
self.screen == Screen::Options
|
||||
|| !matches!(t.mode, horizon_client::title::Mode::Main)
|
||||
}));
|
||||
})
|
||||
|| (self.title.is_none()
|
||||
&& self.player.is_some()
|
||||
&& self.screen.blurs_background(self.pause_menu)));
|
||||
let radius = self.settings.menu_blur as f32;
|
||||
(blurred && radius >= 1.0).then_some(radius)
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
//! client predicts its own movement; the server stays authoritative for
|
||||
//! everything else.
|
||||
use super::{Dim, Game, Mining, Screen};
|
||||
use horizon_client::first_person::Hand;
|
||||
use horizon_client::first_person::{Hand, SwingAnimation};
|
||||
use horizon_client::{
|
||||
Result,
|
||||
chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy},
|
||||
@@ -332,6 +332,11 @@ impl Game<'_> {
|
||||
progress: 0.0,
|
||||
total: 0,
|
||||
};
|
||||
// The connected client never opens a server world (single player also
|
||||
// joins here), so load the registries its argument parsers and local
|
||||
// suggestions need before receiving the server's command tree.
|
||||
self.ui.registries = Default::default();
|
||||
self.build_registries();
|
||||
self.ui.registries.permission = 0;
|
||||
self.ui.chat.clear();
|
||||
self.screen = Screen::Playing;
|
||||
@@ -3458,10 +3463,8 @@ impl Game<'_> {
|
||||
sequence: seq,
|
||||
}));
|
||||
if progress >= 1.0 {
|
||||
// startDestroyBlock: instant survival breaks have no destroy delay.
|
||||
self.predict_break(hit.pos, state, seq);
|
||||
if let Some(r) = self.remote.as_mut() {
|
||||
r.destroy_delay = 5;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if let Some(r) = self.remote.as_mut() {
|
||||
@@ -3638,7 +3641,15 @@ impl Game<'_> {
|
||||
self.predict_use(&changes, seq);
|
||||
}
|
||||
if held_block {
|
||||
self.with_hand(hand, Game::swing_arm);
|
||||
if reacts
|
||||
|| held
|
||||
.as_ref()
|
||||
.is_some_and(|stack| self.remote_can_place(&hit, stack))
|
||||
{
|
||||
self.with_hand(hand, Game::swing_arm);
|
||||
}
|
||||
// BlockItem.place returns FAIL when placement is rejected:
|
||||
// stop this click without trying the item or the other hand.
|
||||
return true;
|
||||
}
|
||||
return reacts;
|
||||
@@ -3696,7 +3707,11 @@ impl Game<'_> {
|
||||
/// container, and the blocks it changed. Vanilla's client runs it on its
|
||||
/// own level first; this runs it on a copy, and `predict_use` keeps the
|
||||
/// changes it predicts.
|
||||
fn remote_block_reacts(&self, hit: &super::Hit, held: Option<&ItemStack>) -> (bool, DryUse) {
|
||||
fn remote_block_reacts(
|
||||
&mut self,
|
||||
hit: &super::Hit,
|
||||
held: Option<&ItemStack>,
|
||||
) -> (bool, DryUse) {
|
||||
// Player.isSecondaryUseActive with something in either hand.
|
||||
let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
|
||||
if self.keys.contains(&KeyCode::ShiftLeft) && hands_full {
|
||||
@@ -3711,26 +3726,53 @@ impl Game<'_> {
|
||||
[-1, 0, 0] => Direction::West,
|
||||
_ => Direction::East,
|
||||
};
|
||||
let mut level = DryLevel {
|
||||
world: &self.world,
|
||||
changed: HashMap::new(),
|
||||
random: horizon_core::random::LegacyRandom::new(0),
|
||||
sounds: Vec::new(),
|
||||
let player = self.use_context();
|
||||
self.with_level(|b, level, _| {
|
||||
let mut level = DryLevel::new(level);
|
||||
let reacts = b
|
||||
.use_item_on(
|
||||
&mut level,
|
||||
&mut horizon_world::level::Ticks::default(),
|
||||
horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
|
||||
face,
|
||||
horizon_core::geometry::Vec3::new(hit.point[0], hit.point[1], hit.point[2]),
|
||||
player,
|
||||
held.map(|s| &*s.item),
|
||||
)
|
||||
.consumes_action();
|
||||
(reacts, (level.changed.into_iter().collect(), level.sounds))
|
||||
})
|
||||
}
|
||||
|
||||
/// Run BlockItem.place on a disposable level before predicting its swing.
|
||||
/// The real level supplies collision shapes and building-blocking entities;
|
||||
/// block writes, random draws, scheduled ticks and events stay in the preview.
|
||||
fn remote_can_place(&mut self, hit: &super::Hit, stack: &ItemStack) -> bool {
|
||||
if !self.may_build() {
|
||||
return false;
|
||||
}
|
||||
let ctx = horizon_world::level::PlaceContext {
|
||||
clicked_pos: horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
|
||||
face: horizon_core::geometry::Direction::ALL[face_direction(hit.face) as usize],
|
||||
hit: Vec3::new(hit.point[0], hit.point[1], hit.point[2]),
|
||||
inside: hit.face == [0; 3],
|
||||
yaw: self.yaw,
|
||||
pitch: self.pitch,
|
||||
sneaking: self.keys.contains(&KeyCode::ShiftLeft),
|
||||
item: stack.item.to_string(),
|
||||
can_use_game_master_blocks: self.can_use_game_master_blocks(),
|
||||
};
|
||||
let reacts = self
|
||||
.res
|
||||
.behaviours()
|
||||
.use_item_on(
|
||||
&mut level,
|
||||
&mut horizon_world::level::Ticks::default(),
|
||||
horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
|
||||
face,
|
||||
horizon_core::geometry::Vec3::new(hit.point[0], hit.point[1], hit.point[2]),
|
||||
self.use_context(),
|
||||
held.map(|s| &*s.item),
|
||||
self.with_level(|b, level, _| {
|
||||
let mut level = DryLevel::new(level);
|
||||
matches!(
|
||||
b.place_block(
|
||||
&mut level,
|
||||
&mut horizon_world::level::Ticks::default(),
|
||||
&ctx
|
||||
),
|
||||
horizon_world::level::PlaceOutcome::Placed { .. }
|
||||
)
|
||||
.consumes_action();
|
||||
(reacts, (level.changed.into_iter().collect(), level.sounds))
|
||||
})
|
||||
}
|
||||
|
||||
/// MultiPlayerGameMode.useItem for `hand`, if it holds something: whether
|
||||
@@ -3985,23 +4027,26 @@ impl Game<'_> {
|
||||
Ok(true)
|
||||
}
|
||||
KeyCode::KeyQ => {
|
||||
if self.spectator() {
|
||||
return Ok(true);
|
||||
}
|
||||
let all = self.keys.contains(&KeyCode::ControlLeft);
|
||||
// MultiPlayerGameMode.dropItem: predict removal before sending
|
||||
// the action, then swing only if a nonempty stack was removed.
|
||||
let dropped = horizon_client::items::take_held_drop(
|
||||
&mut self.inventory[self.selected],
|
||||
all,
|
||||
false,
|
||||
);
|
||||
self.send(S::PlayerAction(play::PlayerAction {
|
||||
action: if all { 4 } else { 5 },
|
||||
pos: [0; 3],
|
||||
direction: 0,
|
||||
sequence: 0,
|
||||
}));
|
||||
// Inventory.removeFromSelected (prediction).
|
||||
let slot = &mut self.inventory[self.selected];
|
||||
if let Some(s) = slot {
|
||||
if all || s.count <= 1 {
|
||||
*slot = None;
|
||||
} else {
|
||||
s.count -= 1;
|
||||
}
|
||||
if dropped.is_some() {
|
||||
self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
|
||||
}
|
||||
self.swing_arm();
|
||||
Ok(true)
|
||||
}
|
||||
KeyCode::KeyE => {
|
||||
@@ -4678,7 +4723,7 @@ pub(super) fn input_ordinal(input: Input) -> i32 {
|
||||
/// The client's world for a guess at what a click does: reads go to the
|
||||
/// world, writes stay here and are dropped.
|
||||
struct DryLevel<'w> {
|
||||
world: &'w horizon_client::world::World,
|
||||
base: &'w dyn horizon_world::level::LevelAccess,
|
||||
changed: HashMap<horizon_core::position::BlockPos, BlockStateId>,
|
||||
random: horizon_core::random::LegacyRandom,
|
||||
/// The sounds the use plays (a door's creak).
|
||||
@@ -4708,6 +4753,17 @@ pub(super) fn hand_operated(name: &str) -> bool {
|
||||
|| name == "lever"
|
||||
}
|
||||
|
||||
impl<'w> DryLevel<'w> {
|
||||
fn new(base: &'w dyn horizon_world::level::LevelAccess) -> Self {
|
||||
Self {
|
||||
base,
|
||||
changed: HashMap::new(),
|
||||
random: horizon_core::random::LegacyRandom::new(0),
|
||||
sounds: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl horizon_world::level::LevelAccess for DryLevel<'_> {
|
||||
fn emit(&mut self, event: horizon_world::level::LevelEvent) {
|
||||
if let horizon_world::level::LevelEvent::Sound {
|
||||
@@ -4724,7 +4780,7 @@ impl horizon_world::level::LevelAccess for DryLevel<'_> {
|
||||
self.changed
|
||||
.get(&pos)
|
||||
.copied()
|
||||
.unwrap_or_else(|| self.world.block(pos.x, pos.y, pos.z))
|
||||
.unwrap_or_else(|| self.base.block_state(pos))
|
||||
}
|
||||
fn set_raw(
|
||||
&mut self,
|
||||
@@ -4736,13 +4792,31 @@ impl horizon_world::level::LevelAccess for DryLevel<'_> {
|
||||
Some(previous)
|
||||
}
|
||||
fn is_loaded(&self, pos: horizon_core::position::BlockPos) -> bool {
|
||||
self.world.loaded(pos.x, pos.z)
|
||||
self.base.is_loaded(pos)
|
||||
}
|
||||
fn min_y(&self) -> i32 {
|
||||
self.base.min_y()
|
||||
}
|
||||
fn max_y(&self) -> i32 {
|
||||
self.base.max_y()
|
||||
}
|
||||
fn block_light(&self, pos: horizon_core::position::BlockPos) -> i32 {
|
||||
self.base.block_light(pos)
|
||||
}
|
||||
fn sky_light(&self, pos: horizon_core::position::BlockPos) -> i32 {
|
||||
self.base.sky_light(pos)
|
||||
}
|
||||
fn sky_darken(&self) -> i32 {
|
||||
self.base.sky_darken()
|
||||
}
|
||||
fn is_unobstructed(&self, pos: horizon_core::position::BlockPos, state: BlockStateId) -> bool {
|
||||
self.base.is_unobstructed(pos, state)
|
||||
}
|
||||
fn random(&mut self) -> &mut horizon_core::random::LegacyRandom {
|
||||
&mut self.random
|
||||
}
|
||||
fn game_time(&self) -> i64 {
|
||||
self.world.game_time
|
||||
self.base.game_time()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4858,6 +4932,110 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_
|
||||
mod tests {
|
||||
use super::Game;
|
||||
|
||||
#[test]
|
||||
fn placement_preview_checks_obstruction_without_changing_the_level() {
|
||||
use super::DryLevel;
|
||||
use horizon_core::{position::BlockPos, random::LegacyRandom};
|
||||
use horizon_world::{
|
||||
level::{
|
||||
Behaviours, LevelAccess, PlaceContext, PlaceOutcome, Ticks, data::load_registry,
|
||||
},
|
||||
registry::BlockStateId,
|
||||
};
|
||||
|
||||
struct Level {
|
||||
air: BlockStateId,
|
||||
stone: BlockStateId,
|
||||
obstructed: bool,
|
||||
loaded: bool,
|
||||
ceiling: i32,
|
||||
}
|
||||
impl LevelAccess for Level {
|
||||
fn block_state(&self, pos: BlockPos) -> BlockStateId {
|
||||
if pos == BlockPos::new(0, 0, 0) {
|
||||
self.stone
|
||||
} else {
|
||||
self.air
|
||||
}
|
||||
}
|
||||
fn set_raw(&mut self, _: BlockPos, _: BlockStateId) -> Option<BlockStateId> {
|
||||
panic!("preview must not write to the live level");
|
||||
}
|
||||
fn is_loaded(&self, _: BlockPos) -> bool {
|
||||
self.loaded
|
||||
}
|
||||
fn max_y(&self) -> i32 {
|
||||
self.ceiling
|
||||
}
|
||||
fn is_unobstructed(&self, pos: BlockPos, _: BlockStateId) -> bool {
|
||||
assert_eq!(pos, BlockPos::new(0, 1, 0));
|
||||
!self.obstructed
|
||||
}
|
||||
fn random(&mut self) -> &mut LegacyRandom {
|
||||
panic!("preview must not advance the live level's random source");
|
||||
}
|
||||
fn game_time(&self) -> i64 {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
// As with the LAN tests, prepared game resources are optional locally.
|
||||
let resources = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../.local/horizon-client")
|
||||
.join(horizon_core::VANILLA_VERSION);
|
||||
if !resources.join("block-behaviours.json").exists() {
|
||||
return;
|
||||
}
|
||||
let registry = load_registry(&resources).unwrap();
|
||||
let behaviours = Behaviours::load(®istry, &resources).unwrap();
|
||||
let mut base = Level {
|
||||
air: registry.default_state("minecraft:air").unwrap(),
|
||||
stone: registry.default_state("minecraft:stone").unwrap(),
|
||||
obstructed: false,
|
||||
loaded: true,
|
||||
ceiling: 320,
|
||||
};
|
||||
for item in [
|
||||
"minecraft:stone",
|
||||
"minecraft:oak_slab",
|
||||
"minecraft:oak_door",
|
||||
// GrowingPlantHeadBlock.getStateForPlacement draws a random age.
|
||||
"minecraft:twisting_vines",
|
||||
] {
|
||||
let ctx = PlaceContext {
|
||||
clicked_pos: BlockPos::new(0, 0, 0),
|
||||
face: horizon_core::geometry::Direction::Up,
|
||||
hit: horizon_core::geometry::Vec3::new(0.5, 1.0, 0.5),
|
||||
inside: false,
|
||||
yaw: 0.0,
|
||||
pitch: 45.0,
|
||||
sneaking: false,
|
||||
item: item.into(),
|
||||
can_use_game_master_blocks: false,
|
||||
};
|
||||
for (obstructed, loaded, ceiling) in [
|
||||
(false, true, 320),
|
||||
(true, true, 320),
|
||||
(false, false, 320),
|
||||
(false, true, 1),
|
||||
] {
|
||||
base.obstructed = obstructed;
|
||||
base.loaded = loaded;
|
||||
base.ceiling = ceiling;
|
||||
let valid = !obstructed && loaded && ceiling > 1;
|
||||
let mut preview = DryLevel::new(&base);
|
||||
let outcome = behaviours.place_block(&mut preview, &mut Ticks::default(), &ctx);
|
||||
assert_eq!(
|
||||
matches!(outcome, PlaceOutcome::Placed { .. }),
|
||||
valid,
|
||||
"{item}, obstructed={obstructed}, loaded={loaded}, ceiling={ceiling}"
|
||||
);
|
||||
assert_eq!(preview.changed.is_empty(), !valid);
|
||||
assert_eq!(base.block_state(BlockPos::new(0, 1, 0)), base.air);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_inventory_menu_slot_is_a_game_slot_and_45_is_the_off_hand() {
|
||||
// InventoryMenu: result, 2x2 grid, armour, 27 + 9 inventory slots, then the off hand.
|
||||
|
||||
@@ -7,6 +7,24 @@ use horizon_client::{
|
||||
ui,
|
||||
};
|
||||
|
||||
impl Screen {
|
||||
/// Screen.extractBackground for non-isInGameUi screens, and
|
||||
/// PauseScreen.extractBackground only when showPauseMenu is true.
|
||||
pub(super) fn blurs_background(self, pause_menu: bool) -> bool {
|
||||
match self {
|
||||
Self::Paused => pause_menu,
|
||||
Self::Options | Self::Stats | Self::Advancements | Self::WorldOptions => true,
|
||||
Self::Playing
|
||||
| Self::GameModeSwitcher
|
||||
| Self::Chat
|
||||
| Self::Creative
|
||||
| Self::Inventory
|
||||
| Self::Dead
|
||||
| Self::CommandBlock => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// PauseScreen buttons: (x, y, width, label key, action id, active).
|
||||
/// https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/PauseScreen
|
||||
fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static str, u8, bool)> {
|
||||
@@ -334,7 +352,34 @@ impl Game<'_> {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::pause_buttons;
|
||||
use super::{Screen, pause_buttons};
|
||||
|
||||
#[test]
|
||||
fn menu_blur_matches_vanilla_screen_backgrounds() {
|
||||
for screen in [
|
||||
Screen::Options,
|
||||
Screen::Stats,
|
||||
Screen::Advancements,
|
||||
Screen::WorldOptions,
|
||||
] {
|
||||
assert!(screen.blurs_background(false));
|
||||
assert!(screen.blurs_background(true));
|
||||
}
|
||||
assert!(Screen::Paused.blurs_background(true));
|
||||
assert!(!Screen::Paused.blurs_background(false));
|
||||
for screen in [
|
||||
Screen::Playing,
|
||||
Screen::GameModeSwitcher,
|
||||
Screen::Chat,
|
||||
Screen::Creative,
|
||||
Screen::Inventory,
|
||||
Screen::Dead,
|
||||
Screen::CommandBlock,
|
||||
] {
|
||||
assert!(!screen.blurs_background(true));
|
||||
assert!(!screen.blurs_background(false));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pause_menu_uses_disconnect_for_servers_and_keeps_world_options() {
|
||||
|
||||
@@ -3841,9 +3841,19 @@ impl Renderer {
|
||||
let first = debug_depth + debug_top;
|
||||
pass.draw(0..4, first..first + crosshair);
|
||||
}
|
||||
if let Some(radius) = frame.menu_blur
|
||||
&& self.config.usage.contains(wgpu::TextureUsages::COPY_SRC)
|
||||
{
|
||||
let menu_blur = frame
|
||||
.menu_blur
|
||||
.filter(|_| self.config.usage.contains(wgpu::TextureUsages::COPY_SRC));
|
||||
let blur_at = menu_blur.map_or(0, |_| frame.hud.blur_at);
|
||||
self.hud.draw_range(
|
||||
&mut encoder,
|
||||
&view_target,
|
||||
&self.depth,
|
||||
frame.hud,
|
||||
[self.config.width, self.config.height],
|
||||
0..blur_at,
|
||||
);
|
||||
if let Some(radius) = menu_blur {
|
||||
let format = self.config.format;
|
||||
let device = &self.device;
|
||||
self.menu_blur
|
||||
@@ -3875,12 +3885,13 @@ impl Renderer {
|
||||
grade,
|
||||
);
|
||||
}
|
||||
self.hud.draw(
|
||||
self.hud.draw_range(
|
||||
&mut encoder,
|
||||
&view_target,
|
||||
&self.depth,
|
||||
frame.hud,
|
||||
[self.config.width, self.config.height],
|
||||
blur_at..frame.hud.vertices.len() as u32,
|
||||
);
|
||||
if culling && let Some(cull) = &mut self.cull {
|
||||
cull.end(&self.device, &mut encoder);
|
||||
|
||||
@@ -365,6 +365,8 @@ pub struct HudBatch {
|
||||
pub patches: Vec<crate::font::Patch>,
|
||||
/// Vertex ranges with another blend or depth/scissor state, in order.
|
||||
pub blends: Vec<(std::ops::Range<u32>, Blend)>,
|
||||
/// Screen's first vertex: the preceding HUD is part of its blurred background.
|
||||
pub blur_at: u32,
|
||||
}
|
||||
/// How a run of HUD vertices blends and tests depth.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
||||
@@ -400,6 +402,7 @@ impl HudBatch {
|
||||
height: (window[1] as f32 / scale as f32).ceil(),
|
||||
patches: Vec::new(),
|
||||
blends: Vec::new(),
|
||||
blur_at: 0,
|
||||
}
|
||||
}
|
||||
/// Draw the vertices added since `start` with the inverting blend.
|
||||
@@ -452,6 +455,14 @@ impl HudBatch {
|
||||
}
|
||||
out
|
||||
}
|
||||
fn runs_in(&self, vertices: std::ops::Range<u32>) -> Vec<(std::ops::Range<u32>, Blend)> {
|
||||
let mut runs = self.runs();
|
||||
for (range, _) in &mut runs {
|
||||
*range = range.start.max(vertices.start)..range.end.min(vertices.end);
|
||||
}
|
||||
runs.retain(|(range, _)| !range.is_empty());
|
||||
runs
|
||||
}
|
||||
/// `AbstractContainerScreen.init`: center in integer GUI coordinates.
|
||||
pub fn centered_origin(&self, width: f32, height: f32) -> (f32, f32) {
|
||||
(
|
||||
@@ -1080,7 +1091,26 @@ impl HudRenderer {
|
||||
batch: &HudBatch,
|
||||
size: [u32; 2],
|
||||
) {
|
||||
if batch.vertices.is_empty() || size.contains(&0) {
|
||||
self.draw_range(
|
||||
encoder,
|
||||
target,
|
||||
depth,
|
||||
batch,
|
||||
size,
|
||||
0..batch.vertices.len() as u32,
|
||||
);
|
||||
}
|
||||
/// Draw part of the prepared batch, preserving its blend/depth runs.
|
||||
pub fn draw_range(
|
||||
&self,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
target: &wgpu::TextureView,
|
||||
depth: &wgpu::TextureView,
|
||||
batch: &HudBatch,
|
||||
size: [u32; 2],
|
||||
vertices: std::ops::Range<u32>,
|
||||
) {
|
||||
if vertices.is_empty() || size.contains(&0) {
|
||||
return;
|
||||
}
|
||||
let attachments = [Some(wgpu::RenderPassColorAttachment {
|
||||
@@ -1092,7 +1122,7 @@ impl HudRenderer {
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})];
|
||||
let runs = batch.runs();
|
||||
let runs = batch.runs_in(vertices);
|
||||
let mut at = 0;
|
||||
while at < runs.len() {
|
||||
let clip = match runs[at].1 {
|
||||
@@ -1331,6 +1361,33 @@ mod tests {
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blur_boundary_splits_blend_runs_without_losing_or_repeating_vertices() {
|
||||
let mut batch = HudBatch::new([854, 480]);
|
||||
for _ in 0..5 {
|
||||
batch.quad([[0.0; 2]; 4], [[0.0; 2]; 4], 0);
|
||||
}
|
||||
batch.blends = vec![
|
||||
(6..18, Blend::Invert),
|
||||
(18..24, Blend::Depth([0, 0, 10, 10])),
|
||||
];
|
||||
for split in [0, 6, 12, 18, 24, 30] {
|
||||
let before = batch.runs_in(0..split);
|
||||
let after = batch.runs_in(split..30);
|
||||
let actual: Vec<_> = before
|
||||
.into_iter()
|
||||
.chain(after)
|
||||
.flat_map(|(range, blend)| range.map(move |v| (v, blend)))
|
||||
.collect();
|
||||
let expected: Vec<_> = batch
|
||||
.runs()
|
||||
.into_iter()
|
||||
.flat_map(|(range, blend)| range.map(move |v| (v, blend)))
|
||||
.collect();
|
||||
assert_eq!(actual, expected, "blur at {split}");
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn container_origins_use_java_integer_division() {
|
||||
// Odd scaled dimensions, odd image sizes and an oversized panel.
|
||||
@@ -1342,6 +1399,7 @@ mod tests {
|
||||
height: height as f32,
|
||||
patches: Vec::new(),
|
||||
blends: Vec::new(),
|
||||
blur_at: 0,
|
||||
};
|
||||
for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] {
|
||||
assert_eq!(
|
||||
|
||||
@@ -609,6 +609,65 @@ mod tests {
|
||||
assert!(container_lines(&ItemStack::new("minecraft:chest", 1), &name, &lang).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fireworks_use_loaded_tooltip_translations() {
|
||||
let root = std::env::temp_dir().join(format!(
|
||||
"horizon-firework-tooltip-language-{}-{}",
|
||||
std::process::id(),
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_nanos(),
|
||||
));
|
||||
let dir = root.join("assets/minecraft/lang");
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(
|
||||
dir.join("en_us.json"),
|
||||
serde_json::to_vec(&serde_json::json!({
|
||||
"item.minecraft.firework_rocket.flight_duration": "Flight Duration: %s",
|
||||
"item.minecraft.firework_rocket.multiple_stars": "%s x %s",
|
||||
"item.minecraft.firework_star.shape.small_ball": "Small Ball",
|
||||
"item.minecraft.firework_star.red": "Red",
|
||||
"item.minecraft.firework_star.custom_color": "Custom",
|
||||
"item.minecraft.firework_star.fade_to": "Fade to",
|
||||
"item.minecraft.firework_star.trail": "Trail",
|
||||
"item.minecraft.firework_star.flicker": "Twinkle",
|
||||
}))
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
let enchantments = crate::enchant::Enchantments::load(&root);
|
||||
std::fs::remove_dir_all(&root).unwrap();
|
||||
let translate = |key: &str| enchantments.translate(key).map(str::to_owned);
|
||||
let mut rocket = ItemStack::new("minecraft:firework_rocket", 1);
|
||||
assert_eq!(firework_lines(&rocket, &translate), ["Flight Duration: 1"]);
|
||||
let explosion = crate::particles::FireworkExplosion {
|
||||
colors: vec![0xB3312C],
|
||||
fade: vec![0x123456],
|
||||
trail: true,
|
||||
twinkle: true,
|
||||
..Default::default()
|
||||
};
|
||||
rocket.data_mut().fireworks = Some((3, vec![explosion.clone(), explosion.clone()]));
|
||||
assert_eq!(
|
||||
firework_lines(&rocket, &translate),
|
||||
[
|
||||
"Flight Duration: 3",
|
||||
"2 x Small Ball",
|
||||
" Red",
|
||||
" Fade to Custom",
|
||||
" Trail",
|
||||
" Twinkle",
|
||||
]
|
||||
);
|
||||
let mut star = ItemStack::new("minecraft:firework_star", 1);
|
||||
star.data_mut().firework_explosion = Some(explosion);
|
||||
assert_eq!(
|
||||
firework_lines(&star, &translate),
|
||||
["Small Ball", "Red", "Fade to Custom", "Trail", "Twinkle"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn amounts_use_two_decimals_at_most() {
|
||||
assert_eq!(format_amount(8.0), "8");
|
||||
|
||||
@@ -1305,8 +1305,73 @@ pub fn load_light(tag: &Tag, chunk: &mut Chunk, sky_light: bool) {
|
||||
};
|
||||
layers[si as usize] = (layer("SkyLight"), layer("BlockLight"));
|
||||
}
|
||||
let above = [if sky_light { 15 } else { 0 }; 256];
|
||||
crate::light::light_from_layers(chunk, &layers, above, sky_light);
|
||||
// Uniform saved layers need no expanded allocation. Both nibbles of
|
||||
// each byte must match, not merely the bytes across the layer.
|
||||
let uniform_layer = |layer: &[u8]| {
|
||||
let first = layer[0];
|
||||
(first & 15 == first >> 4 && layer.iter().all(|&v| v == first)).then_some(first & 15)
|
||||
};
|
||||
let mut above = [if sky_light { 15 } else { 0 }; 256];
|
||||
for (si, (sky, block)) in layers.into_iter().enumerate().rev() {
|
||||
let sky = sky.filter(|_| sky_light);
|
||||
let sky_uniform = sky.map_or_else(
|
||||
|| above.iter().all(|&v| v == above[0]).then_some(above[0]),
|
||||
uniform_layer,
|
||||
);
|
||||
let block_uniform = block.map_or(Some(0), uniform_layer);
|
||||
let section = Arc::make_mut(&mut chunk.sections[si]);
|
||||
if let (Some(s), Some(b)) = (sky_uniform, block_uniform) {
|
||||
section.light = Light::Uniform(s << 4 | b);
|
||||
above.fill(s);
|
||||
} else {
|
||||
let mut data = Box::new([0u8; 4096]);
|
||||
match (sky, block) {
|
||||
(Some(sky), Some(block)) => {
|
||||
for ((pair, &s), &b) in
|
||||
data.as_chunks_mut::<2>().0.iter_mut().zip(sky).zip(block)
|
||||
{
|
||||
pair[0] = s << 4 | (b & 15);
|
||||
pair[1] = (s & 0xf0) | (b >> 4);
|
||||
}
|
||||
}
|
||||
(Some(sky), None) => {
|
||||
for (pair, &s) in data.as_chunks_mut::<2>().0.iter_mut().zip(sky) {
|
||||
pair[0] = s << 4;
|
||||
pair[1] = s & 0xf0;
|
||||
}
|
||||
}
|
||||
(None, Some(block)) => {
|
||||
for (i, (pair, &b)) in data
|
||||
.as_chunks_mut::<2>()
|
||||
.0
|
||||
.iter_mut()
|
||||
.zip(block)
|
||||
.enumerate()
|
||||
{
|
||||
pair[0] = above[(i * 2) & 255] << 4 | (b & 15);
|
||||
pair[1] = above[(i * 2 + 1) & 255] << 4 | (b >> 4);
|
||||
}
|
||||
}
|
||||
(None, None) => {
|
||||
for layer in data.as_chunks_mut::<256>().0 {
|
||||
for (v, &s) in layer.iter_mut().zip(&above) {
|
||||
*v = s << 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(sky) = sky {
|
||||
for (pair, &s) in above.as_chunks_mut::<2>().0.iter_mut().zip(sky) {
|
||||
pair[0] = s & 15;
|
||||
pair[1] = s >> 4;
|
||||
}
|
||||
}
|
||||
section.light = Light::Full(data);
|
||||
}
|
||||
section.compact();
|
||||
}
|
||||
chunk.lit = true;
|
||||
chunk.light_loaded = true;
|
||||
}
|
||||
|
||||
type RegionCache = Mutex<HashMap<(i32, i32), Option<Arc<Mutex<RegionFile>>>>>;
|
||||
@@ -3892,6 +3957,151 @@ mod tests {
|
||||
assert!(!unlit.lit && !unlit.light_loaded);
|
||||
}
|
||||
#[test]
|
||||
fn saved_light_matches_reference_for_layers_and_metadata() {
|
||||
fn reference(tag: &Tag, chunk: &mut Chunk, sky_light: bool) {
|
||||
if tag.get("isLightOn") != Some(&Tag::Byte(1)) {
|
||||
return;
|
||||
}
|
||||
let Some(Tag::List(sections)) = tag.get("sections") else {
|
||||
return;
|
||||
};
|
||||
let mut layers: Vec<(Option<&[u8]>, Option<&[u8]>)> = vec![(None, None); SECTIONS];
|
||||
for section in sections {
|
||||
let Some(y) = number(section.get("Y")) else {
|
||||
continue;
|
||||
};
|
||||
let si = y as i32 - (MIN_Y >> 4);
|
||||
if !(0..SECTIONS as i32).contains(&si) {
|
||||
continue;
|
||||
}
|
||||
let layer = |name: &str| match section.get(name) {
|
||||
Some(Tag::ByteArray(a)) if a.len() == 2048 => Some(&a[..]),
|
||||
_ => None,
|
||||
};
|
||||
layers[si as usize] = (layer("SkyLight"), layer("BlockLight"));
|
||||
}
|
||||
let above = [if sky_light { 15 } else { 0 }; 256];
|
||||
crate::light::light_from_layers(chunk, &layers, above, sky_light);
|
||||
}
|
||||
|
||||
let section = |y: Tag, sky: Option<Tag>, block: Option<Tag>| {
|
||||
let mut entries = vec![("Y", y)];
|
||||
if let Some(v) = sky {
|
||||
entries.push(("SkyLight", v));
|
||||
}
|
||||
if let Some(v) = block {
|
||||
entries.push(("BlockLight", v));
|
||||
}
|
||||
Tag::compound(entries)
|
||||
};
|
||||
let root = |sections| {
|
||||
Tag::compound([
|
||||
("isLightOn", Tag::Byte(1)),
|
||||
("sections", Tag::List(sections)),
|
||||
])
|
||||
};
|
||||
let check = |tag: &Tag| {
|
||||
for sky_light in [false, true] {
|
||||
let mut expected = Chunk::empty(-3, 5);
|
||||
let s = Arc::make_mut(&mut expected.sections[0]);
|
||||
s.light = Light::Full(Box::new([0xab; 4096]));
|
||||
s.blocks.set(0, 1);
|
||||
s.blocks.set(0, 0);
|
||||
s.biomes.set(0, 1);
|
||||
s.biomes.set(0, 0);
|
||||
let mut actual = expected.clone();
|
||||
reference(tag, &mut expected, sky_light);
|
||||
load_light(tag, &mut actual, sky_light);
|
||||
assert_eq!(
|
||||
(actual.lit, actual.light_loaded),
|
||||
(expected.lit, expected.light_loaded)
|
||||
);
|
||||
for (a, b) in actual.sections.iter().zip(&expected.sections) {
|
||||
assert_eq!(
|
||||
std::mem::discriminant(&a.light),
|
||||
std::mem::discriminant(&b.light)
|
||||
);
|
||||
assert_eq!(
|
||||
format!("{:?}", a.blocks.to_wire()),
|
||||
format!("{:?}", b.blocks.to_wire())
|
||||
);
|
||||
assert_eq!(
|
||||
format!("{:?}", a.biomes.to_wire()),
|
||||
format!("{:?}", b.biomes.to_wire())
|
||||
);
|
||||
for i in 0..4096 {
|
||||
assert_eq!(a.light(i), b.light(i), "index {i}, sky {sky_light}");
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
for tag in [
|
||||
Tag::compound(Vec::<(&str, Tag)>::new()),
|
||||
Tag::compound([("isLightOn", Tag::Byte(0))]),
|
||||
Tag::compound([("isLightOn", Tag::Byte(2))]),
|
||||
Tag::compound([("isLightOn", Tag::Int(1)), ("sections", Tag::List(vec![]))]),
|
||||
Tag::compound([("isLightOn", Tag::Byte(1)), ("sections", Tag::Int(0))]),
|
||||
root(vec![]),
|
||||
] {
|
||||
check(&tag);
|
||||
}
|
||||
// Cover every repeated byte, including 0xF0/0x0F: a uniform byte
|
||||
// array need not hold uniform nibbles.
|
||||
for byte in 0..=255u8 {
|
||||
check(&root(vec![section(
|
||||
Tag::Byte(19),
|
||||
Some(Tag::ByteArray(vec![byte; 2048])),
|
||||
Some(Tag::ByteArray(vec![255 - byte; 2048])),
|
||||
)]));
|
||||
}
|
||||
// Every pair of uniform sky/block nibble values, with missing
|
||||
// sections below inheriting the stored bottom row.
|
||||
for sky in 0..16u8 {
|
||||
for block in 0..16u8 {
|
||||
check(&root(vec![section(
|
||||
Tag::Byte(1),
|
||||
Some(Tag::ByteArray(vec![sky * 17; 2048])),
|
||||
Some(Tag::ByteArray(vec![block * 17; 2048])),
|
||||
)]));
|
||||
}
|
||||
}
|
||||
for length in [0, 1, 2047, 2048, 2049] {
|
||||
for invalid in [
|
||||
Tag::Int(1),
|
||||
Tag::List(vec![]),
|
||||
Tag::ByteArray(vec![0xf0; length]),
|
||||
] {
|
||||
check(&root(vec![section(
|
||||
Tag::Byte(-4),
|
||||
Some(invalid.clone()),
|
||||
Some(invalid),
|
||||
)]));
|
||||
}
|
||||
}
|
||||
let varied: Vec<u8> = (0..2048)
|
||||
.map(|i| (i as u8).wrapping_mul(73).wrapping_add(31))
|
||||
.collect();
|
||||
check(&root(vec![
|
||||
section(Tag::Byte(-5), Some(Tag::ByteArray(varied.clone())), None),
|
||||
section(Tag::Byte(20), Some(Tag::ByteArray(varied.clone())), None),
|
||||
section(
|
||||
Tag::String("19".into()),
|
||||
Some(Tag::ByteArray(varied.clone())),
|
||||
None,
|
||||
),
|
||||
section(Tag::Byte(19), Some(Tag::ByteArray(varied.clone())), None),
|
||||
section(Tag::Byte(17), None, Some(Tag::ByteArray(varied.clone()))),
|
||||
section(Tag::Byte(-4), Some(Tag::ByteArray(varied.clone())), None),
|
||||
// Last duplicate wins, even when its arrays have wrong types.
|
||||
section(
|
||||
Tag::Byte(-4),
|
||||
Some(Tag::Int(15)),
|
||||
Some(Tag::ByteArray(vec![7; 2047])),
|
||||
),
|
||||
section(Tag::Byte(0), None, Some(Tag::ByteArray(varied))),
|
||||
]));
|
||||
}
|
||||
#[test]
|
||||
fn level_round_trips_through_the_vanilla_files() {
|
||||
let dir = std::env::temp_dir().join(format!("horizon-level-{}", std::process::id()));
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//! chunkgen_bench <client resource dir> [--seed S] [--size N] [--threads T]
|
||||
//! [--center CX CZ] [--verify <material-stage parity dir>] [--no-decorate]
|
||||
//! [--dimension overworld|the_nether|the_end]
|
||||
//! [--warmup] [--json] [--no-map]
|
||||
//! [--warmup] [--json] [--no-map] [--snapshot PATH]
|
||||
use horizon_core::position::ChunkPos;
|
||||
use horizon_world::{
|
||||
DATA_VERSION,
|
||||
@@ -275,6 +275,7 @@ fn main() -> Result<(), Error> {
|
||||
let resources = PathBuf::from(args.next().expect("client resource directory"));
|
||||
let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0));
|
||||
let mut parity = None;
|
||||
let mut snapshot_path = None;
|
||||
let mut decorate = true;
|
||||
let (mut warmup, mut json, mut map) = (false, false, true);
|
||||
let mut dimension = String::from("minecraft:overworld");
|
||||
@@ -287,6 +288,7 @@ fn main() -> Result<(), Error> {
|
||||
"--threads" => threads = next().parse()?,
|
||||
"--center" => center = (next().parse()?, next().parse()?),
|
||||
"--verify" => parity = Some(PathBuf::from(next())),
|
||||
"--snapshot" => snapshot_path = Some(PathBuf::from(next())),
|
||||
"--no-decorate" => decorate = false,
|
||||
"--warmup" => warmup = true,
|
||||
"--json" => json = true,
|
||||
@@ -409,6 +411,9 @@ fn main() -> Result<(), Error> {
|
||||
.into_iter()
|
||||
.map(|slot| slot.into_inner().unwrap())
|
||||
.collect();
|
||||
if let Some(path) = &snapshot_path {
|
||||
snapshot(&chunks, path, "terrain")?;
|
||||
}
|
||||
if decorate && size >= 3 {
|
||||
let totals = Mutex::new(DecorateStats::default());
|
||||
let start = Instant::now();
|
||||
@@ -494,6 +499,9 @@ fn main() -> Result<(), Error> {
|
||||
);
|
||||
}
|
||||
}
|
||||
if let Some(path) = &snapshot_path {
|
||||
snapshot(&chunks, path, "decorated")?;
|
||||
}
|
||||
let mut structures = BTreeMap::<(String, i32, i32), [[i32; 3]; 2]>::new();
|
||||
for chunk in chunks.iter().flatten() {
|
||||
for (name, start, min, max) in chunk.structures() {
|
||||
@@ -570,3 +578,75 @@ fn main() -> Result<(), Error> {
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Diagnostic only: full ordered chunk state, outside performance measurements.
|
||||
fn snapshot(chunks: &[Option<ProtoChunk>], path: &Path, phase: &str) -> Result<(), Error> {
|
||||
use std::io::Write;
|
||||
let mut out =
|
||||
std::io::BufWriter::new(fs::File::create(format!("{}-{phase}.bin", path.display()))?);
|
||||
for chunk in chunks.iter().flatten() {
|
||||
let terrain = &chunk.terrain;
|
||||
writeln!(
|
||||
out,
|
||||
"chunk {:?} {:?} {} {:?} {:?}",
|
||||
chunk.position(),
|
||||
terrain.generation_stage(),
|
||||
chunk.is_decorated(),
|
||||
chunk.structures(),
|
||||
terrain.below_zero_retrogen().map(|v| v.to_nbt())
|
||||
)?;
|
||||
for section in 0..terrain.height() as usize / 16 {
|
||||
let data = terrain.section(section).unwrap();
|
||||
writeln!(out, "section {section} {:?}", data.to_nbt()?)?;
|
||||
for index in 0..4096 {
|
||||
out.write_all(&data.get(index)?.0.to_le_bytes())?;
|
||||
}
|
||||
}
|
||||
// Compare public reads too, including all-air section behavior.
|
||||
for y in terrain.min_y()..terrain.min_y() + terrain.height() {
|
||||
for z in 0..16 {
|
||||
for x in 0..16 {
|
||||
out.write_all(&terrain.block(x, y, z).0.to_le_bytes())?;
|
||||
}
|
||||
}
|
||||
}
|
||||
for y in (terrain.min_y() >> 2)..((terrain.min_y() + terrain.height()) >> 2) {
|
||||
for z in 0..4 {
|
||||
for x in 0..4 {
|
||||
writeln!(
|
||||
out,
|
||||
"biome {}",
|
||||
chunk.biome_at(
|
||||
chunk.position().x * 16 + x * 4,
|
||||
y * 4,
|
||||
chunk.position().z * 16 + z * 4
|
||||
)
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
for kind in HeightmapType::ALL {
|
||||
writeln!(
|
||||
out,
|
||||
"heightmap {kind:?} {:?}",
|
||||
terrain.heightmap(kind).map(|m| m.raw_data())
|
||||
)?;
|
||||
}
|
||||
writeln!(out, "post {:?}", terrain.postprocessing())?;
|
||||
writeln!(out, "blockticks {:?}", terrain.block_ticks().pack(0))?;
|
||||
writeln!(out, "fluidticks {:?}", terrain.fluid_ticks().pack(0))?;
|
||||
for (position, tag) in &chunk.block_entities {
|
||||
writeln!(out, "blockentity {position:?}")?;
|
||||
let bytes =
|
||||
horizon_world::nbt::write_network(&Tag::Compound(tag.clone()), Default::default())?;
|
||||
out.write_all(&(bytes.len() as u64).to_le_bytes())?;
|
||||
out.write_all(&bytes)?;
|
||||
}
|
||||
let entities = Tag::List(chunk.entities.iter().cloned().map(Tag::Compound).collect());
|
||||
let bytes = horizon_world::nbt::write_network(&entities, Default::default())?;
|
||||
out.write_all(&(bytes.len() as u64).to_le_bytes())?;
|
||||
out.write_all(&bytes)?;
|
||||
}
|
||||
out.flush()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@ struct Cells {
|
||||
cells: HashMap<BlockPos, BlockStateId>,
|
||||
air: BlockStateId,
|
||||
random: LegacyRandom,
|
||||
obstructed: bool,
|
||||
}
|
||||
impl LevelAccess for Cells {
|
||||
fn block_state(&self, pos: BlockPos) -> BlockStateId {
|
||||
@@ -37,6 +38,9 @@ impl LevelAccess for Cells {
|
||||
fn game_time(&self) -> i64 {
|
||||
0
|
||||
}
|
||||
fn is_unobstructed(&self, _pos: BlockPos, _state: BlockStateId) -> bool {
|
||||
!self.obstructed
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
@@ -68,6 +72,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
cells,
|
||||
air,
|
||||
random: LegacyRandom::new(case["seed"].as_i64().unwrap()),
|
||||
obstructed: case["obstructed"].as_bool().unwrap_or(false),
|
||||
};
|
||||
let mut ticks = Ticks::new(0);
|
||||
for x in -2..=2 {
|
||||
|
||||
@@ -995,6 +995,46 @@ where
|
||||
worker.terrain_context = context;
|
||||
result
|
||||
}
|
||||
/// With the native End source there are no badlands/iceberg extensions.
|
||||
/// Disabled aquifers with air as their default fluid can only add lava or
|
||||
/// air to the default solid, so this constant rule would rewrite each solid
|
||||
/// with the state it already has. Check their imported material flags too.
|
||||
/// Noise filling already built the WG maps; these writes add no fluid marks.
|
||||
fn identity_end_surface(&self, pos: ChunkPos) -> bool {
|
||||
if !matches!(self.source, ResolvedBiomeSource::End(_))
|
||||
// At wrapped block coordinates the ordinary biome-region lookup
|
||||
// can fail; retain that lookup and its error outside this range.
|
||||
|| ![pos.x, pos.z].into_iter().all(|c| {
|
||||
c.checked_mul(16).is_some_and(|b| {
|
||||
b.checked_sub(16).is_some() && b.checked_add(31).is_some()
|
||||
})
|
||||
})
|
||||
|| self.aquifer.is_some()
|
||||
|| Some(self.settings.default_block)
|
||||
!= self.data.registry.default_state("minecraft:end_stone")
|
||||
|| Some(self.settings.default_fluid)
|
||||
!= self.data.registry.default_state("minecraft:air")
|
||||
|| !self.data.states.get(self.settings.default_fluid).air
|
||||
|| !self
|
||||
.data
|
||||
.registry
|
||||
.default_state("minecraft:lava")
|
||||
.is_some_and(|lava| self.data.states.get(lava).fluid)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let mut rule = &self.rule;
|
||||
// Restrict the shortcut to shallow block references; other rules still
|
||||
// run their normal compilation, queries and error handling.
|
||||
for _ in 0..32 {
|
||||
match rule {
|
||||
MaterialRule::Reference(next) => rule = next,
|
||||
MaterialRule::Block(state) => return *state == self.settings.default_block,
|
||||
_ => return false,
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
fn generate_with_context(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
@@ -1103,32 +1143,34 @@ where
|
||||
.map_err(stage("noise"))?;
|
||||
let generation = self.generation();
|
||||
worker.timings.noise += lap(&mut clock);
|
||||
build_surface(
|
||||
&mut chunk,
|
||||
self.rule.clone(),
|
||||
SurfaceInputs::<R, _> {
|
||||
generation,
|
||||
noise_volume: volume,
|
||||
root: self.root.clone(),
|
||||
surface: SurfaceQueries {
|
||||
pipeline: self,
|
||||
temperatures: &mut worker.temperatures,
|
||||
biome: Biomes::Region(&biomes),
|
||||
uniform_biomes: Some(UniformSurfaceBiomes::new(
|
||||
pos,
|
||||
self.settings.level_min_y,
|
||||
self.settings.level_height,
|
||||
)),
|
||||
possible: Some(possible),
|
||||
if !self.identity_end_surface(pos) {
|
||||
build_surface(
|
||||
&mut chunk,
|
||||
self.rule.clone(),
|
||||
SurfaceInputs::<R, _> {
|
||||
generation,
|
||||
noise_volume: volume,
|
||||
root: self.root.clone(),
|
||||
surface: SurfaceQueries {
|
||||
pipeline: self,
|
||||
temperatures: &mut worker.temperatures,
|
||||
biome: Biomes::Region(&biomes),
|
||||
uniform_biomes: Some(UniformSurfaceBiomes::new(
|
||||
pos,
|
||||
self.settings.level_min_y,
|
||||
self.settings.level_height,
|
||||
)),
|
||||
possible: Some(possible),
|
||||
},
|
||||
preliminary_surface: self.preliminary.clone(),
|
||||
density_context: context,
|
||||
write_min_y: min,
|
||||
write_max_y: min + height - 1,
|
||||
},
|
||||
preliminary_surface: self.preliminary.clone(),
|
||||
density_context: context,
|
||||
write_min_y: min,
|
||||
write_max_y: min + height - 1,
|
||||
},
|
||||
&self.extensions,
|
||||
)
|
||||
.map_err(stage("surface"))?;
|
||||
&self.extensions,
|
||||
)
|
||||
.map_err(stage("surface"))?;
|
||||
}
|
||||
worker.timings.surface += lap(&mut clock);
|
||||
let carvers = &data.biome_carvers;
|
||||
let mask = generate_carving_mask(self.seed, pos, generation, false, |origin| {
|
||||
@@ -2480,6 +2522,108 @@ impl GeneratorWorker {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn end_identity_surface_matches_normal_surface_and_rejects_custom_rules() {
|
||||
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3")
|
||||
});
|
||||
if !root.join("worldgen/world_presets.json").exists() {
|
||||
eprintln!("skipping: no worldgen bundle at {}", root.display());
|
||||
return;
|
||||
}
|
||||
let registry = Box::leak(Box::new(crate::level::data::load_registry(&root).unwrap()));
|
||||
let data = GeneratorData::load(&root.join("worldgen"), registry).unwrap();
|
||||
let preset: Value = serde_json::from_str(&data.world_presets["minecraft:normal"]).unwrap();
|
||||
let settings: Value = serde_json::from_str(&data.settings["minecraft:end"]).unwrap();
|
||||
let mut pipeline = Pipeline::new(
|
||||
data.clone(),
|
||||
12345,
|
||||
LegacyRandom::new(12345),
|
||||
&preset["dimensions"]["minecraft:the_end"]["generator"],
|
||||
&settings,
|
||||
false,
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
let mut worker = OverworldGenerator::for_world(
|
||||
data.clone(),
|
||||
12345,
|
||||
"minecraft:normal",
|
||||
"minecraft:the_end",
|
||||
false,
|
||||
)
|
||||
.unwrap()
|
||||
.worker();
|
||||
assert!(pipeline.identity_end_surface(ChunkPos::new(0, 0)));
|
||||
for pos in [
|
||||
ChunkPos::new(0, 0),
|
||||
ChunkPos::new(128, 128),
|
||||
ChunkPos::new(-128, 192),
|
||||
ChunkPos::new(1_875_000, -1_875_000),
|
||||
] {
|
||||
let actual = pipeline.generate(&mut worker.state, pos).unwrap();
|
||||
let rule = pipeline.rule.clone();
|
||||
// A singleton sequence evaluates the same block rule through the full surface path.
|
||||
pipeline.rule = MaterialRule::Sequence(vec![rule.clone()]);
|
||||
assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0)));
|
||||
let expected = pipeline.generate(&mut worker.state, pos).unwrap();
|
||||
pipeline.rule = rule;
|
||||
assert_eq!(
|
||||
actual.terrain.generation_stage(),
|
||||
expected.terrain.generation_stage()
|
||||
);
|
||||
for section in 0..actual.terrain.height() as usize / 16 {
|
||||
assert_eq!(
|
||||
actual.terrain.section(section).unwrap().to_nbt().unwrap(),
|
||||
expected.terrain.section(section).unwrap().to_nbt().unwrap()
|
||||
);
|
||||
}
|
||||
for kind in HeightmapType::ALL {
|
||||
assert_eq!(
|
||||
actual.terrain.heightmap(kind).map(|m| m.raw_data()),
|
||||
expected.terrain.heightmap(kind).map(|m| m.raw_data())
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
actual.terrain.postprocessing(),
|
||||
expected.terrain.postprocessing()
|
||||
);
|
||||
assert_eq!(
|
||||
actual.terrain.block_ticks().pack(0),
|
||||
expected.terrain.block_ticks().pack(0)
|
||||
);
|
||||
assert_eq!(
|
||||
actual.terrain.fluid_ticks().pack(0),
|
||||
expected.terrain.fluid_ticks().pack(0)
|
||||
);
|
||||
assert_eq!(actual.block_entities, expected.block_entities);
|
||||
assert_eq!(actual.entities, expected.entities);
|
||||
assert_eq!(actual.structures(), expected.structures());
|
||||
}
|
||||
assert!(!pipeline.identity_end_surface(ChunkPos::new(i32::MAX, 0)));
|
||||
let old_rule = pipeline.rule.clone();
|
||||
pipeline.rule = MaterialRule::Block(registry.default_state("minecraft:stone").unwrap());
|
||||
assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0)));
|
||||
pipeline.rule = old_rule;
|
||||
let old_fluid = pipeline.settings.default_fluid;
|
||||
pipeline.settings.default_fluid = registry.default_state("minecraft:stone").unwrap();
|
||||
assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0)));
|
||||
pipeline.settings.default_fluid = old_fluid;
|
||||
let old_source = std::mem::replace(
|
||||
&mut pipeline.source,
|
||||
ResolvedBiomeSource::Fixed(super::super::biome_source::FixedBiomeSource {
|
||||
biome: "minecraft:the_end".into(),
|
||||
}),
|
||||
);
|
||||
assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0)));
|
||||
pipeline.source = old_source;
|
||||
pipeline.aquifer = Some(std::array::from_fn(|_| {
|
||||
pipeline.router.get(RouterField::Erosion).clone()
|
||||
}));
|
||||
assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn uniform_surface_biomes_preserve_zoom_and_missing_corner_errors() {
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 276 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 148 KiB |
@@ -27,7 +27,7 @@ import net.minecraft.world.phys.shapes.CollisionContext;
|
||||
/**
|
||||
* Native BlockItem placement-state selection (BlockPlaceContext resolution,
|
||||
* updatePlacementContext and getPlacementState) over generated neighbourhoods.
|
||||
* Entities never obstruct; nothing is written to the world.
|
||||
* Entity obstruction can be scripted; nothing is written to the world.
|
||||
*/
|
||||
public final class VanillaBlockPlacementOracle {
|
||||
static Object unsafe;
|
||||
@@ -67,6 +67,7 @@ public final class VanillaBlockPlacementOracle {
|
||||
static final class World extends net.minecraft.server.level.ServerLevel {
|
||||
Map<BlockPos, BlockState> cells;
|
||||
RandomSource random;
|
||||
boolean obstructed;
|
||||
World() {
|
||||
super(null, null, null, null, null, null, false, 0L, List.of(), false);
|
||||
}
|
||||
@@ -77,7 +78,7 @@ public final class VanillaBlockPlacementOracle {
|
||||
@Override public RandomSource getRandom() { return random; }
|
||||
@Override public int getMinY() { return -64; }
|
||||
@Override public int getHeight() { return 384; }
|
||||
@Override public boolean isUnobstructed(BlockState state, BlockPos pos, CollisionContext context) { return true; }
|
||||
@Override public boolean isUnobstructed(BlockState state, BlockPos pos, CollisionContext context) { return !obstructed; }
|
||||
@Override public boolean isUnobstructed(Entity entity) { return true; }
|
||||
@Override public void scheduleTick(BlockPos pos, Block block, int delay) { }
|
||||
@Override public net.minecraft.core.RegistryAccess registryAccess() { return RegistryAccess.fromRegistryOfRegistries(BuiltInRegistries.REGISTRY); }
|
||||
@@ -116,6 +117,7 @@ public final class VanillaBlockPlacementOracle {
|
||||
world.cells.put(new BlockPos(c.get(0).getAsInt(), c.get(1).getAsInt(), c.get(2).getAsInt()), Block.stateById(c.get(3).getAsInt()));
|
||||
}
|
||||
world.random = new LegacyRandomSource(f.get("seed").getAsLong());
|
||||
world.obstructed = f.has("obstructed") && f.get("obstructed").getAsBoolean();
|
||||
var player = make(FakePlayer.class);
|
||||
player.world = world;
|
||||
player.yaw = f.get("yaw").getAsFloat();
|
||||
|
||||
@@ -6,9 +6,14 @@ import java.io.PrintWriter;
|
||||
import net.minecraft.client.*;
|
||||
import net.minecraft.client.gui.Gui;
|
||||
import net.minecraft.client.multiplayer.MultiPlayerGameMode;
|
||||
import net.minecraft.client.multiplayer.ClientPacketListener;
|
||||
import net.minecraft.client.player.LocalPlayer;
|
||||
import net.minecraft.network.protocol.Packet;
|
||||
import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket;
|
||||
import net.minecraft.world.InteractionHand;
|
||||
import net.minecraft.world.entity.player.*;
|
||||
import net.minecraft.world.item.*;
|
||||
import net.minecraft.world.item.component.SwingAnimation;
|
||||
import net.minecraft.world.level.GameType;
|
||||
|
||||
/** Runs the real key handler through its drop loop; stops before item-use handling. */
|
||||
@@ -41,16 +46,36 @@ public final class VanillaHeldDropOracle {
|
||||
}
|
||||
static final class Actor extends LocalPlayer {
|
||||
GameType mode;
|
||||
int swings;
|
||||
Actor() { super(null, null, null, null, null, null, false, null, null); }
|
||||
@Override public GameType gameMode() { return mode; }
|
||||
@Override public boolean isUsingItem() { throw new Done(); }
|
||||
@Override public boolean swing(InteractionHand hand, SwingAnimation animation, boolean sendPacket) {
|
||||
if (hand != InteractionHand.MAIN_HAND || !animation.equals(SwingAnimation.DEFAULT) || sendPacket)
|
||||
throw new AssertionError("unexpected drop swing");
|
||||
swings++;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
static final class Connection extends ClientPacketListener {
|
||||
int drops;
|
||||
ServerboundPlayerActionPacket.Action expected;
|
||||
Connection() { super(null, null, null); }
|
||||
@Override public void send(Packet<?> packet) {
|
||||
if (packet instanceof ServerboundPlayerActionPacket action) {
|
||||
if (action.getAction() != expected) throw new AssertionError("unexpected drop action");
|
||||
drops++;
|
||||
}
|
||||
}
|
||||
}
|
||||
static final class Controller extends MultiPlayerGameMode {
|
||||
int dropped;
|
||||
Controller() { super(null, null); }
|
||||
// Controlled dispatch boundary: no networking, swings, statistics or item entities.
|
||||
// Run vanilla's actual prediction, packet dispatch and conditional swing.
|
||||
@Override public void dropItem(LocalPlayer player, boolean all) {
|
||||
dropped += player.getInventory().removeFromSelected(all).getCount();
|
||||
int before = player.getInventory().getSelectedItem().getCount();
|
||||
super.dropItem(player, all);
|
||||
dropped += before - player.getInventory().getSelectedItem().getCount();
|
||||
}
|
||||
}
|
||||
public static void main(String[] args) throws Exception {
|
||||
@@ -81,6 +106,9 @@ public final class VanillaHeldDropOracle {
|
||||
field(Player.class, "inventory").set(actor, inventory);
|
||||
field(Minecraft.class, "player").set(client, actor);
|
||||
var controller = make(Controller.class);
|
||||
var connection = make(Connection.class);
|
||||
field(MultiPlayerGameMode.class, "minecraft").set(controller, client);
|
||||
field(MultiPlayerGameMode.class, "connection").set(controller, connection);
|
||||
field(Minecraft.class, "gameMode").set(client, controller);
|
||||
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[0])))) {
|
||||
for (var mode : GameType.values()) for (boolean all : new boolean[]{false, true}) {
|
||||
@@ -91,6 +119,10 @@ public final class VanillaHeldDropOracle {
|
||||
inventory.setSelectedSlot(selected);
|
||||
inventory.setItem(selected, new ItemStack(Items.STONE, count));
|
||||
controller.dropped = 0;
|
||||
actor.swings = 0;
|
||||
connection.drops = 0;
|
||||
connection.expected = all ? ServerboundPlayerActionPacket.Action.DROP_ALL_ITEMS
|
||||
: ServerboundPlayerActionPacket.Action.DROP_ITEM;
|
||||
// Two consecutive key presses also cover an emptied stack and repeated spectator drops.
|
||||
for (int press = 0; press < 2; press++) {
|
||||
((Key) options.keyDrop).clicks = 1;
|
||||
@@ -100,7 +132,8 @@ public final class VanillaHeldDropOracle {
|
||||
} catch (InvocationTargetException e) {
|
||||
if (!(e.getCause() instanceof Done)) throw e;
|
||||
}
|
||||
out.println(inventory.getSelectedItem().getCount() + " " + controller.dropped);
|
||||
out.println(inventory.getSelectedItem().getCount() + " " + controller.dropped
|
||||
+ " " + actor.swings + " " + connection.drops);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
"""Exercise the live remote_mining method with scripted world and packet sinks.
|
||||
|
||||
Vanilla reference: MultiPlayerGameMode.startDestroyBlock/continueDestroyBlock.
|
||||
The first_person parity harness separately checks consecutive instant breaks
|
||||
against the pinned client; this fixture catches drift in the multiplayer path.
|
||||
"""
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("rustc"), "requires Rust")
|
||||
class RemoteMiningTests(unittest.TestCase):
|
||||
def test_break_timing_and_packets(self):
|
||||
source = (ROOT / "crates/horizon-client/src/game/remote.rs").read_text()
|
||||
start = source.index(" fn remote_mining(")
|
||||
end = source.index(" /// MultiPlayerGameMode.destroyBlock", start)
|
||||
fixture = r'''
|
||||
#![allow(dead_code)]
|
||||
#[derive(Clone, Copy)]
|
||||
struct Hit { pos: [i32; 3], face: u8 }
|
||||
struct Mining { pos: [i32; 3], progress: f32, ticks: u32 }
|
||||
#[derive(Default)]
|
||||
struct Remote { destroy_delay: u32, destroying: Option<([i32; 3], u8, f32)> }
|
||||
struct Ground { on_ground: bool }
|
||||
struct Player { ground: Ground }
|
||||
#[derive(Clone)]
|
||||
struct Sounds { hit: String, volume: f32, pitch: f32 }
|
||||
#[derive(Clone)]
|
||||
struct Facts { hardness: f32, name: String, requires_tool: bool, sounds: Sounds }
|
||||
struct Resources { facts: Facts, speed: f32 }
|
||||
impl Resources {
|
||||
fn facts(&self) -> &Self { self }
|
||||
fn items(&self) -> &Self { self }
|
||||
fn get(&self, _: u32) -> &Facts { &self.facts }
|
||||
fn is_air(&self, state: u32) -> bool { state == 0 }
|
||||
fn mining_speed(&self, _: Option<&()>, _: &str) -> f32 { self.speed }
|
||||
fn correct_for_drops(&self, _: Option<&()>, _: &str) -> bool { true }
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct World { broken: Vec<[i32; 3]> }
|
||||
impl World {
|
||||
fn block(&self, x: i32, y: i32, z: i32) -> u32 {
|
||||
u32::from(!self.broken.contains(&[x, y, z]))
|
||||
}
|
||||
}
|
||||
struct Audio;
|
||||
impl Audio {
|
||||
fn play(&self, _: &str, _: Option<[f64; 3]>, _: f32, _: f32) {}
|
||||
}
|
||||
mod play {
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct PlayerAction {
|
||||
pub action: u8, pub pos: [i32; 3], pub direction: u8, pub sequence: i32,
|
||||
}
|
||||
}
|
||||
enum S { PlayerAction(play::PlayerAction) }
|
||||
fn face_direction(face: u8) -> u8 { face }
|
||||
struct Game {
|
||||
remote: Option<Remote>, mining: Option<Mining>, creative: bool,
|
||||
world: World, res: Resources, player: Option<Player>, audio: Audio,
|
||||
hit: Hit, sequence: i32, packets: Vec<play::PlayerAction>,
|
||||
}
|
||||
impl Game {
|
||||
fn new(hardness: f32, speed: f32, creative: bool) -> Self {
|
||||
Self {
|
||||
remote: Some(Remote::default()), mining: None, creative,
|
||||
world: World::default(),
|
||||
res: Resources { facts: Facts { hardness, name: "block".into(),
|
||||
requires_tool: false, sounds: Sounds { hit: "hit".into(), volume: 1.0, pitch: 1.0 } }, speed },
|
||||
player: Some(Player { ground: Ground { on_ground: true } }), audio: Audio,
|
||||
hit: Hit { pos: [0, 64, 0], face: 1 }, sequence: 0, packets: vec![],
|
||||
}
|
||||
}
|
||||
fn pick(&self) -> Option<Hit> { Some(self.hit) }
|
||||
fn held(&self) -> Option<&()> { None }
|
||||
fn next_sequence(&mut self) -> i32 { self.sequence += 1; self.sequence }
|
||||
fn predict_break(&mut self, pos: [i32; 3], _: u32, _: i32) { self.world.broken.push(pos); }
|
||||
fn send(&mut self, S::PlayerAction(packet): S) { self.packets.push(packet); }
|
||||
fn crack_particle(&mut self, _: [i32; 3], _: u8, _: u32) {}
|
||||
METHOD
|
||||
}
|
||||
fn main() {
|
||||
// Zero-hardness blocks and a tool fast enough to break in one tick.
|
||||
for (hardness, speed) in [(0.0, 1.0), (0.5, 15.0), (0.5, 30.0)] {
|
||||
let mut game = Game::new(hardness, speed, false);
|
||||
for tick in 0..8 {
|
||||
game.hit.pos[0] = tick;
|
||||
game.remote_mining(tick == 0);
|
||||
assert_eq!(game.world.broken.len(), tick as usize + 1,
|
||||
"instant break must happen every held tick");
|
||||
let remote = game.remote.as_ref().unwrap();
|
||||
assert_eq!(remote.destroy_delay, 0);
|
||||
assert!(remote.destroying.is_none());
|
||||
assert!(game.mining.is_none());
|
||||
assert_eq!(game.packets[tick as usize], play::PlayerAction {
|
||||
action: 0, pos: [tick, 64, 0], direction: 1, sequence: tick + 1,
|
||||
});
|
||||
}
|
||||
assert_eq!(game.packets.len(), 8, "instant breaks only send START");
|
||||
}
|
||||
// Gradual breaking still sends STOP and waits five continuation ticks.
|
||||
let mut game = Game::new(1.0, 15.0, false);
|
||||
game.remote_mining(true);
|
||||
assert!(game.world.broken.is_empty());
|
||||
game.remote_mining(false);
|
||||
assert!(game.world.broken.is_empty());
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.world.broken.len(), 1);
|
||||
assert_eq!(game.packets.iter().map(|p| p.action).collect::<Vec<_>>(), [0, 3]);
|
||||
assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5);
|
||||
game.hit.pos[0] = 1;
|
||||
for _ in 0..5 {
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.packets.len(), 2);
|
||||
}
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.packets.len(), 3);
|
||||
assert_eq!(game.packets[2].action, 0);
|
||||
// Creative also keeps its five-tick delay, even for zero-hardness blocks.
|
||||
let mut game = Game::new(0.0, 1.0, true);
|
||||
game.remote_mining(true);
|
||||
game.hit.pos[0] = 1;
|
||||
assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5);
|
||||
for _ in 0..5 {
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.world.broken.len(), 1);
|
||||
}
|
||||
game.remote_mining(false);
|
||||
assert_eq!(game.world.broken.len(), 2);
|
||||
assert_eq!(game.remote.as_ref().unwrap().destroy_delay, 5);
|
||||
}
|
||||
'''.replace("METHOD", source[start:end])
|
||||
with tempfile.TemporaryDirectory(prefix="remote-mining-") as directory:
|
||||
path = Path(directory)
|
||||
(path / "main.rs").write_text(fixture)
|
||||
subprocess.run(["rustc", "--edition=2024", str(path / "main.rs"), "-o", str(path / "probe")],
|
||||
check=True, capture_output=True, text=True)
|
||||
result = subprocess.run([str(path / "probe")], capture_output=True, text=True)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -10,7 +10,8 @@ the options scenario reads and sets options.txt values by key; the events scenar
|
||||
states (wait-for) and reads the event log; the consume scenario eats and drinks consumables (a
|
||||
golden apple, milk, honey, chorus fruit) and checks their effects, remainders and teleport; the
|
||||
pick scenario middle-clicks slots (AbstractContainerScreen's cloning): a full stack in creative, from
|
||||
the hotbar and from an item tab, and nothing in survival.
|
||||
the hotbar and from an item tab, and nothing in survival; the suggestions scenario checks
|
||||
slash-command Tab completion on single player's connected client after a fresh launch.
|
||||
|
||||
python3 tools/agent_control_e2e.py # both modes
|
||||
python3 tools/agent_control_e2e.py --mode mcp # one of them
|
||||
@@ -45,6 +46,7 @@ LOG_KINDS = ['oak_log', 'birch_log', 'spruce_log', 'jungle_log', 'acacia_log', '
|
||||
'mangrove_log', 'cherry_log']
|
||||
# Positional arguments of the commands the scenario uses, for the CLI.
|
||||
POSITIONAL = {
|
||||
'key': ['key', 'action'],
|
||||
'goto': ['x', 'y', 'z'], 'break': ['x', 'y', 'z'], 'place': ['x', 'y', 'z'], 'block': ['x', 'y', 'z'],
|
||||
'find_block': ['block', 'radius'], 'entities': ['radius', 'type'], 'click_slot': ['slot'],
|
||||
'click_button': ['label'], 'type': ['text'], 'wait': ['ticks'], 'wait_ready': ['seconds'],
|
||||
@@ -522,8 +524,50 @@ def pick_scenario(d, out):
|
||||
return {'cloned': shown['item']}
|
||||
|
||||
|
||||
def suggestions_scenario(d, out):
|
||||
# Start from the title screen: single player's client joins through memory,
|
||||
# without opening a server world and building its command registries.
|
||||
d('click', id='singleplayer')
|
||||
if 'game' not in widgets(d):
|
||||
d('click', id='create-new-world')
|
||||
d('type', field='name', replace=True, text='Suggestions')
|
||||
d('click', id='game-mode') # survival -> hardcore -> creative (commands on)
|
||||
d('click', id='game-mode')
|
||||
d('type', field='seed', text='5')
|
||||
d('click', id='world')
|
||||
d('click', id='world-type') # superflat: this checks chat, without a spawn search
|
||||
d('click', id='create-new-world')
|
||||
d('wait_for', condition='loaded', timeout=400)
|
||||
d('wait_ready', seconds=400)
|
||||
|
||||
cases = [
|
||||
('/giv', '/give'),
|
||||
('/fill ^', '/fill ^ ^'),
|
||||
('/give @s diamond_sw', '/give @s minecraft:diamond_sword'),
|
||||
('/setblock ~ ~ ~ diamond_blo', '/setblock ~ ~ ~ minecraft:diamond_block'),
|
||||
('/fill ~ ~ ~ ~1 ~1 ~1 diamond_blo', '/fill ~ ~ ~ ~1 ~1 ~1 minecraft:diamond_block'),
|
||||
('/setblock ~ ~ ~ oak_stairs[fa', '/setblock ~ ~ ~ oak_stairs[facing='),
|
||||
('/clear @s diamond_sw', '/clear @s minecraft:diamond_sword'),
|
||||
('/execute run give @s diamond_sw', '/execute run give @s minecraft:diamond_sword'),
|
||||
]
|
||||
for text, expected in cases:
|
||||
d('key', key='t', action='tap')
|
||||
d('type', text=text)
|
||||
if text == '/give @s diamond_sw':
|
||||
shot = d('screenshot', path=str((out / f'{d.name}-suggestions.png').resolve()))
|
||||
if '_image' in shot:
|
||||
(out / f'{d.name}-suggestions.png').write_bytes(shot['_image'])
|
||||
d('key', key='tab', action='tap')
|
||||
actual = d('screen')['chat_input']
|
||||
assert actual == expected, (text, expected, actual)
|
||||
d('key', key='esc', action='tap')
|
||||
if d('screen')['screen'] == 'chat': # Escape first dismisses suggestions
|
||||
d('key', key='esc', action='tap')
|
||||
return {'completions': len(cases)}
|
||||
|
||||
|
||||
SCENARIOS = {'survival': scenario, 'ui': ui_scenario, 'options': options_scenario, 'events': events_scenario,
|
||||
'consume': consume_scenario, 'pick': pick_scenario}
|
||||
'consume': consume_scenario, 'pick': pick_scenario, 'suggestions': suggestions_scenario}
|
||||
|
||||
|
||||
def run(mode, ctl, out, resources, which='survival'):
|
||||
|
||||
@@ -69,6 +69,16 @@ def cases(count):
|
||||
'history': rng.sample(HISTORY, rng.randint(0, len(HISTORY))), 'autoSuggest': rng.random() < 0.85,
|
||||
'chatOnly': rng.random() < 0.7, 'opacity': rng.choice([0.0, 0.5, 1.0]), 'actions': actions,
|
||||
'mouse': list(mouse), 'blink': rng.choice([0, 100, 400, 650])})
|
||||
# Always exercise registry-backed suggestions and their replacement ranges,
|
||||
# before and after Tab, including the redirect through execute's root.
|
||||
for text in ['/give @s diamond_sw', '/setblock ~ ~ ~ sto', '/fill ~ ~ ~ ~1 ~1 ~1 sto',
|
||||
'/setblock ~ ~ ~ oak_stairs[fa', '/clear @s diamond_sw',
|
||||
'/execute run give @s diamond_sw', '/fill ']:
|
||||
for keys in [[], ['tab'], ['tab', 'tab', 'shift+tab']]:
|
||||
out.append({'width': 640, 'height': 360, 'initial': '', 'history': [], 'autoSuggest': True,
|
||||
'chatOnly': True, 'opacity': 0.5, 'mouse': [0, 0], 'blink': 0,
|
||||
'actions': [{'type': 'type', 'text': text}]
|
||||
+ [{'type': 'key', 'key': key} for key in keys]})
|
||||
return out
|
||||
|
||||
|
||||
|
||||
@@ -67,6 +67,7 @@ if __name__ == '__main__':
|
||||
'firework-tooltip-parity', 'VanillaFireworkTooltipOracle', 'firework_tooltip_fixture', cases,
|
||||
'Firework rocket and star tooltip lines: flight duration, explosions (counted runs), colours, fade, trail, '
|
||||
'twinkle, defaults and tooltip_display',
|
||||
sources=[lab.ROOT / 'crates/horizon-client/src/item_tooltip.rs', lab.ROOT / 'crates/horizon-client/src/item_data.rs',
|
||||
sources=[lab.ROOT / 'crates/horizon-client/src/enchant.rs',
|
||||
lab.ROOT / 'crates/horizon-client/src/item_tooltip.rs', lab.ROOT / 'crates/horizon-client/src/item_data.rs',
|
||||
lab.ROOT / 'crates/horizon-client/src/particles.rs'],
|
||||
expected_lines=COUNT)
|
||||
|
||||
@@ -69,6 +69,12 @@ def block_hit(pos, face=1):
|
||||
|
||||
def scenarios():
|
||||
stone = {TARGETS[0]: 'minecraft:stone', TARGETS[1]: 'minecraft:dirt', TARGETS[2]: 'minecraft:glass'}
|
||||
# Consecutive instant survival breaks have no destroy delay. Cover both
|
||||
# zero hardness and a shovel with haste reaching one-tick destroy progress.
|
||||
for block, main, haste in [('minecraft:short_grass', None, None),
|
||||
('minecraft:dirt', ['minecraft:diamond_shovel', 1], 9)]:
|
||||
steps = [step(block_hit(p), ac=int(i == 0), ad=True) for i, p in enumerate(TARGETS)]
|
||||
yield case(steps + [step()] * 6, main=main, blocks={p: block for p in TARGETS}, haste=haste)
|
||||
for creative in (False, True):
|
||||
for main in ITEMS:
|
||||
# Hold attack on blocks until they break, then on the air behind.
|
||||
|
||||
@@ -2,10 +2,12 @@
|
||||
"""Compare selected-slot drops with Minecraft.handleKeybinds in all four game modes.
|
||||
|
||||
The oracle invokes the unmodified native key handler, consuming real drop-key
|
||||
clicks. Its controlled dropItem callback removes from the real player Inventory;
|
||||
other keys are idle and execution stops at the following item-use boundary.
|
||||
clicks, and MultiPlayerGameMode.dropItem's real prediction and swing dispatch.
|
||||
Other keys are idle and execution stops at the following item-use boundary.
|
||||
Checks Q/Ctrl+Q, slots 0/8, empty/single/partial/full stacks and repeated drops.
|
||||
Packet delivery, item entities, swing animation and statistics are outside scope.
|
||||
Checks swing attempts and drop packet counts, including packets without swings
|
||||
for empty slots. Packet delivery, animation ticks, item entities and statistics
|
||||
are outside scope.
|
||||
"""
|
||||
import os
|
||||
import subprocess
|
||||
@@ -35,7 +37,7 @@ def main():
|
||||
subprocess.run(['cargo', 'run', '--quiet', '-p', 'horizon-client', '--example',
|
||||
'held_drop_fixture'], cwd=lab.ROOT, stdout=out, check=True)
|
||||
matched = base.compare(build / 'vanilla.txt', build / 'rust.txt')
|
||||
print(f'Held drop parity passed: {matched} selected-stack/drop-count snapshots match vanilla')
|
||||
print(f'Held drop parity passed: {matched} inventory/drop/swing/packet snapshots match vanilla')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -68,6 +68,22 @@ def generate(resources, count, seed):
|
||||
return cases
|
||||
|
||||
|
||||
def obstruction_cases(resources):
|
||||
"""Placement failures must not predict a hand swing.
|
||||
|
||||
Exercise BlockItem.canPlace's entity-obstruction gate with the same
|
||||
otherwise valid placements, including partial shapes and two-block items.
|
||||
"""
|
||||
facts = json.loads((resources / 'facts.json').read_text())
|
||||
states = {s[0]: i for i, s in reversed(list(enumerate(facts['states'])))}
|
||||
stone = states['minecraft:stone']
|
||||
for item in ['minecraft:stone', 'minecraft:oak_slab', 'minecraft:oak_stairs',
|
||||
'minecraft:oak_door', 'minecraft:torch']:
|
||||
for obstructed in [False, True]:
|
||||
yield dict(seed=0, item=item, pos=[0, 0, 0], face=1, hit=[0.5, 1.0, 0.5],
|
||||
yaw=0, pitch=45, sneak=False, cells=[[0, 0, 0, stone]], obstructed=obstructed)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--count', type=int, default=20000)
|
||||
@@ -77,7 +93,7 @@ def main():
|
||||
resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version']
|
||||
work = lab.LOCAL / 'level-place-parity'
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
cases = generate(resources, args.count, args.seed)
|
||||
cases = list(obstruction_cases(resources)) + generate(resources, args.count, args.seed)
|
||||
(work / 'cases.jsonl').write_text(''.join(json.dumps(case) + '\n' for case in cases))
|
||||
classes = work / 'classes'
|
||||
classes.mkdir(exist_ok=True)
|
||||
|
||||
Reference in New Issue
Block a user