diff --git a/crates/horizon-client/examples/firework_tooltip_fixture.rs b/crates/horizon-client/examples/firework_tooltip_fixture.rs index 196fa9955..7f10278b7 100644 --- a/crates/horizon-client/examples/firework_tooltip_fixture.rs +++ b/crates/horizon-client/examples/firework_tooltip_fixture.rs @@ -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> { @@ -12,8 +12,9 @@ fn main() -> Result<(), Box> { .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")?; diff --git a/crates/horizon-client/examples/held_drop_fixture.rs b/crates/horizon-client/examples/held_drop_fixture.rs index 87ca9870c..a0c5d92ba 100644 --- a/crates/horizon-client/examples/held_drop_fixture.rs +++ b/crates/horizon-client/examples/held_drop_fixture.rs @@ -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), + ); } } } diff --git a/crates/horizon-client/examples/streaming_bench.rs b/crates/horizon-client/examples/streaming_bench.rs index 9f8e99899..b8c56b28c 100644 --- a/crates/horizon-client/examples/streaming_bench.rs +++ b/crates/horizon-client/examples/streaming_bench.rs @@ -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 = std::result::Result>; +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::>(); + Some((fields[11].parse::().ok()? + fields[12].parse::().ok()?) / 100.0) + }) + .unwrap_or(0.0) +} + #[derive(Default)] struct Phase { updates: Vec, 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); diff --git a/crates/horizon-client/examples/weather_fixture.rs b/crates/horizon-client/examples/weather_fixture.rs index 15aab6bdb..3cf6c31be 100644 --- a/crates/horizon-client/examples/weather_fixture.rs +++ b/crates/horizon-client/examples/weather_fixture.rs @@ -11,6 +11,7 @@ fn bits(value: f32) -> String { fn main() -> Result<(), Box> { let args: Vec<_> = std::env::args().collect(); let mut output = String::new(); + let mut parameters = weather::ParameterCache::default(); for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() { let p: Vec<&str> = line.split_whitespace().collect(); let int = |i: usize| p[i].parse::().unwrap(); @@ -38,6 +39,13 @@ fn main() -> Result<(), Box> { bits(column.v_offset), column.light_coords )?; + assert_eq!( + parameters + .get(x, z) + .column(kind != 0, ticks, x, bottom, top, z, light, partial), + column, + "cached parameters differ from original random source at case {case}" + ); let max_alpha = if kind == 0 { 1.0 } else { 0.8 }; for v in weather::column_quad(&column, camera, max_alpha, radius, intensity) { write!( diff --git a/crates/horizon-client/src/enchant.rs b/crates/horizon-client/src/enchant.rs index 039ea658f..ca2ea6f5c 100644 --- a/crates/horizon-client/src/enchant.rs +++ b/crates/horizon-client/src/enchant.rs @@ -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.") diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 2c6af26f9..2e865dfb1 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -43,6 +43,7 @@ struct Out { @location(8) back_color: vec4, // entity.vsh's lightMapColor, multiplied in after the overlay. @location(9) light_color: vec4, + @location(10) @interpolate(flat) weather_rect: vec4, } // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed. fn entity_light(normal: vec3, nether: bool) -> f32 { @@ -109,6 +110,13 @@ fn entity_vertex(position: vec3, uv: vec2, @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4) -> Out { return entity_vertex(position, uv, overlay, color, light, normal); } +// Retained bolt-local geometry, translated using the same f64 camera +// subtraction as the former CPU path before adding each local f32 position. +@vertex fn vs_lightning(@location(0) position: vec3, @location(1) uv: vec2, + @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, @location(5) normal: vec4, + @location(6) offset: vec3) -> Out { + return entity_vertex(offset + position, uv, overlay, color, light, normal); +} struct CloudInfo { offset: vec4, colors: array, 4>, @@ -209,3 +217,135 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 { @fragment fn fs_water_mask() -> @location(0) vec4 { return vec4(0.0); } + +// WEATHER_MATH_BEGIN +// Unsigned 64-bit helpers (low word first). Snow adds a random double to a +// float drift before casting to float. Retaining the 53-bit base avoids early +// rounding, including ties, without requiring optional GPU float64 support. +fn weather_shr_jam(v: vec2, n: u32) -> vec2 { + if n == 0u { return v; } + if n < 32u { + return vec2((v.x >> n) | (v.y << (32u - n)) | select(0u, 1u, (v.x << (32u - n)) != 0u), v.y >> n); + } + if n == 32u { return vec2(v.y | select(0u, 1u, v.x != 0u), 0u); } + if n < 64u { + return vec2((v.y >> (n - 32u)) | select(0u, 1u, v.x != 0u || (v.y << (64u - n)) != 0u), 0u); + } + return vec2(select(0u, 1u, any(v != vec2(0u))), 0u); +} +fn weather_add64(a: vec2, b: vec2) -> vec2 { + let lo = a.x + b.x; + return vec2(lo, a.y + b.y + select(0u, 1u, lo < a.x)); +} +fn weather_sub64(a: vec2, b: vec2) -> vec2 { + return vec2(a.x - b.x, a.y - b.y - select(0u, 1u, a.x < b.x)); +} +fn weather_double_plus_float(base: vec2, delta: f32) -> f32 { + // The random base is nonnegative and either zero or >= 2^-53. + if all(base == vec2(0u)) { return select(delta, 0.0, delta == 0.0); } + let db = bitcast(delta); + let mag = db & 0x7fffffffu; + let be = i32((base.y >> 20u) & 2047u) - 1023; + var de = i32(mag >> 23u) - 127; + var dm = (mag & 0x7fffffu) | 0x800000u; + if mag < 0x800000u { + dm = mag; + if dm == 0u { de = -200; } + else { + let shift = countLeadingZeros(dm) - 8u; + dm <<= shift; + de = -126 - i32(shift); + } + } + let e = max(be, de); + // Leading significand bit at 61, with room for addition and guard bits. + var a = vec2(base.x << 9u, ((base.y & 0xfffffu) | 0x100000u) << 9u | (base.x >> 23u)); + var b = vec2(0u, dm << 6u); + a = weather_shr_jam(a, u32(e - be)); + b = weather_shr_jam(b, u32(e - de)); + var sign = 0u; + var value: vec2; + if (db >> 31u) == 0u { value = weather_add64(a, b); } + else if a.y > b.y || (a.y == b.y && a.x >= b.x) { value = weather_sub64(a, b); } + else { value = weather_sub64(b, a); sign = 0x80000000u; } + if all(value == vec2(0u)) { return 0.0; } + let leading = select(31u - countLeadingZeros(value.x), 63u - countLeadingZeros(value.y), value.y != 0u); + var exponent = e + i32(leading) - 61; + // Normalize the leading bit to 62. After jamming, bit 38 is the guard + // bit and bits 0..37 distinguish a tie from a value above the midpoint. + let shift = 62u - leading; + if shift >= 32u { value = vec2(0u, value.x << (shift - 32u)); } + else if shift != 0u { value = vec2(value.x << shift, (value.y << shift) | (value.x >> (32u - shift))); } + // Vanilla first rounds the addition to double, then casts to float. + // Round at bit 10 (53 retained bits) before the 24-bit rounding below; + // otherwise a double-rounding midpoint can select the wrong float. + let double_guard = (value.x & 512u) != 0u; + let double_sticky = (value.x & 511u) != 0u; + let double_odd = (value.x & 1024u) != 0u; + value.x &= 0xfffffc00u; + if double_guard && (double_sticky || double_odd) { + value = weather_add64(value, vec2(1024u, 0u)); + } + if (value.y & 0x80000000u) != 0u { + value = weather_shr_jam(value, 1u); + exponent += 1; + } + var mantissa = value.y >> 7u; + let guard = (value.y & 64u) != 0u; + let sticky = (value.y & 63u) != 0u || value.x != 0u; + if guard && (sticky || (mantissa & 1u) != 0u) { mantissa += 1u; } + if mantissa >= 0x1000000u { mantissa >>= 1u; exponent += 1; } + return bitcast(sign | (u32(exponent + 127) << 23u) | (mantissa & 0x7fffffu)); +} +fn weather_phase(animation: vec4, bases: vec4, snow: u32, time: vec4) -> vec2 { + if snow == 0u { + let ticks = time.x + animation.y; + let t = ticks + time.z; + let step = -t / 32.0; + let offset = step * animation.x; + return vec2(0.0, offset % 32.0); + } + let t = time.x + time.z; + let u_time = t * 0.01; + let du = u_time * animation.z; + let v_time = t * animation.w; + let dv = v_time * 0.001; + let u = weather_double_plus_float(bases.xy, du); + let v = weather_double_plus_float(bases.zw, dv); + let fall_time = time.y + time.z; + let fall = -fall_time / 512.0; + return vec2(u, fall + v); +} +// Atlas sampler is nearest with no mipmaps. Clamp the integer texel inside +// the sprite even when a fractional coordinate rounds up at its far edge. +fn weather_texel(uv: vec2, rect: vec4, dimensions: vec2) -> vec2 { + let size = vec2(dimensions); + let origin = vec2(round(rect.xy * size)); + let extent = max(vec2(round(rect.zw * size)), vec2(1)); + let local = min(vec2(floor(fract(uv) * vec2(extent))), extent - vec2(1)); + return origin + local; +} +// WEATHER_MATH_END + +struct WeatherTime { values: vec4 } +@group(1) @binding(1) var weather_time: WeatherTime; +@vertex fn vs_weather(@location(0) position: vec3, @location(1) uv: vec2, + @location(2) rect: vec4, @location(3) animation: vec4, + @location(4) bases: vec4, @location(5) color: vec4, + @location(6) light: vec4, @location(7) snow: u32) -> Out { + let phase = weather_phase(animation, bases, snow, weather_time.values); + var out = entity_vertex(position, uv + phase, 0u, color, light, vec4(0.0)); + out.weather_rect = rect; + return out; +} +@fragment fn fs_weather(in: Out) -> @location(0) vec4 { + // Repeat within this sprite, never across the atlas. The atlas uses nearest + // filtering and no mipmaps, so fractional UVs have no seam derivatives. + let texel = weather_texel(in.uv, in.weather_rect, textureDimensions(atlas)); + var color = textureLoad(atlas, texel, 0) * in.color; + if color.a < 0.1 { discard; } + color *= in.light_color; + let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y), + linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)); + return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a); +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 652b30e32..f3dd70154 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -76,6 +76,7 @@ mod lan_pvp; mod lan_screen; mod lan_stations; mod lan_trading; +mod lan_vehicles; mod lan_waypoints; mod leads; mod level_particles; @@ -121,6 +122,7 @@ mod remote; mod remote_objects; mod remote_projectiles; mod remote_stations; +mod remote_vehicles; mod render_control; mod render_tick; mod respawn_anchor; @@ -1111,6 +1113,7 @@ struct Game<'a> { /// `FogRenderer`'s evolving state. fog: horizon_client::fog::FogState, screen_fx: horizon_client::screen_effects::ScreenEffects, + weather_parameters: horizon_client::weather::ParameterCache, panorama_rotation: horizon_client::gfx::panorama::Rotation, world: World, streaming: Streaming, @@ -1321,6 +1324,8 @@ struct Game<'a> { /// `ClientAvatarState`: walked distance and view bob. avatar: horizon_client::camera::AvatarBob, flash: u32, + /// Bolts that struck here and sky flashes they made, in total (`status`). + lightning_seen: [u32; 2], /// The head of the bed while sleeping; the visual timer also survives waking. sleeping: Option<[i32; 3]>, sleep_timer: u32, @@ -4848,6 +4853,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. @@ -8952,89 +8960,84 @@ impl Game<'_> { } } /// WeatherEffectRenderer: rain and snow columns within the weather radius. - fn weather_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { + fn weather_geometry( + &mut self, + camera: glam::DVec3, + alpha: f64, + ) -> Vec { use horizon_client::weather; let (intensity, _) = self.world.weather.levels(alpha as f32); if intensity <= 0.0 { - return; + return Vec::new(); } let atlas = &self.gui.atlas; let (Some(rain_tex), Some(snow_tex)) = ( atlas.sprites.get("environment/rain").copied(), atlas.sprites.get("environment/snow").copied(), ) else { - return; + return Vec::new(); }; let (cx, cy, cz) = ( camera.x.floor() as i32, camera.y.floor() as i32, camera.z.floor() as i32, ); - let radius = self.settings.weather_radius; - let ticks = self.world.game_time; - let partial = alpha as f32; - let eye = [camera.x, camera.y, camera.z]; - // Vanilla draws every rain column before the snow ones. - let mut columns = (Vec::new(), Vec::new()); - for z in cz - radius..=cz + radius { - for x in cx - radius..=cx + radius { + // The 32x32 direction table supports at most a 15-block radius. + let radius = self.settings.weather_radius.clamp(0, 15); + let eye = camera.to_array(); + let mut rain = Vec::new(); + let mut snow_vertices = Vec::new(); + // Saturation keeps extreme camera coordinates from overflowing the loop. + for z in cz.saturating_sub(radius)..=cz.saturating_add(radius) { + for x in cx.saturating_sub(radius)..=cx.saturating_add(radius) { let top = self.rain_height(x, z); - let y0 = (cy - radius).max(top); - let y1 = (cy + radius).max(top); + let y0 = cy.saturating_sub(radius).max(top); + let y1 = cy.saturating_add(radius).max(top); if y1 == y0 { continue; } let Some(snow) = self.precipitation(x, cy, z) else { continue; }; - let mut random = weather::column_random(x, z); + let parameters = self.weather_parameters.get(x, z); let light = self.world.light(x, top.max(cy), z); let coords = i32::from(light & 15) << 4 | i32::from(light >> 4) << 20; - if snow { - columns.1.push(weather::snow_column( - &mut random, - ticks, - x, - y0, - y1, - z, - coords, - partial, - )); + // Only light brightening is needed here; UV phases stay zero. + let lc = if snow { + let (block, sky) = (coords >> 4 & 15, coords >> 20 & 15); + ((block * 3 + 15) / 4) << 4 | ((sky * 3 + 15) / 4) << 20 } else { - columns.0.push(weather::rain_column( - &mut random, - ticks, - x, - y0, - y1, - z, - coords, - partial, - )); + coords + }; + let column = weather::Column { + x, + z, + bottom_y: y0, + top_y: y1, + u_offset: 0.0, + v_offset: 0.0, + light_coords: lc, + }; + let r = if snow { snow_tex } else { rain_tex }; + let vertices = weather::vertices( + &column, + parameters, + snow, + eye, + radius, + intensity, + [r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0], + ); + if snow { + snow_vertices.extend(vertices); + } else { + rain.extend(vertices); } } } - let rain = columns.0.iter().map(|c| (c, 1.0, rain_tex)); - let snow = columns.1.iter().map(|c| (c, 0.8, snow_tex)); - for (column, max_alpha, r) in rain.chain(snow) { - let quad = weather::column_quad(column, eye, max_alpha, radius, intensity); - let color = quad[0].color; - let lc = quad[0].light_coords; - let light = ((lc >> 20 & 15) * 16) as u32 | (((lc >> 4 & 15) * 16) as u32) << 8; - weather::tile(&quad, |pos, uvs| { - for (p, [u, v]) in pos.into_iter().zip(uvs) { - out.push(Vertex { - normal: [0; 4], - pos: p, - uv: [r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v], - layer: 0, - color, - light, - }); - } - }); - } + // Vanilla draws every rain column before the snow ones. + rain.extend(snow_vertices); + rain } /// Player.startSleepInBed: night or thunder, no monsters within 8 blocks; /// the bed becomes the respawn point either way. @@ -9792,15 +9795,17 @@ impl Game<'_> { self.entity_geometry(camera, alpha, entities) }); } + let bolts = if title { + Vec::new() + } else { + self.bolt_instances() + }; let mut additive = Vec::new(); - if !title { - self.bolt_geometry(camera, &mut additive); - if self.dim == Dim::End { - let mut dragon = Vec::new(); - self.dragon_geometry(camera, alpha, &mut dragon, &mut additive); - self.dragon_fireball_geometry(camera, alpha, &mut dragon); - entities.extend(dragon); - } + if !title && self.dim == Dim::End { + let mut dragon = Vec::new(); + self.dragon_geometry(camera, alpha, &mut dragon, &mut additive); + self.dragon_fireball_geometry(camera, alpha, &mut dragon); + entities.extend(dragon); } // A Java pack's `clouds` replaces the cloud option (`renderClouds`: // "false", "fast", "true"), as Iris overrides `getCloudsType`. @@ -9822,8 +9827,8 @@ impl Game<'_> { { // Camera.doesMobEffectBlockSky: no sun, moon or stars. self.celestial_geometry(&sky) - } else if self.dim == Dim::End { - (self.end_sky_geometry(), None) + } else if self.dim == Dim::End && self.settings.horizon.sky { + (self.end_flash_geometry(), None) } else { (Vec::new(), None) }; @@ -9840,11 +9845,12 @@ impl Game<'_> { if !title { self.end_geometry(camera, &mut entities); } - if (!title || live) && self.dim == Dim::Overworld && self.settings.horizon.weather { - horizon_client::spans::time("weather", || { - self.weather_geometry(camera, alpha, &mut entities) - }); - } + let weather = + if (!title || live) && self.dim == Dim::Overworld && self.settings.horizon.weather { + horizon_client::spans::time("weather", || self.weather_geometry(camera, alpha)) + } else { + Vec::new() + }; let border = (!title) .then(|| self.border_draw(camera.to_array(), alpha as f32)) .flatten(); @@ -9855,6 +9861,8 @@ impl Game<'_> { self.gather_dynamic_lights(camera, alpha); } let frame = Frame { + weather: &weather, + weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32), shader: self.shader_inputs(camera, alpha as f32), nether_lighting: self.dim == Dim::Nether, camera, @@ -9870,6 +9878,12 @@ impl Game<'_> { title: title && !live, skybox: self.dim == Dim::Overworld && self.settings.horizon.sky, end_sky: self.dim == Dim::End && self.settings.horizon.sky, + end_sky_sprite: self + .gui + .atlas + .sprites + .get("environment/end_sky") + .map(|r| [r.u0, r.v0, r.u1, r.v1]), environment_fog: (self.dim == Dim::Nether).then_some((sky.fog_start, sky.fog_end)), cave_culling, water_fog, @@ -9912,6 +9926,13 @@ impl Game<'_> { }), entities: &entities, dynamic_lights: &self.dynamic_lights, + lightning: horizon_client::gfx::lightning::Input { + bolts: &bolts, + uv: [ + self.gui.atlas.font.white().u0, + self.gui.atlas.font.white().v0, + ], + }, additive: &additive, see_through: &see_through, celestial: if self.settings.horizon.sky || title { @@ -10017,9 +10038,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 { let loading = self.loading_reason() == Some(horizon_client::level_loading::Reason::Other); let blurred = !horizon_client::ui_theme::horizon() @@ -10027,7 +10047,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) } @@ -11448,6 +11471,7 @@ impl<'a> Game<'a> { gui, fog: Default::default(), screen_fx: Default::default(), + weather_parameters: Default::default(), panorama_rotation: Default::default(), world, streaming, @@ -11592,6 +11616,7 @@ impl<'a> Game<'a> { dragging: false, avatar: Default::default(), flash: 0, + lightning_seen: [0; 2], sleeping: None, sleep_timer: 0, dim: Dim::Overworld, @@ -12360,6 +12385,8 @@ fn loading_renderer( /// A title-shaped frame: black clear and panorama, only the HUD is drawn. fn loading_frame(hud: &HudBatch) -> Frame<'_> { Frame { + weather: &[], + weather_time: horizon_client::weather::Time::new(0, 0.0), camera: glam::DVec3::new(0.5, 100.0, 0.5), yaw: 0.0, pitch: 10.0, @@ -12374,6 +12401,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { title: true, skybox: false, end_sky: false, + end_sky_sprite: None, environment_fog: None, water_fog: [0.0; 3], fog: None, @@ -12388,6 +12416,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { entities: &[], dynamic_lights: &[], clouds: None, + lightning: Default::default(), additive: &[], see_through: &[], celestial: &[], diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs index 433c588d0..6b24226d9 100644 --- a/crates/horizon-client/src/game/boats.rs +++ b/crates/horizon-client/src/game/boats.rs @@ -57,7 +57,7 @@ pub(super) const CHEST_SLOTS: usize = 27; const WIDTH: f64 = 1.375; const HEIGHT: f64 = 0.5625; /// Player.DEFAULT_VEHICLE_ATTACHMENT minus the boat's passenger attachment. -const SEAT: f64 = 0.1875 - 0.6; +pub(super) const SEAT: f64 = 0.1875 - 0.6; impl Boat { pub fn new(id: u32, wood: Arc, position: Vec3, yaw: f32) -> Self { Self { @@ -295,7 +295,7 @@ impl Game<'_> { } } /// `AbstractBoat.tick` for one boat (`controlled` when the player rides it). - fn tick_boat(&mut self, mut b: Boat, controlled: bool) -> Boat { + pub(super) fn tick_boat(&mut self, mut b: Boat, controlled: bool) -> Boat { b.previous = b.position; b.previous_yaw = b.yaw; b.old_status = b.status; @@ -448,9 +448,12 @@ impl Game<'_> { pub(super) fn tick_boats(&mut self) { // ServerLevel.tick: only entities in entity-ticking chunks tick. let ticking = self.entity_ticking_area(); + // A server player's boat is driven by its client (lan_vehicles.rs). + let driven = self.guest_vehicles(); for i in 0..self.boats.len() { let p = self.boats[i].position; if Some(self.boats[i].id) == self.riding + || driven.contains(&self.boats[i].id) || !ticking(p.x.floor() as i32, p.z.floor() as i32) { continue; @@ -659,7 +662,11 @@ impl Game<'_> { self.right = false; return true; } - if sneaking || self.boats[i].out_of_control >= 60.0 || self.riding.is_some() { + if sneaking + || self.boats[i].out_of_control >= 60.0 + || self.riding.is_some() + || self.ridden_by_guest(self.boats[i].id) + { return false; } self.riding = Some(self.boats[i].id); diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 6fc456f8d..a04c89ebf 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -926,6 +926,8 @@ impl Game<'_> { status["heard"] = json!(self.audio.heard); // Boats, minecarts, armor stands, item frames and paintings. status["objects"] = json!(self.objects_status()); + status["lightning"] = json!({"bolts": self.bolts.len(), "struck": self.lightning_seen[0], + "flashes": self.lightning_seen[1], "flash": self.flash}); // Primed TNT, falling blocks, projectiles, tridents and end crystals. status["projectiles"] = json!(self.projectiles_status()); status diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs index a7813c767..98a595f76 100644 --- a/crates/horizon-client/src/game/end.rs +++ b/crates/horizon-client/src/game/end.rs @@ -138,47 +138,12 @@ impl Game<'_> { } } - /// SkyRenderer.buildEndSky: six faces of end_sky.png tiled 16 times, - /// tinted 0x282828. The atlas does not wrap, so each face is 16×16 quads. - pub(super) fn end_sky_geometry(&self) -> Vec { - let mut out = Vec::with_capacity(6 * 256 * 4); - let Some(r) = self.gui.atlas.sprites.get("environment/end_sky").copied() else { + /// SkyRenderer.renderEndFlash, drawn after the renderer's resident sky mesh. + pub(super) fn end_flash_geometry(&self) -> Vec { + let mut out = Vec::new(); + // The old combined sky/flash draw also skipped the flash without a sky sprite. + if !self.gui.atlas.sprites.contains_key("environment/end_sky") { return out; - }; - use std::f32::consts::FRAC_PI_2; - let faces = [ - glam::Mat4::IDENTITY, - glam::Mat4::from_rotation_x(FRAC_PI_2), - glam::Mat4::from_rotation_x(-FRAC_PI_2), - glam::Mat4::from_rotation_x(std::f32::consts::PI), - glam::Mat4::from_rotation_z(FRAC_PI_2), - glam::Mat4::from_rotation_z(-FRAC_PI_2), - ]; - let step = 200.0 / 16.0; - for pose in faces { - for a in 0..16 { - for b in 0..16 { - let (x0, z0) = (-100.0 + step * a as f32, -100.0 + step * b as f32); - let (x1, z1) = (x0 + step, z0 + step); - let corners = [ - (x0, z0, [r.u0, r.v0]), - (x0, z1, [r.u0, r.v1]), - (x1, z1, [r.u1, r.v1]), - (x1, z0, [r.u1, r.v0]), - ]; - for (x, z, uv) in corners { - let p = pose.transform_point3(glam::Vec3::new(x, -100.0, z)); - out.push(Vertex { - normal: [0; 4], - pos: p.to_array(), - uv, - layer: 2, - color: 0xFF28_2828, - light: 0, - }); - } - } - } } // SkyRenderer.renderEndFlash: the end_flash sprite at height 100, scale 60. let intensity = self.end.flash.intensity(self.clock.fraction() as f32); diff --git a/crates/horizon-client/src/game/friends.rs b/crates/horizon-client/src/game/friends.rs index 51dfe3fbf..69192265e 100644 --- a/crates/horizon-client/src/game/friends.rs +++ b/crates/horizon-client/src/game/friends.rs @@ -52,10 +52,12 @@ impl Game<'_> { if self.friends.is_some() { return Ok(()); } - if self.remote.is_some() || self.title.is_some() { + // Single player on its server thread shares that server, as Open to + // LAN publishes it; another server can't be shared. + if self.title.is_some() || (self.remote.is_some() && self.integrated.is_none()) { return Err("open a singleplayer world first".into()); } - let opened_lan = self.lan.is_none(); + let opened_lan = self.lan_port().is_none(); if opened_lan { // ShareToLanScreen's defaults, as the world options screen offers them. self.lan_open(LanSettings { @@ -171,14 +173,20 @@ impl Game<'_> { /// What the pause menu shows. pub(super) fn friends_view(&self) -> FriendsView { - let guests = self - .lan - .as_ref() - .map(|h| h.hub.guests.iter().map(|g| g.name.clone()).collect()) - .unwrap_or_default(); + let guests = match &self.lan { + Some(h) => h.hub.guests.iter().map(|g| g.name.clone()).collect(), + // On the server thread: the other players the server lists. + None if self.integrated.is_some() => { + let me = self.options.player_name(); + let mut names = self.remote_online_names().unwrap_or_default(); + names.retain(|n| *n != me); + names + } + None => Vec::new(), + }; let Some(s) = &self.friends else { return FriendsView { - shown: self.remote.is_none(), + shown: self.remote.is_none() || self.integrated.is_some(), ..FriendsView::default() }; }; diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index 548a69e3f..17e1e09a3 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -807,7 +807,13 @@ impl Game<'_> { if has_guests { let host_entity = state.as_ref().map(|s| s.entity_id); self.lan_assign_ids(); - self.lan_riding(host_entity, &mut host.hub.riding); + let guests: Vec<(u32, i32)> = host + .hub + .guests + .iter() + .filter_map(|g| Some((g.vehicle?, g.entity_id))) + .collect(); + self.lan_riding(host_entity, &guests, &mut host.hub.riding); self.lan_entities(host_entity, &mut host.hub, &mut states); } else { states.clear(); diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 7028c2eca..eccbd7f0b 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -292,7 +292,8 @@ impl Game<'_> { let (left, right) = (self.left, self.right); self.left = play.digging.is_some(); self.right = play.using.is_some() || self.using.is_some(); - let riding = self.riding.take(); + // The guest's vehicle (Entity.vehicle) for its turn. + let riding = std::mem::replace(&mut self.riding, g.vehicle); let host_station = self.station.take(); // The guest's bed, sleep counter and respawn point; the host's // respawn point, anchor and action bar stay theirs. @@ -467,7 +468,7 @@ impl Game<'_> { (self.respawn_config, self.level.spawn) = respawn; // ServerPlayer.displayClientMessage(_, true): the guest's action bar. let guest_message = std::mem::replace(&mut self.message, message); - self.riding = riding; + let guest_vehicle = std::mem::replace(&mut self.riding, riding); self.left = left; self.right = right; play.mining = std::mem::replace(&mut self.mining, mining); @@ -491,6 +492,11 @@ impl Game<'_> { self.mount_menu = host_mount_menu; self.keys = host_keys; let g = &mut host.hub.guests[i]; + let left_vehicle = g.vehicle.filter(|_| guest_vehicle.is_none()); + if guest_vehicle.is_none() { + g.vehicle_good = None; + } + g.vehicle = guest_vehicle; let fell_asleep = bed.is_some() && g.bed.is_none(); (g.bed, g.sleep_timer, g.spawn) = (bed, guest_sleep_timer, guest_spawn); g.sleeping = g.bed.is_some(); @@ -549,7 +555,24 @@ impl Game<'_> { let teleported = std::mem::take(&mut m.teleported); let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum(); g.motion = Some(Box::new(m)); - if moved > 0.0001 || turned || teleported { + // Entity.teleportTo takes a rider out of its vehicle. + let left_vehicle = match g.vehicle.filter(|_| teleported) { + Some(v) => { + (g.vehicle, g.vehicle_good) = (None, None); + Some(v) + } + None => left_vehicle, + }; + // ServerPlayer.dismountTo: the client hears it is out of the + // vehicle before the teleport beside it. A rider sits where its + // vehicle puts it (lan_vehicles.rs), with no teleport. + if let Some(vehicle) = left_vehicle { + g.send(&C::SetPassengers(play::SetPassengers { + vehicle: vehicle as i32, + passengers: Vec::new(), + })); + } + if g.vehicle.is_none() && (moved > 0.0001 || turned || teleported) { host.hub.teleport(i, Some(at)); } } @@ -900,16 +923,22 @@ impl Game<'_> { } S::Attack(p) => self.guest_attack(host, conn, p.id), S::Interact(p) => { - if let Some((position, eye)) = self.look_at_entity(host, gi, p.id) { - let _ = (position, eye); + let before = host.hub.guests[gi].vehicle; + if self + .look_at_entity(host, gi, p.id, Some(p.location)) + .is_some() + { let swung = self.as_guest(host, conn, |g| { let swings = g.swings_started; let _ = g.use_item(); g.swings_started != swings }); self.lan_swing_back(host, conn, swung); + self.guest_boarded(host, conn, before); } } + S::MoveVehicle(p) => self.guest_move_vehicle(host, conn, &p), + S::PaddleBoat(p) => self.guest_paddle_boat(host, conn, [p.left, p.right]), S::SetCreativeModeSlot(p) => { let g = &mut host.hub.guests[gi]; if !g.creative() || !(0..46).contains(&p.slot) { @@ -1147,19 +1176,39 @@ impl Game<'_> { } } - /// Aim the swapped-in player at an entity; returns its centre and the eye. + /// Aim the swapped-in player at an entity; returns where it aims and the + /// eye. A boat, minecart, armor stand, item frame or painting is aimed at + /// the point the client hit (the interact packet's location) when that + /// is on it, else at its centre. fn look_at_entity( &mut self, host: &mut LanHost, gi: usize, id: i32, + location: Option<[f64; 3]>, ) -> Option<([f64; 3], [f64; 3])> { + let object = || { + let (lo, hi, origin) = self.object_target(id)?; + let middle = [0, 1, 2].map(|k| (lo[k] + hi[k]) / 2.0); + let Some(l) = location else { + return Some(middle); + }; + let point = [0, 1, 2].map(|k| origin[k] + l[k]); + // A little inside the box, so the ray from the eye meets it. + let inside = [0, 1, 2].map(|k| { + let margin = ((hi[k] - lo[k]) / 2.0).min(0.01); + point[k].clamp(lo[k] + margin, hi[k] - margin) + }); + let on = (0..3).all(|k| (point[k] - inside[k]).abs() < 0.1); + Some(if on { inside } else { middle }) + }; let centre = match self.mobs.iter().find(|m| m.id as i32 == id) { Some(m) => [ m.position.x, m.position.y + m.kind.height * 0.5, m.position.z, ], + None if self.object_target(id).is_some() => object()?, // A dragon part or an end crystal (game/dragon.rs). None => { let b = self.tracked_special_box(id)?; @@ -1210,7 +1259,7 @@ impl Game<'_> { return; } let (old_yaw, old_pitch) = (host.hub.guests[gi].yaw, host.hub.guests[gi].pitch); - if self.look_at_entity(host, gi, id).is_none() { + if self.look_at_entity(host, gi, id, None).is_none() { return; } self.as_guest(host, conn, |g| { @@ -1676,6 +1725,7 @@ impl Game<'_> { /// regeneration and the food tick (ServerPlayer.doTick). Their hurt /// sounds are heard at the guest. fn guest_server_tick(&mut self, host: &mut LanHost, conn: u32) { + self.guest_vehicle_tick(host, conn); let Some(g) = host.hub.guest_mut(conn) else { return; }; diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index 404d00c46..5f46f7c21 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -89,8 +89,17 @@ fn stand_poses(raw: Option<&Tag>) -> Vec<(u8, i32, Value)> { impl Game<'_> { /// Who rides what (`Entity.getPassengers`): mobs on mobs, and the /// host in its boat or minecart. - pub(super) fn lan_riding(&self, host_entity: Option, riding: &mut Riding) { + pub(super) fn lan_riding( + &self, + host_entity: Option, + guests: &[(u32, i32)], + riding: &mut Riding, + ) { riding.clear(); + // The server's players in their boats and minecarts. + for &(vehicle, guest) in guests { + riding.add(vehicle as i32, guest); + } for m in self.mobs.iter().filter(|m| !m.removed) { if let Some(vehicle) = m.extra.mount { riding.add(vehicle as i32, m.id as i32); @@ -264,6 +273,7 @@ impl Game<'_> { self.tridents.iter_mut().for_each(|t| give(&mut t.id)); self.rockets.iter_mut().for_each(|r| give(&mut r.id)); self.crystals.iter_mut().for_each(|c| give(&mut c.id)); + self.bolts.iter_mut().for_each(|b| give(&mut b.id)); } /// Primed TNT, falling blocks, projectiles, tridents, firework rockets and @@ -275,6 +285,10 @@ impl Game<'_> { None => 0, }; let at = |p: horizon_core::geometry::Vec3| [p.x, p.y, p.z]; + // LightningBolt: each client draws and flashes its own. + for b in self.bolts.iter().filter(|b| b.id != 0) { + out.push(state(b.id, "minecraft:lightning_bolt", b.at, 0.0, false)); + } for t in self.tnts.iter().filter(|t| t.id != 0) { let mut e = state(t.id, "minecraft:tnt", at(t.position), 0.0, t.on_ground); e.velocity = at(t.velocity); diff --git a/crates/horizon-client/src/game/lan_vehicles.rs b/crates/horizon-client/src/game/lan_vehicles.rs new file mode 100644 index 000000000..01195e49e --- /dev/null +++ b/crates/horizon-client/src/game/lan_vehicles.rs @@ -0,0 +1,288 @@ +//! Boats and minecarts for a server's players: LAN guests, players on a +//! dedicated server, and single player's window on its server thread. +//! +//! A player aims at a vehicle, item frame, armor stand or painting as at a +//! mob (`ServerGamePacketListenerImpl.handleInteract`), and the game's own +//! code for it runs as that player (`AbstractBoat.interact` seats it, +//! `VehicleEntity.hurtServer` breaks the vehicle). A boat is driven by its +//! rider's client (`handleMoveVehicle`, `handlePaddleBoat`); a minecart moves +//! here with the rider's input (`ServerPlayer.getLastClientMoveIntent`). +//! Sneaking gets out (`Player.rideTick`: `wantsToStopRiding`), and the client +//! is teleported where the player lands (`ServerPlayer.dismountTo`). +use super::{Game, Keys, boats::SEAT, lan::LanHost}; +use horizon_client::collisions::SceneCollisions; +use horizon_core::geometry::{Aabb, Vec3}; +use horizon_protocol::{ + packets::play::{self, Clientbound as C}, + text::translatable, +}; + +/// `PlayerInput` flags, as the server player's client last sent them. +pub(super) fn input_keys(flags: u8) -> Keys { + Keys { + forward: flags & 1 != 0, + backward: flags & 2 != 0, + left: flags & 4 != 0, + right: flags & 8 != 0, + jump: flags & 16 != 0, + shift: flags & 32 != 0, + ..Keys::default() + } +} + +fn corners(b: Aabb) -> ([f64; 3], [f64; 3]) { + let (lo, hi) = (b.min_position(), b.max_position()); + ([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z]) +} + +impl Game<'_> { + /// The box of a boat, minecart, armor stand, item frame or painting, and + /// the point an interact packet's location is measured from (the + /// client's `remote_object_hit` uses the same points). + pub(super) fn object_target(&self, id: i32) -> Option<([f64; 3], [f64; 3], [f64; 3])> { + let id = u32::try_from(id).ok()?; + let at = |v: Vec3| [v.x, v.y, v.z]; + let centre = |p: [i32; 3]| p.map(|v| f64::from(v) + 0.5); + if let Some(b) = self.boats.iter().find(|b| b.id == id) { + let (lo, hi) = corners(b.bounds()); + return Some((lo, hi, at(b.position))); + } + if let Some(c) = self.carts.iter().find(|c| c.id == id) { + let (lo, hi) = corners(c.bounds()); + return Some((lo, hi, at(c.position))); + } + if let Some(a) = self.armor_stands.iter().find(|a| a.id == id) { + let (lo, hi) = corners(a.bounds()); + return Some((lo, hi, at(a.position))); + } + if let Some(f) = self.item_frames.iter().find(|f| f.id == id) { + let (lo, hi) = f.bounds(); + return Some((lo, hi, centre(f.pos))); + } + let p = self.paintings.iter().find(|p| p.id == id)?; + let (lo, hi) = p.bounds(); + Some((lo, hi, centre(p.pos))) + } + + /// The vehicles the server's players ride: they move with their riders, + /// not in `tick_boats` and `tick_carts`. + pub(super) fn guest_vehicles(&self) -> Vec { + self.lan.as_ref().map_or_else(Vec::new, |h| { + h.hub.guests.iter().filter_map(|g| g.vehicle).collect() + }) + } + + /// Whether a server player other than the one acting rides `vehicle` + /// (`Entity.canAddPassenger`: a boat or minecart seats one player here). + pub(super) fn ridden_by_guest(&self, vehicle: u32) -> bool { + self.lan.as_ref().is_some_and(|h| { + h.hub + .guests + .iter() + .any(|g| Some(g.conn) != self.lan_acting && g.vehicle == Some(vehicle)) + }) + } + + /// `Player.rideTick` for a server player, before its moves this tick: + /// it stays in its seat, steers its minecart, or gets out. + pub(super) fn guest_vehicle_tick(&mut self, host: &mut LanHost, conn: u32) { + let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else { + return; + }; + let g = &host.hub.guests[gi]; + let Some(vehicle) = g.vehicle else { + return; + }; + let (keys, dead) = (input_keys(g.input), g.dead || g.health <= 0.0); + let boat = self.boats.iter().position(|b| b.id == vehicle); + let cart = self.carts.iter().any(|c| c.id == vehicle); + // The vehicle is gone (broken, in another level) or the rider died: + // its client drops it with the entity or the death screen. + if dead || (boat.is_none() && !cart) { + let g = &mut host.hub.guests[gi]; + (g.vehicle, g.vehicle_good) = (None, None); + return; + } + if let Some(i) = boat { + // AbstractBoat.tick on the server for a boat its rider drives: + // only the hurt animation and the damage wear off here. + let b = &mut self.boats[i]; + b.hurt_time = (b.hurt_time - 1).max(0); + b.damage = (b.damage - 1.0).max(0.0); + } + // Getting out goes through leave_guest, which tells the client and + // teleports it (ServerPlayer.dismountTo). + let seat = self.as_guest(host, conn, |game| { + if let Some(i) = game.boats.iter().position(|b| Some(b.id) == game.riding) { + if keys.shift { + game.dismount(i); + return None; + } + let p = game.boats[i].position; + return Some([p.x, p.y + SEAT, p.z]); + } + // The minecart moves with the rider's input, and lets it out when + // it sneaks or the cart breaks. + game.tick_cart_riding(keys); + game.riding?; + let p = game.player.as_ref()?.position; + Some([p.x, p.y, p.z]) + }); + if let Some(Some(at)) = seat { + let g = &mut host.hub.guests[gi]; + g.previous_position = g.position; + g.position = at; + } + } + + /// After an interaction: a player that got into a vehicle sits in it, + /// and its last good vehicle position is where the vehicle is. + pub(super) fn guest_boarded(&mut self, host: &mut LanHost, conn: u32, before: Option) { + let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else { + return; + }; + let Some(vehicle) = host.hub.guests[gi].vehicle else { + return; + }; + if before == Some(vehicle) { + return; + } + // The host in the window rides it already. + if self.riding == Some(vehicle) { + host.hub.guests[gi].vehicle = before; + return; + } + let at = self + .boats + .iter() + .find(|b| b.id == vehicle) + .map(|b| b.position) + .or_else(|| { + self.carts + .iter() + .find(|c| c.id == vehicle) + .map(|c| c.position) + }); + let g = &mut host.hub.guests[gi]; + if let Some(p) = at { + g.vehicle_good = Some([p.x, p.y, p.z]); + g.previous_position = g.position; + g.position = [p.x, p.y + SEAT, p.z]; + g.on_ground = false; + } + } + + /// `ServerGamePacketListenerImpl.handleMoveVehicle`: the boat its rider + /// drives goes where the client says, unless it moved too quickly or + /// wrongly; then it stays, and the client is told where it is. + pub(super) fn guest_move_vehicle( + &mut self, + host: &mut LanHost, + conn: u32, + p: &play::MoveVehicleRequest, + ) { + let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else { + return; + }; + let [x, y, z] = p.position; + if !(x.is_finite() && y.is_finite() && z.is_finite()) + || !p.yaw.is_finite() + || !p.pitch.is_finite() + { + host.hub.kick( + conn, + translatable("multiplayer.disconnect.invalid_vehicle_movement", &[]), + ); + return; + } + let g = &host.hub.guests[gi]; + if g.awaiting_teleport.is_some() || !g.loaded { + return; + } + let owner = host.hub.singleplayer_owner == Some(g.uuid); + let (vehicle, good) = (g.vehicle, g.vehicle_good); + let back = |host: &mut LanHost, position: Vec3, yaw: f32| { + let packet = play::MoveVehicle { + position: [position.x, position.y, position.z], + yaw, + pitch: 0.0, + }; + host.hub.send_to(conn, &C::MoveVehicle(packet)); + }; + // Only a boat is driven by its rider (getControllingPassenger); a + // minecart that is elsewhere on the client is put back. + let Some(i) = vehicle.and_then(|v| self.boats.iter().position(|b| b.id == v)) else { + if let Some(c) = vehicle.and_then(|v| self.carts.iter().find(|c| c.id == v)) + && c.position.distance_squared(Vec3::new(x, y, z)) > 1.0 + { + back(host, c.position, c.yaw); + } + return; + }; + let b = &self.boats[i]; + let old = b.position; + let good = good.map_or(old, |g| Vec3::new(g[0], g[1], g[2])); + let target = Vec3::new( + x.clamp(-3.0E7, 3.0E7), + y.clamp(-2.0E7, 2.0E7), + z.clamp(-3.0E7, 3.0E7), + ); + // Moved too quickly: more than 10 blocks past its own motion. + let moved = target.distance_squared(old) - b.velocity.length_squared(); + if moved > 100.0 && !owner { + log::warn!("boat {} moved too quickly! {moved}", b.id); + back(host, old, b.yaw); + return; + } + // vehicle.move(PLAYER, target - lastGood) with the boat's collisions: + // where it can't follow the client (a quarter block off, the height + // aside), it moved wrongly. + let bounds = b.bounds(); + let mut scene = SceneCollisions { + world: &self.world, + binding: self.collision, + subject: None, + }; + let wanted = target.subtract(good); + let resolved = scene + .resolve(bounds, wanted, 0.0, b.on_ground) + .unwrap_or(wanted); + let reached = old.add_vector(resolved); + let wrongly = (target.x - reached.x).powi(2) + (target.z - reached.z).powi(2) > 0.0625; + let free_before = scene.unobstructed(bounds).unwrap_or(true); + // isEntityCollidingWithAnythingNew: a box that was free is not there. + let moved_box = bounds.move_by(target.subtract(old)); + let free_after = scene + .unobstructed(moved_box.deflate(Vec3::new(1.0E-5, 1.0E-5, 1.0E-5))) + .unwrap_or(true); + if free_before && (wrongly || !free_after) { + log::warn!("boat {} moved wrongly", b.id); + back(host, old, b.yaw); + return; + } + let b = &mut self.boats[i]; + b.previous = old; + b.velocity = target.subtract(old); + b.position = target; + b.previous_yaw = b.yaw; + b.yaw = p.yaw; + b.on_ground = p.on_ground; + let g = &mut host.hub.guests[gi]; + g.vehicle_good = Some([target.x, target.y, target.z]); + g.previous_position = g.position; + g.position = [target.x, target.y + SEAT, target.z]; + } + + /// `handlePaddleBoat`: the paddles of the boat the player drives. + pub(super) fn guest_paddle_boat(&mut self, host: &LanHost, conn: u32, paddles: [bool; 2]) { + let vehicle = host + .hub + .guests + .iter() + .find(|g| g.conn == conn) + .and_then(|g| g.vehicle); + if let Some(b) = self.boats.iter_mut().find(|b| Some(b.id) == vehicle) { + b.paddling = paddles; + } + } +} diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 6c4dd933f..476cb5aa4 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -5,17 +5,13 @@ //! witches, mooshroom colours, turtles, burnt items), lightning rods, the sky //! flash, the sounds and the branching additive bolt. use super::Game; -use horizon_client::{ - mesher::Vertex, - mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species}, -}; -use horizon_core::{ - position::BlockPos, - random::{LegacyRandom, RandomSource}, -}; +use horizon_client::mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species}; +use horizon_core::{position::BlockPos, random::RandomSource}; pub(super) struct Bolt { - at: [f64; 3], + /// The entity id a server's players know it by (0 until it has one). + pub id: u32, + pub at: [f64; 3], life: i32, flashes: i32, seed: i64, @@ -137,7 +133,9 @@ impl Game<'_> { let r = &mut self.world.random; let seed = r.next_long(); let flashes = r.next_int_bound(3).unwrap_or(0) + 1; + self.lightning_seen[0] += 1; self.bolts.push(Bolt { + id: 0, at, life: 2, flashes, @@ -146,6 +144,24 @@ impl Game<'_> { converted: Vec::new(), }); } + /// `ClientLevel.addEntity` for a server's lightning bolt: on a client it + /// only flashes, sounds and draws (`LightningBolt.tick` off the server). + pub(super) fn spawn_remote_bolt(&mut self, id: u32, at: [f64; 3]) { + self.bolts.retain(|b| b.id != id); + let r = &mut self.world.random; + let seed = r.next_long(); + let flashes = r.next_int_bound(3).unwrap_or(0) + 1; + self.lightning_seen[0] += 1; + self.bolts.push(Bolt { + id, + at, + life: 2, + flashes, + seed, + visual_only: true, + converted: Vec::new(), + }); + } /// `spawnFire`: fire at the strike point and `extra` random neighbours. fn bolt_fire(&mut self, at: [f64; 3], extra: i32) { if self.ui.difficulty < 2 { @@ -222,6 +238,9 @@ impl Game<'_> { } } if b.life >= 0 { + if self.flash == 0 { + self.lightning_seen[1] += 1; + } self.flash = 2; if !b.visual_only { self.thunder_hit(b); @@ -349,71 +368,14 @@ impl Game<'_> { || e.stack.item.contains("netherite") }); } - /// `LightningBoltRenderer`: 4 layers of a trunk and two branches, 8 - /// segments of 16 blocks, from the bolt's seed. - pub(super) fn bolt_geometry(&self, camera: glam::DVec3, out: &mut Vec) { - let white = self.gui.atlas.font.white(); - let uv = [white.u0, white.v0]; - // ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA. - let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114; - for b in &self.bolts { - let o = (glam::DVec3::from_array(b.at) - camera).as_vec3(); - let mut random = LegacyRandom::new(b.seed); - let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]); - let (mut x_off, mut z_off) = (0f32, 0f32); - for i in (0..8).rev() { - xs[i] = x_off; - zs[i] = z_off; - x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; - z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; - } - for layer in 0..4 { - let mut random = LegacyRandom::new(b.seed); - for branch in 0..3 { - let trunk = branch == 0; - let start = 7 - branch; - let end = if trunk { 0 } else { start - 3 + 1 }; - let mut sx = xs[start] - x_off; - let mut sz = zs[start] - z_off; - for segment in (end..=start).rev() { - let (ex, ez) = (sx, sz); - let spread = if trunk { 11 } else { 31 }; - sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; - sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; - let mut top = 0.1 + layer as f32 * 0.2; - let mut bottom = top; - if trunk { - top *= segment as f32 * 0.1 + 1.0; - bottom *= (segment as f32 - 1.0) * 0.1 + 1.0; - } - for (rx, rz, lx, lz) in [ - (false, false, true, false), - (true, false, true, true), - (true, true, false, true), - (false, true, false, false), - ] { - let s = |p: bool, r: f32| if p { r } else { -r }; - let y0 = segment as f32 * 16.0; - let corners = [ - [sx + s(rx, bottom), y0, sz + s(rz, bottom)], - [ex + s(rx, top), y0 + 16.0, ez + s(rz, top)], - [ex + s(lx, top), y0 + 16.0, ez + s(lz, top)], - [sx + s(lx, bottom), y0, sz + s(lz, bottom)], - ]; - for c in corners { - out.push(Vertex { - normal: [0; 4], - pos: (o + glam::Vec3::from_array(c)).to_array(), - uv, - layer: 2, - color, - light: 240 | 240 << 8, - }); - } - } - } - } - } - } + /// Simulation-order render inputs; seeded geometry lives in the renderer. + pub(super) fn bolt_instances(&self) -> Vec { + self.bolts + .iter() + .map(|b| horizon_client::gfx::lightning::Bolt { + at: b.at, + seed: b.seed, + }) + .collect() } } diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 367dc6aaf..756202530 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -775,10 +775,13 @@ impl Game<'_> { self.push_carts(); // ServerLevel.tick: only entities in entity-ticking chunks tick. let ticking = self.entity_ticking_area(); + // A server player's minecart moves with its rider (lan_vehicles.rs). + let ridden = self.guest_vehicles(); let mut i = 0; while i < self.carts.len() { let p = self.carts[i].position; if Some(self.carts[i].id) == self.riding + || ridden.contains(&self.carts[i].id) || !ticking(p.x.floor() as i32, p.z.floor() as i32) { i += 1; @@ -986,7 +989,7 @@ impl Game<'_> { let held = self.held().cloned(); match self.carts[i].kind { CartKind::Rideable => { - if sneaking || self.riding.is_some() { + if sneaking || self.riding.is_some() || self.ridden_by_guest(self.carts[i].id) { return false; } self.riding = Some(self.carts[i].id); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index ea8137776..c482d9728 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -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}, @@ -93,7 +93,7 @@ pub(super) struct Remote { pub(super) registries: Arc, joined: bool, status: String, - entity_id: i32, + pub(super) entity_id: i32, dimension: DimensionType, biome_map: Vec, biome_bits: u8, @@ -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; @@ -1362,6 +1367,10 @@ impl Game<'_> { self.turn_remote_projectile(id, rotation); } fn remove_entity(&mut self, id: i32) { + // The vehicle the player rode is gone (Entity.removeVehicle). + if self.riding == Some(id as u32) { + self.riding = None; + } self.mobs.retain(|m| m.id != id as u32); self.orbs.retain(|o| o.id != id as u32); self.dropped.retain(|d| d.id != id as u32); @@ -1748,6 +1757,8 @@ impl Game<'_> { ]; self.move_entity(p.id, position, Some((p.yaw, p.pitch)), p.on_ground); } + C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers), + C::MoveVehicle(p) => self.remote_move_vehicle(p.position, p.yaw), // ClientPacketListener.handleRotateMob: lerpHeadTo(yHeadRot, 3). C::RotateHead(p) => { if let Some(r) = self.remote.as_mut() { @@ -2927,9 +2938,9 @@ impl Game<'_> { self.capture_loaded_world(); } let stick = self.pad_move(); - let Some(player) = self.player.as_mut() else { + if self.player.is_none() { return Ok(()); - }; + } let playing = self.screen == Screen::Playing; let held = |k| playing && self.keys.contains(&k); let keys = Keys { @@ -2950,7 +2961,14 @@ impl Game<'_> { | u8::from(keys.jump) << 4 | u8::from(keys.shift) << 5 | u8::from(keys.sprint) << 6; - self.previous_position = player.position; + // A passenger moves with its vehicle (Entity.rideTick), not by itself. + let riding = self.screen != Screen::Dead && self.remote_ride(keys); + let Some(player) = self.player.as_mut() else { + return Ok(()); + }; + if !riding { + self.previous_position = player.position; + } let before = ( player.ground.on_ground, [player.velocity.x, player.velocity.y, player.velocity.z], @@ -2967,7 +2985,7 @@ impl Game<'_> { f64::from(head[2]) + 0.5, ); player.velocity = Vec3::ZERO; - } else if !dead { + } else if !dead && !riding { player.velocity = player.velocity.add_vector(pushed); MotionWorld { entities: &ghast_collisions, @@ -3253,6 +3271,9 @@ impl Game<'_> { }; self.tick_remote_objects(&mut step); self.tick_remote_projectiles(&mut step); + // LightningBolt.tick on a client, and the sky flash fading. + self.flash = self.flash.saturating_sub(1); + self.tick_bolts(); } lerps.retain(|_, l| l.steps > 0); if let Some(r) = self.remote.as_mut() { @@ -3314,6 +3335,8 @@ impl Game<'_> { p.sprinting, ); let (yaw, pitch, selected) = (self.yaw, self.pitch, self.selected); + let riding = self.riding.is_some(); + let vehicle = self.remote_vehicle_packets(); let Some(r) = self.remote.as_mut() else { return; }; @@ -3336,9 +3359,18 @@ impl Game<'_> { data: 0, })); } - if let Some(packet) = r - .position_sender - .update(pos, (yaw, pitch), on_ground, collision) + if riding { + // LocalPlayer.tick: a passenger sends its look, then the vehicle + // it controls. + out.push(S::MovePlayerRot(play::MovePlayerRot { + yaw, + pitch, + flags: u8::from(on_ground) | u8::from(collision) << 1, + })); + out.extend(vehicle); + } else if let Some(packet) = + r.position_sender + .update(pos, (yaw, pitch), on_ground, collision) { out.push(packet); } @@ -3458,10 +3490,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() { @@ -3571,6 +3601,21 @@ impl Game<'_> { fn remote_use_entity(&mut self) -> bool { let sneaking = self.keys.contains(&KeyCode::ShiftLeft); + // A boat, minecart, item frame, armor stand or painting nearer than + // any mob: the server uses it (AbstractBoat.interact boards it). + if let Some(hit) = self.remote_object_hit() + && self.mob_hit().is_none_or(|(_, d)| hit.distance < d) + && self.before_block(hit.distance) + { + self.send(S::Interact(play::Interact { + id: hit.id, + hand: 0, + location: hit.location, + secondary: sneaking, + })); + self.swing_arm(); + return true; + } if let Some((i, distance)) = self.mob_hit() && self.before_block(distance) { @@ -3638,7 +3683,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 +3749,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 +3768,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 @@ -3911,6 +3995,14 @@ impl Game<'_> { id: self.creatures.projectiles[i].id as i32, })); self.reset_attack_strength(); + } else if let Some(hit) = self.remote_object_hit() + && self.mob_hit().is_none_or(|(_, d)| hit.distance < d) + && self.before_block(hit.distance) + { + // VehicleEntity.hurtServer, ItemFrame and ArmorStand hurtServer, + // a painting broken: the server decides. + self.send(S::Attack(play::Attack { id: hit.id })); + self.reset_attack_strength(); } else if let Some((i, distance)) = self.mob_hit() && self.before_block(distance) { @@ -3985,23 +4077,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 +4773,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, random: horizon_core::random::LegacyRandom, /// The sounds the use plays (a door's creak). @@ -4708,6 +4803,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 +4830,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 +4842,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 +4982,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 { + 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. diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 4cf9cb1a8..4bba24946 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -52,6 +52,8 @@ impl Game<'_> { invisible: false, check_interval: 0, }); + } else if kind == "minecraft:lightning_bolt" { + self.spawn_remote_bolt(id, position); } else if kind == "minecraft:painting" { // The variant comes with the entity data; until then the // registry's first one (VariantUtils.getAny). @@ -188,7 +190,12 @@ impl Game<'_> { /// A move's rotation and ground state for an object. pub(super) fn turn_remote_object(&mut self, id: i32, yaw: Option, on_ground: bool) { let id = id as u32; + // The boat the player drives turns here (isLocalInstanceAuthoritative). + let driven = self.riding; if let Some(b) = self.boats.iter_mut().find(|b| b.id == id) { + if Some(id) == driven { + return; + } if let Some(yaw) = yaw { b.yaw = yaw; } @@ -213,7 +220,12 @@ impl Game<'_> { c.previous_yaw = c.yaw; c.position = step(c.id, c.position); } + // The boat the player drives moves here, not where the server says. + let driven = self.riding; for b in &mut self.boats { + if Some(b.id) == driven { + continue; + } b.previous = b.position; b.previous_yaw = b.yaw; b.position = step(b.id, b.position); @@ -274,5 +286,6 @@ impl Game<'_> { self.armor_stands.retain(|a| a.id != id); self.item_frames.retain(|f| f.id != id); self.paintings.retain(|p| p.id != id); + self.bolts.retain(|b| b.id != id); } } diff --git a/crates/horizon-client/src/game/remote_vehicles.rs b/crates/horizon-client/src/game/remote_vehicles.rs new file mode 100644 index 000000000..dc3b2b686 --- /dev/null +++ b/crates/horizon-client/src/game/remote_vehicles.rs @@ -0,0 +1,181 @@ +//! Boats, minecarts, item frames, armor stands and paintings for a server's +//! client: single player on its server thread, a LAN guest, a player on a +//! dedicated server. +//! +//! The client aims at them like at mobs (`Minecraft.hitResult`, then +//! `ServerboundInteractPacket`), and rides the vehicle the server seats it in +//! (`ClientPacketListener.handleSetEntityPassengersPacket`). A boat is +//! controlled by its rider's client: it ticks here and its moves go to the +//! server (`LocalPlayer.tick`: `ServerboundMoveVehiclePacket`, +//! `AbstractBoat.tick`: `ServerboundPaddleBoatPacket`). A minecart moves on +//! the server with the rider's input, and the rider sits in it. +use super::{Game, Keys, view_vector}; +use horizon_core::geometry::Vec3; +use horizon_protocol::packets::play::{self, Serverbound as S}; + +/// An object under the crosshair: its entity id, how far along the view it +/// was hit, and where (`EntityHitResult.getLocation` minus the entity's +/// position, the interact packet's location). +pub(super) struct ObjectHit { + pub id: i32, + pub distance: f64, + pub location: [f64; 3], +} + +impl Game<'_> { + /// The nearest boat, minecart, item frame, armor stand or painting the + /// view hits within reach. + pub(super) fn remote_object_hit(&self) -> Option { + let eye = self.eye_position()?; + let dir = view_vector(self.yaw, self.pitch); + let at = |d: f64| { + [ + eye[0] + dir[0] * d, + eye[1] + dir[1] * d, + eye[2] + dir[2] * d, + ] + }; + let block_centre = |p: [i32; 3]| { + [ + f64::from(p[0]) + 0.5, + f64::from(p[1]) + 0.5, + f64::from(p[2]) + 0.5, + ] + }; + let mut hits: Vec<(i32, f64, [f64; 3])> = Vec::new(); + if let Some((i, d)) = self.painting_hit() { + let p = &self.paintings[i]; + hits.push((p.id as i32, d, block_centre(p.pos))); + } + if let Some((i, d)) = self.frame_hit() { + let f = &self.item_frames[i]; + hits.push((f.id as i32, d, block_centre(f.pos))); + } + if let Some((i, d, _)) = self.armor_stand_hit() { + let a = &self.armor_stands[i]; + let p = a.position; + hits.push((a.id as i32, d, [p.x, p.y, p.z])); + } + if let Some((i, d)) = self.boat_hit() { + let p = self.boats[i].position; + hits.push((self.boats[i].id as i32, d, [p.x, p.y, p.z])); + } + if let Some((i, d)) = self.cart_hit() { + let p = self.carts[i].position; + hits.push((self.carts[i].id as i32, d, [p.x, p.y, p.z])); + } + let (id, distance, origin) = hits.into_iter().min_by(|a, b| a.1.total_cmp(&b.1))?; + let point = at(distance); + Some(ObjectHit { + id, + distance, + location: [ + point[0] - origin[0], + point[1] - origin[1], + point[2] - origin[2], + ], + }) + } + + /// `ClientPacketListener.handleSetEntityPassengersPacket`: who rides + /// `vehicle` now. The local player gets in or out; mobs and other + /// players sit where the server keeps them. + pub(super) fn remote_set_passengers(&mut self, vehicle: i32, passengers: &[i32]) { + let Some(me) = self.remote.as_ref().map(|r| r.entity_id) else { + return; + }; + let vehicle_id = vehicle as u32; + for m in &mut self.mobs { + if m.extra.mount == Some(vehicle_id) && !passengers.contains(&(m.id as i32)) { + m.extra.mount = None; + } else if passengers.contains(&(m.id as i32)) { + m.extra.mount = Some(vehicle_id); + } + } + if passengers.contains(&me) { + if self.riding != Some(vehicle_id) { + self.riding = Some(vehicle_id); + if let Some(p) = self.player.as_mut() { + p.velocity = Vec3::ZERO; + p.fall_distance = 0.0; + } + } + } else if self.riding == Some(vehicle_id) { + // The server takes the player out, then teleports it. + self.riding = None; + } + } + + /// The local player's tick in its vehicle, in place of its own movement: + /// false when it rides nothing. + pub(super) fn remote_ride(&mut self, keys: Keys) -> bool { + let Some(id) = self.riding else { + return false; + }; + let seat = if let Some(i) = self.boats.iter().position(|b| b.id == id) { + // AbstractBoat.tick on the controlling client: steer and move. + let mut b = self.boats[i].clone(); + b.input = [keys.left, keys.right, keys.forward, keys.backward]; + let b = self.tick_boat(b, true); + // positionRider: the seat turns with the boat; clampRotation. + self.yaw += b.delta_rotation; + let delta = (self.yaw - b.yaw + 180.0).rem_euclid(360.0) - 180.0; + self.yaw += delta.clamp(-105.0, 105.0) - delta; + let seat = b.position; + self.boats[i] = b; + Some(seat) + } else { + // A minecart: the server moves it, the rider sits in it. + self.carts.iter().find(|c| c.id == id).map(|c| c.position) + }; + if let Some(p) = self.player.as_mut() { + self.previous_position = p.position; + if let Some(v) = seat { + p.position = Vec3::new(v.x, v.y + super::boats::SEAT, v.z); + } + p.velocity = Vec3::ZERO; + p.fall_distance = 0.0; + } + true + } + + /// `LocalPlayer.tick` for a passenger: the boat it controls goes to the + /// server every tick with its paddles (the rider's own position does not). + pub(super) fn remote_vehicle_packets(&self) -> Vec { + let Some(b) = self + .riding + .and_then(|id| self.boats.iter().find(|b| b.id == id)) + else { + return Vec::new(); + }; + vec![ + S::MoveVehicle(play::MoveVehicleRequest { + position: [b.position.x, b.position.y, b.position.z], + yaw: b.yaw, + pitch: 0.0, + on_ground: b.on_ground, + }), + S::PaddleBoat(play::PaddleBoat { + left: b.paddling[0], + right: b.paddling[1], + }), + ] + } + + /// `ClientPacketListener.handleMoveVehicle`: the server put the boat the + /// player drives back. + pub(super) fn remote_move_vehicle(&mut self, position: [f64; 3], yaw: f32) { + let Some(b) = self + .riding + .and_then(|id| self.boats.iter_mut().find(|b| b.id == id)) + else { + return; + }; + let at = Vec3::new(position[0], position[1], position[2]); + b.previous = at; + b.position = at; + b.yaw = yaw; + b.previous_yaw = yaw; + b.velocity = Vec3::ZERO; + } +} diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index cecd8d46f..07eacfb49 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -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() { diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..b0389ca4f 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -33,6 +33,7 @@ fn entity_shader() -> String { } mod entity_batch; +mod weather; use entity_batch::EntityBatch; pub use entity_batch::WATER_MASK_OVERLAY; @@ -61,8 +62,10 @@ pub fn outline_vertices(edges: &[[f64; 6]], camera: glam::DVec3) -> Vec<[f32; 6] mod arena; mod cull; +mod end_sky; mod flat; mod java_stages; +pub mod lightning; mod lod; mod occlusion; mod pack_stages; @@ -163,8 +166,10 @@ pub struct Frame<'a> { pub title: bool, /// Dimensions without a skybox (the Nether) clear to the fog colour. pub skybox: bool, - /// The End: clear to black and draw `celestial` (the End sky box) behind the world. + /// The End: clear to black and draw the resident sky box behind the world. pub end_sky: bool, + /// End sky atlas bounds (u0, v0, u1, v1); absent when the sprite is missing. + pub end_sky_sprite: Option<[f32; 4]>, /// Environmental fog start/end (Nether 10..96), if any. pub environment_fog: Option<(f32, f32)>, pub water_fog: [f32; 3], @@ -189,16 +194,20 @@ pub struct Frame<'a> { pub nether_lighting: bool, /// Camera-relative entity geometry textured from the shared atlas. pub entities: &'a [Vertex], + pub weather: &'a [crate::weather::Vertex], + pub weather_time: crate::weather::Time, /// Horizon Extras' dynamic lights, nearest first (`dynamic_light::select`); empty when off. pub dynamic_lights: &'a [[f32; 4]], /// Cloud mesh inputs; geometry and GPU storage are retained by the renderer. pub clouds: Option>, - /// Additive translucent geometry after the entities (lightning, dragon rays). + /// Retained lightning bolts, drawn before the other additive entities. + pub lightning: lightning::Input<'a>, + /// Additive translucent geometry after lightning (dragon rays). pub additive: &'a [Vertex], /// Name tags over everything, without depth (`TEXT_SEE_THROUGH`). pub see_through: &'a [Vertex], - /// Camera-relative sun and moon, or the End sky box (drawn behind - /// everything, additive). + /// Camera-relative sun and moon, or the animated End flash (additive, + /// behind everything and after the resident End sky box). pub celestial: &'a [Vertex], /// The stars, drawn from their static buffer after the sun and moon: /// the sky's rotation (camera-relative world from star space) and the @@ -324,6 +333,7 @@ pub struct Renderer { crosshair_group: wgpu::BindGroup, crosshair_globals: wgpu::Buffer, entity_pipeline: wgpu::RenderPipeline, + weather: weather::Weather, crumbling_pipeline: wgpu::RenderPipeline, /// `RenderPipelines.WATER_MASK`: depth writes only, no colour. water_mask_pipeline: wgpu::RenderPipeline, @@ -334,9 +344,12 @@ pub struct Renderer { cloud_uniform: wgpu::Buffer, cloud_group: wgpu::BindGroup, additive_pipeline: wgpu::RenderPipeline, + lightning_pipeline: wgpu::RenderPipeline, + lightning: lightning::Renderer, see_through_pipeline: wgpu::RenderPipeline, celestial_pipeline: wgpu::RenderPipeline, celestial_buffer: wgpu::Buffer, + end_sky: end_sky::EndSky, stars: stars::Stars, panorama: panorama::Panorama, /// `RenderPipelines.WORLD_BORDER` and its buffers. @@ -1445,6 +1458,12 @@ impl Renderer { ), ], }); + let weather = weather::Weather::new( + &device, + config.format.remove_srgb_suffix(), + &entity_bindings, + &entity_shader, + ); let atlas_sampler = device.create_sampler(&wgpu::SamplerDescriptor { label: Some("Atlas"), ..Default::default() @@ -1664,8 +1683,17 @@ impl Renderer { alpha_blend, false, ); + let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3]; + let lightning_vertex = [ + entity_vertex[0].clone(), + Some(wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::<[f32; 3]>() as u64, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &lightning_attributes, + }), + ]; // BlendFunction.LIGHTNING: src alpha, one; no depth writes. - let additive_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + let additive_descriptor = wgpu::RenderPipelineDescriptor { label: Some("Additive entities"), layout: Some(&entity_layout), vertex: wgpu::VertexState { @@ -1709,6 +1737,16 @@ impl Renderer { }), multiview_mask: None, cache: None, + }; + let additive_pipeline = device.create_render_pipeline(&additive_descriptor); + let lightning_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Lightning"), + vertex: wgpu::VertexState { + entry_point: Some("vs_lightning"), + buffers: &lightning_vertex, + ..additive_descriptor.vertex.clone() + }, + ..additive_descriptor }); let celestial_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("Celestial bodies"), @@ -2101,6 +2139,7 @@ impl Renderer { crosshair_group, crosshair_globals, entity_pipeline, + weather, crumbling_pipeline, water_mask_pipeline, cloud_pipeline, @@ -2110,9 +2149,12 @@ impl Renderer { cloud_uniform, cloud_group, additive_pipeline, + lightning_pipeline, + lightning: lightning::Renderer::new(), see_through_pipeline, celestial_pipeline, celestial_buffer, + end_sky: end_sky::EndSky::default(), stars, panorama, border_pipeline, @@ -3229,6 +3271,13 @@ impl Renderer { bytemuck::cast_slice(&all), ); } + self.weather.prepare( + &self.device, + &mut encoder, + &mut self.uploads, + frame.weather, + frame.weather_time, + ); let outline_edges = frame.outline.len().min(MAX_OUTLINE_EDGES as usize); if outline_edges > 0 { let lines = outline_vertices(&frame.outline[..outline_edges], camera); @@ -3246,6 +3295,7 @@ impl Renderer { frame.hand, frame.see_through, ); + let weather_quads = frame.weather.len() as u32 / 4; let world_quads = entity_quads + crumbling_quads + translucent_crumbling_quads + water_mask_quads; let cloud_quads = if let Some(input) = &frame.clouds { @@ -3279,6 +3329,13 @@ impl Renderer { } else { 0 }; + self.lightning.prepare( + &self.device, + &mut self.uploads, + &mut encoder, + &frame.lightning, + camera, + ); let all_entities = &self.entity_batch.combined; let hand_quads = (frame.hand.len() / 4) as u32; let additive_quads = (frame.additive.len() / 4) as u32; @@ -3310,6 +3367,9 @@ impl Renderer { ); } let celestial_vertices = frame.celestial.len().min(2048 * 4); + if frame.end_sky && !frame.title { + self.end_sky.prepare(&self.device, frame.end_sky_sprite); + } if celestial_vertices > 0 { self.uploads.buffer( &mut encoder, @@ -3318,8 +3378,14 @@ impl Renderer { bytemuck::cast_slice(&frame.celestial[..celestial_vertices]), ); } - let max_quads = - (world_quads + additive_quads + hand_quads + see_through_quads).max(cloud_quads); + let max_quads = (world_quads + additive_quads + hand_quads + see_through_quads) + .max(cloud_quads) + .max(if frame.lightning.bolts.is_empty() { + 0 + } else { + lightning::QUADS + }) + .max(weather_quads); if max_quads > self.index_quads { self.index_quads = max_quads.next_power_of_two(); self.indices = Self::quad_indices(&self.device, self.index_quads); @@ -3510,12 +3576,17 @@ impl Renderer { if frame.title { self.panorama.draw(&mut pass); pass.set_bind_group(0, &self.group, &[]); - } else if celestial_vertices > 0 { + } else if celestial_vertices > 0 || frame.end_sky { pass.set_pipeline(&self.celestial_pipeline); pass.set_bind_group(0, &self.entity_group, &[]); pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); - pass.set_vertex_buffer(0, self.celestial_buffer.slice(..)); - pass.draw_indexed(0..(celestial_vertices as u32 / 4) * 6, 0, 0..1); + if frame.end_sky { + self.end_sky.draw(&mut pass); + } + if celestial_vertices > 0 { + pass.set_vertex_buffer(0, self.celestial_buffer.slice(..)); + pass.draw_indexed(0..(celestial_vertices as u32 / 4) * 6, 0, 0..1); + } pass.set_bind_group(0, &self.group, &[]); } if !frame.title && frame.stars.is_some() { @@ -3602,6 +3673,8 @@ impl Renderer { pass.draw_indexed(0..entity_quads * 6, 0, 0..1); pass.set_bind_group(0, &self.group, &[]); } + self.weather.draw(&mut pass, &self.entity_group); + pass.set_bind_group(0, &self.group, &[]); if crumbling_quads > 0 { pass.set_pipeline(&self.crumbling_pipeline); pass.set_bind_group(0, &self.entity_group, &[]); @@ -3622,6 +3695,12 @@ impl Renderer { ); pass.set_bind_group(0, &self.group, &[]); } + if !frame.lightning.bolts.is_empty() { + pass.set_pipeline(&self.lightning_pipeline); + pass.set_bind_group(0, &self.entity_group, &[]); + self.lightning.draw(&mut pass, &frame.lightning); + pass.set_bind_group(0, &self.group, &[]); + } if additive_quads > 0 { pass.set_pipeline(&self.additive_pipeline); pass.set_bind_group(0, &self.entity_group, &[]); @@ -3841,9 +3920,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 +3964,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); diff --git a/crates/horizon-client/src/gfx/end_sky.rs b/crates/horizon-client/src/gfx/end_sky.rs new file mode 100644 index 000000000..15e9001fc --- /dev/null +++ b/crates/horizon-client/src/gfx/end_sky.rs @@ -0,0 +1,84 @@ +//! The End sky's six tiled faces, retained for the lifetime of the renderer's atlas. +use crate::mesher::Vertex; +use wgpu::util::DeviceExt; + +const VERTICES: u32 = 6 * 16 * 16 * 4; + +#[derive(Default)] +pub(super) struct EndSky { + mesh: Option<([f32; 4], wgpu::Buffer)>, +} + +impl EndSky { + /// Called only when the End sky is enabled. Rebuild on atlas UV changes; + /// resource reload and device recreation also replace the owning renderer. + pub(super) fn prepare(&mut self, device: &wgpu::Device, uv: Option<[f32; 4]>) { + let Some(uv) = uv else { + self.mesh = None; + return; + }; + if self.mesh.as_ref().is_some_and(|(old, _)| *old == uv) { + return; + } + let vertices = vertices(uv); + let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("End sky vertices"), + contents: bytemuck::cast_slice(&vertices), + usage: wgpu::BufferUsages::VERTEX, + }); + self.mesh = Some((uv, buffer)); + } + + /// The celestial pipeline, atlas bind group and quad indices are already bound. + pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>) { + if let Some((_, buffer)) = &self.mesh { + pass.set_vertex_buffer(0, buffer.slice(..)); + pass.draw_indexed(0..VERTICES / 4 * 6, 0, 0..1); + } + } +} + +/// SkyRenderer.buildEndSky: six faces of end_sky.png tiled 16 times, +/// tinted 0x282828. The atlas does not wrap, so each face is 16×16 quads. +fn vertices(uv: [f32; 4]) -> Vec { + let mut out = Vec::with_capacity(VERTICES as usize); + use std::f32::consts::FRAC_PI_2; + let faces = [ + glam::Mat4::IDENTITY, + glam::Mat4::from_rotation_x(FRAC_PI_2), + glam::Mat4::from_rotation_x(-FRAC_PI_2), + glam::Mat4::from_rotation_x(std::f32::consts::PI), + glam::Mat4::from_rotation_z(FRAC_PI_2), + glam::Mat4::from_rotation_z(-FRAC_PI_2), + ]; + let step = 200.0 / 16.0; + for pose in faces { + for a in 0..16 { + for b in 0..16 { + let (x0, z0) = (-100.0 + step * a as f32, -100.0 + step * b as f32); + let (x1, z1) = (x0 + step, z0 + step); + let corners = [ + (x0, z0, [uv[0], uv[1]]), + (x0, z1, [uv[0], uv[3]]), + (x1, z1, [uv[2], uv[3]]), + (x1, z0, [uv[2], uv[1]]), + ]; + for (x, z, uv) in corners { + let p = pose.transform_point3(glam::Vec3::new(x, -100.0, z)); + out.push(Vertex { + normal: [0; 4], + pos: p.to_array(), + uv, + layer: 2, + color: 0xFF28_2828, + light: 0, + }); + } + } + } + } + out +} + +#[cfg(test)] +mod tests; diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs new file mode 100644 index 000000000..61266003d --- /dev/null +++ b/crates/horizon-client/src/gfx/end_sky/tests.rs @@ -0,0 +1,330 @@ +use super::*; +use crate::gfx::{Globals, Renderer}; +use bytemuck::Zeroable; +use glam::Mat4; + +#[test] +fn geometry_matches_pre_residency_vertex_snapshots() { + use sha2::{Digest, Sha256}; + // Captured from game/end.rs at 34c3c1cf for full, tiled and non-binary UVs. + // Quantize positions only, avoiding platform sin/cos rounding differences; + // quad order, UVs, tint, material and light retain their exact byte values. + for (uv, expected) in [ + ( + [0.0, 0.0, 1.0, 1.0], + "f7ee23457fc557b33ecf09c9afaf858f3d8907e108abf06055f627523f733536", + ), + ( + [0.125, 0.25, 0.375, 0.5], + "f74c4b8d23ec2b7c11b5752821d0733851bf11358f1b26f9448226ff62a6a318", + ), + ( + [0.13, 0.27, 0.41, 0.59], + "f0aaa39c5b22168bdc7c6c329acb4d3598a2feb61ff7b6f2850b644682749b39", + ), + ] { + let mut mesh = vertices(uv); + assert_eq!(mesh.len(), VERTICES as usize); + for vertex in &mut mesh { + vertex.pos = vertex.pos.map(|x| { + let n = (x * 1024.0).round() / 1024.0; + if n == 0.0 { 0.0 } else { n } + }); + } + assert_eq!( + format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))), + expected + ); + } +} + +fn device() -> Option<(wgpu::Device, wgpu::Queue)> { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?; + eprintln!("End sky test adapter: {:?}", adapter.get_info()); + pollster::block_on(adapter.request_device(&Default::default())).ok() +} + +#[test] +fn resident_buffer_survives_frames_and_refreshes_with_the_atlas() { + let Some((device, _)) = device() else { + eprintln!("no GPU adapter: skipped"); + return; + }; + let mut sky = EndSky::default(); + let uv = [0.125, 0.25, 0.375, 0.5]; + sky.prepare(&device, Some(uv)); + let first = sky.mesh.as_ref().unwrap().1.clone(); + assert_eq!( + first.size(), + u64::from(VERTICES) * size_of::() as u64 + ); + // Immutable: steady-state frames cannot upload into this buffer. + assert_eq!(first.usage(), wgpu::BufferUsages::VERTEX); + for _ in 0..600 { + sky.prepare(&device, Some(uv)); + assert_eq!(sky.mesh.as_ref().unwrap().1, first); + } + let moved = [0.5, 0.5, 0.75, 0.75]; + sky.prepare(&device, Some(moved)); + assert_ne!(sky.mesh.as_ref().unwrap().1, first); + assert_eq!(sky.mesh.as_ref().unwrap().0, moved); + sky.prepare(&device, None); + assert!(sky.mesh.is_none()); + sky.prepare(&device, Some(uv)); + assert_ne!(sky.mesh.as_ref().unwrap().1, first); + // A resource reload/device recreation starts a new renderer-owned cache, + // even if the replacement atlas happens to use exactly the same UVs. + let mut replacement = EndSky::default(); + replacement.prepare(&device, Some(uv)); + assert_ne!( + replacement.mesh.as_ref().unwrap().1, + sky.mesh.as_ref().unwrap().1 + ); +} + +/// The actual entity shader and celestial blend, comparing the old combined +/// vertex stream with a resident sky draw followed by a separate flash draw. +#[test] +fn separate_draws_match_combined_celestial_pixels() { + let Some((device, queue)) = device() else { + eprintln!("no GPU adapter: skipped"); + return; + }; + let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("End sky differential shader"), + source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), + }); + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("End sky differential pipeline"), + layout: None, + vertex: wgpu::VertexState { + module: &shader, + entry_point: Some("vs_entity"), + compilation_options: Default::default(), + buffers: &[Some(wgpu::VertexBufferLayout { + array_stride: size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &attributes, + })], + }, + primitive: wgpu::PrimitiveState { + cull_mode: None, + ..Default::default() + }, + depth_stencil: None, + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &shader, + entry_point: Some("fs_celestial"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: Some(wgpu::BlendState { + color: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::SrcAlpha, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + alpha: wgpu::BlendComponent::OVER, + }), + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }); + let texture = |pixels: &[u8], width, height| { + device.create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width, + height, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + pixels, + ) + }; + // Asymmetric, translucent texels expose UV/winding and blend-order errors. + let pixels: Vec = (0..16 * 16) + .flat_map(|i| { + [ + (i * 17) as u8, + (i * 31) as u8, + (i * 7) as u8, + (80 + i % 176) as u8, + ] + }) + .collect(); + let atlas = texture(&pixels, 16, 16).create_view(&Default::default()); + let lightmap = texture(&[255; 4], 1, 1).create_view(&Default::default()); + let sampler = device.create_sampler(&Default::default()); + let uniform = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: size_of::() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &pipeline.get_bind_group_layout(0), + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: uniform.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&atlas), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(&lightmap), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + ], + }); + let indices = Renderer::quad_indices(&device, VERTICES / 4 + 1); + let mut resident = EndSky::default(); + let uv = [0.125, 0.25, 0.375, 0.5]; + resident.prepare(&device, Some(uv)); + let first = resident.mesh.as_ref().unwrap().1.clone(); + let render = |sky: &EndSky, flash: &[Vertex], combined: bool| { + let target = device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 64, + height: 64, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, + view_formats: &[], + }); + let view = target.create_view(&Default::default()); + let mut vertices = if combined { vertices(uv) } else { Vec::new() }; + vertices.extend_from_slice(flash); + let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::cast_slice(&vertices), + usage: wgpu::BufferUsages::VERTEX, + }); + let readback = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: 64 * 64 * 4, + usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, + mapped_at_creation: false, + }); + let mut encoder = device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &view, + depth_slice: None, + resolve_target: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::BLACK), + store: wgpu::StoreOp::Store, + }, + })], + ..Default::default() + }); + pass.set_pipeline(&pipeline); + pass.set_bind_group(0, &group, &[]); + pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32); + if !combined { + sky.draw(&mut pass); + } + if !vertices.is_empty() { + pass.set_vertex_buffer(0, buffer.slice(..)); + pass.draw_indexed(0..vertices.len() as u32 / 4 * 6, 0, 0..1); + } + } + encoder.copy_texture_to_buffer( + target.as_image_copy(), + wgpu::TexelCopyBufferInfo { + buffer: &readback, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(256), + rows_per_image: Some(64), + }, + }, + target.size(), + ); + queue.submit([encoder.finish()]); + readback + .slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + readback.slice(..).get_mapped_range().unwrap().to_vec() + }; + let mut cases = 0; + let mut visible_flash_cases = 0; + for yaw in [0.0_f32, 45.0, 90.0, 180.0, 270.0] { + for pitch in [-85.0_f32, -30.0, 0.0, 45.0, 85.0] { + let mut globals = Globals::zeroed(); + globals.view_proj = (Mat4::perspective_rh(90_f32.to_radians(), 1.0, 0.05, 1024.0) + * Mat4::from_rotation_x(pitch.to_radians()) + * Mat4::from_rotation_y(yaw.to_radians())) + .to_cols_array_2d(); + queue.write_buffer(&uniform, 0, bytemuck::bytes_of(&globals)); + let no_flash = render(&resident, &[], true); + for level in [0_u32, 1, 127, 255] { + let flash: Vec<_> = if level == 0 { + Vec::new() + } else { + // Same flash size/height, with an arbitrary EndFlashState pose. + let pose = Mat4::from_rotation_y(1.3) * Mat4::from_rotation_x(-1.6); + [(-60.0, -60.0), (60.0, -60.0), (60.0, 60.0), (-60.0, 60.0)] + .map(|(x, z)| Vertex { + pos: pose.transform_point3(glam::vec3(x, 100.0, z)).to_array(), + uv: [0.75 + x / 480.0, 0.75 + z / 480.0], + layer: 2, + color: level * 0x01010101, + light: 0, + normal: [0; 4], + }) + .to_vec() + }; + resident.prepare(&device, Some(uv)); + let expected = render(&resident, &flash, true); + let actual = render(&resident, &flash, false); + visible_flash_cases += usize::from(expected != no_flash); + assert_eq!(actual, expected, "yaw={yaw} pitch={pitch} flash={level}"); + assert!( + actual.as_chunks::<4>().0.iter().any(|p| p[..3] != [0; 3]), + "empty frame" + ); + assert_eq!(resident.mesh.as_ref().unwrap().1, first); + cases += 1; + } + } + } + assert!( + visible_flash_cases > 0, + "the flash must affect the comparison" + ); + eprintln!("{cases} combined/resident framebuffer cases matched exactly"); +} diff --git a/crates/horizon-client/src/gfx/lightning.rs b/crates/horizon-client/src/gfx/lightning.rs new file mode 100644 index 000000000..251dbf00e --- /dev/null +++ b/crates/horizon-client/src/gfx/lightning.rs @@ -0,0 +1,211 @@ +//! Seeded, bolt-local lightning meshes retained until their last active bolt disappears. +use crate::{gfx::upload::Uploads, mesher::Vertex}; +use glam::DVec3; +use horizon_core::random::{LegacyRandom, RandomSource}; +use std::collections::HashMap; +use wgpu::util::DeviceExt; + +/// A bolt's render state. Simulation lifetime and flashes stay in the game. +#[derive(Clone, Copy)] +pub struct Bolt { + pub at: [f64; 3], + pub seed: i64, +} + +#[derive(Default)] +pub struct Input<'a> { + pub bolts: &'a [Bolt], + /// Current atlas white texel; a changed rect invalidates retained vertices. + pub uv: [f32; 2], +} + +// Four layers, fourteen segments (eight trunk, two branches of three), four quads. +pub(super) const QUADS: u32 = 4 * 14 * 4; + +/// `LightningBoltRenderer.submit`: keep random draws, layers and quad order unchanged. +fn geometry(seed: i64, uv: [f32; 2]) -> Vec { + let mut out = Vec::with_capacity(QUADS as usize * 4); + // ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA. + let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114; + let mut random = LegacyRandom::new(seed); + let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]); + let (mut x_off, mut z_off) = (0f32, 0f32); + for i in (0..8).rev() { + xs[i] = x_off; + zs[i] = z_off; + x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + } + for layer in 0..4 { + let mut random = LegacyRandom::new(seed); + for branch in 0..3 { + let trunk = branch == 0; + let start = 7 - branch; + let end = if trunk { 0 } else { start - 3 + 1 }; + let mut sx = xs[start] - x_off; + let mut sz = zs[start] - z_off; + for segment in (end..=start).rev() { + let (ex, ez) = (sx, sz); + let spread = if trunk { 11 } else { 31 }; + sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + let mut top = 0.1 + layer as f32 * 0.2; + let mut bottom = top; + if trunk { + top *= segment as f32 * 0.1 + 1.0; + bottom *= (segment as f32 - 1.0) * 0.1 + 1.0; + } + for (rx, rz, lx, lz) in [ + (false, false, true, false), + (true, false, true, true), + (true, true, false, true), + (false, true, false, false), + ] { + let s = |p: bool, r: f32| if p { r } else { -r }; + let y0 = segment as f32 * 16.0; + let corners = [ + [sx + s(rx, bottom), y0, sz + s(rz, bottom)], + [ex + s(rx, top), y0 + 16.0, ez + s(rz, top)], + [ex + s(lx, top), y0 + 16.0, ez + s(lz, top)], + [sx + s(lx, bottom), y0, sz + s(lz, bottom)], + ]; + for c in corners { + out.push(Vertex { + normal: [0; 4], + pos: c, + uv, + layer: 2, + color, + light: 240 | 240 << 8, + }); + } + } + } + } + } + out +} + +struct Cached { + mesh: T, + used: bool, +} + +/// Shared seeds use the same mesh; storage is bounded by active unique seeds, +/// including after seed changes, removals, dimension switches and disconnects. +struct Cache { + uv: Option<[f32; 2]>, + meshes: HashMap>, +} +impl Cache { + fn new() -> Self { + Self { + uv: None, + meshes: HashMap::new(), + } + } + + fn prepare(&mut self, input: &Input<'_>, mut build: impl FnMut(i64, [f32; 2]) -> T) { + if self.uv != Some(input.uv) { + self.meshes.clear(); + self.uv = Some(input.uv); + } + for cached in self.meshes.values_mut() { + cached.used = false; + } + for bolt in input.bolts { + self.meshes + .entry(bolt.seed) + .or_insert_with(|| Cached { + mesh: build(bolt.seed, input.uv), + used: true, + }) + .used = true; + } + self.meshes.retain(|_, cached| cached.used); + // HashMap::retain keeps its allocation. Release historical peak capacity + // as well as meshes once the storm (or connection) is gone. + if self.meshes.is_empty() { + self.meshes = HashMap::new(); + } else if self.meshes.capacity() > self.meshes.len() * 4 { + self.meshes.shrink_to_fit(); + } + } +} + +fn offset(bolt: &Bolt, camera: DVec3) -> [f32; 3] { + (DVec3::from_array(bolt.at) - camera).as_vec3().to_array() +} + +pub(super) struct Renderer { + cache: Cache, + instances: Option, + capacity: usize, +} +impl Renderer { + pub(super) fn new() -> Self { + Self { + cache: Cache::new(), + instances: None, + capacity: 0, + } + } + + pub(super) fn prepare( + &mut self, + device: &wgpu::Device, + uploads: &mut Uploads, + encoder: &mut wgpu::CommandEncoder, + input: &Input<'_>, + camera: DVec3, + ) { + self.cache.prepare(input, |seed, uv| { + device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("Lightning vertices"), + contents: bytemuck::cast_slice(&geometry(seed, uv)), + usage: wgpu::BufferUsages::VERTEX, + }) + }); + if input.bolts.is_empty() { + self.instances = None; + self.capacity = 0; + return; + } + if input.bolts.len() > self.capacity || input.bolts.len() < self.capacity / 4 { + self.capacity = input.bolts.len().next_power_of_two(); + self.instances = Some(device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Lightning offsets"), + size: (self.capacity * std::mem::size_of::<[f32; 3]>()) as u64, + usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + })); + } + let offsets: Vec<_> = input + .bolts + .iter() + .map(|bolt| offset(bolt, camera)) + .collect(); + uploads.buffer( + encoder, + self.instances.as_ref().unwrap(), + 0, + bytemuck::cast_slice(&offsets), + ); + } + + pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>, input: &Input<'_>) { + let Some(instances) = &self.instances else { + return; + }; + pass.set_vertex_buffer(1, instances.slice(..)); + // Follow simulation order, including repeated seeds; HashMap order must + // never change additive accumulation or the order before dragon rays. + for (i, bolt) in input.bolts.iter().enumerate() { + pass.set_vertex_buffer(0, self.cache.meshes[&bolt.seed].mesh.slice(..)); + pass.draw_indexed(0..QUADS * 6, 0, i as u32..i as u32 + 1); + } + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs new file mode 100644 index 000000000..f89f402de --- /dev/null +++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs @@ -0,0 +1,495 @@ +use super::*; +use std::cell::Cell; + +// Frozen pre-cache generator: compare every Vertex byte, including primitive +// order and the original camera-relative rounding, without game resources. +fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec { + let mut out = Vec::new(); + // ARGB 0.45, 0.45, 0.5 at 0.3 alpha, packed RGBA. + let color = (76u32 << 24) | (127 << 16) | (114 << 8) | 114; + let b = Bolt { seed, at }; + { + let o = (glam::DVec3::from_array(b.at) - camera).as_vec3(); + let mut random = LegacyRandom::new(b.seed); + let (mut xs, mut zs) = ([0f32; 8], [0f32; 8]); + let (mut x_off, mut z_off) = (0f32, 0f32); + for i in (0..8).rev() { + xs[i] = x_off; + zs[i] = z_off; + x_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + z_off += (random.next_int_bound(11).unwrap_or(5) - 5) as f32; + } + for layer in 0..4 { + let mut random = LegacyRandom::new(b.seed); + for branch in 0..3 { + let trunk = branch == 0; + let start = 7 - branch; + let end = if trunk { 0 } else { start - 3 + 1 }; + let mut sx = xs[start] - x_off; + let mut sz = zs[start] - z_off; + for segment in (end..=start).rev() { + let (ex, ez) = (sx, sz); + let spread = if trunk { 11 } else { 31 }; + sx += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + sz += (random.next_int_bound(spread).unwrap_or(0) - spread / 2) as f32; + let mut top = 0.1 + layer as f32 * 0.2; + let mut bottom = top; + if trunk { + top *= segment as f32 * 0.1 + 1.0; + bottom *= (segment as f32 - 1.0) * 0.1 + 1.0; + } + for (rx, rz, lx, lz) in [ + (false, false, true, false), + (true, false, true, true), + (true, true, false, true), + (false, true, false, false), + ] { + let s = |p: bool, r: f32| if p { r } else { -r }; + let y0 = segment as f32 * 16.0; + let corners = [ + [sx + s(rx, bottom), y0, sz + s(rz, bottom)], + [ex + s(rx, top), y0 + 16.0, ez + s(rz, top)], + [ex + s(lx, top), y0 + 16.0, ez + s(lz, top)], + [sx + s(lx, bottom), y0, sz + s(lz, bottom)], + ]; + for c in corners { + out.push(Vertex { + normal: [0; 4], + pos: (o + glam::Vec3::from_array(c)).to_array(), + uv, + layer: 2, + color, + light: 240 | 240 << 8, + }); + } + } + } + } + } + } + out +} + +fn seeds() -> Vec { + let mut seeds = vec![0, 1, -1, i64::MIN, i64::MAX, 0x123456789abcdef]; + let mut random = LegacyRandom::new(42); + seeds.extend((0..256).map(|_| random.next_long())); + seeds +} + +/// Pinned 26.3 LightningBoltRenderer.lambda$submit$0, captured with an +/// identity PoseStack and a VertexConsumer recording big-endian xyz floats. +#[test] +fn geometry_matches_pinned_vanilla_vertex_digest() { + use sha2::{Digest, Sha256}; + let mut digest = Sha256::new(); + for seed in seeds() { + for vertex in geometry(seed, [0.0; 2]) { + for value in vertex.pos { + digest.update(value.to_be_bytes()); + } + } + } + assert_eq!( + format!("{:x}", digest.finalize()), + "a9ed25caa50b9aa340faa4bb417b3d533b061f0dce66514e4bb212931444dee6" + ); +} + +#[test] +fn retained_geometry_matches_original_generator() { + let uv = [0.8125, 0.03125]; + for seed in seeds() { + let local = geometry(seed, uv); + assert_eq!(local.len(), QUADS as usize * 4); + for (at, camera) in [ + ([0.0; 3], DVec3::ZERO), + ([12.5, 64.0, -12.5], DVec3::new(-4.25, 71.125, 32.5)), + ( + [29_999_999.5, -64.0, -29_999_999.5], + DVec3::new(29_999_987.125, 67.75, -29_999_983.875), + ), + ] { + let offset = offset(&Bolt { seed, at }, camera); + let translated: Vec<_> = local + .iter() + .map(|v| Vertex { + pos: (glam::Vec3::from_array(offset) + glam::Vec3::from_array(v.pos)) + .to_array(), + ..*v + }) + .collect(); + let expected = reference(seed, at, camera, uv); + assert_eq!( + bytemuck::cast_slice::<_, u8>(&translated), + bytemuck::cast_slice::<_, u8>(&expected), + "seed {seed}" + ); + } + } +} + +#[test] +fn cache_tracks_seed_lifecycle_movement_and_atlas_reload() { + let mut cache = Cache::new(); + let builds = Cell::new(0); + let build = |seed, uv| { + builds.set(builds.get() + 1); + geometry(seed, uv) + }; + let mut bolts = [ + Bolt { + seed: 123, + at: [0.0; 3], + }, + Bolt { + seed: 456, + at: [1.0; 3], + }, + ]; + fn input(bolts: &[Bolt]) -> Input<'_> { + Input { + bolts, + uv: [0.25, 0.5], + } + } + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 2); + assert_eq!(cache.meshes.len(), 2); + // Any number of rendered frames or multiplayer position updates reuse meshes. + for i in 0..100 { + bolts[0].at = [i as f64; 3]; + cache.prepare(&input(&bolts), build); + } + assert_eq!(builds.get(), 2); + // A flash changes the seed; retire its previous mesh immediately. + bolts[0].seed = 789; + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 3); + assert!(!cache.meshes.contains_key(&123)); + // Removal retains other bolts, and repeated seeds still share geometry. + bolts[0].seed = 456; + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 3); + assert_eq!(cache.meshes.len(), 1); + // Atlas replacement must update white texel UVs without changing the seed. + cache.prepare( + &Input { + bolts: &bolts, + uv: [0.75, 0.25], + }, + build, + ); + assert_eq!(builds.get(), 4); + assert_eq!(cache.meshes[&456].mesh[0].uv, [0.75, 0.25]); + // Disconnect/dimension switch/expiry drops every retained resource. + cache.prepare(&Input::default(), build); + assert!(cache.meshes.is_empty()); + assert_eq!(cache.meshes.capacity(), 0); + cache.prepare(&input(&bolts), build); + assert_eq!(builds.get(), 5); +} + +#[test] +fn long_flash_sequence_keeps_only_active_seeds() { + let mut cache = Cache::new(); + for seed in 0..10_000 { + cache.prepare( + &Input { + bolts: &[Bolt { seed, at: [0.0; 3] }], + uv: [0.0; 2], + }, + |seed, _| seed, + ); + assert_eq!(cache.meshes.len(), 1); + assert_eq!(cache.meshes[&seed].mesh, seed); + assert!(cache.meshes.capacity() < 16); + } +} + +/// Exercise the actual entity shader and retained draw path offscreen. Run +/// explicitly, separately from other headless device tests (some GPU drivers +/// fail during concurrent device teardown). Machines without an adapter skip it. +#[test] +#[ignore = "requires GPU; run separately with --ignored --exact"] +fn retained_gpu_draw_matches_transient_additive_draw() { + use bytemuck::Zeroable; + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else { + eprintln!("no GPU adapter: skipped"); + return; + }; + eprintln!("lightning differential GPU: {}", adapter.get_info().name); + let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap(); + let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Lightning differential shader"), + source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()), + }); + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4]; + let offsets = wgpu::vertex_attr_array![6=>Float32x3]; + let vertices = [Some(wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &attributes, + })]; + let retained_vertices = [ + vertices[0].clone(), + Some(wgpu::VertexBufferLayout { + array_stride: 12, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &offsets, + }), + ]; + let pipelines: Vec<_> = [false, true] + .into_iter() + .map(|retained| { + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Lightning differential pipeline"), + layout: None, + vertex: wgpu::VertexState { + module: &shader, + entry_point: Some(if retained { + "vs_lightning" + } else { + "vs_entity" + }), + compilation_options: Default::default(), + buffers: if retained { + &retained_vertices + } else { + &vertices + }, + }, + primitive: wgpu::PrimitiveState { + cull_mode: None, + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(false), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &shader, + entry_point: Some("fs_celestial"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format: wgpu::TextureFormat::Rgba8Unorm, + blend: Some(wgpu::BlendState { + color: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::SrcAlpha, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + alpha: wgpu::BlendComponent { + src_factor: wgpu::BlendFactor::SrcAlpha, + dst_factor: wgpu::BlendFactor::One, + operation: wgpu::BlendOperation::Add, + }, + }), + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) + }) + .collect(); + let globals = crate::gfx::Globals { + view_proj: (glam::Mat4::orthographic_rh(-100.0, 100.0, -10.0, 150.0, 0.1, 400.0) + * glam::Mat4::look_at_rh( + glam::Vec3::new(80.0, 30.0, 160.0), + glam::Vec3::new(0.0, 60.0, 0.0), + glam::Vec3::Y, + )) + .to_cols_array_2d(), + ..crate::gfx::Globals::zeroed() + }; + let globals = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::bytes_of(&globals), + usage: wgpu::BufferUsages::UNIFORM, + }); + let size = wgpu::Extent3d { + width: 256, + height: 256, + depth_or_array_layers: 1, + }; + let texture = |format, usage| { + device.create_texture(&wgpu::TextureDescriptor { + label: None, + size, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage, + view_formats: &[], + }) + }; + let white = device + .create_texture_with_data( + &queue, + &wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 1, + height: 1, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8Unorm, + usage: wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }, + wgpu::util::TextureDataOrder::LayerMajor, + &[255; 4], + ) + .create_view(&Default::default()); + let sampler = device.create_sampler(&Default::default()); + let groups: Vec<_> = pipelines + .iter() + .map(|pipeline| { + device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &pipeline.get_bind_group_layout(0), + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: globals.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&white), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::TextureView(&white), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: wgpu::BindingResource::Sampler(&sampler), + }, + ], + }) + }) + .collect(); + let mut renderer = Renderer::new(); + let mut uploads = Uploads::new(&device); + let mut bolts = [Bolt { + seed: 123, + at: [29_999_999.5, 64.0, -29_999_999.5], + }; 3]; + bolts[1].seed = -456; + bolts[1].at[0] -= 32.0; + bolts[2].at[2] += 20.0; + let indices = crate::gfx::Renderer::quad_indices(&device, QUADS * 3); + for frame in 0..4 { + let camera = DVec3::new(29_999_997.125 + frame as f64, 62.75, -29_999_998.875); + if frame == 2 { + bolts[0].seed = 789; + } + let input = Input { + bolts: &bolts[..if frame == 3 { 1 } else { 3 }], + uv: if frame == 3 { [0.75; 2] } else { [0.5; 2] }, + }; + let expected: Vec<_> = input + .bolts + .iter() + .flat_map(|bolt| reference(bolt.seed, bolt.at, camera, input.uv)) + .collect(); + let transient = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::cast_slice(&expected), + usage: wgpu::BufferUsages::VERTEX, + }); + let mut encoder = device.create_command_encoder(&Default::default()); + renderer.prepare(&device, &mut uploads, &mut encoder, &input, camera); + let mut readbacks = Vec::new(); + for mode in 0..2 { + let color = texture( + wgpu::TextureFormat::Rgba8Unorm, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, + ); + let view = color.create_view(&Default::default()); + let depth = texture( + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::RENDER_ATTACHMENT, + ) + .create_view(&Default::default()); + { + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: None, + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: &depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + ..Default::default() + }); + pass.set_pipeline(&pipelines[mode]); + pass.set_bind_group(0, &groups[mode], &[]); + pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32); + if mode == 0 { + pass.set_vertex_buffer(0, transient.slice(..)); + pass.draw_indexed(0..expected.len() as u32 / 4 * 6, 0, 0..1); + } else { + renderer.draw(&mut pass, &input); + } + } + let read = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: 256 * 256 * 4, + usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, + mapped_at_creation: false, + }); + encoder.copy_texture_to_buffer( + color.as_image_copy(), + wgpu::TexelCopyBufferInfo { + buffer: &read, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(1024), + rows_per_image: None, + }, + }, + size, + ); + readbacks.push(read); + } + uploads.finish(&encoder); + queue.submit([encoder.finish()]); + for read in &readbacks { + read.slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + } + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + let pixels: Vec> = readbacks + .iter() + .map(|read| read.slice(..).get_mapped_range().unwrap().to_vec()) + .collect(); + assert!(pixels[0].iter().any(|&b| b != 0), "empty reference frame"); + assert_eq!(pixels[0], pixels[1], "frame {frame}: GPU output differs"); + } +} diff --git a/crates/horizon-client/src/gfx/weather.rs b/crates/horizon-client/src/gfx/weather.rs new file mode 100644 index 000000000..15886b8f2 --- /dev/null +++ b/crates/horizon-client/src/gfx/weather.rs @@ -0,0 +1,330 @@ +//! Weather's unsplit quads, using the entity atlas/lightmap resources. +use crate::weather::{Time, Vertex}; + +pub(super) struct Weather { + pipeline: wgpu::RenderPipeline, + group: wgpu::BindGroup, + uniform: wgpu::Buffer, + vertices: wgpu::Buffer, + capacity: usize, + count: u32, +} +impl Weather { + pub fn new( + device: &wgpu::Device, + format: wgpu::TextureFormat, + entities: &wgpu::BindGroupLayout, + shader: &wgpu::ShaderModule, + ) -> Self { + let bindings = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Weather time"), + entries: &[wgpu::BindGroupLayoutEntry { + binding: 1, + visibility: wgpu::ShaderStages::VERTEX, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }], + }); + let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Weather layout"), + bind_group_layouts: &[Some(entities), Some(&bindings)], + ..Default::default() + }); + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x4, + 3=>Float32x4,4=>Uint32x4,5=>Unorm8x4,6=>Uint8x4,7=>Uint32]; + let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Weather"), + layout: Some(&layout), + vertex: wgpu::VertexState { + module: shader, + entry_point: Some("vs_weather"), + compilation_options: Default::default(), + buffers: &[Some(wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &attributes, + })], + }, + primitive: wgpu::PrimitiveState { + topology: wgpu::PrimitiveTopology::TriangleList, + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::GreaterEqual), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: shader, + entry_point: Some("fs_weather"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format, + blend: Some(wgpu::BlendState::ALPHA_BLENDING), + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }); + let uniform = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Weather time"), + size: 16, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Weather time"), + layout: &bindings, + entries: &[wgpu::BindGroupEntry { + binding: 1, + resource: uniform.as_entire_binding(), + }], + }); + Self { + pipeline, + group, + uniform, + vertices: Self::buffer(device, 4), + capacity: 4, + count: 0, + } + } + fn buffer(device: &wgpu::Device, capacity: usize) -> wgpu::Buffer { + device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Weather vertices"), + size: (capacity * std::mem::size_of::()) as u64, + usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }) + } + pub fn prepare( + &mut self, + device: &wgpu::Device, + encoder: &mut wgpu::CommandEncoder, + uploads: &mut super::upload::Uploads, + vertices: &[Vertex], + time: Time, + ) { + self.count = vertices.len() as u32; + if vertices.is_empty() { + return; + } + if vertices.len() > self.capacity { + self.capacity = vertices.len().next_power_of_two(); + self.vertices = Self::buffer(device, self.capacity); + } + uploads.buffer(encoder, &self.vertices, 0, bytemuck::cast_slice(vertices)); + uploads.buffer(encoder, &self.uniform, 0, bytemuck::bytes_of(&time)); + } + pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>, entities: &wgpu::BindGroup) { + if self.count == 0 { + return; + } + pass.set_pipeline(&self.pipeline); + pass.set_bind_group(0, entities, &[]); + pass.set_bind_group(1, &self.group, &[]); + pass.set_vertex_buffer(0, self.vertices.slice(..)); + // The renderer binds the shared triangle-list quad indices. + pass.draw_indexed(0..self.count / 4 * 6, 0, 0..1); + } +} + +#[cfg(test)] +mod tests { + use crate::weather::{Parameters, Time}; + use wgpu::util::DeviceExt; + + #[repr(C)] + #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)] + struct Case { + animation: [f32; 4], + bases: [u32; 4], + time: [f32; 4], + uv: [f32; 2], + snow: u32, + _pad: u32, + } + + /// Execute the production WGSL math, rather than a Rust translation of it. + /// Requires a GPU; run explicitly on renderer changes, not on headless CI. + #[test] + #[ignore = "requires a Vulkan/Metal/DX12 adapter"] + fn weather_shader_uvs_match_legacy_bits() { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let adapter = + pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) + .unwrap(); + eprintln!("weather parity adapter: {:?}", adapter.get_info()); + let (device, queue) = + pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).unwrap(); + let mut cases = Vec::new(); + let mut expected = Vec::new(); + for i in 0..4096i32 { + let x = i.wrapping_mul(45_238_971); + let z = i.wrapping_mul(-418_711).wrapping_add(i32::MIN); + let p = Parameters::new(x, z); + let bases = p.snow_base.map(f64::to_bits); + for ticks in [-1, 0, 511, 512, 131_071, 131_072, i64::MAX] { + let partial = [0.0, 0.5, 0.999, f32::from_bits(0x3f7fffff)][i as usize % 4]; + for snow in [false, true] { + let column = p.column(snow, ticks, x, -64, 320, z, 0, partial); + let uv = [1.0, if i & 1 == 0 { -16.0 } else { 80.0 }]; + cases.push(Case { + animation: [ + p.rain_speed, + p.rain_tick_offset, + p.snow_drift[0], + p.snow_drift[1], + ], + bases: [ + bases[0] as u32, + (bases[0] >> 32) as u32, + bases[1] as u32, + (bases[1] >> 32) as u32, + ], + time: Time::new(ticks, partial).values, + uv, + snow: u32::from(snow), + _pad: 0, + }); + expected.push([ + (uv[0] + column.u_offset).to_bits(), + (uv[1] + column.v_offset).to_bits(), + ]); + } + } + } + // Force halfway rounding, cancellation, zero, tiny bases and either + // sign of drift. Gaussian seeds alone rarely land on exact midpoints. + for base in [ + 0.0, + 2.0f64.powi(-53), + 0.5, + 0.5 + 2.0f64.powi(-25), + 0.5 + 2.0f64.powi(-25) + 2.0f64.powi(-53), + 0.5 + 2.0f64.powi(-14) + 2.0f64.powi(-53), + 1.0 - 2.0f64.powi(-53), + ] { + for delta in [0.0f32, -0.0, -0.5, 0.5, 1024.0, -1024.0, 2.0f32.powi(-40)] { + // time=100, u scale=.01 -> delta exactly, v is unused. + let bits = base.to_bits(); + cases.push(Case { + animation: [3.0, 0.0, delta, 0.0], + bases: [bits as u32, (bits >> 32) as u32, 0, 0], + time: [100.0, 0.0, 0.0, 0.0], + uv: [0.0, 0.0], + snow: 1, + _pad: 0, + }); + expected.push([((base + f64::from(delta)) as f32).to_bits(), 0]); + } + } + let expected: Vec<[u32; 4]> = expected + .into_iter() + .map(|bits| { + let uv = bits.map(f32::from_bits); + let texel = [ + 256 + ((uv[0] - uv[0].floor()) * 16.0).floor() as u32, + 512 + ((uv[1] - uv[1].floor()) * 32.0).floor() as u32, + ]; + [bits[0], bits[1], texel[0], texel[1]] + }) + .collect(); + let math = include_str!("../entity.wgsl") + .split("// WEATHER_MATH_BEGIN") + .nth(1) + .unwrap() + .split("// WEATHER_MATH_END") + .next() + .unwrap(); + let source = format!( + "{math}\n{}", + r#" +struct Case { animation: vec4, bases: vec4, time: vec4, uv: vec2, snow: u32, pad: u32 } +@group(0) @binding(0) var cases: array; +@group(0) @binding(1) var results: array>; +@compute @workgroup_size(64) fn main(@builtin(global_invocation_id) id: vec3) { + if id.x >= arrayLength(&cases) { return; } + let c = cases[id.x]; + let uv = c.uv + weather_phase(c.animation, c.bases, c.snow, c.time); + let texel = weather_texel(uv, vec4(0.25, 0.5, 0.015625, 0.03125), vec2(1024u)); + results[id.x] = vec4(bitcast>(uv), vec2(texel)); +}"# + ); + let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Weather parity"), + source: wgpu::ShaderSource::Wgsl(source.into()), + }); + let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Weather parity"), + layout: None, + module: &shader, + entry_point: Some("main"), + compilation_options: Default::default(), + cache: None, + }); + let input = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: None, + contents: bytemuck::cast_slice(&cases), + usage: wgpu::BufferUsages::STORAGE, + }); + let size = (expected.len() * 16) as u64; + let output = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size, + usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, + mapped_at_creation: false, + }); + let readback = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size, + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &pipeline.get_bind_group_layout(0), + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: input.as_entire_binding(), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: output.as_entire_binding(), + }, + ], + }); + let mut encoder = device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_compute_pass(&Default::default()); + pass.set_pipeline(&pipeline); + pass.set_bind_group(0, &group, &[]); + pass.dispatch_workgroups((cases.len() as u32).div_ceil(64), 1, 1); + } + encoder.copy_buffer_to_buffer(&output, 0, &readback, 0, size); + queue.submit([encoder.finish()]); + let (tx, rx) = std::sync::mpsc::channel(); + readback.map_async(wgpu::MapMode::Read, .., move |r| tx.send(r).unwrap()); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + rx.recv().unwrap().unwrap(); + let mapped = readback.get_mapped_range(..).unwrap(); + let actual: &[[u32; 4]] = bytemuck::cast_slice(&mapped); + for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() { + assert_eq!( + actual, expected, + "case {i}, snow={}, time={:?}, animation={:?}", + cases[i].snow, cases[i].time, cases[i].animation + ); + } + eprintln!("{} GPU weather UV cases matched bit for bit", cases.len()); + } +} diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 6c2b3a006..b4bfe72ac 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -365,6 +365,8 @@ pub struct HudBatch { pub patches: Vec, /// Vertex ranges with another blend or depth/scissor state, in order. pub blends: Vec<(std::ops::Range, 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) -> Vec<(std::ops::Range, 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, + ) { + 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!( diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index bf398edfc..ca6ff481b 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -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"); diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs index 4be5aa29f..1916344bb 100644 --- a/crates/horizon-client/src/lan/guest.rs +++ b/crates/horizon-client/src/lan/guest.rs @@ -71,6 +71,13 @@ pub struct Guest { /// The permission level (0 none, 2 game masters, 4 owners). pub permission: u8, pub sneaking: bool, + /// The last `ServerboundPlayerInputPacket` flags (forward 1, backward 2, + /// left 4, right 8, jump 16, shift 32, sprint 64). + pub input: u8, + /// The boat or minecart the player rides (`Entity.getVehicle`). + pub vehicle: Option, + /// `ServerGamePacketListenerImpl.lastGoodX/Y/Z` of the vehicle it controls. + pub vehicle_good: Option<[f64; 3]>, pub sprinting: bool, pub fall_flying: bool, pub flying: bool, @@ -233,6 +240,9 @@ impl Guest { game_mode: SURVIVAL, permission: 0, sneaking: false, + input: 0, + vehicle: None, + vehicle_good: None, sprinting: false, fall_flying: false, flying: false, diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index bb24940f4..8d7b5e29a 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -1968,6 +1968,7 @@ impl Hub { g.center = None; } S::PlayerInput(p) => { + self.guests[i].input = p.flags; self.guests[i].sneaking = p.flags & 32 != 0; self.guests[i].sprinting = p.flags & 64 != 0 && p.flags & 1 != 0; } @@ -2050,6 +2051,11 @@ impl Hub { to[2].clamp(-3.0E7, 3.0E7), ]; let (yaw, pitch) = (wrap_degrees(yaw), wrap_degrees(pitch)); + // A passenger only turns: its vehicle carries it (absSnapTo where it is). + if g.vehicle.is_some() { + (g.yaw, g.pitch) = (yaw, pitch); + return; + } let d = [0, 1, 2].map(|k| to[k] - g.first_good[k]); let moved = d[0] * d[0] + d[1] * d[1] + d[2] * d[2]; if g.sleeping { diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 2e1eb8455..0cfe3c585 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -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>>>>; @@ -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, block: Option| { + 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 = (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); diff --git a/crates/horizon-client/src/weather.rs b/crates/horizon-client/src/weather.rs index 3eb39e14c..f15ae028d 100644 --- a/crates/horizon-client/src/weather.rs +++ b/crates/horizon-client/src/weather.rs @@ -3,8 +3,9 @@ //! Vanilla draws each column as one camera-facing quad whose texture //! coordinates run past 0..1 (`v` advances a quarter of the texture per block, //! so `rain.png` repeats every 4 blocks) and relies on a repeating sampler. -//! Horizon samples the sprite from its atlas, so [`tile`] splits a quad at -//! every whole texture repeat into pieces that stay inside the sprite. +//! The live renderer repeats UVs inside the atlas sprite in its shader, using +//! cached coordinate-only [`Parameters`]. The reference [`tile`] path splits +//! at whole repeats and remains available for CPU callers and parity probes. use horizon_core::random::{LegacyRandom, RandomSource}; /// `WeatherEffectRenderer.ColumnInstance`. @@ -47,6 +48,176 @@ pub fn column_random(x: i32, z: i32) -> LegacyRandom { LegacyRandom::new(i64::from(column_seed(x, z))) } +/// Coordinate-only random values. Keep the snow bases as doubles: rounding them +/// before adding the float drift changes vanilla's UVs at rounding boundaries. +#[derive(Clone, Copy, Debug)] +pub struct Parameters { + pub rain_speed: f32, + pub rain_tick_offset: f32, + pub snow_base: [f64; 2], + pub snow_drift: [f32; 2], +} +impl Parameters { + pub fn new(x: i32, z: i32) -> Self { + let rain_speed = 3.0 + column_random(x, z).next_float(); + let mut random = column_random(x, z); + let u = random.next_double(); + let du = random.next_gaussian() as f32; + let v = random.next_double(); + let dv = random.next_gaussian() as f32; + Self { + rain_speed, + rain_tick_offset: (x + .wrapping_mul(x) + .wrapping_mul(3121) + .wrapping_add(x.wrapping_mul(45_238_971)) + .wrapping_add(z.wrapping_mul(z).wrapping_mul(418_711)) + .wrapping_add(z.wrapping_mul(13761)) + & 255) as f32, + snow_base: [u, v], + snow_drift: [du, dv], + } + } + + /// CPU reference for fixtures and GPU differential tests. The public random + /// source helpers below retain their original draw/advancement semantics. + #[allow(clippy::too_many_arguments)] + pub fn column( + self, + snow: bool, + ticks: i64, + x: i32, + bottom_y: i32, + top_y: i32, + z: i32, + light_coords: i32, + partial: f32, + ) -> Column { + let time = (ticks & 131_071) as f32 + partial; + let (u_offset, v_offset, light_coords) = if snow { + let u = (self.snow_base[0] + f64::from(time * 0.01 * self.snow_drift[0])) as f32; + let v = (self.snow_base[1] + f64::from(time * self.snow_drift[1] * 0.001)) as f32; + let fall = -((ticks & 511) as f32 + partial) / 512.0; + let (block, sky) = (light_coords >> 4 & 15, light_coords >> 20 & 15); + ( + u, + fall + v, + ((block * 3 + 15) / 4) << 4 | ((sky * 3 + 15) / 4) << 20, + ) + } else { + let offset = -(((ticks & 131_071) as f32 + self.rain_tick_offset) + partial) / 32.0 + * self.rain_speed; + (0.0, offset % 32.0, light_coords) + }; + Column { + x, + z, + bottom_y, + top_y, + u_offset, + v_offset, + light_coords, + } + } +} + +/// Direct-mapped 32x32 cache: at most 1024 coordinate keys, including after +/// teleports or radius changes. Full keys disambiguate collisions and wrapping. +/// Nothing world-dependent is cached, so dimension/biome/pack changes need no +/// invalidation; the caller still samples heights, precipitation and light. +pub struct ParameterCache { + entries: Box<[Option<((i32, i32), Parameters)>]>, +} +impl Default for ParameterCache { + fn default() -> Self { + Self { + entries: vec![None; 32 * 32].into_boxed_slice(), + } + } +} +impl ParameterCache { + pub fn get(&mut self, x: i32, z: i32) -> Parameters { + let index = ((z as u32 & 31) * 32 + (x as u32 & 31)) as usize; + let entry = &mut self.entries[index]; + if let Some((key, parameters)) = entry + && *key == (x, z) + { + return *parameters; + } + let parameters = Parameters::new(x, z); + *entry = Some(((x, z), parameters)); + parameters + } +} + +/// One unsplit camera-relative weather vertex. UV animation and atlas-local +/// repetition happen in the weather shader, rather than rebuilding tiled quads. +#[repr(C)] +#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)] +pub struct Vertex { + pub pos: [f32; 3], + pub uv: [f32; 2], + pub rect: [f32; 4], + pub animation: [f32; 4], + pub bases: [u32; 4], + pub color: u32, + pub light: u32, + pub snow: u32, +} + +/// Current ticks are masked on the CPU before conversion to float, including +/// negative/large tick values. Do not use the renderer's unbounded game_time. +#[repr(C)] +#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)] +pub struct Time { + pub values: [f32; 4], +} +impl Time { + pub fn new(ticks: i64, partial: f32) -> Self { + Self { + values: [(ticks & 131_071) as f32, (ticks & 511) as f32, partial, 0.0], + } + } +} + +/// Emit a single quad, retaining column_quad's position, fade, UV rounding and +/// light semantics. The zero phase leaves the shader to animate both UV axes. +pub fn vertices( + column: &Column, + parameters: Parameters, + snow: bool, + camera: [f64; 3], + radius: i32, + intensity: f32, + rect: [f32; 4], +) -> [Vertex; 4] { + let quad = column_quad( + column, + camera, + if snow { 0.8 } else { 1.0 }, + radius, + intensity, + ); + let lc = column.light_coords; + let light = ((lc >> 20 & 15) * 16) as u32 | (((lc >> 4 & 15) * 16) as u32) << 8; + let [u, v] = parameters.snow_base.map(f64::to_bits); + quad.map(|q| Vertex { + pos: q.pos, + uv: q.uv, + rect, + animation: [ + parameters.rain_speed, + parameters.rain_tick_offset, + parameters.snow_drift[0], + parameters.snow_drift[1], + ], + bases: [u as u32, (u >> 32) as u32, v as u32, (v >> 32) as u32], + color: q.color, + light, + snow: u32::from(snow), + }) +} + /// `createRainColumnInstance`. #[allow(clippy::too_many_arguments)] pub fn rain_column( @@ -114,10 +285,15 @@ pub fn snow_column( /// The constructor's 32x32 table of horizontal column half-widths, indexed /// relative to the camera block. The camera's own column divides 0 by 0. fn column_size(index: usize) -> (f32, f32) { - let delta_x = (index % 32) as f32 - 16.0; - let delta_z = (index / 32) as f32 - 16.0; - let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; - (-delta_z / distance, delta_x / distance) + static SIZES: std::sync::LazyLock<[(f32, f32); 32 * 32]> = std::sync::LazyLock::new(|| { + std::array::from_fn(|index| { + let delta_x = (index % 32) as f32 - 16.0; + let delta_z = (index / 32) as f32 - 16.0; + let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; + (-delta_z / distance, delta_x / distance) + }) + }); + SIZES[index] } /// `prepareInstances` for one column: rain uses `max_alpha` 1, snow 0.8. @@ -135,8 +311,8 @@ pub fn column_quad( let t = (distance_sq / radius_sq).min(1.0); let alpha = (max_alpha + t * (0.5 - max_alpha)) * intensity; let color = ((alpha * 255.0).floor() as i32 as u32) << 24 | 0xFF_FFFF; - let index = - (column.z - camera[2].floor() as i32 + 16) * 32 + column.x - camera[0].floor() as i32 + 16; + let index = (column.z - camera[2].floor() as i32 + 16) * 32 + + (column.x - camera[0].floor() as i32 + 16); let (size_x, size_z) = column_size(index as usize); let (half_x, half_z) = (size_x / 2.0, size_z / 2.0); let (x0, x1) = (relative_x - half_x, relative_x + half_x); @@ -219,6 +395,103 @@ fn pieces(a: f32, b: f32) -> impl Iterator { mod tests { use super::*; + #[test] + fn column_size_table_matches_original_arithmetic() { + for z in 0..32 { + for x in 0..32 { + let delta_x = x as f32 - 16.0; + let delta_z = z as f32 - 16.0; + let distance = f64::from(delta_x * delta_x + delta_z * delta_z).sqrt() as f32; + let expected = [-delta_z / distance, delta_x / distance]; + let actual = column_size(z * 32 + x); + for (actual, expected) in [actual.0, actual.1].into_iter().zip(expected) { + if x == 16 && z == 16 { + assert!(expected.is_nan()); + assert!(actual.is_nan()); + } else { + assert_eq!(actual.to_bits(), expected.to_bits(), "column ({x}, {z})"); + } + } + } + } + } + + #[test] + fn cached_parameters_match_original_random_draws() { + let mut cache = ParameterCache::default(); + for i in 0..2048i32 { + let x = i.wrapping_mul(45_238_971); + let z = i.wrapping_mul(-418_711).wrapping_add(i32::MIN); + for ticks in [i64::MIN, -1, 0, 511, 512, 131_071, 131_072, i64::MAX] { + for partial in [0.0, 0.5, 0.999] { + for snow in [false, true] { + let mut random = column_random(x, z); + let reference = if snow { + snow_column(&mut random, ticks, x, -64, 320, z, 0xf000f0, partial) + } else { + rain_column(&mut random, ticks, x, -64, 320, z, 0xf000f0, partial) + }; + assert_eq!( + cache + .get(x, z) + .column(snow, ticks, x, -64, 320, z, 0xf000f0, partial), + reference + ); + } + } + } + } + } + + #[test] + fn parameter_cache_reuses_full_keys_and_stays_bounded() { + let mut cache = ParameterCache::default(); + let expected = cache.get(-1, i32::MAX); + // A changed entry proves that a hit does not regenerate random values. + let index = 31 * 32 + 31; + cache.entries[index].as_mut().unwrap().1.rain_speed = 123.0; + assert_eq!(cache.get(-1, i32::MAX).rain_speed, 123.0); + // Colliding positions must replace the entry, rather than reuse it. + cache.get(31, -1); + assert_eq!(cache.get(-1, i32::MAX).rain_speed, expected.rain_speed); + for i in 0..100_000i32 { + cache.get(i.wrapping_mul(3121), i.wrapping_mul(418_711)); + } + assert_eq!(cache.entries.len(), 1024); + assert!(cache.entries.iter().flatten().count() <= 1024); + } + + #[test] + fn unsplit_vertices_keep_live_geometry_light_and_atlas_inputs() { + let x = i32::MAX - 5; + let z = i32::MIN + 5; + let parameters = Parameters::new(x, z); + let camera = [f64::from(x) - 2.25, 80.75, f64::from(z) + 0.25]; + for (bottom_y, top_y, light_coords, radius, intensity, rect) in [ + (64, 90, 0, 5, 0.25, [0.1, 0.2, 0.03, 0.04]), + (85, 95, 0xf000f0, 10, 1.0, [0.5, 0.5, 0.1, 0.2]), + ] { + let column = Column { + x, + z, + bottom_y, + top_y, + light_coords, + u_offset: 0.0, + v_offset: 0.0, + }; + let quad = column_quad(&column, camera, 1.0, radius, intensity); + let vertices = vertices(&column, parameters, false, camera, radius, intensity, rect); + for (a, b) in vertices.iter().zip(quad) { + assert_eq!(a.pos, b.pos); + assert_eq!(a.uv, b.uv); + assert_eq!(a.color, b.color); + assert_eq!(a.rect, rect); + assert_eq!(a.light, if light_coords == 0 { 0 } else { 0xf0f0 }); + } + } + } + #[test] fn rain_repeats_every_four_blocks() { let column = Column { @@ -282,6 +555,10 @@ mod tests { light_coords: 0, }; let quad = column_quad(&column, [0.5, 70.0, 0.5], 1.0, 10, 1.0); - assert!(quad[0].pos[0].is_nan()); + for vertex in quad { + assert!(vertex.pos[0].is_nan()); + assert!(vertex.pos[2].is_nan()); + assert!(vertex.pos[1].is_finite()); + } } } diff --git a/crates/horizon-core/src/density/end_islands.rs b/crates/horizon-core/src/density/end_islands.rs index 148f3575d..2ae9f9b5f 100644 --- a/crates/horizon-core/src/density/end_islands.rs +++ b/crates/horizon-core/src/density/end_islands.rs @@ -50,6 +50,64 @@ impl EndIslandSampler { } height } + // Nearby volume columns visit overlapping 25-by-25 island neighborhoods. + // Collect the eligible islands once, retaining their original X/Z order. + // Larger or coordinate-wrapping volumes keep the scalar evaluation path. + fn volume_islands(&self, volume: DensityVolume) -> Option> { + let sizes = volume.sizes(); + if sizes[0] * sizes[2] < 4 { + return None; + } + let minimum = volume.minimum(); + let steps = volume.steps(); + let end = |axis: usize| { + i32::try_from( + i64::from(minimum[axis]) + (sizes[axis] - 1) as i64 * i64::from(steps[axis]), + ) + .ok() + }; + let first_x = minimum[0] / 8 / 2 - 12; + let first_z = minimum[2] / 8 / 2 - 12; + let last_x = end(0)? / 8 / 2 + 12; + let last_z = end(2)? / 8 / 2 + 12; + if last_x - first_x >= 64 || last_z - first_z >= 64 { + return None; + } + let mut islands = Vec::new(); + for x in first_x..=last_x { + for z in first_z..=last_z { + if i64::from(x) * i64::from(x) + i64::from(z) * i64::from(z) <= 4096 + || self.noise.get2(f64::from(x), f64::from(z)) >= -0.9 + { + continue; + } + let scale = ((x as f32).abs() * 3439.0 + (z as f32).abs() * 147.0) % 13.0 + 9.0; + islands.push((x, z, scale)); + } + } + Some(islands) + } + fn density_from_islands(x: i32, z: i32, islands: &[(i32, i32, f32)]) -> f32 { + let x = x / 8; + let z = z / 8; + let center_x = x / 2; + let center_z = z / 2; + let mut height = -100.0; + for &(island_x, island_z, scale) in islands { + let offset_x = island_x - center_x; + let offset_z = island_z - center_z; + if !(-12..=12).contains(&offset_x) || !(-12..=12).contains(&offset_z) { + continue; + } + let dx = (x % 2 - offset_x * 2) as f32; + let dz = (z % 2 - offset_z * 2) as f32; + let candidate = 100.0 - ((dx * dx + dz * dz) as f64).sqrt() as f32 * scale; + let candidate = + super::arithmetic::java_min(super::arithmetic::java_max(candidate, -100.0), 80.0); + height = super::arithmetic::java_max(height, candidate); + } + (height - 8.0) / 128.0 + } fn density(&self, x: i32, z: i32) -> f32 { (self.height(x / 8, z / 8) - 8.0) / 128.0 } @@ -66,10 +124,15 @@ impl DensitySampler for EndIslandSampler { ) -> Result<(), SampleError> { check_buffer(buffer, volume)?; let [sx, sy, sz] = volume.sizes(); + let islands = self.volume_islands(volume); for z in 0..sz { let block_z = volume.block(Axis::Z, z).unwrap(); for x in 0..sx { - let value = self.density(volume.block(Axis::X, x).unwrap(), block_z); + let block_x = volume.block(Axis::X, x).unwrap(); + let value = match &islands { + Some(islands) => Self::density_from_islands(block_x, block_z, islands), + None => self.density(block_x, block_z), + }; let start = (x + z * sx) * sy; buffer[start..start + sy].fill(value); } @@ -77,3 +140,78 @@ impl DensitySampler for EndIslandSampler { Ok(()) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn end_island_volumes_match_scalar_at_truncation_and_world_boundaries() { + let cases = [ + ([5, 3, 5], [0, -64, 0], [4, 8, 4]), + ([5, 3, 5], [1920, -64, 2240], [8, 8, 8]), + ([5, 3, 5], [-2049, -64, 3071], [4, 8, 4]), + ([5, 3, 5], [1023, -64, -1025], [1, 8, 1]), + ([5, 3, 5], [30_000_000, 0, -30_000_000], [8, 1, 8]), + ([5, 3, 5], [i32::MIN, 0, i32::MIN], [8, 1, 8]), + ([5, 3, 5], [i32::MAX - 32, 0, i32::MAX - 32], [8, 1, 8]), + // Also exercise wrapping, wide, sparse and single-column volumes. + ([5, 3, 5], [i32::MAX - 12, 0, i32::MAX - 3], [8, 1, 8]), + ([5, 3, 5], [4096, 0, -8192], [1024, 1, 1024]), + ([2, 3, 2], [-4096, 0, 8192], [599, 1, 599]), + ([1, 4, 1], [-15, 0, -17], [1, 1, 1]), + ]; + for seed in [0, 12345, -1, i64::MIN, i64::MAX] { + let sampler = EndIslandSampler::new(seed); + let mut context = SamplerContext::default(); + let mut compare = |volume: DensityVolume| { + let sentinel = 123.0_f32; + let mut output = vec![sentinel; volume.size() + 1]; + sampler + .sample_volume(&mut context, &mut output, volume) + .unwrap(); + visit(volume, |index, position| { + let expected = sampler.sample_value(&mut context, position)?; + assert_eq!( + output[index].to_bits(), + expected.to_bits(), + "seed {seed}, position {position:?}, volume {volume:?}" + ); + Ok(()) + }) + .unwrap(); + assert_eq!(output[volume.size()], sentinel); + let mut short = vec![sentinel; volume.size() - 1]; + assert_eq!( + sampler.sample_volume(&mut context, &mut short, volume), + Err(DensityError::BufferTooShort.into()) + ); + assert!(short.iter().all(|&value| value == sentinel)); + }; + for (sizes, minimum, steps) in cases { + compare(DensityVolume::new(sizes, minimum, steps).unwrap()); + } + // Every signed remainder around both coordinate divisions, in a + // neighborhood that straddles the central-island exclusion circle. + for offset in -17..=17 { + compare( + DensityVolume::new([5, 2, 5], [1024 + offset, -32, -offset], [3, 16, 5]) + .unwrap(), + ); + } + } + let sampler = EndIslandSampler::new(12345); + assert!( + sampler + .volume_islands(DensityVolume::new([5, 2, 5], [-2049, 0, 3071], [4, 8, 4]).unwrap()) + .is_some() + ); + for (sizes, minimum, steps) in [cases[7], cases[8], cases[10]] { + assert!( + sampler + .volume_islands(DensityVolume::new(sizes, minimum, steps).unwrap()) + .is_none() + ); + } + } +} diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index 537ecf6ef..e737258c5 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -672,6 +672,11 @@ packet!( /// ClientboundSetPassengersPacket: a vehicle and every entity riding it. SetPassengers { vehicle: i32 => VarInt, passengers: Vec => List } ); +packet!( + /// ClientboundMoveVehiclePacket: the server puts a vehicle its rider + /// controls back where it was (PositionAndRotation: x, y, z, yRot, xRot). + MoveVehicle { position: [f64; 3] => Vec3d, yaw: f32 => Float, pitch: f32 => Float } +); /// ClientboundSetEquipmentPacket: (EquipmentSlot ordinal, stack) pairs. pub struct Equipment; impl Codec)>> for Equipment { @@ -1529,6 +1534,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound { SetHeldSlot(SetHeldSlot) = SET_HELD_SLOT, SetObjective(SetObjective) = SET_OBJECTIVE, SetPassengers(SetPassengers) = SET_PASSENGERS, + MoveVehicle(MoveVehicle) = MOVE_VEHICLE, ProjectilePower(ProjectilePower) = PROJECTILE_POWER, SetPlayerInventory(SetPlayerInventory) = SET_PLAYER_INVENTORY, SetPlayerTeam(SetPlayerTeam) = SET_PLAYER_TEAM, @@ -1802,6 +1808,15 @@ packet!( packet!(MovePlayerPosRot { x: f64 => Double, y: f64 => Double, z: f64 => Double, yaw: f32 => Float, pitch: f32 => Float, flags: u8 => UByte }); packet!(MovePlayerRot { yaw: f32 => Float, pitch: f32 => Float, flags: u8 => UByte }); packet!(MovePlayerStatus { flags: u8 => UByte }); +packet!( + /// ServerboundMoveVehiclePacket: where the rider moved the vehicle it + /// controls (PositionAndRotation, then onGround). + MoveVehicleRequest { position: [f64; 3] => Vec3d, yaw: f32 => Float, pitch: f32 => Float, on_ground: bool => Bool } +); +packet!( + /// ServerboundPaddleBoatPacket: the boat's left and right paddles. + PaddleBoat { left: bool => Bool, right: bool => Bool } +); packet!(PickItemFromBlock { pos: [i32; 3] => Pos, include_data: bool => Bool }); packet!( /// ServerboundPlayerActionPacket.Action: 0 start destroy, 1 change destroy @@ -1869,6 +1884,8 @@ packet_enum!(Serverbound, crate::ids::play::serverbound { MovePlayerPosRot(MovePlayerPosRot) = MOVE_PLAYER_POS_ROT, MovePlayerRot(MovePlayerRot) = MOVE_PLAYER_ROT, MovePlayerStatus(MovePlayerStatus) = MOVE_PLAYER_STATUS_ONLY, + MoveVehicle(MoveVehicleRequest) = MOVE_VEHICLE, + PaddleBoat(PaddleBoat) = PADDLE_BOAT, PickItemFromBlock(PickItemFromBlock) = PICK_ITEM_FROM_BLOCK, PingRequest(crate::packets::status::Ping) = PING_REQUEST, PlayerAbilities(PlayerAbilitiesRequest) = PLAYER_ABILITIES, diff --git a/crates/horizon-world/examples/chunkgen_bench.rs b/crates/horizon-world/examples/chunkgen_bench.rs index 23360b637..2eb433600 100644 --- a/crates/horizon-world/examples/chunkgen_bench.rs +++ b/crates/horizon-world/examples/chunkgen_bench.rs @@ -3,7 +3,7 @@ //! chunkgen_bench [--seed S] [--size N] [--threads T] //! [--center CX CZ] [--verify ] [--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], 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(()) +} diff --git a/crates/horizon-world/examples/level_place_fixture.rs b/crates/horizon-world/examples/level_place_fixture.rs index a8f00edd1..13595726d 100644 --- a/crates/horizon-world/examples/level_place_fixture.rs +++ b/crates/horizon-world/examples/level_place_fixture.rs @@ -20,6 +20,7 @@ struct Cells { cells: HashMap, 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> { @@ -68,6 +72,7 @@ fn main() -> Result<(), Box> { 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 { diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 2d7dd251c..2595173ad 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -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,27 +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:: { - generation, - noise_volume: volume, - root: self.root.clone(), - surface: SurfaceQueries { - pipeline: self, - temperatures: &mut worker.temperatures, - biome: Biomes::Region(&biomes), - possible: Some(possible), + if !self.identity_end_surface(pos) { + build_surface( + &mut chunk, + self.rule.clone(), + SurfaceInputs:: { + 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| { @@ -1149,6 +1196,7 @@ where pipeline: self, temperatures: &mut worker.temperatures, biome: Biomes::Resolver(&mut resolver, &mut biome_context), + uniform_biomes: None, possible: None, }, preliminary_surface: self.preliminary.clone(), @@ -1393,6 +1441,63 @@ enum Biomes<'a, 'b> { &'a mut SamplerContext, ), } +// Lazy equality proofs for the eight quart corners of a block-biome cell. +// Adjacent blocks share these candidates even though their zoom distances differ. +struct UniformSurfaceBiomes { + origin: [i32; 3], + height: i32, + cells: Vec>>, +} +impl UniformSurfaceBiomes { + fn new(pos: ChunkPos, min_y: i32, height: i32) -> Self { + let height = (height >> 2) + 1; + Self { + origin: [ + pos.x.wrapping_shl(4).wrapping_sub(2) >> 2, + min_y.wrapping_sub(2) >> 2, + pos.z.wrapping_shl(4).wrapping_sub(2) >> 2, + ], + height, + cells: vec![None; 25 * height as usize], + } + } + fn get(&mut self, region: &BiomeRegion, p: BlockPos) -> Option { + let base = [p.x, p.y, p.z].map(|v| v.wrapping_sub(2) >> 2); + let d: [i32; 3] = std::array::from_fn(|i| base[i].wrapping_sub(self.origin[i])); + if !(0..5).contains(&d[0]) || !(0..self.height).contains(&d[1]) || !(0..5).contains(&d[2]) { + return None; + } + let slot = &mut self.cells[((d[0] * 5 + d[2]) * self.height + d[1]) as usize]; + if let Some(value) = slot { + return *value; + } + let value = (|| { + // These are immutable stored lookups. A missing candidate prevents + // the shortcut; only the original selected lookup may report errors. + let first = *region.noise_biome(base).ok()?; + for x in 0..2 { + for y in 0..2 { + for z in 0..2 { + if *region + .noise_biome([ + base[0].wrapping_add(x), + base[1].wrapping_add(y), + base[2].wrapping_add(z), + ]) + .ok()? + != first + { + return None; + } + } + } + } + Some(first) + })(); + *slot = Some(value); + value + } +} /// Material-rule world queries for one chunk: shared seed-bound noises, the /// worker's temperature caches and either stored or raw-resolver biomes. struct SurfaceQueries<'a, 'b, R: RandomSource> { @@ -1400,6 +1505,7 @@ struct SurfaceQueries<'a, 'b, R: RandomSource> { temperatures: &'a mut [BiomeTemperature], biome: Biomes<'a, 'b>, possible: Option>, + uniform_biomes: Option, } impl SurfaceQueries<'_, '_, R> { fn temperature(&mut self, name: &str) -> Result<&mut BiomeTemperature, MaterialRuleError> { @@ -1437,9 +1543,16 @@ impl MaterialSurfaceQueries for SurfaceQueries<'_, '_, R> { fn biome(&mut self, p: BlockPos) -> Result>, MaterialRuleError> { let data = &self.pipeline.data; let id = match &mut self.biome { - Biomes::Region(region) => *region - .biome(p) - .map_err(|_| MaterialRuleError::MissingBiome)?, + Biomes::Region(region) => match self + .uniform_biomes + .as_mut() + .and_then(|cache| cache.get(region, p)) + { + Some(id) => id, + None => *region + .biome(p) + .map_err(|_| MaterialRuleError::MissingBiome)?, + }, Biomes::Resolver(resolver, context) => { let name = resolver .sample(context, self.pipeline.zoom.quart_at_block(p)) @@ -1778,6 +1891,7 @@ where pipeline: self, temperatures: &mut worker.temperatures, biome: Biomes::Resolver(&mut resolver, &mut biome_context), + uniform_biomes: None, possible: None, }; let sources = MaterialDensitySources::new( @@ -1944,6 +2058,7 @@ where pipeline: self, temperatures: &mut worker.temperatures, biome: Biomes::Resolver(&mut resolver, &mut biome_context), + uniform_biomes: None, possible: None, }; let sources = MaterialDensitySources::new( @@ -2407,6 +2522,191 @@ 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() { + use super::super::biome_chunk::BiomeChunk; + use std::convert::Infallible; + + for pos in [ + ChunkPos::new(0, 0), + ChunkPos::new(-17, 23), + ChunkPos::new(i32::MIN >> 4, i32::MAX >> 4), + ] { + for seed in [0, -1, i64::MIN] { + for mixed in [false, true] { + let mut chunks = Vec::new(); + for dz in -1..=1 { + for dx in -1..=1 { + let mut chunk = BiomeChunk::new( + ChunkPos::new(pos.x + dx, pos.z + dz), + -64, + 128, + BiomeId(7), + ) + .unwrap(); + chunk + .fill(-64, 63, |[x, y, z]| { + Ok::<_, Infallible>(if mixed { + BiomeId( + (x.div_euclid(3) + y.div_euclid(4) + z.div_euclid(2)) + .rem_euclid(5) + as u32, + ) + } else { + BiomeId(7) + }) + }) + .unwrap(); + chunks.push(chunk); + } + } + let region = BiomeRegion::new(chunks, seed).unwrap(); + let mut cache = UniformSurfaceBiomes::new(pos, -64, 128); + let mut hits = 0; + for x in 0..16 { + for z in 0..16 { + // Include clamped Y, out-of-cache Y, and revisit each + // cached proof in the ordinary descending traversal. + for y in (-70..70).rev() { + let p = BlockPos::new(pos.x * 16 + x, y, pos.z * 16 + z); + let shortcut = cache.get(®ion, p); + hits += usize::from(shortcut.is_some()); + let actual = shortcut.map_or_else(|| region.biome(p).copied(), Ok); + assert_eq!(actual, region.biome(p).copied()); + } + } + } + if !mixed && pos.x != i32::MIN >> 4 { + assert!(hits > 0); + } + } + } + } + + // Some unselected corners are missing. Probing them must neither invent + // an error nor hide the original selected-corner error. + let pos = ChunkPos::new(0, 0); + let region = + BiomeRegion::new(vec![BiomeChunk::new(pos, 0, 16, BiomeId(7)).unwrap()], -1).unwrap(); + let mut cache = UniformSurfaceBiomes::new(pos, 0, 16); + let mut successes = 0; + let mut failures = 0; + for x in -2..18 { + for z in -2..18 { + let p = BlockPos::new(x, 7, z); + let actual = cache + .get(®ion, p) + .map_or_else(|| region.biome(p).copied(), Ok); + assert_eq!(actual, region.biome(p).copied()); + successes += usize::from(actual.is_ok()); + failures += usize::from(actual.is_err()); + } + } + assert!(successes > 0 && failures > 0); + } #[test] fn far_surface_matches_undecorated_land_and_keeps_end_void() { diff --git a/docs/media/command-suggestions/after.png b/docs/media/command-suggestions/after.png new file mode 100644 index 000000000..9c1a9cd4c Binary files /dev/null and b/docs/media/command-suggestions/after.png differ diff --git a/docs/media/command-suggestions/before.png b/docs/media/command-suggestions/before.png new file mode 100644 index 000000000..66c3925c4 Binary files /dev/null and b/docs/media/command-suggestions/before.png differ diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java index 0757bc2ef..e204d3cc0 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaBlockPlacementOracle.java @@ -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 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(); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java index 8034968a5..b2cdb3383 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeldDropOracle.java @@ -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); } } } diff --git a/tests/test_remote_mining.py b/tests/test_remote_mining.py new file mode 100644 index 000000000..236b85c28 --- /dev/null +++ b/tests/test_remote_mining.py @@ -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, mining: Option, creative: bool, + world: World, res: Resources, player: Option, audio: Audio, + hit: Hit, sequence: i32, packets: Vec, +} +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 { 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::>(), [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() diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 977d2e292..6f75b8a14 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -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'): diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 082a517b1..a93115f63 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -116,6 +116,15 @@ address. The script then checks, from both sides, what a guest's game used to ge and wheat on farmland grows (random ticks), however the host runs its world. - ladder: the guest climbs down ten blocks of ladder and lands unhurt: the server resets its fall distance on a ladder every tick, as LivingEntity.handleOnClimbable does (#1255). +- boats: the host (single player, on its server thread or not) and the guest each right-click a + boat on water and ride it, paddle it forward (the other side sees it move), sneak out, + and break it with their fists (#1222). +- minecarts: the host and the guest each get into a minecart on rails, sneak out beside it, and break + it (#1222). +- frames: the host and the guest each put a diamond in an item frame and turn it, and put a + helmet on an armor stand and take it back (#1222). +- lightning: a bolt summoned beside the host, then the guest: both sides get the bolt and flash the + sky (on its server thread the host's window is a client of it too). - flight: a player in creative double-taps jump and flies, stays up, and stops flying in survival: the guest, and on the server thread the host's window too, take what may fly from the server's abilities (ClientPacketListener.handlePlayerAbilities). @@ -157,7 +166,7 @@ ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' # The host plays single player on its server thread (--server-thread). SERVER_THREAD = False -CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder'] +CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'lightning'] class Game: @@ -2310,6 +2319,223 @@ def check_ladder(host, guest, out): guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') +def apart(host, guest): + """The host where it stands and the guest 12 blocks east, each on a stone floor with room + around: neither stands in the other's way (a ray from inside a player's box hits that player).""" + x, y, z = (int(v // 1) for v in pos_of(host)) + spots = {} + for label, player, dx in (('host', host, 0), ('guest', guest, 12)): + px = x + dx + host('command', command=f'fill {px - 3} {y - 1} {z - 3} {px + 4} {y - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {px - 3} {y} {z - 3} {px + 4} {y + 3} {z + 6} minecraft:air') + player('command', command=f'tp @s {px + 0.5} {y} {z + 0.5} 0 0') + spots[label] = (px, y, z) + host.wait(10) + guest.wait(10) + return spots + + +def board(player, kind, at): + """Right-click the `kind` object near `at` and check `player` rides it.""" + found = [o for o in player('status')['objects'] if o['kind'].endswith(kind) + and abs(o['position'][0] - at[0]) < 2 and abs(o['position'][2] - at[2]) < 2] + assert found, f'no {kind} near {at}' + vehicle = found[0] + vp = vehicle['position'] + player.raw('look-at', f'{vp[0]:.2f}', f'{vp[1] + 0.3:.2f}', f'{vp[2]:.2f}') + player.raw('mouse', 'right', 'click') + player.wait(10) + riding = player('status').get('riding') + assert riding == vehicle['id'], f'right-clicking the {kind} {vehicle["id"]}: riding {riding}' + return vehicle + + +def leave_vehicle(player, kind): + player.raw('key', 'shift', 'down') + player.wait(10) + player.raw('key', 'shift', 'up') + player.wait(10) + riding = player('status').get('riding') + assert riding is None, f'sneaking out of the {kind}: riding {riding}' + + +def break_vehicle(player, vehicle_id, kind): + """Hit it with fists until it breaks: VehicleEntity.tick takes 1 off its damage every tick.""" + for _ in range(10): + here = [o for o in player('status')['objects'] if o['id'] == vehicle_id] + if not here: + return + vp = here[0]['position'] + player.raw('look-at', f'{vp[0]:.2f}', f'{vp[1] + 0.3:.2f}', f'{vp[2]:.2f}') + player.raw('mouse', 'left', 'click') + player.wait(2) + raise AssertionError(f'ten hits left the {kind} in place') + + +def check_boats(host, guest, out): + """#1222: the host (single player, on its server thread or not) and the guest each board a boat + on water with a right click, paddle it forward (the other side sees it move), sneak out, and + break it with their fists.""" + result = {} + spots = apart(host, guest) + for label, player, other in (('host', host, guest), ('guest', guest, host)): + x, y, z = spots[label] + bx = x + 3 + player('command', command='gamemode survival') + # A pool ten blocks long in a stone basin (the world may float), with a path beside it to + # walk back to the boat. + player('command', command=f'fill {bx - 3} {y} {z - 2} {bx + 2} {y + 3} {z + 10} minecraft:air') + player('command', command=f'fill {bx - 3} {y - 2} {z - 2} {bx + 2} {y - 1} {z + 10} minecraft:stone') + player('command', command=f'fill {bx - 1} {y - 1} {z - 1} {bx + 1} {y - 1} {z + 9} minecraft:water') + player('command', command=f'summon minecraft:oak_boat {bx + 0.5} {y - 0.1} {z + 0.5}') + player.wait(30) + try: + boat = board(player, 'oak_boat', (bx + 0.5, y, z + 0.5)) + start = boat['position'] + # The summoned boat faces south: forward paddles it along the pool. + player.raw('key', 'w', 'down') + player.wait(30) + player.raw('key', 'w', 'up') + player.wait(20) + mine = [o for o in player('status')['objects'] if o['id'] == boat['id']] + assert mine, f'the {label} lost its boat' + moved = math.dist(start, mine[0]['position']) + assert moved > 0.5, f'paddling forward moved the {label}\'s boat {moved:.2f} blocks' + # The other side sees the boat where its rider took it (the server accepted its moves). + theirs = [o for o in objects_near(other, mine[0]['position'], 'objects') + if o['kind'].endswith('oak_boat')] + assert theirs, f'the other side sees no boat near the {label}\'s' + far = min(math.dist(o['position'], mine[0]['position']) for o in theirs) + assert far < 1.0, f'the other side sees the {label}\'s boat {far:.2f} blocks off' + leave_vehicle(player, 'boat') + player('command', command=f'tp @s {bx - 1.5} {y} {mine[0]["position"][2]:.2f}') + player.wait(5) + break_vehicle(player, boat['id'], 'boat') + result[label] = {'boat': boat['id'], 'paddled': round(moved, 2), 'broken': True} + finally: + player('command', command=f'kill @e[type=minecraft:oak_boat,x={bx},y={y},z={z + 4},distance=..10]') + player('command', command=f'fill {bx - 1} {y - 1} {z - 1} {bx + 1} {y - 1} {z + 9} minecraft:stone') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + player.wait(5) + return result + + +def check_minecarts(host, guest, out): + """#1222: the host and the guest each get into a minecart on rails with a right click, sneak out + beside it, and break it with their fists.""" + result = {} + spots = apart(host, guest) + for label, player in (('host', host), ('guest', guest)): + x, y, z = spots[label] + cx = x + 3 + player('command', command='gamemode survival') + player('command', command=f'fill {cx - 2} {y} {z - 2} {cx + 2} {y + 3} {z + 6} minecraft:air') + player('command', command=f'fill {cx - 2} {y - 1} {z - 2} {cx + 2} {y - 1} {z + 6} minecraft:stone') + player('command', command=f'fill {cx} {y} {z} {cx} {y} {z + 4} minecraft:rail') + player('command', command=f'summon minecraft:minecart {cx + 0.5} {y} {z + 0.5}') + player.wait(30) + try: + cart = board(player, 'minecart', (cx + 0.5, y, z + 0.5)) + seated = pos_of(player) + assert abs(seated[0] - (cx + 0.5)) < 0.6, f'the {label} sits at {seated}, not in the cart' + leave_vehicle(player, 'minecart') + out_at = pos_of(player) + assert math.dist(out_at, seated) > 0.3, f'the {label} stayed in its seat at {out_at}' + player.wait(5) + break_vehicle(player, cart['id'], 'minecart') + result[label] = {'cart': cart['id'], 'out_at': [round(v, 2) for v in out_at], 'broken': True} + finally: + player('command', command=f'kill @e[type=minecraft:minecart,x={cx},y={y},z={z},distance=..8]') + player('command', command=f'kill @e[type=minecraft:item,x={cx},y={y},z={z},distance=..8]') + player('command', command=f'fill {cx} {y} {z} {cx} {y} {z + 4} minecraft:air') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + player.wait(5) + return result + + +def check_frames(host, guest, out): + """#1222: the host and the guest each put a diamond in an item frame and turn it, and put a + helmet on an armor stand and take it back, with right clicks.""" + result = {} + spots = apart(host, guest) + for label, player, other in (('host', host, guest), ('guest', guest, host)): + x, y, z = spots[label] + player('command', command='gamemode survival') + # Within a survival player's 3 blocks of reach: a frame on a wall, an armor stand beside it. + player('command', command=f'fill {x - 2} {y} {z + 1} {x + 2} {y + 2} {z + 2} minecraft:air') + player('command', command=f'fill {x - 2} {y} {z + 3} {x + 2} {y + 2} {z + 3} minecraft:stone') + player('command', command=f'summon minecraft:item_frame {x + 0.5} {y + 1.5} {z + 2.97} ' + f'{{block_pos:[I;{x},{y + 1},{z + 2}],Facing:2b}}') + player('command', command=f'summon minecraft:armor_stand {x - 1.5} {y} {z + 1.5}') + player('command', command='clear @s') + player('command', command='item replace entity @s weapon.mainhand with minecraft:diamond') + player.wait(30) + try: + frame = [o for o in player('status')['objects'] if o['kind'].endswith('item_frame') + and o['position'] == [x, y + 1, z + 2]] + assert frame, f'the {label} sees no item frame at {[x, y + 1, z + 2]}' + player.raw('look-at', f'{x + 0.5:.2f}', f'{y + 1.5:.2f}', f'{z + 2.95:.2f}') + player.raw('mouse', 'right', 'click') + player.wait(10) + player.raw('mouse', 'right', 'click') + player.wait(10) + frame = [o for o in player('status')['objects'] if o['id'] == frame[0]['id']][0] + assert frame['item'] == 'minecraft:diamond', f'the {label}\'s frame holds {frame["item"]}' + assert frame['rotation'] == 1, f'the {label}\'s frame turned to {frame["rotation"]}' + theirs = [o for o in other('status')['objects'] if o['kind'].endswith('item_frame') + and o['position'] == [x, y + 1, z + 2]] + assert theirs and theirs[0]['item'] == 'minecraft:diamond' and theirs[0]['rotation'] == 1, \ + f'the other side sees the {label}\'s frame as {theirs}' + player('command', command='item replace entity @s weapon.mainhand with minecraft:iron_helmet') + player.wait(5) + stand = [o for o in player('status')['objects'] if o['kind'] == 'minecraft:armor_stand' + and abs(o['position'][0] - (x - 1.5)) < 0.5 and abs(o['position'][2] - (z + 1.5)) < 0.5] + assert stand, f'the {label} sees no armor stand' + player.raw('look-at', f'{x - 1.5:.2f}', f'{y + 1.7:.2f}', f'{z + 1.5:.2f}') + player.raw('mouse', 'right', 'click') + player.wait(10) + worn = [o for o in player('status')['objects'] if o['id'] == stand[0]['id']][0]['equipment'] + assert 'minecraft:iron_helmet' in worn, f'the {label}\'s armor stand wears {worn}' + player.raw('look-at', f'{x - 1.5:.2f}', f'{y + 1.7:.2f}', f'{z + 1.5:.2f}') + player.raw('mouse', 'right', 'click') + player.wait(10) + worn = [o for o in player('status')['objects'] if o['id'] == stand[0]['id']][0]['equipment'] + assert 'minecraft:iron_helmet' not in worn, f'taking the helmet back left {worn}' + result[label] = {'frame': 'diamond, turned', 'stand': 'helmet on and off'} + finally: + player('command', command=f'kill @e[type=!minecraft:player,x={x - 3},y={y - 1},z={z},dx=6,dy=4,dz=6]') + player('command', command=f'fill {x - 2} {y} {z + 3} {x + 2} {y + 2} {z + 3} minecraft:air') + player('command', command='clear @s') + return result + + +def check_lightning(host, guest, out): + """A bolt summoned beside each player: both sides get the bolt entity and flash the sky (the + host's window too on its server thread, FEATURES 4z(f)).""" + result = {} + for label, player in (('host', host), ('guest', guest)): + x, y, z = (int(v // 1) for v in pos_of(player)) + before = {g.name: g('status')['lightning'] for g in (host, guest)} + # No fire where it strikes: on stone with nothing around. + player('command', command=f'fill {x + 4} {y - 1} {z - 2} {x + 8} {y - 1} {z + 2} minecraft:stone') + player('command', command=f'fill {x + 4} {y} {z - 2} {x + 8} {y + 3} {z + 2} minecraft:air') + player('command', command=f'summon minecraft:lightning_bolt {x + 6.5} {y} {z + 0.5}') + seen = {} + for _ in range(40): + player.wait(1) + seen = {g.name: g('status')['lightning'] for g in (host, guest)} + if all(seen[n]['struck'] > before[n]['struck'] and seen[n]['flashes'] > before[n]['flashes'] + for n in seen): + break + player('command', command=f'fill {x + 4} {y} {z - 2} {x + 8} {y + 3} {z + 2} minecraft:air') + for n in seen: + assert seen[n]['struck'] > before[n]['struck'], f"{label}'s bolt: the {n} got no bolt ({seen[n]})" + assert seen[n]['flashes'] > before[n]['flashes'], f"{label}'s bolt: the {n}'s sky didn't flash ({seen[n]})" + result[label] = {n: {'bolts': seen[n]['struck'] - before[n]['struck'], + 'flashes': seen[n]['flashes'] - before[n]['flashes']} for n in seen} + return result + + def check_growth(host, guest, out): """Block ticks near a guest 1000 blocks from the host: only the guest's tickets tick them.""" x0, y0, z0 = pos_of(guest) @@ -2622,7 +2848,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name 'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast, 'light': check_light, 'plates': check_plates, 'swings': check_swings, 'cracks': check_cracks, - 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder} + 'time': check_time, 'growth': check_growth, 'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'lightning': check_lightning} def run(ctl, out, resources, checks): diff --git a/tools/test_chat_screen_parity.py b/tools/test_chat_screen_parity.py index 52febd9f6..1447ebaa6 100644 --- a/tools/test_chat_screen_parity.py +++ b/tools/test_chat_screen_parity.py @@ -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 diff --git a/tools/test_firework_tooltip_parity.py b/tools/test_firework_tooltip_parity.py index e6cea9925..b3114c01a 100644 --- a/tools/test_firework_tooltip_parity.py +++ b/tools/test_firework_tooltip_parity.py @@ -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) diff --git a/tools/test_first_person_parity.py b/tools/test_first_person_parity.py index d73262595..476d2cc52 100644 --- a/tools/test_first_person_parity.py +++ b/tools/test_first_person_parity.py @@ -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. diff --git a/tools/test_friends.py b/tools/test_friends.py index f89f3e599..3daeb28e7 100644 --- a/tools/test_friends.py +++ b/tools/test_friends.py @@ -15,6 +15,9 @@ is off: nothing leaves the machine. python3 tools/test_friends.py --client target/fast/horizon-client --relay target/fast/horizon-relay +`--server-thread` runs the host's world on its integrated server's own +thread (the window is a client of it, as Open to LAN publishes it). + `--role host|guest` runs one side only (two machines, e.g. over a tailnet): the host prints the code, the guest takes it with `--code` (`--relay-url` for a relay elsewhere, `--path relay` to force it). Needs a display on Linux @@ -86,8 +89,12 @@ class Game: # Extra words before and after the client (`--xvfb`, `--offscreen`). prefix = [] extra = [] + # The host's world on its server thread (`--server-thread`), else in the window. + server_thread = False def __init__(self, client, resources, work, name, env): + # Either way explicitly, whatever the game's default. + env = dict(env, HORIZON_SERVER_THREAD='1' if Game.server_thread and name == 'host' else '0') self.home = work / name self.home.mkdir() self.endpoint = self.home / 'c.sock' @@ -155,7 +162,9 @@ def play_together(host, guest, name, round_index): # The host moves; the guest sees the host's player there. hp = host('status')['player']['position'] target = [hp[0] + 3.0, hp[1], hp[2] + 1.0] - host(f'tp {target[0]} {target[1]} {target[2]}') + # The /tp command, not the control socket's local move: on the server thread the window is a + # client, and its server has the last word on where the host stands. + host(f'command tp @s {target[0]} {target[1]} {target[2]}') guest.wait('status', lambda v: any(math.dist(p, target) < 0.6 for p in v['server']['player_positions']), 20, 'host movement on the guest') # A block the host places, which the guest sees and then breaks. @@ -163,8 +172,9 @@ def play_together(host, guest, name, round_index): feet = [math.floor(gp[0]), math.floor(gp[1]), math.floor(gp[2])] block = [feet[0] + 2, feet[1] + 1, feet[2]] # Clear the line of sight (the test terrain has hills), then the block at eye level. - host(f'fill {feet[0] + 1} {feet[1]} {feet[2]} {feet[0] + 1} {feet[1] + 2} {feet[2]} minecraft:air') - host(f'setblock {block[0]} {block[1]} {block[2]} minecraft:gold_block') + # As commands, for the same reason as the /tp above. + host(f'command fill {feet[0] + 1} {feet[1]} {feet[2]} {feet[0] + 1} {feet[1] + 2} {feet[2]} minecraft:air') + host(f'command setblock {block[0]} {block[1]} {block[2]} minecraft:gold_block') guest.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:gold_block', 20, 'the host block on the guest') eye = [gp[0], gp[1] + 1.62, gp[2]] @@ -343,10 +353,12 @@ def main(): parser.add_argument('--hold', type=float, default=0, help='guest: stay this many seconds before leaving') parser.add_argument('--baseline', action='store_true', help='first run the same checks over plain LAN') parser.add_argument('--offscreen', action='store_true', help='run the games without a window') + parser.add_argument('--server-thread', action='store_true', help="the host's world on its server thread") parser.add_argument('--xvfb', action='store_true', help='run the games under xvfb-run (headless Linux)') args = parser.parse_args() Game.prefix = ['xvfb-run', '-a'] if args.xvfb else [] Game.extra = ['--offscreen'] if args.offscreen else [] + Game.server_thread = args.server_thread args.client, args.resources = args.client.resolve(), args.resources.resolve() # Short: Unix socket paths are limited to about 100 bytes. with tempfile.TemporaryDirectory(prefix='hzf-', dir='/tmp') as directory: diff --git a/tools/test_held_drop_parity.py b/tools/test_held_drop_parity.py index c546c5987..842ad3d8a 100644 --- a/tools/test_held_drop_parity.py +++ b/tools/test_held_drop_parity.py @@ -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__': diff --git a/tools/test_level_place_parity.py b/tools/test_level_place_parity.py index 423951942..23a68800c 100644 --- a/tools/test_level_place_parity.py +++ b/tools/test_level_place_parity.py @@ -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) diff --git a/tools/test_weather_render_parity.py b/tools/test_weather_render_parity.py index af713ec80..cf52156e0 100644 --- a/tools/test_weather_render_parity.py +++ b/tools/test_weather_render_parity.py @@ -12,8 +12,8 @@ def make_input(build): rng = random.Random(71) cases = [] for kind in (0, 1): - for ticks in (0, 1, 511, 512, 131071, 131072, 24000 * 37 + 5, 9_000_000_123): - for x, z in ((0, 0), (1, 0), (0, -1), (3, 7), (-10, 10), (10, -10), (-4, -9), (1_000_003, -2_000_011)): + for ticks in (-9223372036854775808, -1, 0, 1, 511, 512, 131071, 131072, 24000 * 37 + 5, 9_000_000_123, 9223372036854775807): + for x, z in ((0, 0), (1, 0), (0, -1), (3, 7), (-10, 10), (10, -10), (-4, -9), (1_000_003, -2_000_011), (30_000_000, -30_000_000), (2_147_483_631, -2_147_483_632)): for bottom, top in ((60, 80), (64, 65), (-64, -44), (300, 310)): light = (rng.randrange(16) << 4) | (rng.randrange(16) << 20) partial = rng.choice(("0.0", "0.5", "0.999", f"{rng.random():.6f}"))