From 0eaa13020cc16264f6e0488da7e7108f013750cd Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:18:39 +0100 Subject: [PATCH 01/22] perf: load uniform saved light without expanding nibble layers --- crates/horizon-client/src/save.rs | 214 +++++++++++++++++++++++++- docs/saved-light-loading-benchmark.md | 44 ++++++ 2 files changed, 256 insertions(+), 2 deletions(-) create mode 100644 docs/saved-light-loading-benchmark.md 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/docs/saved-light-loading-benchmark.md b/docs/saved-light-loading-benchmark.md new file mode 100644 index 000000000..f11d72443 --- /dev/null +++ b/docs/saved-light-loading-benchmark.md @@ -0,0 +1,44 @@ +# Saved-light loading benchmark + +Saved-light reconstruction reduces complete saved-chunk loading by a median **6.179% on the normal world** and **10.981% on the flat world**, incremental to the accepted palette-loading optimization. Every measured process pair improves. The implementation changes only `save.rs::load_light` and its tests. + +## Implementation and scope + +Detect uniform stored nibble layers before allocating expanded resident light. Both nibbles must match: repeated bytes such as `0xF0` and `0x0F` remain nonuniform. Decode two resident light values per stored byte for remaining layers. Preserve section compaction, low-nibble-first indexing, missing-block darkness, missing-sky bottom-row inheritance, skyless behavior, section bounds, last duplicate section, invalid array handling, and loaded flags. Pinned Minecraft 26.3 `DataLayer` and `SkyLightSectionStorage.repeatFirstLayer` bytecode was inspected first. No saved-light optimization overlap was found among the 34 open PRs checked on 2026-10-22. + +## Measurements + +Baseline `411c5574` includes accepted palette loading and aquifer changes; the candidate differs only in saved-light reconstruction. Both loader executables were rebuilt from those sources using identical benchmark source (SHA256 `b6f5042731d7c9d5622758043f7c1e125a3f7d098c57ee0501012474c2df7325`), dependencies, resources and flags. Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM; Linux 7.2.11-zen1-1-zen; Rust 1.99.0. Release optimization, thin LTO, one codegen unit, client default features disabled; CPU boost enabled, powersave governor, ordinary desktop activity. No builds, tests or profiles overlapped timing. + +Each corpus uses one discarded process pair followed by five measured pairs in alternating baseline/candidate order. Each observation is a process's median of five rounds loading the same sorted 256 full chunks. Checksumming and setup are outside timing; allocation/destruction and region reads/decompression/NBT/native decode/saved light are inside complete loading. Storage is warm. Reductions are medians/ranges of paired reductions; independently reported medians need not give the same ratio. Separate stage loops do not sum to a timing breakdown. + +| Corpus | Complete load, baseline → candidate | Paired reduction (range) | Inflate/NBT, baseline → candidate | Native decode, baseline → candidate | +| --- | ---: | ---: | ---: | ---: | +| Normal vanilla 26.3, seed 12345 | 50.036 → 47.005 ms | 6.179% (5.217–6.836%) | 22.187 → 22.087 ms | 20.464 → 21.621 ms | +| Flat vanilla 26.3 | 12.030 → 10.688 ms | 10.981% (10.423–11.751%) | 4.562 → 4.549 ms | 4.076 → 4.183 ms | + +Values are milliseconds per complete 256-chunk batch. The separate native-decode loop slows by a paired median 4.644% on normal and 3.185% on flat; the flat observations are variable. Its source is unchanged, and the cause of this separate-loop change was not isolated. Complete `SaveDir::load`, which includes native decode and saved light, improves in all ten measured pairs. The earlier two-pair normal pilot improved 5.894% and 6.553%; final-source qualification was repeated after the iterator syntax change. All timed compressed-record and block/biome/light hashes agree. Normal compressed records: `ff9bf9e822e334e117e3d6ba5c26a88b7698456ec6d83bdbe4355ad0af1d6f55`; block/biome/light: `661dd26eed78b051afeca11d8ba69222162b5da72e5d1572a12ce2a3b3a4f764`. + +## Correctness + +All 20 save unit tests pass. The new differential test compares the original loader with the candidate for every repeated packed byte, all 256 pairs of uniform sky/block nibble values, nonuniform inherited rows, missing/wrong layer types and lengths, skyless dimensions, out-of-range/invalid section Y values and duplicate sections. It compares every resident light value, uniform/full representation, block/biome storage and loaded flags. + +A fresh pinned Java 26.3 oracle uses `DataLayer.get` and `SkyLightSectionStorage.repeatFirstLayer` over all 256 repeated byte patterns in both sky modes. Baseline and candidate exactly match all **50,331,648 light values** plus flags (SHA256 `608bab077edc713110f827740cb5d9baf2af9c1a251ea2458441e2d981f25920`). + +The same comprehensive snapshot harness runs on the actual accepted-source baseline and final candidate: **400 normal chunks, 289 flat chunks, and two synthetic unknown-NBT/nonempty-tick cases**. All 691 outputs match byte-for-byte. It covers resident blocks/biomes/light, complete reencoded NBT, heightmaps, block entities and their saved sources/order, structures, unknown NBT, ticks, postprocessing, entities, names and loaded/arrival flags. Light representation is additionally covered by the unit test. Temporary diagnostic sources were removed. + +The final source uses the fixed-size chunk iterator syntax required by Clippy. Its rebuilt executable (SHA256 `40d7031e7d3efe785815b1286af05553807bbc59f66a9275a5f89191f0ecda7e`) is the one used for final qualification; snapshot/oracle harnesses use the same production source. Earlier pilot artifacts are retained separately: section extraction normalized ELF metadata (original timed SHA256 `eb28209fd54b6deedab1ff701c291ae36b8116b2ba52a02d1ec82600b57e427f`; normalized SHA256 `78f2092b2661655fdea8d0fa2247389ccc8f48f37dd9abfbb8d8864867187297`). Those earlier artifacts are superseded by the final-source qualification. + +The required repository quick self-check passes: public-tree validation, formatting, Clippy with warnings denied, **1,443 client/core/world tests**, and the doc-test step. Command: `RUST_TEST_THREADS=1 CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-check-target python3 tools/pr_ready.py --quick --base origin/main` (11 min 15 s). Tests were serialized after an initial client-test process SIGSEGV; the failed log is retained as `pr-ready-attempt1.txt`. Relevant oracle checks were run separately; `--quick` lists other affected parity harnesses for CI. + +## Reproduction and evidence + +Private/generated evidence: `/srv/bob-data/horizon-chunk-campaign-41055168/saved-light/`. Preserved baseline/candidate sources and executables, source/binary hashes, open-PR catalog, pinned bytecode, build logs, `final-pairs.py`, `final-raw.json`, final qualification logs and `final-summary.json`; earlier pilot/qualification artifacts are retained there. Resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Normal corpus: `/srv/bob-data/horizon-chunk-campaign-41055168/vanilla-normal/world/dimensions/minecraft/overworld`; flat: `/srv/bob-data/horizon/.local/locator-bar-parity/generate/world/dimensions/minecraft/overworld`. + +```sh +CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-client --no-default-features --example load_bench +load_bench RESOURCES DIMENSION_DIR --rounds 5 --limit 256 --checksum +python3 /srv/bob-data/horizon-chunk-campaign-41055168/saved-light/final-pairs.py final 5 +``` + +These results cover the declared warm saved-load workloads. Cold physical I/O, remote chunk streams and complete gameplay parity are outside this comparison. From 756cf4af07901f18d4e5b8e95a7d293b7f144231 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:18:40 +0100 Subject: [PATCH 02/22] bench: measure read-only saved chunk loading --- crates/horizon-client/examples/load_bench.rs | 153 +++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 crates/horizon-client/examples/load_bench.rs diff --git a/crates/horizon-client/examples/load_bench.rs b/crates/horizon-client/examples/load_bench.rs new file mode 100644 index 000000000..5c30a71ff --- /dev/null +++ b/crates/horizon-client/examples/load_bench.rs @@ -0,0 +1,153 @@ +//! Read-only saved chunk benchmark. All timings exclude resource/corpus setup. +//! +//! load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum] +//! Add --profile-worker when a sampling collector cannot sample the main thread. +//! Reports warm filesystem SaveDir::load (read, inflate, NBT, decode and light), +//! plus isolated inflate/NBT and native decode. No files in the save are changed. +use horizon_client::{ + assets::Assets, + biome::Biomes, + blocks::BlockFacts, + save::{SaveDir, SaveTables, decode_with}, +}; +use horizon_world::{nbt::Limits, region::RegionFile}; +use sha2::{Digest, Sha256}; +use std::{hint::black_box, path::PathBuf, sync::Arc, time::Instant}; + +type Result = std::result::Result>; + +fn main() -> Result<()> { + if std::env::args().any(|a| a == "--profile-worker") { + std::thread::spawn(|| run().map_err(|e| e.to_string())) + .join() + .expect("benchmark worker") + .map_err(Into::into) + } else { + run() + } +} + +fn run() -> Result<()> { + let args: Vec = std::env::args().skip(1).collect(); + let usage = "load_bench RESOURCES DIMENSION_DIR [--rounds N] [--limit N] [--checksum]"; + let root = PathBuf::from(args.first().ok_or(usage)?); + let dimension = PathBuf::from(args.get(1).ok_or(usage)?); + let flag = |name: &str, default: usize| -> Result { + Ok(match args.iter().position(|a| a == name) { + Some(i) => args.get(i + 1).ok_or(usage)?.parse()?, + None => default, + }) + }; + let rounds = flag("--rounds", 5)?; + let limit = flag("--limit", 256)?; + if rounds == 0 || limit == 0 { + return Err("rounds and limit must be positive".into()); + } + let assets = Assets::load(&root)?; + let facts = BlockFacts::load(&root, assets.registry)?; + let biomes = Biomes::load(&root)?; + let tables = Arc::new(SaveTables::new(&assets).with_block_entities(&facts)); + let source = SaveDir::new(dimension.clone()); + let _ = source.tables.set(tables.clone()); + let mut paths: Vec<_> = std::fs::read_dir(dimension.join("region"))? + .map(|e| e.map(|e| e.path())) + .collect::>()?; + paths.retain(|p| p.extension().is_some_and(|e| e == "mca")); + paths.sort(); + let mut corpus = Vec::new(); + 'regions: for path in paths { + let mut region = RegionFile::open(path)?; + let mut positions: Vec<_> = region.chunks().map(|(pos, _)| pos).collect(); + positions.sort_by_key(|p| (p.x, p.z)); + for pos in positions { + let record = region.read(pos)?.ok_or("missing record")?; + let tag = record.nbt(Limits::default())?; + if decode_with(&tag, assets.registry, &biomes, Some(&tables)).is_none() { + continue; + } + corpus.push((pos, record, tag)); + if corpus.len() == limit { + break 'regions; + } + } + } + if corpus.is_empty() { + return Err("no full chunks in corpus".into()); + } + let mut records_hash = Sha256::new(); + for (pos, record, _) in &corpus { + records_hash.update(pos.x.to_le_bytes()); + records_hash.update(pos.z.to_le_bytes()); + records_hash.update((record.compressed.len() as u64).to_le_bytes()); + records_hash.update(&record.compressed); + } + println!( + "{}", + serde_json::json!({"corpus": dimension, "chunks": corpus.len(), "rounds": rounds, + "compressed_records_sha256": format!("{:x}", records_hash.finalize()), + "compressed_bytes": corpus.iter().map(|(_, r, _)| r.compressed.len()).sum::()}) + ); + // Prime SaveDir's region handles and the filesystem cache before measurement. + for (pos, _, _) in &corpus { + black_box( + source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?, + ); + } + for round in 0..rounds { + let started = Instant::now(); + for (pos, _, _) in &corpus { + black_box( + source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?, + ); + } + let load_s = started.elapsed().as_secs_f64(); + let started = Instant::now(); + for (_, record, _) in &corpus { + black_box(record.nbt(Limits::default())?); + } + let nbt_s = started.elapsed().as_secs_f64(); + let started = Instant::now(); + for (_, _, tag) in &corpus { + black_box( + decode_with(tag, assets.registry, &biomes, Some(&tables)).ok_or("decode failed")?, + ); + } + let decode_s = started.elapsed().as_secs_f64(); + println!( + "{}", + serde_json::json!({"round": round, "load_s": load_s, + "inflate_nbt_s": nbt_s, "decode_s": decode_s}) + ); + } + if args.iter().any(|a| a == "--checksum") { + let mut hash = Sha256::new(); + let mut light_loaded = 0; + for (pos, _, _) in &corpus { + let chunk = source + .load(pos.x, pos.z, assets.registry, &biomes) + .ok_or("load failed")?; + hash.update(pos.x.to_le_bytes()); + hash.update(pos.z.to_le_bytes()); + light_loaded += usize::from(chunk.light_loaded); + for section in &chunk.sections { + for i in 0..4096 { + hash.update(section.get(i).to_le_bytes()); + hash.update([section.light(i)]); + } + for i in 0..64 { + hash.update(section.biomes.get(i).to_le_bytes()); + } + } + } + println!( + "{}", + serde_json::json!({"blocks_biomes_light_sha256": format!("{:x}", hash.finalize()), + "light_loaded": light_loaded}) + ); + } + Ok(()) +} From 05400438c7f034a380815b6ed606b181bb3bdb3b Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:44:32 +0100 Subject: [PATCH 03/22] perf(client): cache weather column direction table --- crates/horizon-client/src/weather.rs | 40 ++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/crates/horizon-client/src/weather.rs b/crates/horizon-client/src/weather.rs index 3eb39e14c..ba15de9ae 100644 --- a/crates/horizon-client/src/weather.rs +++ b/crates/horizon-client/src/weather.rs @@ -114,10 +114,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. @@ -219,6 +224,27 @@ 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 rain_repeats_every_four_blocks() { let column = Column { @@ -282,6 +308,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()); + } } } From 92b8cd692da2ffb244b4c81bb1a965d4608f956a Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:50:29 +0100 Subject: [PATCH 04/22] perf(client): retain the End sky mesh on the GPU --- crates/horizon-client/src/game.rs | 11 +- crates/horizon-client/src/game/end.rs | 45 +-- crates/horizon-client/src/gfx.rs | 25 +- crates/horizon-client/src/gfx/end_sky.rs | 84 +++++ .../horizon-client/src/gfx/end_sky/tests.rs | 330 ++++++++++++++++++ 5 files changed, 447 insertions(+), 48 deletions(-) create mode 100644 crates/horizon-client/src/gfx/end_sky.rs create mode 100644 crates/horizon-client/src/gfx/end_sky/tests.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..ccc838bbb 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9812,8 +9812,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) }; @@ -9860,6 +9860,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, @@ -12363,6 +12369,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, 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/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..fb1cd322e 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -61,6 +61,7 @@ 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; mod lod; @@ -163,8 +164,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], @@ -197,8 +200,8 @@ pub struct Frame<'a> { 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 @@ -337,6 +340,7 @@ pub struct 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. @@ -2113,6 +2117,7 @@ impl Renderer { see_through_pipeline, celestial_pipeline, celestial_buffer, + end_sky: end_sky::EndSky::default(), stars, panorama, border_pipeline, @@ -3310,6 +3315,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, @@ -3510,12 +3518,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() { 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..d01fca18c --- /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.chunks_exact(4).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"); +} From e4ea9e0199d3a2bbf4f99aa761e212b2bb897ca9 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:54:09 +0100 Subject: [PATCH 05/22] Cache weather column parameters and animate atlas UVs in shader --- .../examples/weather_fixture.rs | 8 + crates/horizon-client/src/entity.wgsl | 133 +++++++ crates/horizon-client/src/game.rs | 122 +++---- crates/horizon-client/src/gfx.rs | 26 +- crates/horizon-client/src/gfx/weather.rs | 330 ++++++++++++++++++ crates/horizon-client/src/weather.rs | 255 +++++++++++++- tools/test_weather_render_parity.py | 4 +- 7 files changed, 810 insertions(+), 68 deletions(-) create mode 100644 crates/horizon-client/src/gfx/weather.rs 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/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 2c6af26f9..99211ec5f 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 { @@ -209,3 +210,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 f706e9348..5c8d64d18 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1110,6 +1110,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, @@ -8942,89 +8943,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. @@ -9830,11 +9826,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(); @@ -9845,6 +9842,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, @@ -11438,6 +11437,7 @@ impl<'a> Game<'a> { gui, fog: Default::default(), screen_fx: Default::default(), + weather_parameters: Default::default(), panorama_rotation: Default::default(), world, streaming, @@ -12349,6 +12349,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, diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..41576bd5f 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; @@ -189,6 +190,8 @@ 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. @@ -324,6 +327,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, @@ -1445,6 +1449,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() @@ -2101,6 +2111,7 @@ impl Renderer { crosshair_group, crosshair_globals, entity_pipeline, + weather, crumbling_pipeline, water_mask_pipeline, cloud_pipeline, @@ -3229,6 +3240,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 +3264,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 { @@ -3318,8 +3337,9 @@ 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(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); @@ -3602,6 +3622,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, &[]); 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/weather.rs b/crates/horizon-client/src/weather.rs index 3eb39e14c..d687604cb 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( @@ -135,8 +306,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 +390,82 @@ fn pieces(a: f32, b: f32) -> impl Iterator { mod tests { use super::*; + #[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 { 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}")) From fa14833b41782f59ef6087cce092081e813620e5 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:56:23 +0100 Subject: [PATCH 06/22] perf(client): retain seeded lightning bolt geometry --- crates/horizon-client/src/entity.wgsl | 7 + crates/horizon-client/src/game.rs | 26 +- crates/horizon-client/src/game/lightning.rs | 85 +-- crates/horizon-client/src/gfx.rs | 52 +- crates/horizon-client/src/gfx/lightning.rs | 211 ++++++++ .../src/gfx/lightning/tests/mod.rs | 495 ++++++++++++++++++ 6 files changed, 790 insertions(+), 86 deletions(-) create mode 100644 crates/horizon-client/src/gfx/lightning.rs create mode 100644 crates/horizon-client/src/gfx/lightning/tests/mod.rs diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index 2c6af26f9..3b5dd9dcc 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -109,6 +109,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>, diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..c2d3b37e8 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9782,15 +9782,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`. @@ -9902,6 +9904,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 { @@ -12377,6 +12386,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/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 6c4dd933f..0f43c4c54 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -5,14 +5,8 @@ //! 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], @@ -349,71 +343,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/gfx.rs b/crates/horizon-client/src/gfx.rs index 14c040c5c..243904424 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -63,6 +63,7 @@ mod arena; mod cull; mod flat; mod java_stages; +pub mod lightning; mod lod; mod occlusion; mod pack_stages; @@ -193,7 +194,9 @@ pub struct Frame<'a> { 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], @@ -334,6 +337,8 @@ 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, @@ -1664,8 +1669,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 +1723,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"), @@ -2110,6 +2134,8 @@ impl Renderer { cloud_uniform, cloud_group, additive_pipeline, + lightning_pipeline, + lightning: lightning::Renderer::new(), see_through_pipeline, celestial_pipeline, celestial_buffer, @@ -3279,6 +3305,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; @@ -3318,8 +3351,13 @@ 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 + }); 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); @@ -3622,6 +3660,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, &[]); 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"); + } +} From ca2d5e04dc35394c859146a64d35f47e1e2c1059 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:15:46 +0100 Subject: [PATCH 07/22] Remove benchmark report from pull request --- docs/saved-light-loading-benchmark.md | 44 --------------------------- 1 file changed, 44 deletions(-) delete mode 100644 docs/saved-light-loading-benchmark.md diff --git a/docs/saved-light-loading-benchmark.md b/docs/saved-light-loading-benchmark.md deleted file mode 100644 index f11d72443..000000000 --- a/docs/saved-light-loading-benchmark.md +++ /dev/null @@ -1,44 +0,0 @@ -# Saved-light loading benchmark - -Saved-light reconstruction reduces complete saved-chunk loading by a median **6.179% on the normal world** and **10.981% on the flat world**, incremental to the accepted palette-loading optimization. Every measured process pair improves. The implementation changes only `save.rs::load_light` and its tests. - -## Implementation and scope - -Detect uniform stored nibble layers before allocating expanded resident light. Both nibbles must match: repeated bytes such as `0xF0` and `0x0F` remain nonuniform. Decode two resident light values per stored byte for remaining layers. Preserve section compaction, low-nibble-first indexing, missing-block darkness, missing-sky bottom-row inheritance, skyless behavior, section bounds, last duplicate section, invalid array handling, and loaded flags. Pinned Minecraft 26.3 `DataLayer` and `SkyLightSectionStorage.repeatFirstLayer` bytecode was inspected first. No saved-light optimization overlap was found among the 34 open PRs checked on 2026-10-22. - -## Measurements - -Baseline `411c5574` includes accepted palette loading and aquifer changes; the candidate differs only in saved-light reconstruction. Both loader executables were rebuilt from those sources using identical benchmark source (SHA256 `b6f5042731d7c9d5622758043f7c1e125a3f7d098c57ee0501012474c2df7325`), dependencies, resources and flags. Machine: AMD Ryzen 5 5600X, 6 cores/12 logical CPUs, 32 GiB RAM; Linux 7.2.11-zen1-1-zen; Rust 1.99.0. Release optimization, thin LTO, one codegen unit, client default features disabled; CPU boost enabled, powersave governor, ordinary desktop activity. No builds, tests or profiles overlapped timing. - -Each corpus uses one discarded process pair followed by five measured pairs in alternating baseline/candidate order. Each observation is a process's median of five rounds loading the same sorted 256 full chunks. Checksumming and setup are outside timing; allocation/destruction and region reads/decompression/NBT/native decode/saved light are inside complete loading. Storage is warm. Reductions are medians/ranges of paired reductions; independently reported medians need not give the same ratio. Separate stage loops do not sum to a timing breakdown. - -| Corpus | Complete load, baseline → candidate | Paired reduction (range) | Inflate/NBT, baseline → candidate | Native decode, baseline → candidate | -| --- | ---: | ---: | ---: | ---: | -| Normal vanilla 26.3, seed 12345 | 50.036 → 47.005 ms | 6.179% (5.217–6.836%) | 22.187 → 22.087 ms | 20.464 → 21.621 ms | -| Flat vanilla 26.3 | 12.030 → 10.688 ms | 10.981% (10.423–11.751%) | 4.562 → 4.549 ms | 4.076 → 4.183 ms | - -Values are milliseconds per complete 256-chunk batch. The separate native-decode loop slows by a paired median 4.644% on normal and 3.185% on flat; the flat observations are variable. Its source is unchanged, and the cause of this separate-loop change was not isolated. Complete `SaveDir::load`, which includes native decode and saved light, improves in all ten measured pairs. The earlier two-pair normal pilot improved 5.894% and 6.553%; final-source qualification was repeated after the iterator syntax change. All timed compressed-record and block/biome/light hashes agree. Normal compressed records: `ff9bf9e822e334e117e3d6ba5c26a88b7698456ec6d83bdbe4355ad0af1d6f55`; block/biome/light: `661dd26eed78b051afeca11d8ba69222162b5da72e5d1572a12ce2a3b3a4f764`. - -## Correctness - -All 20 save unit tests pass. The new differential test compares the original loader with the candidate for every repeated packed byte, all 256 pairs of uniform sky/block nibble values, nonuniform inherited rows, missing/wrong layer types and lengths, skyless dimensions, out-of-range/invalid section Y values and duplicate sections. It compares every resident light value, uniform/full representation, block/biome storage and loaded flags. - -A fresh pinned Java 26.3 oracle uses `DataLayer.get` and `SkyLightSectionStorage.repeatFirstLayer` over all 256 repeated byte patterns in both sky modes. Baseline and candidate exactly match all **50,331,648 light values** plus flags (SHA256 `608bab077edc713110f827740cb5d9baf2af9c1a251ea2458441e2d981f25920`). - -The same comprehensive snapshot harness runs on the actual accepted-source baseline and final candidate: **400 normal chunks, 289 flat chunks, and two synthetic unknown-NBT/nonempty-tick cases**. All 691 outputs match byte-for-byte. It covers resident blocks/biomes/light, complete reencoded NBT, heightmaps, block entities and their saved sources/order, structures, unknown NBT, ticks, postprocessing, entities, names and loaded/arrival flags. Light representation is additionally covered by the unit test. Temporary diagnostic sources were removed. - -The final source uses the fixed-size chunk iterator syntax required by Clippy. Its rebuilt executable (SHA256 `40d7031e7d3efe785815b1286af05553807bbc59f66a9275a5f89191f0ecda7e`) is the one used for final qualification; snapshot/oracle harnesses use the same production source. Earlier pilot artifacts are retained separately: section extraction normalized ELF metadata (original timed SHA256 `eb28209fd54b6deedab1ff701c291ae36b8116b2ba52a02d1ec82600b57e427f`; normalized SHA256 `78f2092b2661655fdea8d0fa2247389ccc8f48f37dd9abfbb8d8864867187297`). Those earlier artifacts are superseded by the final-source qualification. - -The required repository quick self-check passes: public-tree validation, formatting, Clippy with warnings denied, **1,443 client/core/world tests**, and the doc-test step. Command: `RUST_TEST_THREADS=1 CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-check-target python3 tools/pr_ready.py --quick --base origin/main` (11 min 15 s). Tests were serialized after an initial client-test process SIGSEGV; the failed log is retained as `pr-ready-attempt1.txt`. Relevant oracle checks were run separately; `--quick` lists other affected parity harnesses for CI. - -## Reproduction and evidence - -Private/generated evidence: `/srv/bob-data/horizon-chunk-campaign-41055168/saved-light/`. Preserved baseline/candidate sources and executables, source/binary hashes, open-PR catalog, pinned bytecode, build logs, `final-pairs.py`, `final-raw.json`, final qualification logs and `final-summary.json`; earlier pilot/qualification artifacts are retained there. Resources: `/srv/bob-data/horizon/.local/horizon-client/26.3`. Normal corpus: `/srv/bob-data/horizon-chunk-campaign-41055168/vanilla-normal/world/dimensions/minecraft/overworld`; flat: `/srv/bob-data/horizon/.local/locator-bar-parity/generate/world/dimensions/minecraft/overworld`. - -```sh -CARGO_BUILD_JOBS=6 CARGO_TARGET_DIR=/srv/bob-data/horizon-chunk-campaign-target cargo build --locked --release -p horizon-client --no-default-features --example load_bench -load_bench RESOURCES DIMENSION_DIR --rounds 5 --limit 256 --checksum -python3 /srv/bob-data/horizon-chunk-campaign-41055168/saved-light/final-pairs.py final 5 -``` - -These results cover the declared warm saved-load workloads. Cold physical I/O, remote chunk streams and complete gameplay parity are outside this comparison. From d86a1b2882b81d403bde2f02076143ab50814dad Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:26:39 +0100 Subject: [PATCH 08/22] Fix cooldown after instant survival breaks in multiplayer --- crates/horizon-client/src/game/remote.rs | 4 +- tests/test_remote_mining.py | 149 +++++++++++++++++++++++ tools/test_first_person_parity.py | 6 + 3 files changed, 156 insertions(+), 3 deletions(-) create mode 100644 tests/test_remote_mining.py diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..ea12eb4d2 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3309,10 +3309,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() { 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/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. From 6d36d468e70d0aea524e61f32081879ea064fa3b Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:29:55 +0100 Subject: [PATCH 09/22] Fix empty-hand drop animations --- .../examples/held_drop_fixture.rs | 11 +++++- crates/horizon-client/src/game/remote.rs | 23 ++++++----- .../parity/VanillaHeldDropOracle.java | 39 +++++++++++++++++-- tools/test_held_drop_parity.py | 10 +++-- 4 files changed, 65 insertions(+), 18 deletions(-) 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/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..6614c68a3 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}, @@ -3836,23 +3836,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 => { 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/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__': From 6e83037fca77eeb7884ceec25292c806efc48937 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 18:32:54 +0200 Subject: [PATCH 10/22] end sky test: as_chunks instead of chunks_exact (clippy 1.99) Rust 1.99's clippy denies chunks_exact with a constant size (chunks_exact_to_as_chunks), so `cargo clippy --all-targets -D warnings` failed on this test. Same check, written as as_chunks::<4>(). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx/end_sky/tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs index d01fca18c..61266003d 100644 --- a/crates/horizon-client/src/gfx/end_sky/tests.rs +++ b/crates/horizon-client/src/gfx/end_sky/tests.rs @@ -314,7 +314,7 @@ fn separate_draws_match_combined_celestial_pixels() { visible_flash_cases += usize::from(expected != no_flash); assert_eq!(actual, expected, "yaw={yaw} pitch={pitch} flash={level}"); assert!( - actual.chunks_exact(4).any(|p| p[..3] != [0; 3]), + actual.as_chunks::<4>().0.iter().any(|p| p[..3] != [0; 3]), "empty frame" ); assert_eq!(resident.mesh.as_ref().unwrap().1, first); From 15b85145845f2c500dcee979d1401217093426b6 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:37:23 +0100 Subject: [PATCH 11/22] Fix registry-backed slash command suggestions on connected clients --- crates/horizon-client/src/game/remote.rs | 5 +++ tools/agent_control_e2e.py | 45 ++++++++++++++++++++++-- tools/test_chat_screen_parity.py | 10 ++++++ 3 files changed, 58 insertions(+), 2 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..020746d68 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -306,6 +306,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; diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 977d2e292..962d04575 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,47 @@ 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('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 ~ ~ ~ sto', '/setblock ~ ~ ~ minecraft:stone'), + ('/fill ~ ~ ~ ~1 ~1 ~1 sto', '/fill ~ ~ ~ ~1 ~1 ~1 minecraft:stone'), + ('/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/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 From ecbb0368c551b060fb6c13766552062c9508d487 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:37:42 +0100 Subject: [PATCH 12/22] Fix hand swing prediction for rejected block placements --- crates/horizon-client/src/game/remote.rs | 220 ++++++++++++++++-- .../examples/level_place_fixture.rs | 5 + .../parity/VanillaBlockPlacementOracle.java | 6 +- tools/test_level_place_parity.py | 18 +- 4 files changed, 222 insertions(+), 27 deletions(-) diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 7c96e7bad..f6404223e 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3489,7 +3489,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; @@ -3547,7 +3555,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 { @@ -3562,26 +3574,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 @@ -4529,7 +4568,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). @@ -4559,6 +4598,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 { @@ -4575,7 +4625,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, @@ -4587,13 +4637,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() } } @@ -4709,6 +4777,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-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/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/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) From e7d42dc9d077e93f1546732c803a427ab0ea3043 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:41:17 +0100 Subject: [PATCH 13/22] Fix in-world menu background blur --- crates/horizon-client/src/game.rs | 13 +++-- crates/horizon-client/src/game/screens.rs | 47 ++++++++++++++++- crates/horizon-client/src/gfx.rs | 19 +++++-- crates/horizon-client/src/hud.rs | 62 ++++++++++++++++++++++- 4 files changed, 130 insertions(+), 11 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f706e9348..be7010c61 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -4838,6 +4838,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. @@ -10007,9 +10010,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() @@ -10017,7 +10019,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) } 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..3de07b17b 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3841,9 +3841,19 @@ impl Renderer { let first = debug_depth + debug_top; pass.draw(0..4, first..first + crosshair); } - if let Some(radius) = frame.menu_blur - && self.config.usage.contains(wgpu::TextureUsages::COPY_SRC) - { + let menu_blur = frame + .menu_blur + .filter(|_| self.config.usage.contains(wgpu::TextureUsages::COPY_SRC)); + let blur_at = menu_blur.map_or(0, |_| frame.hud.blur_at); + self.hud.draw_range( + &mut encoder, + &view_target, + &self.depth, + frame.hud, + [self.config.width, self.config.height], + 0..blur_at, + ); + if let Some(radius) = menu_blur { let format = self.config.format; let device = &self.device; self.menu_blur @@ -3875,12 +3885,13 @@ impl Renderer { grade, ); } - self.hud.draw( + self.hud.draw_range( &mut encoder, &view_target, &self.depth, frame.hud, [self.config.width, self.config.height], + blur_at..frame.hud.vertices.len() as u32, ); if culling && let Some(cull) = &mut self.cull { cull.end(&self.device, &mut encoder); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 0cc99b07b..0c3bde1d1 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -363,6 +363,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)] @@ -398,6 +400,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. @@ -450,6 +453,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) { ( @@ -1078,7 +1089,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 { @@ -1090,7 +1120,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 { @@ -1329,6 +1359,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. @@ -1340,6 +1397,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!( From d67779d5a17432e553a36013e5ba3970cb6f9a20 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:42:56 +0100 Subject: [PATCH 14/22] Make completion regression deterministic and include screenshots --- docs/media/command-suggestions/after.png | Bin 0 -> 282564 bytes docs/media/command-suggestions/before.png | Bin 0 -> 151763 bytes tools/agent_control_e2e.py | 7 +++++-- 3 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 docs/media/command-suggestions/after.png create mode 100644 docs/media/command-suggestions/before.png diff --git a/docs/media/command-suggestions/after.png b/docs/media/command-suggestions/after.png new file mode 100644 index 0000000000000000000000000000000000000000..9c1a9cd4c0526ca9b93024d403f80a75f3610f24 GIT binary patch literal 282564 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

HKJ1g<6>+)l=W zInx}yLoqeT#;#qv9d^I@w=h6Kv<$j*_>(%049`J829uT-kc7$xuD9&i)yX~P+mY>x zbE&@~%P9JNyxIY3FEoKV0)Ty5Bf2QUTs6RUalK4hFpnP3;g=|M|6%-ftwR~fyiYuY zt(`Ui&FRq;{pgIpW_#-pi(^kZ+fDz>qYnT_fT?r1Doxekz^E9yykXw~*aH$AAjpyR z{Mh5u;GP1A*h_+A{uAUklr^wxFfWd)_gxxK$SonG@=|Sl2B3z1Iyp}Q-Dkmt* zAlbiOs{fY>8*XFcu~yCw;{iz`|q24 zSrOXs@)FxpT7!$PQHDuaNIP<7GXV@19ps`)5!q%z*+hxl&$(nRvWAPHsYc&_?ND{~ z%C%YQ*nxiqInT^$tM&7+W!k&938X@~CjvbB|KED$P<8Fvb*zMPUu7AJ;F(Zo8Yr2$ z*98Cpr2+Vh5Ew@Vs@nj6^AZ|Kxsa?>3DHGBkTG79D3P@S`uQ{ff4m)KRNya~TF~!v zH4nQXMg&x{x9G9QCp-I=;E?8UjZ(uz6dZP2ZoX$9Jph5KSFc>DwyS{(q>bd*R@O!w z1V1=05j(oc{{2lrkPyw)Jxm55sP@3X^KfKf8dz&AXu;#gSJZkKKv4FJAsP&1j!;9< zkvY#GWgG-5+U*GXX84zSl0y8_9;c{rz-xmS#bJ@1{Y$U|0w*_c6}x7<{ix;-?awad z{Dli55J>kg;r-T+?>)Qs20$RKm8}ZqHKz63w08OHN~EU|qzj#oT|c=a|06&A1By@U zt83N4Ci-to6y8a2Iyl&uO@XH9`hp)tXog_MP}{D}3c{EwtKq{?Ju^61;8sll(CYd! zRni=w8^GHC=)76LV8H$^1qSa1pf5*kJrB_L{o~8kwX4^%6-@Vp=T1Lh?*!*wKG6oM zlk0Wv+}WhE9nOWVv6|r%+cWqPWo;iT$q3W#FrIxA_-BdmK|tliV*~t6yQtco(ae4b zQW`qqNNd)~_41N!!0$IS*n}*J1nT1xiH~j`wSi=iJ(68y%D>ivf59f5V5f}i@pVtx zjWNe*{fu=0{x!iGtY5AIPSMb|vm>9DdAne3@2b-8he>Qs8RK>AaZn-$dDNO1-A=v` zC*cLSt#av75Bw=}`j4w$SToJrSy^Q-UAoj4Eww)|J>W=Z`gHfe4YmM)2Pw!igTx6U2VT-$Bydu?c4mTib7K%0L~FzrO*%^ zH~<47zJ^3^oAc);qr1d4I7U@8U&2o()ZbS@7hBHf#|-;F~-wJ zBz4b*ybR4@fHRxx@co}mYpbjMk>E08k*7GgF9jSdReF)0gJoKUM5SU?N!BWgyk&e# zdJSe&9|HyfMhKa$1q?zT^^&=7aiA|oPL8NWHVsTP$VWU0=F2}7Nc zjBD(Ge>O1@i#=)8Tdy1r(#lf=&q(n!$TxG3Z^D3DJHIx=5$duO?e)hmOJZ6)nFSU# zS&Ymkz844JPov=u|4_cG$N>E1lX1KZY1uKHQh1o^*b__a9fj;(FHNJQ+|Tr&p9Zux zo_<|E^bWuXPZ|GD%?qfGyyJ|NN`>9F`S(Kh@4qj6?p;7Rf`OqBf;aXhjJhBa+4y(5 zdv&X0+rS4T!?q`@0ea8SSwM423+UqL0ubc!SmS-!XMg^&sB?jXq9(l9M0I8X z1|eaKYd>zh{yWf@zHk5jYs=NjxpQ6C1qb6eae4sCDK7_*`mzH6c&@KYS<)}#kK`7n zEj$p4E?3uyfVDEJaq{$^$#fh1YevlKT6j-1W$eCphPY>o^u}S72I^u+d|~)2zWq>g zv5fv#;W0$@KY4eV$i!htJT~6lffJoyXKY-ntSE1US(SDf?_TTv|J_-79Lg+^cHzcZ zL*PAjx02e5KeLv078u) zq94D2=pvHqTh9=Xgp!g2c!FsKfUUY@JJ;ocC8Y}xN=1#yIS6@Yl;RAo_bCE52^gG* z%6l%*hUg+a`rJ&-op}un0AOhf41vMU_5r{=DSedQx>{L@JE~j$dN|kMnuE+DK%U}Y zqz)AB*~5Ef?db!tG_t0%~1f_ztM9ND_ApmT?9><28YW>rp7C97yX!_o zX+lajyjvhJ1zWNz{(N&0WZeLP>qDkG}?N!S>A;xN#LJN4fr<^UndUy1B${RUwM*E z>avm|`OUXj>A)Yv*##VsvUV;C_(P;dkttiC+-ULNe~TFJm<(cDR)nwfl2SRuEEfLA z0ysrBcNZJNkbLY^ANb3qPuG;dA*4Fwcy#2A@hQ9rB=hYDafeQoEGQh#GfJ^@l4(4>l)&mE(Cd%k?^Y;_Z zJ1bvKgeJ7Se+LG)AkatuGMfnW6(` z_!Vr=2ym*fz?tvjD}$tKz+dN4lqN$e6#{=5;~;AY%?Ue83w6oyn8%C69z~Y1Z&rE? z(IsO+KP0=i|A6b(ksTD)reS`Y!l0k&J^i4JVBgz;a!FPW8<}VQ!khm+v|{SIdg#Co zFNyfp4W^CHJQ=|g>cmiRhaJOTDJxNMBHkh?-Tb7BFD~n!8X9cmx%@%WT6pbG6aC|v5}rH`sl2K=ajwG)#a85h&itn zazI18(00L(uwq|gFrB$XP-iI;vc|%x+XQOK`9y|+T=c#=dJmB@#`}7p$GN?1&p)xm z=zM4V`|?J2XC69Z$iN^L2hr0n`q;Pkel@_nB-#1>VFnLCpJQE}IX_jv2LoL$?#9x9 z$A`UAUIyCQ@rSbm2%3U!6o%I!j7%)CG7+HDh|~n?(B6R-NI_-u+oON@)Fb=wX0bsO z2~bpk!kxQzj(`8+)LLQ}i4B62un?h!?T2T(s7TJyU|pa-uUTv{J;O{>Bq6GnMCHbbB!Jy6TdVOh_ax~t6&DeF11uxlD(mLyhX-ry`L4w+)_pNS9d5DM{a&UyMO2?9$} zWkF*tF#hL~p9o+@si9{!v+o~E3c`RGQEZfxW;)0S^HrNpke9p`&z0Au%RT6qCt`Z| z3F7G&C6Ky5k)}XSv~3#?2onB2nV_Jp1MPt_fPwej zcc0Fx7En1*6}^~XcpCtrO(uL2zVcKDto-7GAXIM_FRkQURCNn|yZLe+C+21)z-ZHKRjvkEY*I25rfEa&|5pyTh-36y z?(RPo(MdE+w+Mypy;U_$i4QOr2v)8T1pYbonY(|;Pz_oU`fs>Ubm0i{0x2wLtxhfm zf+K~s;JM7YKE#jbt-oBE1Z%+*=3Nl*b6(Njd%Fewl;gc7PLEI5KSv8dLI)EX$*Z%} z^KPdNO~MfDSE4iPw;Y4?;UygqBvqksC<2%oI?~3^M(?sZ{wOJYgq74{0t9WRz71p~&Ypw2Yv z?ELufvp==`+M~fLTT*F-dXPI&=L;7uR1X{o?-6u80)@rGI?DXJ;eJ2?2y}-(RbL;p zceR(w=10}k`3>q1cLRZoh^h-j)20O0!R3uyx!AU{_||@SoCt8xS5O30t09ci$U&MGSJU8 z-(0@O`Ax#7oZLW01=0QYKOjDzz(7hDqTlF@)UYJ7X-W_Mif&-QeAXC$^6*z9uYSYE zL6~hy2!OzTEf~E4$zg@eU#2(uWD+pc>|(OM;GL03oA&F~k{@lkqVD~}jCdRjr+8)< zQmj&mM~kCD5B9ClrwRP9sTh+nlPo^|T0(ss%asxJEVc+YFH3?&c>ot)q@2$DkV4=4 zMYYJvq8CZkU)xqkv&hL*hOB#kY|&*kFlBP(XUL+?C}EK-hu(gz`8KYo?>htes6^=zWcjdqb3@<{LWx!pilv2Gqmal)M*^>~f%g zP2&Mb8KQ;*QFvs9+;ocjPD6Yyn*MAfr_?eS7;I0+j~;!&ZDHh;{rm3|j8h3Y>Wyio zHmwfzHnLeE^82kG5_M)zJ#sGt%6dtbL38WYEf%duJpd{7D8Td5rAzJqU;EnENL`-& z=04Rp-L-31`~T11r@+FR9_NYyH}yXFB?1iYK>~IbyCJ%85LBebL38Z`Xzit37$OU| z_XGBW!&KFaPwexMtU3vB8uISmy}SCS-!zw_cL}FH`*ZcwgI-i&`wJ2gz=o=vy|9JZ zw0`#2x$eL9^>rt33LOB*);WbL)xut-2mxAfSp-$M@6h~sTm;a!K#-5waFeZ& z)uk9X#?iR7OOcT#GKvGa=XW1YKkK?WcW&||gba|VcXtlpRA+)MKwfZvP!kMK_TV2k zZ)vV{JFl+NAJP5&#L3p9uiyMRBGHkA?UjdDlnT1|o`NvQWxod%Sb+3Kl*S~J&G%Z> z^rP6-IUZudI5jcj-Utek&_$>VwMQ4d0z(-tzm&G>1=Oev-zow^|RIC%0w;)U|Y$` z^UtmSpLuk$LvP={9S;QebcY15!+dlQ5Ngv-?pCH@89wnV&H;iv&*9M+MwvWvOmQ1_ zd>(*Rb3r`pPM`tFaDkB)*M3lq>#H|vX#onFW6PhmLli`!^0a8@&OSg#U01hm-Avzp zQR^=wdH@0&y8r&KCGEstedgf!;(zzO)%aI2wLSY&o46Khh#316 z9S1t#*ZmixHvsqrkB!O-V(4>(0KbWzd2C6DDx63lyX~}@9|s~K@=F1N9T?c9J$!IS z+_$~f=9xgg0Ss(_r2YH$x!@s%;U@xu<3J|v4-^E18GOrRG&0K=AUk(<-gO}mhyg3e zyzxKgT)fzUf%i9FfgteX)A47QJs>b=R@B&$ z7g3xSYuU(yjQ{vTcRc8ynq#$f;|=Hr6oKRw01EsU3gr>g0D%XyA^<0JPGk{xouaZY z2plAIOOoOI61*qmqC(~Z6XweZ4zjG$!9iR*C1DthvGnmRIVI#;9nVGtHROiQovspz?W2Lt~JKq*CfRW#$+t8*nDdX4y@!+ z9P?<5M$K5Va$K7k^wkzGrv#Zqz)vlP0)9Z=fG6T*sLXL={b4fpBV<{cVFUUpS#bFo zR6pO`0oeX!B~qp_33j{lGh}20pbV9dNE`SmZ9qZ>Igr{YdB0cr=y#`eyKK1cm$Y%C5B_D3VXlL@4x^4KBBR&TwT5U zzP=g4@4yP%3g!pYix*4uISEPmLU2$KN4)&+Ck<0FO?Dix=zZXsaV}~`J0C{FhfP6(tc?NOT z<>!zFApZz88l5wGGu<%HxkC)nF#-%TiN2Viv!6Ww=zgf|Z~pBvK0c6KNWdrnG_&)Ds}lzb>g$-ec51*QkvfGY& z?_R(iJ9f~=$gO?xmCKziioP4EyLzdzPTTi?PG|89b!L20%1sHMQ%R!Ig7=V{2$dus zHFpuXEI8%--cRsOO!g4;&!BT2f>7hMv~$PK_VIAPpI!o4h$jyN2&avZVYj=TE>HK5-lowh)xWqoKzy5lbQpdUsi!Va=!hflV5sR}UG{@EFAIt+y(fi$G(@NHGo z_{o5v^E4I^1oFAsDX3MV(U9bPWO^X5r^YLg8XP#=sixezsPckALduwHqpLW%8oFTL zC)k65gP7+3SD#sKJ!-<^!4{VU4>P?E0594WDhLpQKw#p)K#Tc6pnWuWxF3+?9?Yw9 zm?#Sb{xpaH%xPyQ2%uV)_aG#lk}79qi_F}>2sl_ojAS7EJ2)t{71Uox_srTP~PJsJf+`bNF$i4e&NmkjmSwH&jpVu z@{TaR(M5%)W%7|*U%xydm^8dyj|$EdlpT6(9(2Z9%h$@bp(;t-l#e$Ks_L7|_k=of z#{h$7q4Hq{2YO@;IX3FH3!jaDw$1Yjbma~}AbtWEn+s6g*ur5#bQ{=@dtIF9!k&KI ztRndmN96IcZte~Q3_;`$2%PBYAy5b;W*gY7%v@-Ke;f>hfBdBP28=Si!Fg01AQb8* zrNr=4iwJ8@IqDYeqDQFNY~^lK?AU?peHm%wpGwZ;_dZ-SYF%4!JH@B-U zih>%7%798jcG4z-S1_i9ZRY7@41Cz?AYbZHVfHf+%q|vDv_Pxk$D0Q+c0F=H1+J{l zlLmB5GAe|Yq>oId*MlVDLVkRulRi8uBpusxkiwjCrR&U#FvPMD1I+tvGyVRn=MJ&` zd+|bd+KVeY(1)LW4(bx#y@>*prpmatlQ=dHM@x@74yxv2u;Q@ni%*7jk)P}G#w7+* zrN$LAw?y#TFjp`5S*LsunUEh92BRc^ zznK8Q8Uf9mWWvOR?-e7AcJf+4)VPniQ&0yjaRYN3XfSM(jUfqKLGJRZ88DCnX=w$C zqbS{RduuR_JaT- zS~(Tmj5d_R=)+BY|M52i;6?y}f_S|q{kQ|#Kn4P3{=E?5X`F#h;K2ZjlLhxdYYxr| zSg$fk9FwY;^m*xgB*M5%`Jpzw3&26O9uia)S-(vK2bH(fw)th`b1KCjHHgdcFTuhr z6u`;@`DD)N9v`YPw1q%EDVqd>zW(&SX#VK6ig^I^9CsY{ye%21itqmJvdbasPC+Ws zGuneb%qMpo=w3Dq6Xkh0-$0lqp_UeMLfY}^U=Xd30ml`UU227xbp`_fDd2A`+bj6d z*$MPZ24FZ2Xn&vzPT9o4+u`uD0l)_IlQm&KXfizJ5u+a4NJoKIQ382UrmA-B+SQJO8_iuBqE7L0 z$axF!ChrHd*N(pI2cLaGgMd*ol^22qPpz-5S4&GS2>9(64|gCSTOVvZp+vq9t<)rd zFkUJp1ZP!K+<6&geC_-VLMSC)jARrjA6g7JVf9RzCwjJjkw?xAZrG~3d<&}FANSw=G$@44k9Ll`--@HB`!b*wNA$A zp4!39$0t1(>0Tp7-Nc;-dOZyJx!fRdOB4bVZW3Cf(n+krFZVTbhoEn!GRjdFI$1s6 zsAu?*(QZMxRaJew@_GB`H`~0WBJZtf! z+n!ab6hKIM*oD|BosjI=r!B@L;un#fFR(4+$SM6!As4J<5g2&s9(ykj4w77jtXN(z zM*XCQQhZav!KQ!fvcRCf+VeUIGSa>#r7{sY`Ij)5FB!;Zvbvj)0UOGR{FOPVjtJJ; z3a`q^k8+BZ$Fk8`jk-Vm-toiXT83CX5zB)i=QC2VNl3dFF=aury6y}-^vWetuJ#V_ zJZ_{O;gaP3h;NI~rX#qtV6M))+t*_4QiD-7DUEa1M6yXKTd>zpl|+u`&?AX7^Q3p1 zn=?$Ri9Nb!n_s+mp&O^xHp6H4;RyUuAF!}?rtCb*D~m20ronTXxWhj1nq{_oqy#c? zTbcfCyP8}ZKF438}wWHtBVX)$)vYEmDE8SXkTjR&Xo4#gVX(gQSb>h-{8KaG@5?-$9^07r(d6o1Yhdv zsTK&NWZAj^3~Q{c4FonX#Gn5196Jz2FvxrK>e2gj9ccy0Bov5}elkhDj8u!dPA>A! zsmrQdx!w^K)OfH{G96e7WRzHTkc>$HAjn^PHGmwGOM$QRWd2DdXK9p@3?eBL$j~j- znKg(2`I3}K^j3f~q}Lw4QxF8xaJg0W`ZN3Ff*`-Wd-seZer08iVUQ2DsmICqg3padk^u)JcUBgGb`7fK}z@UQ;+OZk;ff7 zdjO3A$S-ePR!3(e7txb$XW7GUYGwxDH6cF}J7$e_T+>CteEm<9t)F{6YV`<#s`)v|eZsXzMLkPikbns`6cK_rqNQ6Rb%wMpG) z{(XBPZU+SFT5zOk=W(I-V^)^+_4Cyd0RqO#In{dvHb5X(5~?3qczu1XI^ckSel}45 ze0xNYkO%w_Z6?{rDH>lwl|H&j;vuLt|7ZyWN8Ay~{uNi_J_Gi^-Ts zk`ds7gK2ZNp#I#ZmSvNsS-sFB#dGv;fdxxs0U9Qyg%?|g&CE?Q;|n8(e}o$Te%PkQ zWAEzq;q-wpR1tZ-VX(5|f6y)0W*)TRJ)Ea+igPtp_1>pn#6U!G%*EdwedpyP?f=)W z-^k=&nyen4MHB{X___H6xMX3H-tDG=a@LkkyxeSp8G` z*P}KNSjUZx*hsm~m2g9oD(&KnxYQs0{o4HxI2v`w3N=EINyYm}ceql8k*JKCrv2`2^tK}LHu+jOzfer|i!AW@?Id$gq76c?+`bE9t$K?6-;aKni z`k1*Om+wJ;vSVICbTdmW2?78XPDvllFN+T%W39>Z)~iRVAN~BSKX`>g?%$H>BY}fB za43C+oZbaje@!;sCS#w2MaRCio;6pe*g1G66hmSULLOx%l1y{5NJj_YBi<>;f;|P@X%F;o z3x=EIO9IG}#L-0>hhf$Yzl(|XBLlV2YWshLZQ80Q^^t8PQrW<{%8s>AADx$Vt&>v} z)g?@zZmnt8NkS)s%weltUVQQ(tzUa}0SHz#-hNh4j9%+77j+DkSQF{>&!0!uH49Ez zN2I&IvfpJUkeb%tLrH3Rqv{*%{vtlkP^W1r??%XT-SkI*Lk$TvsZ|yQ5Okm>Dzske zabI3AR+a>GKv1hYqo=lM)NxS19EUCeU?SdDjBGB=F~(CZ7V=iR7&I+-j2tcJZ9cRf zApk>`+?H<1b?u^~jBpKubG$Ka69+WuWvpjH6;mT7bITdgkk2wK#Bme2@pq zmZaBMqns$f4nv*~B4hcW<#}nU>c_trfIzVA{l|6es#B;P1Sy44RhKvOE9R(rfsBc4 z`1xN(i#hd=<*mFUV))NBWRrou5;-JwczsbXfy21g$T0l;Qht^yu=C7tVd zfDb=P6%+-Jdgah`pOg`SJ(wSvn%D+}olMbpUODWj-<+i2^+5-x4(c`Z{^`%7*wMOZ z6aoSHlqV^i%TmCWR@3yRDp84bF-QA*pauB|yB z;A>CqhsurYW3}$H@7=q%^*WTcE3ZG@>ykm+(2rgK?YVbP_4n`E$EB&w2LL+3QI_RzX`C zq8SQ;TJJwoRjaEj`TS@RMB=>tQEpf=oFak0H(!0Qx^~S!UM<4~`Vl>eXoGT~J$v?y zIc(rBnoPWIyLRucUVgF*csI~5fA0n|P!KUa1)4H(GUCZWJyJ@|M+nN3RuIfBy-NzW zeJVfJrV)UyOlpq!*3P|qRRH=?99jKYV6`k>H(&VB0YOAa7BtP=j-Bli@|_L>4oo3x{racmL?H znFI(TrUMQL(!Ll}J8N1S!6m8=bCF$HgPlN8KG-AA-==@5D7L6BgqaI_Y7v8+6cI+M zB0cda7U)rWpI7@~f+}05cZ&z&A%-Vy`wJjpw6`Qh6Mxh*jrJf90T27Qw5T0ijamWV z2l>-lv1j+*_Wv6H1j(}m2)Zy_ z`mXuzt4FH8f7d#C93dD19=SHboiFPEOpF6OO*}YAXC_{0ivb5|QPz7<8t$dMTm|Cy z9fHR`S0qJ_p9?nbWhwK3d?*;6VpzwvtFwa#{>u?@{A_ zk_cPv{P{Kgeb$~L$HsTyO@MmV*=<9*t5#nyuv z)y%fdTMx*0wA{Z_w*?L0%IcF;-?AaII@U~N#9zGudyYZ7mx>C`$!(~;*Kb;m**p8X z3}YiXz?8k>xy|RV#pJ}Z*wU+9hwNBQodrt>LPt%BlZ{DVK9OLMa1dggG%E=;N?pVSQMNi`=$`-3baywdU+Hl{~ zp1mDdT85Yn_xP-?zI)sQ0SoQdW&xi}bJ6~h>WA-qHldg~%!0oL65dMCK$v@BC;$#t z^U~X|AFBTDUso1<-(cL}O&{t^$zrySDO-XBXi6Jq5j>N#&7m{1kDo=vyfPeFCApb- z1lh&k`&0w}QgoQJy-l^=-FQ3~2yq z$yF>cSq;8ZN|q5*mU%P=^kAObz#j@kc5oa1f-=%GH0Z!@f*+o>~a$o=ZF*($pBfz-fA7 zu7aa}Dl|h@qpqHKXutE27CY6qCNl2a(ILMlKI&hZ3=2z2*g6>=VtilvJwW7B`$5bI z>Jn>`O?~R{iv=yoq_FK{y*b=0)ZF6a;`IDu(-FnC4G5;q=ILj@wT=y<-AiV~JUGx= zbUM2wU-FLP@}rj0PZ|gA%%Z3P=iDpS!0}AZRj4S-(f*Ik6&27WEeAfgc)kfuD)KAD ztU9#ZUyf{=2!;bN>u6iuxN$XIKQ34EeoNGSdHGOv^{S>5{f@^1Bf0dm52(9R^tmJy z3Fz3v-MZ4XNn)SI)~z@K=rTNXXt}y}<(gPx@4b7gzkA062@}AuPPyx?hj{vL_9%v$vX&Kn*GvYXkaTHi4f4?&W#xQT>4edvU<19nIHn zgN+UTZae=jIUYmf+ujAq2viShzA0FU1{9O+$Mi4X)Moli^)4sm(nH7NZOhPft*SHY zH|aZg`#+C<^FaIe?azm`%^$e*So7zD>j5~r(YgjEy|pwEU#AUk^cjK|a7?l*<{26_ z*P;r)zRI+}ol;K{2}S|Uke+{Hnz+CH(7QXs4^j;Efj>Gi@E|Bp{DRFqWYV*4B&miC zvw%1W-dKzhg^&LzHdJCwrH1m-G%(d0&mU_4YJot5AWJ+iog%gLUxL=c7A_MxMzE%P zUG3hzr~S+E((@&QZ9|WqoVFpTF2x2El&FtXEDP4iynk?IwK;lxP{?Mg-MjZz*Kb@a z4#nsjP3?n|$lYo59B;(d zN}3t7&7?QA&n_$=hI<44^~EA2%tSMK9!i{B@GrKINA&%An(-V-AodW$FuAyBY`gRU z7ziX;2^i3DOO?o#&MKe340LcwIq#7IZ6b=tBAMq44uPEVRSOwPpkK5qKF%cOMJpHX z7wMskH{CAdT=ycxr9K>%SQric-6|KI=uO0>rV0Sh&|Li8qPW#wG8XAkaWwTOH0 za>2n9pWYe007+u^7Buf{%H6crO+T$vd;7aTi;?u65W&GYLB1^j#1-QmWBq*jK)xv0 zM#%cT*Lv^|WVEvCM-GmqIG`qyb2J5a`5}8>g4USe8c{l#x!3qe0k+MXxGc56UoxOW z80?%fk$SPlJxVa>kWcD*HQW0kqg@O-`bsFT@W>Jo7LJ`q8%QvZI2HIu&D=<=Z+1^m zLo-w`J)*OT6iz&ra-CVfA(n4JKe&}9foOfFBf#uQE@9(r9nr&%C)!>MM1JpbcF~W{ ze@Nc(N6Da)z{{t%Z4+gD{ou}Cl~6y@UyIQBzWr{*!?qu{b@@*Gel6~p>~N$Tpc;)v zNgcx?+Y~go0*6F`KO=)?w++jiam<*urTSxPNi2!cL83-+Z934CM|L=Kb;{EH`@jSD zPq9t<9UT#t6e8=0ACcGFhUG`9!OWXn zs`J4jZX`_XQpPo|OY(967mDelNDhpMjt10zB0{& zXsKM`qn|wI0RW5v_T-~-nZOFgrbyR^9EMW_2$KLBNddJyUF^AI9~(|&>WQHB+qG*? zP_tj0+JO0M&)`<^&zxprA>c&lXukRN&>aj;jKUvp1Ug7uuKzq^|zx_lJzTWBJDn0%>dhzHonLYr6Zo6^(0)c&Y zOy_&ebJ77KnDAe1CXk z?P38>v-mm9j3G16WQfRSvfISu*lJmn!H~gAUVHWs40zYk8n8%G6qiWu(9`&GCfy@Y zE1K9I_w=z0I38E7T+v5tXMn2Y+Np_T(s~7Hp1~&Tj`ju*s2?I-yLv^HE7_C{HK3oJ zZ##RClrlnt4YOo%*5B5DJ1lU3}RDj#f2@>+OYuD~pNCO0l9~-!LKCmdw0uJSX zgA#TmDc#rZiAVE?KlaqH`r|;|%gz+GLQ;+n?YX zEJkmW`0iUcIGBX?%nb6)bnjGoAj>Y0uX79j1#HT;h1ui=G{iL#QLOXCv$VFhnvYWf zkEh7IC2MSrzf#y+46~xFVpmS;w+8N&2AtAaXwd8N=ep~M^47$%Ylsgn7CBJ7u=kF! z?*3y(jOWpv1cg;QcI*_lc2}%u!<=YYg7+)64TGX4g$tY0&U>cEf6(AO0VmS{esVBB zk&6ZRi95k#-}-Nabwz9tok+PPVitMaclZxK>@)nNk5Vy5Fnw0&QCGXBweVar=B>hV zJ&CpwWCr>X^2!|dB?}Xe>avl13mQCbE)BnES+3g`T@XzyzU^96r3523Z6YSQX4R;RGp{` zooV^t^7x|u(a+B&9W6ih2=VPrQYKvb7eY? zYjUT{w|jSYb(UAOx_I%Tu8X4b0H(N!2&^|1+qrYn@4Y{4fPg1@EEw&$aBR?bWKsYb zIwq&Y=b!BEy{6tX&A#ID<;(n9;_GR%R_7}5bR1UFd?VHmrzyg9(V)YMd~bz?&#c`D z$AJO>`hhwGEqH#`dMPhgVH=`OYOYJYtUmfcsbcXO>uusd9hR-HS@)opUbdo< zZx3D%^r}TgXnAg7QkI)U8Gu1Yk*^>PoWmAWrd^2fO4;y3ztUV%EZAU$)%ikV&;__o zVBwFoNWO|dd7Y<#T0~sN*g*Lj*Hi7(XUztouAX{mCoj#E?Ha5Zn9|NN1_17A4qL8J z(UJih7%~2G9;l#>k4PO0vC}pY`kILAvbwf9f`F+NIPu9B3J9oez|%i|#L~*@N(Ta} zuXJ8#W;Jr?4A63pk=Bp3Uca0Jp+GDoGn_D%P@dvXF1$!X4Lf(&v%!{d~!8b}# zldl0HMoh5`_|lScSxA5fm)d}SsRAd^FM$kYBc%`g5%{yS&%EyQDHM=dR@MOeanyi* zC@)G~pcIJ81s&r2>0X)U{vF$7MtB>aS!M306!{^Z|8Z>qy%CskD@OtL84w_ruZHW} z!z)e7^Dj~yF~vww(At3efS~s{EKC~N7GmKQ8JopHDI|U6Hkg{(Bmsh9Dro$YdLn&D zT3&2!C)LM{vyCM7?IrVt0Hi$QmLD3{O1W^5u;X10B+LVUPMz+)6h8IPj;Q0tDc3n> zndZbsV=7oDE$0|kEpRFw&DAK$ggA2DBB?Mk0kDHH8;ywt0v=pC=rXS3BsU=7a{>rh zm#9(fj;H29K=PdcP9$ynl@*{z)5Fsxm1!t~+3gtQRiCv22}Hbnm2Fp;XD$P$9BDlx z(Vo3Pz>{J|ImbSNZoR!HlAX^OtN)v?#zZczs0Z z!#%zvAyp$|H^mo^8t6ncPg<;ZjF)Y9x;JUL)>F2-S<7D`W(<)@;$Zah>0lmy^phM3 z1Ye9FeNq@bg3d4$t1Ib6H4Hd5s4+z7^1|cy5v7>2tWKl?MA?pR-lW2)D|3jL+8WWv zeZg^{%8>?n*ox8cfOAYd9$a8x4xODkHS3}P2)o8I$p;Tko1g2~iE)H2LotJhNSYG& z?A=rS$T?lyQdC zTRi}{wzf`}i1u93a;2lKgDTncXJiy#b||s4xu=s!c?ahZru(sNM6i2k5)-Hjn_SzN?U=7}Y+L6xT z*O*V6#!TH#eY{Z&VRMfKPZ^$na+z$?D;DTSflh7RkYPyx!F2P{Af`V>$n{K{t7A7% zbI@3To|n(WMI{+E1_l-qE!dy{bn8&a>E^dsI2c{o{JIIyZR;xh^#!&!6&*i;XLLJAt-ZJs=jJskva3cE>Oo04p(F+c<;;j-F{ zYAKTk_~L}V0I2?EIFgET(Wg^QMGaNg0Z5mV+zzVQh@$(f9x3fWEnwf|^}t*TpCpBq_6jb{uk8 zS2!vM7%z&*P5pcV3bUq}t2O|n(;RIv8BJv+n3=Nk8S`}S4Z27s9Qfz*#iW0A%1PPfU4(XSJEDTo}blOgB0%!x>;GmV(T|UMY3D`A0-xrpuyj zMRgpeP20ch_)`mex$9W?(9IMP8Td&rkcT}^>*7bAt$eC>I7l5A!MdgbF~j77E8JR= zNW^squs%qePMH&QiP4HG1I|^Jxev5tG<3{xQCJ*2*hSp^(Yt3vX0Jc(9=9K}fdgi5 zd))YJRf5U^gi(@;WKHjPtsMH5PN!p!*zcRU+O`y#t-}&PAW9e;vDA35a`e5|9;#MX zRv6LKUnf8LqM%B~@jxDqAG7=en<*Y@%+>v0Ke)sm6@K%06R6|*Y<+wOM7H+yA0?X^ zyS5(Q2^f!$F~+K?s`o#YgKLmCNWmRU=lRx454w9LQ&s2B>vtcL!G|Nz!uL<#_H<>D zG&Nn10ju!j%6SbPPMMq;paWuTGVGP*|I5fQZs3m_H*bpQ-!A)(y*};Y1^oU$X}r+K zJSirzAdfv@iM|Aig-5c(Qhz+x-GNT4Y>JMJk)891KQitP=YGzqfFD0MU4F<>b?#Vy z_$z2D2Ypt0+Mr-2qq8#ayX3H}7TuQ>(G`Z*Z2!;k26Fq(k!DeE!`LIPD-KV8(@PzV z^1K~v288iKRjY0*>>Ge&PM#54H|p)=Tba|sNWvS=fU_U_LcOKcbM329#eI2}tRWTY zN|mg-gPBzw>=wY-D?lN`9pXt8BS#f^WV5tk#x1Z2A~tde{^GeYjL^4RU;OuHZhAmq zI1YFnBIGO0O}*mvIUwW^)(dCtCcCFj8lmM)eSJO*tt8FWaLHx(f&ihW6*@lRrc0Jo zR)n?*zZvT!J>EKg#Jh7aLGf_U6DXpA+&D$d7BK64-hvMmpbWUr@MOshg{;Vm8X88VP5j(n|4$|=5JmX8pD63*p|CIa%e$~4 zCUgn1_=QJyga?e|CgMCs>Lz*EDdt04Ey9yba3|rND+c`~0E2~M$zNfS8aFbUc1-fv zBLxd3V)_G-fwqCH75Av?KVnS6+|aradEtN`6h9(}PefTDlh|)h*v2A2df@vL+WKryTVQSkcJd^6GZ%;cW{=!*UOK zCh?l1N}i#j1AKF+({XzJ8DgG@o&_!qr-0Vh1~3PMxoDLrbE914Pk!>JfO`x6^>Ww8 zIw&F&^oaAOrIK#rfEit(l*`a@}?Z@=OKtj$`ozP^qd_7r#aB75W9 z^E}Wmf2RZhiP43yrRnt~1LQ_8=|>SPAZjX`0|niTh^$nvJvUrc;AZ5#`H1$51OTk#$Yvt9D>R@)mZrI%_0g&I$l^hGS-D-Cm*NnbqG zV6`S5!QxcwRajR?Eg(?tTUJ3$3zq!VMlJ}p=~&Jz_Rc|#fyfAX?bQiWpWzDt@X1w4 z=uSHq1{j0n30+%lJOP*6=#%YnVDG(m;*&pB$G&k7!ir2;U0bb|4>nQYtaVUp$e^0h z1xS*HLHO>;SYsmBYb~o;#Ck|6ki=HoN=Llk3lqGNF2ig#YQaDBwHrk`m+!vzV0CRc z#UtB(>bg*bX6%QPpUB5uM*uTJ2h_AybAUP+0{kO)#?8JxwqB8A0Hp@_gH=cnv)cmx zVnGF33F0RbX){|`{CJRfX0PAKzAKWnW4tj^7%V7eVbl5hZ9t<&QIdA<*yR931J%W* zV9+vAxz(HiuuLVn?P=z_ngDh{iN8bWBaX|cBYaJTA(D|}-=dKplnSy@c#uX$8omNA zqXB^Ie%r5rYd8S5n#IZ$VpzM`Gmfc&hJb>j(dnZsG<5$2xGB(+4}g(?AYmX7 zARP^;T7P*B*A?;W6a%c1dqZ$77@{REAF3LQ{bF{wK(Prs;oSl~@u z0ko(#DNWME;`d_Ef)qDTqni`)?$aL`NE&(!pBQTfZ9haQWz|r0teYnPx%O>;t#RpLw{6-=LT~`MVbkWv_1^6F-We0u;IlOZ8e&_d%n{>qE zY52tlk`bS#9!cbu`>L*%mb#;;4gJF}P6vga{rV1}e8^AF7*PlKh%LekOP%Sb)RQAc~N zj7>nFX1uJfuB2->E1)NsdeG6kj&=vYSeNOYCLoAFZ@&6aJMM>w@0{E~!w5`T2XEp~ zGX1EU?lq?!38qa>??|H1Oy7RlIu2Y*UV&+K8N7DvqNm0HAU5!x0A|R7iDD+}!v-?$ zX@1nWp@2P18(IkVkw7}8%_q^kUw!s)b@L{1_njqU=Poy(U`KVeap@uxh=wXVH0sq`CAW<)iP^D5f(MF|Bvs zc(hj_2mD)PTLLB&Q^@^a$=cnAmsl|e{2Q&mC^hw5bM${Y@JBaqXyB*P1pb)`_)Fwx zfb>(Rkw6IvQWUH}N0VX-&2RrxpUKvbHZ9`XoGzujQ`$!v?b6eB9Z&)Rryv^- z3L4H^rgc zV%zflk3X-TA@94JiFIKD-^%q zrR16BF2K@e>wv#z!u^bPm6-$^2_c%qL};?#XC*Xs&#D5@kKetU{8a$@H9zE!UYWqq zcUQe1=ONxyDqMzwQDIsF;1m!N<{kG?dHQ&{K0NtSf@s#U( z|NWcu>0HseN|Qcx8S(1UrLg>`|{z5a1PnDWme~)GN zJrzr$ksmtPfuQcVE|P+yMU~d+;?XJA!GVZ>#Yu{#q}Z(X`B0nsxVvIg2K9U_ zC~ABF+kx`27eYfCHc3m#qr*rhk5B7B6!#d@7P0TB6!%BYz$&(o$fJ(M9JLBbDJQ@3 z13FpGe=N;d2Cadf-*)uso}TR@PCZ&*Ck)bB)(Nbgu934Arz+~lm0Py}5SZ5R(~sXi z(mk!~>K{HQF7$6Gm#SK10TnAqoED+0B3*(hOX>85^#KSh7$JFBhYDEFN_!q@og0J7 zfPhZ#0Wh5vkl)D8&dpbA4+s#jF4S**MdL|l@8m;dzid76dJs^%>GIa;^&2; z6^tMh$J-q>O|`tdGHPB)a-23-vlOL~VKgwpKs}rk6YsS-Qg4h+q8+8+pA(( z@EXnFoGX(`nl}CA%Gw0_x*4T=b+ksvM^t5PBX&)rxtW3%xCFRy165au&$u_wEV}p}CP~5-8(fj@B4(zT+ z2d^5Flv*lJHOM7%n^4epod=*&(PgFa;}dRICOO`a!-zC-*eCm#E|q?CVs{~bxyU~X z!6j(Yg2B*yf5tj2B~z7Dgz(gbu3tKvP(hDm!?hz9D3G~vwNxHXEV!qafzF~$|6GqQk*{{m z4+8l0=(Y2_He zK*+Z(nK>3rg)y=kBXCH-spi-b41A9?U$}W`M57F z%uIju%N_Y8G<7bp()jlhg5V_T$lhJKzx`;b`mcX5M}~2|q*tU3NkB$>je$UOcwDC? z8SEbH2#BP7FG!?{!BLIQ)q|tmSGBOZ^n>0%SY-MMthHKD+fyl(zx!yhx=%%jruM)^ zobqbYulPDYBC&!LV_T41q%?qkQ739=A#bz^sh#Wctf@h?R&yU}Ay=|>2K=+j@5TWB zY4;0p5wO1+CJend^9n2Yq?J$gCkMa_GODZ_Ib`y|r;uJ~4~Bq4W@_!K)V>^b92qe| z-^{oHtRYV5R2PIb>df&L_6mb`_uiYhTeN+pvjmcLNpiq_(5U)A11?GPnU^WF8)I@# zPzj=P1a>_Gz_p!vPHLog2fNODf^HF&cbgs z)+QJzi)jq=%uQl!@YHO3{15q2hiN%eDF{$-_?Uv5d6UkyA?bd}XidpXWGfl6rRiay zP)a#Kp@Qx(6=k}TVLdbJ?txod3pc#=h~{vcrWoAg-aX{<#hElvNP}W&RldzY3nskH=H5I#adcMR^b~_AN)sw7baRNlm`zC~ z%UeVM%V?{aVON%|z6^Tl$k0P)BcWNGxnoJ1LJ4C!Bg)cweILlaRv*R*TsW4pilaIt!D zA7A&NJ1C3{M;*vDzhge~`m^Pg#x4{FWdoCQ)G#*@@Taf@vl#0~m-qPbGbRb{F@X;h zZ1ey?M!yEn^ie-yse+?{uBuk%5x^c5fS?r6Rmz7w*Z?f12HCXhQkWm?oKOI5LE9vK zoeSXm5EY&qI6#H+_-iodx%ZoTsJ^5`%e zuv9!?xoVE$4wVwfSTd-A!j0wQs>8~S9*9!|8GvS;9_)gB)p)sVlTvD`1m05LTz)VB zKQBK&>n#loc&54Zd=aGr>j)j&i7j@o9?O2C4}4;b*}u1*fZqF$q>!~RZH@x;4kj+8TRHhqajkAsXr^ST6|7^(o8$<{ z)RXP`@7aS8ZT7g@vB!+~>!wQg?Yj(F44u1SYeM5m{(f&%+ zPIAp|rp3(uKH0+oJSZ+h2-1jp2-UYM66{Zu{Tx2gzn_Z}v+u3{)qngiUEd1ExPSS6 z@-V1c3whyW3QId4F`4b#x3z!2K7TVcilHnf18hUk1|PKp+^-ZGgq)G)^%cv8FeYn7 zpT-3t7=*ngUtU}QeA2!e>PohY(nE1(W~Tb$oZ@(i0%+)(+vUA}Y>$^8m20N~-GG_t znd-AMSG~dtQ8=R=WKnC2PtrP)>%MZNKN1?vSr%$jdh9`%W{bA}5O(X{qFPLYYPHDI-_1chma_R^F`h9R5dMMUJRG5(b>9mvOnsa z>UMe!@<}&BzRuyRV|oYs`w;*B6X`fGIO7&z&dJ9ku0Ok=EAM3eJNIsR)DUm?m z=CPd0Q#lZjQ@}oX^H{g%%Ssd2NE;GgLI4oKzB#-ny~_`c2i+C(86`#=_T>cZy?dee zolZUtfTcE3wM8a+=bT9(xPk)Yp@F{)qdciP!g~vngvMTtek)RPb%)aK0b_+uV(T_BpbF9w39;6*+ZuCPC>{4f%WC% zJFfp^9^Kc?;`dhDwrG*4JX#xlzhJLJMcsDZB3)O;qY3}<9w^%Z1FLXVd7!speqac` zz`AZx+s9Lbw;N%&riOkbU<5qHd}~TT6j9d~btq=R!0zuW$HI%*zqw%VfOeq(tEi zZ@zkH`25AWYpG1FC^DGQiKN@qu;zW;RPP=?+~?HQXJ1{7invw4Gokxh(qRZc!2KtT zXOzCaycPn1LVuws++j0MuMjl8ZX`65bKpOO=%$p-nUeB%vx^4P3y{59*Xe^;ah!`Vaf zOPYq6n&^@H4;<*9>cMi|#(_bbRquuPsT*OG$oD$rn>(+;3om#q=%*rpP?;oykZH5j z>yz^!EPEqnSwERZLkSnP-CUGtLSLSLf=h`37;^hvDo=0bamiXWzee557RzRcW|E8d zi?xv8HBn!MBm;iEytOftF$CufQk>aRXFtj35 z@@MZZy6?UhslTOC13$_i13@4eWbNv>5@SmholK#Ol2kNY&3qikx&0wKR%g^vVHH7* zC|G|&uS(TiqhurU#Wk&;FUS#ql`r_1Grm$=dTN0!;)iW7`D3Xl*x z@#p8e%h=;?byaEy1_tzMVIidurR;`%`5PP$OJEgkeO zwr9rB_LW*5uZZt4YCrAVwF|Rqd@xYr;f;9z@rA>EdkAonI~KfqVfT=;B?7)aZ^1z2 zJZL)_&n+oo@p#~ox2;tuK*n+DF1@li$FCZ4{t2m;+v`|p+X3X$^ruH}@7{d@-vFkT0hW^9C;$0~RdPoy8Kc>**OLUU9SOM<@6nM7Z=%U#;d<_#Oa0 zSZiVcpPHkR@1zCmjlZU*3pvy;isb;o)i+_#b2 z^U}Nx$W%A!y?iMvHfe#R{81N-?E+6hBkQS)>qFgNyuVaEc);yNbU=kKO1@YrH1_G4 z6UE zsHAHzq^G{i5ETm+BwbZ~k0hWs0RT0TEW!JjVB1=Ijp`WR@5&i=a68*aR0;7g zA7p7%A>B>Zg9mog&^@1P0YOKh#gW=Z$H#|JJ8IEWkZe=h$n=xtFiD$RG-+=lYlbMqnaKsBI$bZ6Dcw6L%cNd0!}8Q2y4{3{=z1al)Ei-{P33L`6- z&lJ0y4Fab3^`&le^vaRBU|w-Jljcq`H{F1YadpsMUk8Nsv~9-TT`RX%5+Lx|q^A1m zJ4f0L@NYkhBN?Z2n0+Oe0EHYq%uvHD(u_LrRpuLIs=?nhnR}-!2&kDU@|0?Zi}G6# zkfcn=rZ5!7MK+c;v^oHqr4>9?fP`qHHxa;07||cfi*Q7Hr8&yVnQb2`-aRGs$|{fH zsN_3o!SwA_nk#wF1U>cZ4~|w3+UV)}M3^bzKAtfK+dKUf`cry-14fqDQz=U&{j8+O z7xBhiAp8(&^>K$oAMJPz-@ z!N+|$#8)`ZNJN)5U?4SJgJZ(X7^3vTb6pg-uulBJ&v2Q$ckd$kes1p!#FQzx7PIBn zhsyGta71iK5{+f|j{yT+78qZ}(x)C$k;iqIKscUMaU9bD6P}&*JZCAc&})|AQCHR6 zoIRrLYW?;z=AJnA`UGWSmob&AThlD9LNrC&t7%1UPIe#6apEy4^h0;)z`+A9=tlun z?rUCE;y&A=lmilKxF|qEHHk?=b#?w4@~V7%9C_=Fln?F~w29sj{yy>!{NVvU9g$!Y z{JjEvlLPmD{m~J^n~UGTTiby1wxf~_uHo~QOegoX46f|F_qr$U$NaoBKR>Sk|4PQ0 zF^~(rl)A1`%0iUu0$+8{e)0Zdu@rF4r~S1mKHrs< zWd$eVSz%P>GY0fiMm^T>RckHfI?@y6y_CYd@|!~SU=`9EN?wsSaabx7h$Hb%w5EAk zWUf4TB|M1OD%WqL`w6yT6A*km@&aI&{RQ#QV?L#mDzqxq3{k!NL1xA2fa+V#4LqRODnDp1Cx_j4o;kjeNU@((4 z2ioklT3=twYV@FOn4%qR#Rjc!tJrh32}bfz2>|NH!IWIbr*=I?vPM%ACId%js|& z)#6uH1)By1SXbxD1@{dSQOO)p=u7a9qj?t2TUex{rPjrw)my(&G;!n4I*dC(ntfYlTkM> z6#Ry7s1C;^Ew8Z5z$21+XwG5P%fe?O0bznjbDOC>eV zh-!K5ot>G>4(8B!*Q>ak5epKGKPnm@^Hpmql5fe}uyq>U)MktMqt<*6dQmffL?Zb- zC$t8!*B1PurkGuqEb8VhZf=fzlKz+IaoRu`prieW)?&`PN03O_t`6|?tqil*s=MV-= zqga8peqD-ku|jxo)ucf}upTD@5;DIga9T$bpaG?aYOgLG;OOwlx=bGKzBe(tZBRH5 z$`pWyF@R0VRx%F4@`_m_X6c@n89n%Mm-FR?N3g)hC*6Fdy8glaht*trf+l=u0_|}g zdM5e$#hFjtr}#(tfTx*%>fcGqy{VA?YfY|F5Fxm;+>>uK_{Y2{t?AKt9)GwBNh?Wh zGiVzuDj1Qc_ni;Hsfe!x54+!fc0Qud2_6>G09~TW5p6r&_`3b1*FVzS7+6#9X~kZm z(a!r#rQX5?G{6l$g$0TS-<80ND*1iSKTlF%w%65Lue*EbAFV&aJ%Gr8w)y=M>kVm+ zsE%_7PD?qSzOL`TxfEahAvP`#>;wCK-1M|y*N(U?8S?ezUwPpmES7lPH({}>%MVz9 zum%6Z?QpWsGHp-;_~;q~q^6`FTfCP@lXOQ~ck1Z#?t=RZSKO~MjqEQGN(L-XqvTBP z)YSGMf8)vH;DuxxpYCnL=V`J5KN7?(Akj^wo<}0Cr^Ne@5AM6kF+aa!kRdT`5=1Xz zI;4JaM4*L!+l>~w4?;DJ7Xu!bIDu^rX`Ed2JO>RJh`N4g9k&3Ydf`#v4h*EX9$}Ws z>?FsFODr0c%qzb72(U1DB!Gop?_sss<-Y&Mk)gmRr!I$7;~i<{1{0@_*4LN2HD-ap zRKG_f8e`n#*sE=7QZ{K1rvfSy4VtFz-kZ7$GQzGC?R=diP{^Wn0WB3Buei9~Bw4F1 z$ZAaTuZb|nuYU6>eUBe}J8BIJ9m-15Y7{y`w>C1zk*x|g&Cd)ZlysnimRk|k50f$h zwP&8R8bn(h7`4TTRUoM3s1iwW?YdT`>&Y?PMn(3^^C)mzRsHIt#p>a3Ot#zQ?I~1$yYMCCy+t2;Lj^IO1QKi#gU|K_R;*M zVy%3mbc9yua)2CJgSqW2c$k&6L4~x`xb*gG&!wfB@*gH9HvM7(B?Q|SfS~=dUgqKZ zS1nR%-0_0IF=zH~F@0FHad*#xqF0x@XZmR0{25%+*E2(D1iZJy^%7XfCq z_e&^XSABCH+*c8UdMpqUgBm!{2wh8xfDn}I(w6kui$@mNehFFB<$(|4fG|W55SalH z#Deg|o1S)2j{kh_D$!Hvd8*Vf$KhcyT|VqQl7@Oc~+ zm}!7|Kon~lk>nz}jPBD+0%+ORb@jpPp~s(jr#$TMSj}ekzE*dDOj2emIcO7lBl$M0r{2FE2bE3Ghw0 zjMB);De=+qGEYtw=gdG6ZQzax0wXs4>Z7GL0=Zg{39;uqCB8hL2CMkx2S?jEd2{(D z?nafts26e6@kq27GK{sE*}?!*fcWg(%&_M$$APoR0D5V^(DQpH3V`<68Hv9RCD1{$ zzBkPG0aj^&4zTWv!KxmJD^RDj_EG310Jgk;@<{u4ecc728HzWhAbjtQh{a;*X|-#! zndYCdHan>D_Ui`x>(_Gs{O+B*(TEfxaR66snoY4vAWZPA(Mizu0WagW?c4FyoF^5T^WI2#b2!}_NFJoAwcfaywJ$1DhTAa)1JM6E?Hl#T&S{$J`ih4>)>Q%s zID^t7Wp=`Vedj+bL_t*WZkJI)1sVYdN=Yr-=OjU$kdkSWM+E8%`Q zcd7FVe04FF6$8D2EDZw=M^$7GKa{68{@b2uaNS$CR@ye~*}JzBWElELkMw_k@@{tz z(C-2ukejm#6gwJZj4^d8go<1n|zBotvxH;PEtnj-+&#msf_n z*T$s5Tr@fntRp1TFW)~}{kKmqc&`NA4+rtPCqp`@hkQD+%F%3&37LcqTAQ<_1SFI; ztBg!_Ref>cQT4{L?z#k>2Kc@~LZQ!FRm96Q&TB=Jyv-I#(%Yl4wDRZJuRmDoj-X~3 ztQxv5yKkSb^P?jCy+2{eqGaw9M1eiDTe}f55pVhy{0ol^I|GKj`;gc+m5v;HMUD4G zZDhxh1l!N4(Q52?{1BPYQb@q6R^LWaHH4aB zmISgPP(k8Yohs>Sg!_noUI7E0s0}!R{^rbz;5&Lph9E*)w63c6PaFxSc6sZ#(MnC~#60^a-4&#OR{z zo}|0ZkJvv4>$b0Y{73%@za0_|9SDF+Vi3x92v40i!k`ixJm)lWhhIZ!dcy`=z#xkO zB9ws4P@D2If-)!yu+~*7@T!a?;pyRdgJ%ISo`pW&wR2bU z=!>)0$h#nMs;k$Jh28_$8xfHMBLwd)4D)7YrrS08*;iMB=Xwl^o}0nEWxf5RT)Gc5 zeHwq)HjP{}CHg=p`_60ruQ_%9i>Q*7Uo+F?(DsG_32n{aetuEKSek$68L9tD=UZ_} zye4z|@5IqLettsE{TkC$D#duXsT-vO2M)Fy&~R=;V8j*uy%f_eJJG2iQOGAZ`*n{3is)!H8va#??z+|}3w!6|Ooqm&~q?$5PH zLJH1Uo^S8pBRm6X_R&Y3Aiw-@saj@_k;-F7b=j#4v3DO2Z?R7qw7~orVr)s#>rH_Y zsN~b24awu&krBxN3G~LZs+a(Ra#dz#LeIv}&f2k27|U55B)3_&E@`i#AHBT@gU|)F zgSxhjge+eA;_H=>N7dotM*@zSD_YnrFM)Ts7=NdW3VHS|3ue)vgw(7gf z-S~%?5!2=v45r$z^z2j5tHB#vdbe!q-|tQQR00pNSD!B*ou`$bk)@}%3tsM$ax?kk#&;hlw-Z-yQ*iwEQ5m;5c+VG|oX^w=y+>qQ?CvvyrF zmzCGRtLg4Nd#7Ms?b@}|V*~^xlc%&4Kr#24t66@jOz$3le#q*;z(R{!QXnMAtt1-P z$l2fxouX?Sp=rPi3IR95bCOfIQCeSL^ByyEQp+mg+zj4=rt&`HEjWmz*r4}1Fn|20 zB0>Wuc1NLm&y)a#Hl4okum=G#c}OcR;^|66Ckt8yY?_NeLP93AXJHA-D?oS^{s1YkRx~Axp6ZKB z8}cw&Z!^)@$`miJvP?YmteHfzvneugvc*duewl!O+Nx!3TfPy4f80(>BL{jg(bdouJ0nVOmkOw0>cSAqznH0EcGH(B!zd=aIjI@rj! z$53OwEH}Thmn#`}Q44|0q30D%E`3;6z`>3%T=1QOX;;yG`r?s2oN(2KL6!w0k?!KS zp9u3S$Kxj+wmxI$u3h1HG)?vB@nfC5$xwCwK7MR3-$wHFCH=aPunr_%SlEppG)?vS zSMDe?mRs3>XzoJbOhYPj+~WF7B=9$1*~e8RWKOkCwsf`e`ZI=(07un%ZQE-Bz4mDD z#R8y^So^tEhw)dzZAEhB66*SDG8~T|!=5(atuTU1d^A<6HJSBh(*6ToBr+~Yi7ZLM znk@ziwZ)=d$zQmo6^UwDaBmLb5d`b8T^y#r8gQ?GR#jCeHC~g&HU|e9P7YA~f&$ev zzSeT$qW^%8z-hw)rc(ctt{px&rjl|F2JKFwTUIF)mLu!g~ z%K-Mc(Nm9zfPr>W)6~wI04HrZ{*JSlN0H zWmDwvU78GV_T^vv=+Lg<2Ojum((0W%EFjht_H&Bk^x&9w-I4Q-?krnJ7x5R%VSz3Q zYvH`D{IYo(G_IdI15xAA6zc!PgOcp)?(^lFc0JqnastwQ36GH{1tnmUQBG~2aQ(mm z-#|7{1h)=2a0MO9jg$;fx{n@rkG}8e=a(~St+iM20@*|!faw6&^q}@0SOdW5Z6c3a zG_udT=mit$=vd%`x{)T$byCzRr9e0eR524EtZUkU4Q@11t;b43u&LR)zM%1%p^p$p z9ZPr%V$i`(E>Et+kuNs;q6LUAR!n{^FzHDEsJT9(=67uRa!Q;BEmO8}x@Ycn=&S77 z-GhOY`?1GyxJClZ4SSD*0Vy6m!jbqmFGWLVXa=VQYI84z`8BR9ynA;D2EKFLg{%MU ztE;h?G5#)?ggGxSnvQr+LIA2xN*<b9WK%CHQ!P>T-eHI8rFDc2m zSKQh_2^$C=Fy)H@usG!;zfeV)+Q-__;yIq~4Ym^m5EzKWCPF7AM8XoJwxLx2P^4CS z#q2+@ulk$!u_vI!NZ1BPRlLfo&G#6fQ23R$rz7KZn$ZRFaGO+{BQVFUY|7V0M%#qh z+C9}69hoI`#WU%UwXz#9Ie8eHq?D@jsM8yEd}_v4B{GUTnl_9kJQw*R&-&!Q9#3C* zK=WHsUd2F(Oo8g#75O#l$|j-S5Rjj>=`}gMReg zc_bGJOOOTd9^78FC!iFGc&BT-SvBr)A=IbJKEh8l@7FPR%jxz8RJH{EH|*O^HvwS~ z6`@njX+X%E>?gzn>~yyo`QvbxAf0NipLJaywM~ss zb)|#GcYoe^`M^Ns(IfhPmJH2-pC>~i&r_7+d-k;velt8GTW{sMZa0ws@F&TmE0rP* zRYM5reShb*10o=cp3Kb6R=@jFqkT8ed*lHS(aD+VB1nYm%;NCAkSY#uB z4;OWhVI6JKsiUzb^6fGTe9Y(GI(bR71k7} z_h>7#c?Y3Vb6ynT_J_k}GT@zB)ZRF6DBv%E4kiE&GbGGieKu&NjQc`0(TnPQq$(1agXSo-b)b5&FN?eR0?yl(F1Yh z=pdcQI(Ps9U?BpACfiIT3;FAMV0?BGcl>o; zCT$BF#^^$_44vwpwNo^x@6|)Igt}MI_F(L8&;m;_-%L-z;ZIuN@{Lg896318s%d*{ zuVK2k^Q@C!v%xG2L<92=w9SikOvuuE;lVkP^5(XZqP-Q&>2wTjAq3pUUDb(JS9kgg zY8@B|J0bY{o_CkvAHTXxf<|o>0Rpv~y7t6)iYx~@WYD9M-te?+lkYJ(H#^gVfSRbsK3%%cpn8F`iqsH^ z5(4VIO*e0@RQnI^@79V!c2?S^3@GfTQj-r7lA9(8l+?6Tv*89(C8Ra8g3-f7MpFzD z67n>;Afd*v5+AUMG#tl~Evpz!^O4tFb;)z-H&JgXew|lZJog&_{((8Go9dE9I@!?^ z=UQqYX%kw0&N{(qcoNtE_F-ZY%R+<%iHEv&QKf!nz(4cO>GxbUtkYDtR`Bsu3UCvF zIO=_Z3iW$s^XJUP9(W@5&*}TEhdjnD)geenH^sqQ5~XQC+e;#*Y|Ler;USJ5<~$G0dZ+;;*%gszCb?>rTu+sgBBVX z%Q%OyapE`xjzuI;i-+yQy35~~c*nlu*HIgga_GK@uQuAWDf-iY{hv`wu+bUYizGM~ zqGzdFH1G-}EGl%L9uS3?3ceiN#u^wK@E*UEJP$eebP-2T*YAfxeDu;Q<4c2rI@6K! z;!6XGaFp#s50GF)q3_D_dJ=8^^ev++j_I^^1uVC174IhGj^veAoBac97 zEpRN}eeGcIeQh0i$gnH6{jhiMJ~48h`PKcmpIHzS(9?KY)+VYieT0{n80+yeLfM6q zlDW~0QQCi?^V;{f_OP@$EdQDS$%YZ zxmT2+A*o_2{r;YEgAF;pnyO$hN#>v*Q3chdfTCa?xtzXd2NugmaSs4K+ji7f%Gl!!s)a`$^sZO% zg(J?+dK|~W@QKD=xG|xji3k8pb?4TtTT$57YHclkug3r>;+!_j4x{DcN`y79FW;@| zpZu#30PO5Y4y2%scgnzt>(0*341!*~>XbSJx&}Ky0=)bvx{5jh&_k!7!vR=c1GS!!5RuTB3>`>Iuo6=U2Bu(NB3{Uu5H%VBrNI{lgJF`Uq5V-!^09(m za$Ivv@Qik@3A4T}QdbMRc6&#L({eM@vx&0!%<~w;0`M8RZ3C;RO)oF*7`z~pIxGwA zTI8~Epb?I5mWl4`A}<+FLO<&tKfg#*R<4D2Uq1k!#Xz8D#h4?{Yisx}OzT-^$QV73 zk2UK7EDZ=K>)lf5j(@DZCP2@P2XYS_*kAqT54qr)Bk}>hn0MaDW(3)+}vFCfBneE7yvb?1&fwMHi#X9EK(hS$lL?0!rFUu>yp{x$AMuL1p3^>wox;JzuC z0Z-Ewx>mQE3DmuCwF9QZW~Z`npqs$he!=;$!OuPnq|NJVsuBB(MHP zH*w(6{IpGYZKH_=p1^TS3mU#J9NABvTG@E~BoUvIqg&(BIuFJGFI+-CxB&DqUZ>S52*~#=rVFKy2TF_ktSk^P?uEIX=~uL8(0&JTudEo+roB zVgG1wSNBpMQMhAkH`YG080m8Z9*RUkYTylPKlO6da3cAX(qm-}5d|Z~EzoAVYvIsN zXrK^^WjI0%9>wic0tE@8tV#|rymSL>QVFmx_8hb)6TS7B$h2d}&H?u|>GU_(NTAc^ z96cO+laXT4iR_GSPDZm7lMsw4@-9eBELHB7jyG*gT5SW1ILTu0$a)9v_B;k@WmKzQ zXs8;ML2dNDzH~1s@8s`3z3O`l4i9r)=$trJy37j8f#hwY3Msy@=GZ8G1{Y@24-^F9vH)9NPhOeDys9G|>fX z*|+aN_5XcpJo;ps=E>>r9%v?FDhrd`U1@sYhy%d6yVnwVNYQAJFl&7w?u|yq$)xT| zltC+J)D(0tTNLOCQup%jBYi5Um`npbjbDDS!~m;}cNI;T{xEoC>Vzxm4#9{hBiK~S zz@stG-k#L`fjG_1&8n;Z{QaeB?cqZvK!OHr)3rt}#a+6dlaw@?E~+qHdUImH3eAKu zG{thw2wr*ZSXfx_UN~L9+`4^RV}Gk38ZeG~{)aCv>huFOkE8Vd$;Ik}lMB_F2LjOb zMRF~e5Z>!Y6bIgUUwsF>q=~uq*74_ux5lFYz;I>GDCzM{l{%uCu2$aTE-M$Fr`g#X~-b z;?lP5Q`NT@S0cj~@bnB!6cp0Jgd@9%@M8g+o>`}IhzxggD z^sK%1iiwi?7lD5hlSQk>m^3$le`)FWBTr4EZ+OB@_5N%736DTpuI8C}>}g*bT**nz zm(j~nTsuF0`>3=&v3 zxa_86@#>f3SNIYJukN`Cc&f8Xzdx$SvPI2zQ|zCH6YPys#hFwO3G zumi*{4Z%YEvOre)@-5MmC6LZ*TS9=e5u%=|>uT|^1pw;=0F3K>cX2sv2VqPjezeS} zY=2BzZR^;c5h_@M0>Z-ezLe!MdzmQABdYw;(q2N`u$%z{VQ>nm=>tveopMwunb#K8 zz!B>hfuNxFZu@I%t0$a+{8h0QQah<$iN~UuR0G&%oA?l z>;CT9v#0&+?*H@pY}8$HY2DY3rk=6Vk>@>o_Ex|9{332GyMAe~Fh2{$b2!Rv z(&>hLc`~^T>EsLZ<=i5f_wV0dJp|DiePbUV2af3mf6@m=?ql?^Id!V@i$80S5T&^} zdT(U_K)p_)QvFQ8z4D|t>P$L$6nmR-27JRE<()XVCjoo;G~)C(Cc5x40}KjCEB91& zk-wry=oQ!uI$>p*1{`K)=J+GQ8GTsZ1AQlaFTh@zw__OVBDYi0@;^5B?e!^k*q{Kw zAH98a*e{wrRcLE!#|i@y1^~QGf__n52I%k~owLDA=t>EVlBM9vI?(F*iYYHbw9wfY3L3FW$LTPInYCP zL;wt}XraRf_cqk>Nc%;-%p(srx&numdNsks$M3PG+^Y}VcdENPl8*eG)J69MHeJp! z?`UwhkL56%7r2eC(z=4srm=t=^LiHjfN@>lMF6GPUv|Hc3Oeq!254PZhxXy)ropeD z5$N;X#hd=6hbb4)@ZZ81Q{E@hSl~cN9vEQD!D1W$SdXT+c*u=IK#c{FwW*FG^7e~0 zB6I(q|6)XIK?j0%^E3tWm?|vLz~LjickdpQiLDymAD98oMMaoZ+@|T->FSTC%-w^a zlqPV5I-rOpImvqqa|XpF1Nd2B`k&x^d4Yg}Af-3A`H9i(b; zN;a)gW^pPvu>1-|lK5?E{#t;&q6$G(a((o7aCX3;4&Z>foZX?ML6tZS0#5w=y$*b$ zfI;KQtxJsY9A%22-l+K^GT~~0Z_S7?(t!ZR^UtOgB5Lm03-#$y z`ne#x4aA`W_0&iW_@WylHK2n^vEF{+vm}ylV?Z|5EO!d1myxS zBrJ9I{7S){n;bY5rjxHcH#l(EJ|MlWqV&y0e||?T$WiLz@#bi*i7{gkJ?&g0=p}t3 z(ewK<<{{`3&%=x@XTN#?`3sBPJMHn4C$J5so*xDB?& zo4UHb9Bx()?Q_58KYZ{Y2qrPyRbx9QqB$HDj3$$_CBZNG_9HmwXvoI%cb<}-erqY(6Lob&V1UW;L4!B~@5J$P4`{4l|QzR4$XE=SLX>7m!ne%Tim4+Oy}ToKxuJ$7VY5GA|Y3Au5l`6K<%3}4qC zu18}jz5Bq+W_aGvnqOO^ zYD#VM(B<=2h&y|Lp_hImT^_=c_84kFGp)4r+=4RlE|ALyqXw~39^1BUA3lG5{stgt zE0=q+Y=Pjd);p!HmRj$?Ja3kkFL7)Sv9@5Kec7D)+6F7B%0Va4kH?Z0?oGohDXqAo=V^b8#|%bX#QN6|LRz z>AI@^@MqtP4~>VM!u6IvPxTcf#o|6BGoM&n`7-3Rhk{X2(YiqA=F5?i*9P(_*MDJk znvNbQ96L7pwusW!V~+dgueXt-AX8-+%nm04(&AZ>fFU2bWgpnP1}Bg{ITL$)sLcaZ z4So5+fW1-PgGyjeOY9f#AFEbYxTC)^jj_PkDdUkBRr~pSN2}!(+Uw`5#PhEV)ax>6 zBP&1Qh^DwGWxkgh^J8eF5@7F-9D01kkKgK|QJd5r&&B9Y_b+!xSCqn|xd1jQLYxI7 zo&h5Z84L1Q78qFL`wGkP&g)0ozIycNaa6S{KRrDif{S;J^=m+UY z4%pA$Jn206Tza~(5%r6EwsotCI_zeKwa?erA5~Lv`#Yn!EjHxM%uLglwgz@i_zS&X zzV%m#-FE_q3K*Tjt6x=H+J?9Wbd3&K`~2->a(5ASpr8doU0JJ9>_1(JxXCqY955#B zLUB{Cu8tZvRS$W+aAgGs9XVoyhcHGey2H-z7xGxyaQxEArQfUuVMn^*^UEb&&`&mV z^zzt&VWK>VTzfUZ)b{P$tFzx-k0%@HGw|Y(aB;XhC~00BzFcubqm%|^>F0|-jrw%= zZXa0c~C2AtxYOXo8m|Y@H%#TPF^yny(vC9x+gcK z(y9DaB;A-P1N@e6fsJG@=z>Ye;XTIp{!M5WC-)Ae>2&LnmnI(ki#)p``w9xeCgt}9vxv@f2lsTeeOoTse_&xBwbys0tF3SMS~7iXwxw zPPehZx<&@~z6E3yxFfZgZOw>6-@AuBnRk(QJ)kYQ4=$Fm9soeU*x7Hdv$DK+B=Tt3 zA_IUCW3Q^$r)*uW|N3@JZx7};=M4yat$a2rStvQ=`tn16t-a6#f%+IFTjXNV`q2ug z#s;Hy*wg`z-LE5*TolnRfKjKnKl$R+5P!b|r zM=)N!*oJr&r5~@C7vB;6P~<=rxJHC`+d=+Rd)C522IvWS`C z_kiiBK+~}R{C3lQB)F-nP6JgzE=NlMr}DLzZ_#t0fs%&A4SGxoNJEs~IlkCFy=%a| zh(Vtj`%h6~gzKjn5-n)NK#yO%)1NvdFKv6WNpsq4HUd)4eT!#Lr zKOg>z#^SmR2K*%Es1MljLIVB`R)EKj90-oYu3N7_1Tq5eOOtNi3V)zNQa4asKraRa zQ-Tc82v=hNNCE)EXU`p22ud1Ij~~OBuGhAHxayC8{l7QV#qF)@U|m%=mhS}l`}gdC z(K4r|O!+SF+D&w1*!u92l0|;(1uPyL5zp!%E80jupp8iH7Xwew9Necd;$;{WpK_OEe2GM9Plo< zw_sI{0X^WDVD5?rA>DyHcY5A=1`utLc~B4>wPtzsuKuQ9zHEU-CqpJ&21L;Spg8;Z ziwE1k-7gTifmw&u!03o{=kgBBwr5`oD&(OPApQzM!gWn%UJhHUB`M@(GvAvN|c42eQJgvZRV;F?^z0x zHAQ`@0P|RS0w4v(oCB!n60v|yHW*Io3y$V+>{sZOhO3(}3O^Hb90GC_Sm=F5O|jGt zx4<7x20t+OASU#o3QK!ssuj>b&KY+aC7`_9ArL!qyE zcLdt(388>e~s1EPn6#!Ggkz$Wo64^Bd z2B~>gQ>vz})}u?w?L9y@BINquUJF!)eU$>Xu5GT5f`$wyu%n*y{_Wezted81Os### zHYL&xTV(wNK>{%I`w#91M*EKWzE9kwO;pvT8}3)BBZqp>jciv85XzBuQWCBo{o~JZ zx_9qxa6h13lB{>4&on8Pu8}uiH32lb^u@U=^z>xFSXuz0tnfyhp57iFx8;oaWIm;9 znt%U;@nofoGmvo3QQFPAu;}gK2=GGT&NEoyE|Y9W#=Nl^O;vsLW*2So_kWHevl8>6 z$!rIJO1+0U8#k|hut#V{f`vJYn*s~D%@M924x^$UFq+45#rt&%ES$vgW98O!BFB#f z{Uo%-a5;71AqD|Gg_5dRpn#zs)+DFj_>E=>P^h&Cz@AF3q)dQX7TH1>6wLILg_0s6 znUlC`CNUHmBH7-0If8MWjl!5>h!IfNI~JvHvv5_mrr$M-rQ|Q z>S3QT(lg4s$#zhf2$4ESIin7tdM1`p_ui}6K%hQNaaUb)*TNp-97& zC~+X!kAC^T4xwyqkd4@*VR|@%>GDn4&CRF4$f>Jo?`|y%pgrBNv;+3uN5V+4$7v%T zDGB3&IF;1D+D0%2JUtTo_oPROIv%0>R1HCflpYr#A*LAyDygf@zMrVJbsmC!ZempV zUMZ=>(ZeWtz+3Yz3;+eS!%6)U;CM^qV6!S8LS#@$;_{o#Ue7^*| zW&V6T5`P}B1z8%%`)JqB?ii~{UwnO;kxxE~%S++rzSJAZy@UZBDrN$?_~>#H*1#R{ z&YWBRe6UA{*Ve+L!{q$!E6>i%v^x3IQ=wPh$(Ik%(Ws;EkJh7kOD+5U??M}CxT@CI z)}XGMHae+ks^5PR%7j&S%`@c^x<8g=s34{tH{y%tK2l6j=mRxboerj}QnkkE%DiP! z*oQ%NYA;YU!r70th4>O`VT<{ffrO=rfMq6cu@P0r0((lMU?dIFOlu|u?CIMv4g}$d zPsm#@uad65!ZRqxQ%^tZ(vm-V>u7tYI_@r>G4hW3)47{UP*1~6KY(;lk+DFY0O*O+ zj2j&d_|Rm{p{za>=atUjXUU67SW6GIOdUw3(+9%z*Y4v;d5XG4WX0 z9`#XSptCa9qojk|U?!>o@Bt>S0_uApNif$M*{e6_J*$_o}OE!$#iqOVo8AS!Ad({CWB`cD?Q% zPMPxkU2K*{T+SI92x{}cd2~DsW6F!V8~tq94^?E@uQ#!ylLE2ZE|O2hp7<9Cj>e8V3En^Eoh)0rC@$wWGI z@d8j#svl+X^S5vM#JL!g@vz|e*g0uYS^mt=Ew$J~4e0Jf2Nf#nhdIV`<8 z0K|~={-?nUaL5J$VkmM6CZXuRsIPcQQBa(;#?D3P=%)mPJMlq zOQq9qp0B;X%bzC?bZ2rE%LcXucnmsxB6NmW;foyX1dL(sD z0gbFrmWbYLqq-rt@(4gi1?)A?7}!(6c0U-X7Z>5S`sD#7S>jv`_>HclGbVG>_&fD% z`%C8%o~as93;=lR)~)=Cpu*XU{k1Wg?jV4qvJRvHJ$NC%roN^u2Rd-}wUCp0=bWy? zah;swwk$Ow$N|9?WS7j|eteaHp-LEdx0Z_ubtL$}w7#f`gb zZwU6$eg63Iqkv@n?$7?iPI^y;j3Kbb0&~dP z2Ggx4j!AuYfa8(fabg)vLf%c(kyy?+WerDkeA9vzQTCyI@eyYkKs9BQxEYRE%NVEO z42dj45NtXUObe8OLPQ0|A^_tVq7h68&p@1P7eYJbH4JOhhdp!7+#n645Ce_nv zkNP&%C;d@gHD06veaRG!Z8l(-3HF84x>#=6b6HKPfVuy%9!WR5!(pM^R&=kUX9ILf zI!~&f$DW>lf4x9q^knQXP)RUqwWf?s@4dEvj1WWmKkhyd}Ym zLNH7XUa6xfOAsMb3whgQ1BqGaWuNT>t@-uC=gp|~D}q(ST0rHLyjc*6Uu-gUu70D` z8+gI!c$e!wEfA~*xiulSqvNxr<|NTWP=oWPi^|cfl>z{1dJXGo*|>ipporz8OEv^w zMza>&3+Rt^e6-i(xl@c$c`r=`!ukO#h0{~Fw@bc_U8vn?~;zNVl`Ah^k2bH1$+V`EnQ^6c=Lb+7<@x5 zo!7(kqEcP+ZpHws3-v|RCS?lD%Wl$>Wn=MTlbzfo1Ph?9?%g$kReY+^3d!9kcpanq z#V%+Ao*^j@l6hK}X@Wnmw|i@RxM0-=CD8Q2FlPb|P(q*ryr(YRxwAR|fu=9tKex*|HAkdrXb;^JB_ATkvjVdQAln|51jJSxKwWvPOhwPe7I#n1nqESFwkR(fk zoV@+&!DzW;_y&qsNK7aZH0Ne#tKWWh-Y*z_67*)sBdjlO-rytjKDF;ll>k~ssdS|Q zO#;$%eMx>|btdmpHBjikAZe;X%G3EJ^+|nR`p)vwd#@dUoAA&4d)HXoY6NpzKi4RX zzNxCyFM%I0P(}uSM*gx^MAkqy5xK(c+s=jzzZw!CkE4X~zDSaUTMCns$bD)(k zuN}T8k-nzVK<61owKY1A>Lc|ala$%2Vsi!KP|Qn}DgF8->S~gz8nk()V@KRF5C|U>`bSjQeY9bF+&i=|{{Q+)V?c9`79od&f?m#DM4l zDP~_AR2e2=*9aHg*JrvJ=Euzj1Y26|2mk1?H{+Z17P|Gdb;q~vF6=i?Ojzb?2m~Ae zu`bdd=)I^Mo`aoPNOf3m=Gci)$2aF8ng)e)lj24T2*yQ_S)1d{fI!MF9op}XEBk47 zZnpaNqTOJ3PY>^(?|$uwjw#Rgk$+nkRxfQl*$6Ee1IQ#(FjShU{bnIJwBR7TM6}d1 z{x};muJ26*&h{H*4+`o)M_+H48pZ=KJo*bKqL5WX2Cp3LJUi(1-Y=;B50%b+w@h|G zI6H`!8A1E>U(8)Pb@d_{n1qu)EK+OU{$@@RVme_RSNm=C&g}pQwCUWX&_JlO!JtTq zvoCa%f&2bh0*0`DgwoniEbu`$>Y0Frh|C~%X+&hpN}78?S1IQQq}lb`Pu@9Nt*xyo zrSk!lLa>lkrf3s|9^twyhKGfS7zrEqp(AskV6^lm{pnnPXP%aj%D|N# zq@~VXxZ^z)C$pGEvn%W|q1|G&;k#~pM-;-f3guVxSG=$IaTVlZ>1*1=?no4KWWxQ% zdT*8RE<64zSMhaRwvteD!qbyf+GTvRU(?!t7sf4l#nJk!!ka(JRYCM_Won z!kfmP_K|)Equr;s`7{LlB7@ArD##VIGl@-5f<8z=$E5wUyy6+S9{IfsJKM;^-H~jM zS|Wno`i943JB}T=6bM9msktxaK0yPP4jt%uzzv1qi@HwxW#C(9x$#0^keW9GSPJeQ zOe(oCf;KW1(n*ExY4pYe3DUDwqV3Yr4CcB8#d zu;Mq8d8P9KDc^@{|sFo24&A6uw z=%!0u-LEb@U%3#ynupewO&(DoUX!Qmlc$0DK>ZR3!4z$(!@U=uO&d?2 zq^3iiy8JwT)H{87X_NBUMn< z;8a~#Plw3HA#&&<8`ss1Ze#1zbYHDj2^|y^q z3|?@^RDoVVab9Gkaunrc!M2hM%K5g~dkZaXNS+-Jo;T{NU^vjG!mpoZrKPC544J-i zroV2E+bkdSvkU!kA4Qppyy>@M`}Fo!F@5#TH3G+o=MiqiD@XUWf1jB92Zpsw&vRzE zS37s^3|@3!oV}ut!0fHSqN&ZUU0dMU-({#-(q;7hV#GYvP{Ru|ON6i{y{0v5PQ_Fo z#Rryn%R9=8Dzr0RH@rcHi|DSMCsWV-?rP-i1BY@BVZlkFQ$xoVQo_uGiFf z_qEOwDN7pV+N3-wbD5mE7y@8f{qT%{z4D~8th8`WKJN_B^ZNqzWRkH}qo|W>fRjZ_ zK!TW{GunUj_OW($-d??}s*7$VYS2+yg&{<<0>+v^E_VfeKY$5QSKT*dqr6!NMuv6r z!AN{{R0(@d+emcn+~xuhDC*}{6C<-~_?GK5?!LMVn2n$JFiU$+9-yJUgH5K|e*=pU z>WMoyxwV)5tBRMFMUrxT3@HvQ^RP>b`5FT=4$$n zl0G8ZiaIwWkr`z&-HkuW{dIml6&LUf~9Vi&~ z3R3O+_U`K389iZEZW%AJF0I~um~3JfcFuM=mQWpgjd?~w-QD>Wd&|^=&U4Zn+}B4{ zsjC4n^Z`HwTKSCwSZjzy7=fvcLyJsz-<~_zMF+Kga(ReM9D@((oqZ6yaZL2DM#AzA z@bfIa)A8;;!h^T{y@f6v-k*BT)XgS;^pOMzu(0ucohX=#eb^Rd@SkB$fx7)N;$OW0 zg+o1M*Xe_MZk?DkzhfSFhj{f9{@t?^FF!Zroc`ttd9NYa>wVko4*{kRA3t*5mvLoU z_t(|kyZ46T1`G_8u84U={Y@nXM9RI(u&W6dn}TQjpx3y$>uQ*jRKE~!bl!nrA6gf5V)wCuH2ua-BufptKLFf1CHjnAH9r8b zH|!w`>Xs8$aKoE#DJz?4QZrxfBEE#NH%9UjF--c=TSwbUw<7S5>s|`Toah~TV)W92 z-b&<_X)q>gnk|ycmD!sYS|wM)pO}wfj+Qqnr>qN$rEgm`_&&PN%JhMBpE+Wo$W%U! zWht9;5+~fm3G}u9S@-%9WtO{GuMa5x)AY@W2FB=8c24%v z2ipzr6GYaWZZZyBhQecS4?Rc<+}<1i6S<|z2LRKr#CvrB90=K95Eb`f%hs*Q6;yZb z_CE*%;1Inor#8KuEy3ef@4~LxpdHrmXp*C(KGaxM8}`!2y6(IOZKa_zO~ZRy6o6y)^*wm>^y!Az zNi`2w*naCjJl$}h$;|X@Hx>bK(oNd11+L$^Z`e8t00NC|)9_x98VmTV7*)b3v6Y1*$7HHjvW~bkY{!!p$A$3`Uf#}sG?!64xY4`uV z2PVizt@gIE!2Ql4Ixq(Qr1bTL?#{2J!`-??0Ih$0B?q$Z+}Q=Y_~P80i zT>#&5KtoOPi}ek`8&nQ-^XF_@mkUmtK8SyOpaB5?xqtsFo8Z}FTsL@?5OOE}$LbAh z24ILHY&WHVVVCjebJwd^mt52>{q>9f{j=#)mjx#`C{HkEeq6Ah)X~iw3>Kcb5b9%+ zidRl$ybVK(ASxCGO^L(>nOgyzY_9J5!wfGy^&ALA;tBBY=n&}Vbqve8DE+m2>rtF^ za*t0n_D(6HUEEmO_%KOOAIZKh+n~%SUDtiEjA*aK&_j2JpKZZEUT$78xLJ;hPz3dD z4ojwO9t8qxWDc@&nfUS&bs5#=oJK}0G!anZo(HCXUe%z0QvTq_n7)qZtR_>5_lH6a zIIfH)7CXWFoIPZ;y_H0mC3Kf|KjadjLzp=k9>cd2v{dindaw_`kFR6&Zop%(V;j|6 zk>1rN2x^E7_1DKG3YOMg-R)Iz;KW9brZRwsvEWTaVzb(|eOnL#w|nH#C+Are%|q(l z>6cIEO;CLh+N%Tjb4~ZLG#|(`K}zmDSSQvgcweTas``zO|EJ`q=)f$C_y56D&k%EH zM#>o6ALvNe1peZ_Y~QwB+_kK%rUnU$J{-0#ezBmPf4-;cd@@iaOkh3kGy%1 z(Ut_XV(SvevXf%eczA8@HxV*O5pOtH>4tJUcFqqb_T$I4&%!jl-QBl%<}cSss>ye? zah%R$u@s?q)IkrVzG8tIr09A#!zRolpRl^_+is$2Vr%E^}xW^sehqH7Vlg1o-s z`-9T)-Itk}?%nc-FD~XtsauE2Ir-|*U24Am;}Ihnbg87H78dqY|41I=jkP2BP?9LW zjJNhtZS2*DX}aUrIZ4;J+1XiG?Q+Q zXv+99#`ze@H3T$w2x-`4*9FAzktPlG0=^P3#vK`x_%>Db{+mnHBO72aN?(3+vj`eP zhHF?rOOXfkxN_>d^U6>+rZQR&nzgBID=rit^K2%q>&Sl6&GvLW2w}&J2c?M>fSArJ z5VV)+g6#LgP%@q`IqxIHl?EWCOsZd&p5GgMf6@lPjLF!jvmuS^H(ekiZ66r#zUYYq z02_O(7PW)|yO?y_6i0TW{zuf~Hf^cheSK*a)SE45 zLU4)~EI8!XCqFa*U~D&Pz>(o1Kix{hA^~7z0TAuLCW4qcy6Idb3T_CTekX#Mb9{WjIcp z5k*w(?h=n1ZWAU)^s!RDBZn3`?@LH|n2hN|i06PY%IpIPFhumU_gs=?eSQR30Q-Ug zoObNk5xfe{{KbzVOv!+B1TKT*mXoeeNYJntMPUR?rf>OOn^;fg*VcoE_`%7S4u}^L zJ^~l$a{3R+q*4cr3?zRdf6pEhaK!*XX^(JmUW0wWd&^e5UiuR3T*cWZg=5T>!y(y-HrkZk4QRpYRkL2;B z$57T8^zWe6(Urr&8VKHM9=cf+f3$oX0{G+a5ypeLe47ZCfQq@Us59ZNcI}DpNMJ2u;SDM|Cozs70l1gc!HrVtVcN7OnOzi zKlT_=fWrF5ti5v(Uc3f4Hp7uc|LANN#n`XlUM6;MO!<9#e8Zr2fS_Ns1%sR{x9_=r zvWDF5U9&+G%oC&2YTvE53kO>@-kplxX==Y}|2bSVL*U9#obK+tXa>YU5{jHVZM_QX zs(SA5o`KiZ!8=d@Am|IQqOb8(BkUM>mfF=dPoF!u8?zzjN)rThG5>FDbn~UVV-g#m zp*MCoNI@H#Jg`RGH#hN-Ja-2qrX6OoubEySqTmXy>pdsnCS9KW?5ghFcfVE`FfhDh zkna>)#=b5Zl12vtU^^Ko-J~GD(+h_Lfe*^fp4W%U$rEMiFM@w_sgJF%vQRQ=PRI}p&kk6eL9FI7%tWB?X|w*spqFkq;;KhGRf zzFWPvQ~&~cdV<{Zh}m^I1JOQ-Avf75$WczV9*HPq)W>74svu=5N%mn!F&c5Kv5&^0d51H*9YBlLpZK%ppv-NV%N*V~;t0QhSh@P|m-LL>`8 z?%?=aPGS{>h8|u6vi{NSH`wRUhE~><)F>=QuXi|d=)J8SB5WsEza z`_f18H*w#yCQg-gAGX{3{k-z=S^QfjA~D$yp;@wbVFw#|bh8bGMa!IaPki(<{Sx%S z;OU4GFsMCGMr*WF03f6X#*X34)QjdCVbnc$FbwJ479|aykX+{pD37C~3FN}ena4F* zuGaLE{Tr`KFu+L8x%v4v*F*tEYsGrc+8KZDyBkzfNSVo}vDgalEL92?1nx1BDkY0b z4Bc^GxLk{)RZH`b%S!txhbx|_b@kE_`qwk)(Ko0cNtXV3QCB$tPG35keAfzL3N7s3 zqXz(M{c%(bgz0EonfEO0X*UqR|AIcwD-#n-sGlTdh)Jwl9D(LG?9MmgrWC5s05X%BTG622gL7AkikuP?8DbSQx zH#Dy&1n6mbi$-EDUmYFS+JZiAy{$^;gX0bXl}s=%Z*uP!dl^#>@aUZ*;`IY+@s%`5eDfo`$I`@^(ls|Ey}NM)iPr*-wyUjL&=A{5f? z9zAP^uUp5WKn0|85(Vu@?tL_g@C3C#@Jwx;>hU!bBiqnC{@aC+HxyF)s*UPO9$yW^lPYS9<1ax4*?>;hhgfRRnN1UsiuBr?*C9LX-OTkKsZv=hinZo`@!=qyzRXD?C# zPjE{}z%W_clz`l?$)Jyz;3lYEHzed%m5>P}Sft2Y3OA?OBy!gT$+?_o76HoOk?5B7 zEv%~+Ka*#HywXghv$e7b`vuQFC`(#-Q4woHWpbH7RMq_Do6^YUKYDHF^mXa12JgEG z0*_ez=5&m}Lrse7A98c4U?TN9^PKHxsbPFw_0$e(6t3+E0L&W_c@E{I_*5aom`(QH zJL5p*V<_Rhd+}Tk=OwzA65sFY@-{Y}RIB&aTORvOP}r#WMjJ>L^tGthn+QwCZHVcR z9@Wg;ZB&MQs3Y0g6Z8>!gX-o`y>#N|AP7kMi+l+E(H;T%yUQZ53K~suT>x;!<-}j) zk+(sb(ZX(&Obnf_ip$(>?hf=oCX!D7(Un66V;E&Qq)`vveD>k>_=-bKNQ`pEytue85h}#yWagdcZe5-E=Bg~Vc2W}ZYU?FjgbN>E zeSrx~AnGpXvHRyUmq7nz4IstbqlX`bS$bgWr6c`OelFmLB6UBB@bc|m*xkPGK0W1o zyYc)^zI;fWLXW|<3Yvb`=mF_LI@e^P3kwUG9)IjxGbbZsK5FM$^}VcVzB;3e^#WuR zpPXl*N{oN@pk67U7uA{=pjSO3KyUMV2K4mxQX94uAZyBcg*2kIw9Dj`0+rAe%MJc! z447APEO@Ak*o^6Ot_VMy)u7P?)^wTYO(A&5R7)VmoPKM@0f6LqX9JJQIX-ysjENf^ zAU!Jf(A!Eqhw}g;Kp^F-VO_!_4!}W{V@kO&wF1{zcTjUQ&ELOgXHwcl`}JlekQ3kM z*f`n2nuz=1zKOWYtO5Clq;%d5+8e$CFiA&?ccQh_0n+z0OlF7 zX_?>&Q58hN)s|Om-c^AV29zQ#YmXQYMFXrVlr;o9YFdT?puj;+pivRT0C7MP*(RH| zL`HF+woaM5@apR3@*N%_g1MXl!L+*+Xy7Eu;t|sW;2}Zo;NBfs(V?Aqe8g;4z5ysC z_%dWnfE$f*Ilse1`E^U(fPgj%a48IvAaDYq#e>#E%+<>QMt1CQ_j&nY-tqjS#z`uX zEPg=Qu1mx+?F{2-YtonJE?38%V~)^LAfA`CYiHL7R+oQq_EP@@o)6b#5d}4~f}y4Y z4RdFnH(|1|AE82BRWC;XCHw&>Lx%=WM(8idA&M1cGZ%I*RBL^7HVsD;Y5osiUP#w+ zxny20N3*m)zHhKFv+h4zu<&0Zs8?#B{t%!ZZE)kKc}DbTKu^daY%5J>_5PbjtMw?N zpk)D=$1tSXjPe?zmIPhz z_{-0=*XzKQVU7w%+23Bgsg!QSTF&fi_Y|*X*#l6fPZwoj>$EC2*Hk28xJC)$O%lvi zzjreNH9UN+YT{0PgqIy>j*ys2mUC8SduhlwGUg%1E$)y5N} zkBG)Vb>GQVFTMV=MzY-a&3p>z&|roF?2Bl@Y(NK7un#E{(6wpTPUnT?vkt`sTq3X( zMdl5=)$`&byc>}RX3PtLo5;hi1pp&*H%HXMlm-JC>fY^ zaNiCB*b`)-3}fW=1o{-Vf?N+?4S*rV6phEBxd0UdPVW2m?NhCi_~yIoK%fqKq}#!z zx;kROKmh=BcPXX}rjvU-V>!~b)zOqB^UM47DDPW>N*#Ia^@`gDFETGJAf8&*ojXGy z@r$#UQ9~4|n**;io{2$sMq^>un*llh^pyo8Nh(>oCgeQ=Fj7@@guE>b-XGqXgGx*8EE2=`Joy$CZIG`uTwIqT{I%ecFFz z@51A9$%>m`%`@+xrmFVY$h#5Er<+eBg+6Zu;&~yb{rtPz4t^i<9~A{y2}d~*?JI)FhVp4k=6qc z)KU98000RYTnf{a5s3!U{Pg^xg`_MxUf%^TAxJWFjWcNH=el1Q9&bGHW^+7ed;oA; zphQ|Aa44%h&JE{)Yw@uod#jBnpsmr=&;)%6yOGdC3ULvL4}k=dVC?PeK2C45$Mjw1 zlQtTaR>HLC&Rx4bPe5GkwHFSuL}XlxS{+^fjJZ#=jU3iTXZKkQcoENpe!4|n!5CR2 zsG{ahgN7VMf7D-EjE+0AWMw(I6W;k4Tv+4li}4Ra{M^o2PYJ<%VdWg*-CN8Ly{9*o%(pjHtLwG?M?8(ZXTQ6t0ua=|gR_F^ zGD@mBK#NT;E$xT-+qQ2TUU$R2WjtPze(V2ipWas8H}`7~fCVj&c{Bvu>x+GNX_;&Z z0VR&Rdyw&P^1q-`FD@Odp7eHtUoQnzXnvRayW7KZWJ_^whCXCH1>+o+T!2VP8|;0O-@sHP;LKdjRlp0>Xo^Aiz7jV}aX|j%W8}i|1_9l}YE` zmU>Hj$6z22m>@0-$%XSf#SuW-N^qPxq7{i?icYmC zw{M&g3)Qxz|7KelzL<=G12@r~93J~^ zMHtH1I?mnNUqA=;?F#yJb7NC=%#Momxw0Ato~Y6IppN8pEYdjRwQF}z7o9FfgivjMAD3sP)R-uZc!xWfu56tF8FqVCw;qeo< zVV|3us}>KtXv{{rUbu2w?sT|`+v2I2rka|H0`QRDlC^kk+>^l-nt1^;G}>O2f`ZuR z%sT0pXClh_V|zSP08xB^Z^w@6QTvN?_-Fw1O_Xu)!hH3Z1O0}zPfh>E2O_zm@!anw z;iJdv)vnenF?b_%<<*-w>e>fxR)^`G*B9Hr@YjC2S`aCIdS<%%>=ftCh-ilIsc$Z= z>Z)l$ZN;@58g2(Xr|wLxi#_t4u7G4@_x9~Q$e7(`=e_vW>x*Fk z!zR2JxOq~fea#QB)|+mU9-aw3TTk6IVbXHE;srvyjBy=rxAL^Z7q)Gi zYS(JokJMsvN9wT`H)va*xA7DJg%N|N5o@1b@F`&9bZnSS=~VxtN3}7IKAT_>4R5F5 zJ(WIB%iDi39-F=!>LaiHI4bIPhsNdE*+m3M;Z=NW*quTSGgNbxYDOp_gFHAr>4vQiWv`k1^NLF%$2Pzx|KL zsr#_aJ4WfdygGLAnS0t??d}>3+mL#()z!*s7cn`?#`4BRU`oNbvB@3Y;^4mdWPEurfbmL-j6~EYxLbH6z&xIv?c{9l7zn0ZU2WfH zJOmw$A%F=lU?7W?q5TykDTH)RN`omjWKh#W??sCBj%F4SD?jQ8swAKs$+C0D&gzSE z{Sjbqsrvw+N$s(3Rw{z0MaQK1lKT{9;lUJEM)1XWLfK~S|-KsHB)tFdb+xM|1J|eA?)Mtt^$v5 zp*6s!*C_%5Fwn71=cJ!bynLknd+z~=(!QC~|0!1p7;2i^FT8EUkJ@SZCh^p|c;!|g zi$Fn@Wjy-)6kI{mm!E3w{knR%_7Hj!#eG6~K5d(_o{wHXMxA`+#;Rg!gusTF5b(qX zxL}!!w1@9S%fNzC+P2X;Le9zo8Dp@EphEVCSKgC(Z+q`wHxHbX2Ce^T5HdWLZKog! zz72fB=hWP5h`<~14;fqlApa5kp(X0bt_#p&OXnKIJMFl6sdX3udM(cMQHqeN^`Zzs zBd|GV4c8PPZ0}L%-Hf{TQ$u(&MW$bEU-TAo@IV-oUvG9`g5Sq}+v?ssXkg;UKy|;Y zZ*JBRSm+=Q!+&V*aIQOU^HX<3)pI!WThx7Qi6qwybl_5|wESapohsEsy6?qjtvvRLD0? z%4;YJ#JFmH%`)DTdt5LIH;KaDGv0l61KnvB<7w+k+*rA3Y2A55{ zB`jp7*n@|iXD8xg=Fj~6d@}!1@u`=vyVP`Mc6NC1&G~EnW5@ORgXUf~H)g@o78}<3 z7AKezGO zDC$rm1SBY)gCQXt`ySc}FHog7D?IQKZ975Xcw=(s&K(g8!{gq4c(lG=?b_wM8F}%Y zjOp_<|DBUd)#q(wVmJ5osjeE}X$FLfYSA+G1(*laucth*?!6?Wq(~}fqXrE7(NGI& z=P2Bo6B!{dQYRY`D9T9*bFsCMnb4+KLp6h+Xvj#ERRb9$%Bzm! z=u|~Y{JoP)?K=?BT)o41B1dCnJ;{cgrWtf;oYuW#yD81Q{`Y}|{Ha(nw|YZ}Uye>b zxs*WYf3Wu+T6W|}mf-VXkP#F?Et5=Lx_ZR+p56cdf<3c4Gu_qIRjDOYQfvAixP-W7 zb^-Sn5lq7JoMbp)Fc<&>-0eOCAkUdkzqx0Y8J)xX_YrUxZlQMc`8Vm9Cw^nr{FL&E z3F-SJbbTJ5V)y_4k2FgEk5g1&>+PBt%eI@7Cr@?D-ouBFlv)S-5NHIrI^Kls^-vl% z9Ml!+7yN75caCND-+PZAKNh*i9Z4A2OD{JWQayG1Kc2mK=Jip$eucbP)wFK;NzY-& z!D2{zI{UCqfth)!|<2g8o z8{+Dw^>}7*{?6kkPc!;RvvKrei}a$Jbrolb@qN?W{@wrG>OV=R5g6my2EnBi6EBF^ zKoLOb?6=O-ju41Qk3a@>YwzfgMEsI|0pJ<(?z%~p{AH(0mb zli@jxzutS8wm$L2L4U?=o6@6xR?!A`L-J{ll{=3sY|_}yCIAUXy6bKzhC0gfMans& zFjADiwbziFhu)~*OIRtXpP|S*H!ckaioV1EBC$s>@8;*AAc&fsFDDsk`jrTpX>1#^ zF5~$Q!FnN}eprfTJAK~4xn6I#EIglnS(U9xnwR~&Xf}WQ$2a;=D~N+SD#<#UH-?V; z_wV1Bp1UpLs_pXfgD6;{n9gFX9q!Vn^XJ0|KWY7xo~<>&{pudwD(vXOg$v#LV~XVP zitnA;+x)+O`!c%hNz;g-qVT=KNW;Q4VbC$R^j|){VT#r0-~RbSj)hV(83lO2u&^%a zQ!ayS9HSI?p&!fYGCp{1$=HF(l_Jr<{^i|nF#6~@yWBs&x*q_2^ES_!9B_C4-hD&E z0+7c5AeilNy7QJ^){sxB!=~U+9^pujq|i{X1L}$`)Bqvu$tD*wo#_nyL}qC`iSbH6 zlAJMalmGwW!&}|ALcHa7q*Et*-{RrJhdDDm$k^RIG4VKg?sYu=5N-)b01I(!v0l60 zg#?4d;Q7mMf6nN_knzJi*QS&wPo5Z4+#hq9xt+-AATOUWTR@8*-NZ9lsLcK zB)S|VV*oZED5ZE;SU1d7m{@y}-ZCf{tq#NE#S8t}^L=(R_+)c;O6zH7y0Fm!$P3ulPAx!+5&l%c{C@b;{o*t^)>JO?*9sscTb$? zqtN{CNgsR|k=Y2iYQ}4tBPY{swT01xQ_DGAmbJr!Us9TSF+(rV-$LwiU%M^A zaBE=dWP=`nx18>rm~U5geSH7Ed+`8(QUpChPYU;a#GgaT)?-U5(nYV!`y3y zmkUx3Pe~u(wxTsc*qtjl)|?{`=W4cJuJME=)}3zOA2`<2}6h z&IQ75h`PGpFz_moB^5*)x*L*R7yi%x_>zXuU|&(H*i0!_*i7J{Z@UhZ{2u`*N!F8g zZI*seU~?FNp_*X|bGJ2jPqc`T@xu8FoB!wEzRc2**OpsnH2q-ef;Cq!vjBV%l1kwc z%*vIa018u7USDX@c`^O#U*8p@>S7iC`PIDu{BuJ_l@;WLjtyIAF7VH=Aa(E>~gfV{X020)EON3M28 z)jiW6K6+=`bJ1PKVb&SC&3LP|T*lAS0iroi-j3d9eEUPcUHPN;ZcJ%U9zCME;k&LZ zJPl3-gFd)(O+6#K3v3za$+X?SRrl6QfXdyU9~1&$B{rM2HDN9Xhgh$_=;EPRW`?cf z)hS9b0VK#M$~DjB8{Z-1AjR8h{n>co{MjHQI09;%Zvfcp4BB!T0bqu|8ovoBmSfeppS)*xdO;9|0Idy!jwc3^)xk(vR*G z(3|8Y{=|>~WCVxfV=vyj1=j!07M#g}X;jPIx)SJ{RMCfXp58wt-Y^^&4Am44vPVGY z09?+`&2)ZT@E#uy(DW}wnAs{x2|1Gxdt10HQr>@VcA;0MD}1h znBE!?sLYQqIzH5b_WXjn$<7z}=vw$shC>h5rr<{qwT?7bTE?_8=MK&d7juALkpLL! zqQ^%1+dsd~h-l55hcUBi2gEwT*5m(~0lCp@gw|Kq_+~JtOycdz;vX4wh@fFXMDQ9> zh9BKNU-W)*bn!w20P;$_5rE;JKe|fI!GHf`zMWEY(BDizFB8lQiYx$OGE`ukO9uc3 zU|Wf5(18dOKKU8}dS(6a-~N1O^I(Wf^&o=K#7$Ku3?dEv;hVV8~)g-`u?~f`SqN^YQyPyMLc_=j6#C z!1#9$+96q>Rj&)@u2`h6=Yu=L`G0P!;-k60hU$XD9upcn)XUXHr_dhgNZ%5Zz`m=*w3gYEs&1qtPxD5IQ#8UaP{ z{VTR9lp#RX;7_0n0H1xR?A)2t;pigZ&i@b`+8f+U(1y}|`4eEK7;VThGd}k&Z0vwW z#$?IJ*HO!p$(;)`sEK;6lMlMTxjjSx2A`}Ts-hXLOb*k-n-9md&Q*?3h1gMi@$%IK zbU6y4Ft2{_jk^{N(v&fA3@{JKnbJ$xNz>ot}{o zhEhfGUeO<}KgWo~cD(X9(xd|gh4QgpTHn}CNj?CmMIm0gcup+f+i6g0M{;HR=hv^t ziLW^NaU|)~ty-D+ZwCm@xBI*jfFB*>KVt_l0c0uREL}gQjXGpfBf(oHA3#zVz-?+RclGV z*;(;Qn_pFanPwp%ms3;s|LmeoLH2e4!;fxzXVogqpM3q`_yBsQm`uQ8MKJHrA6?4; zWY`+)D3;*jpn?ATpYKd(!jYI*kcojlrA!u3Msi7tmmb`o;{Y3}kspk5^XoC}<}bgy z-A&OK&z=L=i=8X{=p;@v*{n~#{DEWbD&YVaSwNg*$;kuCdY_r%G<8dDMw2lEb1wQx z-A*6R2QO;qoA1#XpGu!=^$>i?%mj+RbMx|ix!;SI=J*HT2gE^AFv)-V;V0?%gC3f* zhWGlFi_=-auZF8*XZ)_6{jm-JZ2RwPeX+1wJoDfsZ*%{_lL`DA8J>GLH;?2nfDsf- zqP(VRu&uhb+<*8aP7TXK&F9;o4-U=*Ulp&0v;NYq2R0e>VU#~SKYIKuVLo?uIFf9* zWaecY*aNquk7sknd@X2TD`1eJ?ruD~J1s_)oqfEHFA(z2icHrg`IdC_&h72R@9%z^ zwVT&Y+2B}8X-;{1x$^IP{C^HmSL6wcH)PJRR2V3TJn0D5^9qcAzL-Kkk#{j`HiBJ! zG60;IGX+Nnf{JV#Zv+l`pFD8}8MbwQiWUTJWN^-3tV!zpr4eTs%yDP&&Hd`>>|f>H z8Qi>`yNN+TsUA?DkbreYE{)`(2~OgNqUeSBbQO=O9L!H+)nc4VUbs_Rf~w z-=EK2d^z4{4vI$iG>3d{+xqnKYBpbe>qmNQHrFnnOUg*+^XZPa0(C?kynp)4aR1G) z01bbB{`C*0+?!VqLd(i^&b^CT)QB%|BtXK$ph^}<5|;;{YA!VAuR#8qc<$hA^0D#v zPyFr0*^L?OdI89kRg{3}P^hU~yRO^tC#Palu%6nweUL=AMbU+TCLB50(O!#VFx+EW)zm<(G>M5eXV_T6v3|Ao@6 zhe1*~cWzysUJbKP9;gEQAXe{$^V8clx|B$W|I?eM_rZ{M;>3x~55cx$avruG_~#ym z#`|YW;;sibL`N4H393%{-BD?ZQlUAA=iIsWj+`$1ss{yy#`$%FHTvNMu8oaAta9HU z41W5^7i{Al$4%O<8$6`Zd#|N?VgdkkGTfcwSDoZU>ojAA+^6x%uJ0w&_uHJHf|Un;U6=KBI^_>?aCaLh|hJ4%gpP> z8K+;j7&V*EzfL0^VlD36x-9AyzJSoY(q+%Q_*w1;+b|PbBjyKHCSvwkqzik_440Pt zJvv`7XeEn*7&ilBSqmZ#p**poF75a4U)8sAOYaInqPwi+fB#*%K*ZdJKbQH#2Lmuf zb%?M+8W*vgI<>d?pa1dI;(B0i<02KWFCN*Eo`Egz494uv^Lsj-Ulb`AmH*qP;Kzn7 zgN7d};E`YQ({Jz@N^CuT_6z`O>&i^Vr+N<*miXC#+!zEO$eUc?)K=tgpZu^Gd~^T% zuYbDJ-FP3EkDYvrp<0r6B-scQ_8}+q=q*-+`{7j61ik1n<44!v!H>^=Lzvofo+`Zm(@cpdSNt_&C0?Z^Qmh%g$rj$2*qQL*4S`8@orZ3Qk$C}{I@o7dIIDEeLQ-O zSOjqS_>~CHdFR*7kwD>xdWY&N0G)Zxj|31V+n5C@Flx+m9uYv86j1uk`*Uyauc&qpb1I{nMuv0MOS7Shm@Bs?vgfI@p5B-ne=`(=2kpz~QKa40%be z7;zdu$o3&y9~YK(_T1Ty?eCv_yZRgpS);AdSxW}N40O}LE-C%}Tj!&GXRR%LaF>j@ zN%U;G@p(Rn(Y=cQ?eAZc;i)~(2k-d0Wx;P0+rdG92I>R?nv(Q+>;ry|dgmQW69U*x z4JgtgkCkEv=g)8czrRTllSAod-L1(Vx-lj+{PY{`HdplSmq`KudCGIhb1s;O+xcJr z^iCSZ<+j-X;H}TnD@*!u0l?q@!29yNxz2V~AAC$daJ*~c=y>bet-RgyZE7>j}IP85a2}o;mL>0_8@vOgLEAFtU&X;7&^|)v~$Jc{-SOtCL zw5VJCVjg^1fmhq`=Z`;oKrsT0RFI=jy?t~3q4e2Pe{1Mimtt|=fSEtEB!G=!U7+v$ zOK9{nL)l2LxdQFt20Xg{_>PT}`9lU7D1zmae7UcHmR>#W=J5~#cra|Koh>B%Ug&S_ z4eN-lN&6uJUfK}=in5+v3XB+Tg$Uku)3hl*G;Na(8qp>yyco8ui@MHi_bi8O=G`=X}uJ1})WQieMQSb%b(_4G@Xy7QDAIx5DQ{8UAsM67}dmK0`m= z2!aeV`5@RTyas3n`q~ilU;cD^^Wgsd44g^l908=LkoW&2S>%tY2Lv^smT>^}dS;-H zSD1p{0Mozx;ZCsi&1W?A2TsM`Khq-l6#-DU+a2&{_v7eDNxH?{Iq+HDZKIPjXI{pU z7n3TE2n9BbTM5IQucOGm@;MJ2cU6o5`aqVPF_Tjry?^I=zb1|{n`Vf7o42baqjXBAxK^i-)LffI%E>kfJ0~Rj63iDidH)TcRGEeiQ14G$S(sbca zME=D=HrA zQpSAB)njTep6j|qy^fDRn4{a!Wh$@^utogbxr5FB{?D)N!jWFQDcOSGPe3}aj-mMZ zg9GoZ9-kG<_wDTYxCN5Xi&<3+Mw(~=@=pHEiTq5h#*Z=@PxNhZ@eV4kM>6(jxRqJX!q#&sGac&!HnUbdk-Juix1k( z=Bjs@#(ZWT0;i(l2{4L4DXGKL#a?P!JRZ{cxm|)$9G|C}(O-TV-g7(Y;qRhzN3@OL znYwld+o6@HOVHMEn!9riU*h*vdoss^Me4c6nJmFYGPIJxf}) zx%S?_w9t8r9OUFL;iG@XaC9fy1TNsYTLvhWW(H{!zwu4HbK*p_b*XnY`)$daWKj&D z4FFvD+neY9LE8-Hi!9t<{bEG|L4HP{JJ5#(830Iv^+*AQ99KRTVV4feBsQ`TT#)sW zMM>wa=_+V$v4Qqw0t;$gR^OATgga1oG=KkBwwT)l@IkV_!t4*{208#xvSq&=(+5+t z*?jqpbpDqPP-1o(?wYvn+#Jp@+(|E>NzFsIsZirl2-d{?DmK1j{`vWLkrcV_(`C8@ zq2VLd&=Y3n#!I#|-06323K4=)zn(jHZu9RB;OjGm%1TbelVs`q))f8S``4oPuU^3f z?g8nhYWcVGP&w*1gHdH40V$u^w$#p%BlMpm_#vuV&`+5~sK{2;$Ib+UET{bq1M~Ro zIl%`26SqSG4F=%)!Nc;c#+(aiHO=lM+XA=|9WPn+bSN`YUy9mOEl+7}l zef3=rEJ8(016EyVs8c?H(MhogRmYFtzd5b9&!2}|;=ULzYy0TEo6~ySIqX^wN`S+V z{N;BJ2n3*%x-Lae*hj6SD!qYquWqK90W9&b+h#@S@M?RXXr;acfz056v4)( zbHqsgz6?`O4A>Bh0@&8-Qg*saHNB{*)f$0|x&L;2R85fx4jUZZlF~-CdPfSr2>D`F8j>CvOfl}UH=kNz%3}Bs}EQMtc$^d2HMI|OlvLwKXaBPKfEYV5E6v}}Hw4EFB zsq@6DBu&&|hk0Uf;_Utm&m(L$S1z43^iiJuKPA&3^ooxw=x$YxihS99%nEji(k+yQ zpcw$%3C`D$Ry0({bjWXkPG`@|7vi`NfKNXE-eb26)t2vPNj;lK%#FjSw_RGjOhpj+zOapZWS})Q8QB@>-_$ynaR>ST zZ*42MRtI{ukvb(MONOo(gpeE-oj+GTff4X^kjg5qRPd*6pQI$qp)e`;vWJuj79)jz z@ojWz1S-R!U>teQX_`kN9oaeo$O^FX4!M+XPs2?6h@z)rNiOp5@naug=^4Mhd#?lj z{BJCu4{jwD`hM4)tJit}AUtPFZA4a9{$^`?fe|kqi0Iv0S2s`M3#y22dk@n~Q4&6)4!xysCQ=%2-1<>gChb!yYOdY+OKW|3iVgsEHl2JUFM_GkBn5aBfD_qa zL6=k*e8YCc4ifasxU(0$h`{+Kq5(XNK)Rq?5^&J3H|?+Pww<_vEjX|ep4|vMiLBdr z%YYEd4Wn+$)GB8H3qcbpG3hQ#KgBg;K~)CC5u2LMw>(TJZm>D}ysUw)Ts)WZB{%K* zxjL93DKbo}L>`dbU526ofRX5YpvV|!cace$t{qr_w&G@tlMh@Cbmq*N{$rtu55Df{ z3xr5aH8|mMBACuKM#)Ukl3*t1zN#L zB)Bk=0{|aCaoa5cKlG{P_I~%H5bZjdi$6}w))tmuSn*Qbmgv;k0xo;|<`pjjtF>zx zn@QSf&lLklUSA0!#2EvZr(S07w+=lzWd3^JipI6u5ZYC{xp<+E?t4A#Iub3eZ8y6+ z;WpawatNO%ZqLq66Grk0{S;adVgS7;MDiisqmqIGvAlE+J&U4xX97U56}jf~B~uQp z5~7_NQGD%q1GZ_PO5Y0r-^Kv=#(t&Nn5gxry-}L_Hj1NZW4_stk~;7OF=1MB_4c3I z#Cskyz5lBp_2SuK1fT-y4LH?$4bTdfO}E~aoim6Wp%{orWwXmJjn>Jr| z3!dKxn#UCC4xMF&V4tD>Bb@6jbSY&%duA_)2z9qtyZ_u``OpvHw)(?QgH9CT^rC_^ zD5CU~V8a=j!1*9fyI%1eb#q+j&E<%xVZ7W~d^D7m4F0LeL7Z>C>*>=D2wXaUEq2bfXIU}`f^!N$7URrAy2t7D zM=PEi$(1vQ!}SdVg_-gP`eHg4i&#UocfE^Dc@LkhHqwjnR%WWJ3hW_k3iLT&j9Vbh z>PTBtzFC&YPidLMO}cSZ_FsPY&OEkLcIudf0ARcM>+f&Fb016eNxz-B{&_yt&pPMj z07eX^|M_>fA=nt#(eZFdSU}@#w-bj4B)I5T_hf^ekz?ET0H9E%(h7?;c807{g1ZNb z{qDnC-RycE*=SN;vY$wo&%Qj~^{13=9);~bqr0D=1r zKxV>tPV0Rmk12iH&%Ztj%HO zutnMA!kl~Emfv=B;o#ixsn{mpjw1l*-4C4f$?I1RMgp}8fUFM!`l-&pjIoz9r%xHt zdU1b7l}wKcZ<00(>43eg^K`-NO#Vp0Cc%mzfR~t`a!E*FbI5L|e{`S>t~mfGYw5CS zU*Ktl^%CABux!#Jpiig&YxPcLrO3qouja}-e;ohBxETfJ$x(jOU&MtCqKlwyX*HaN zl&zuaU8HkEf~11{v@3T+`Opa!`eZIv228~|YfcI8@9b>$_f8SpJ`q4Lo34M}TY4jr z3~B|DXTc(`^Y6Hb&$fTK|KO3eUv)~za{I;krj(JZ2JAMFl%&&GnU<@s7qNOOphI`4 zYy)w9Q1B859?Tiq5(*uD^h3)H|E6N2#Q1c&ixk{!KK;^*28`B_Vz31!D|1yUx>odI z61a`l98$hfgzi0RB5OrU=1HDDxt3X~&wIl8jOx?_neP0?fBVN6nHMf-69k?ZUP#Z)MGap8?HQ&&&Jxy{l%Se}3^}kU5r7T;=X;yoc^=JVTL_9UwI`y^z4K z3?Iq9ozj+|k^7;gloE$psqT|6$LKt=@ogW$=S)VsEF-O&(`U{POMMmJN*l<@2a!ZE z%62whe9Hgv2e-m)v5Nd}?hb7wq5{`H2hZRi^4@><+NNon>0;GA~DI6JX_=?|(7* zWq2UAfdX3?0feG?D-=?kaJ75MdCRny1|vk8A+yUD&-VcpUUB!>Z4sSB3qXjdptSK* zx;;7Ne)#C==Hh|BlgPihRgf=SeDFGJzV#7xPo9Dwa^TQp_KgO38D*fh@F+;(e8|H* zhi}S$O@416!${|3I+OwsY3SAyzPuy{z$-0_>P6+k>e{R^L}i;Rw|?L612Y`X$(cx4 z%gRy!na>xMG5%U31Wa?bGPv9`zH-2d=pZRwSciIA3~{Rr=udTVsFV zj@rz(F!hP!ugESio6#rSfrmghUoWM9<0k=kfHyS{5ohB~U5;LRA3D>oMai&8zykok z1Q5YpP~%Jb^;fWsf^a~kdR1sb1Z;9B-2SVTHn)dofFo!&WPuR`$Rq=Z&E}@NAz5kn z?(WIWSKs1G1F%%G-;?>ul}q|wEtX*e*1D&yVReZ6D^Recmw%iW5 zm&y)Lh|bMACqpm{MbPm+ZHK51(> zE}M?E)tCLlu3xlKI=k(n(E6Sp4W#WHq`0%)*KnUU@pXSiqZHhz;U3-5njse1KZGk~ z4~)d2rKzJ5h;ht=uBfBJ3pYUXhmLVN&e>7hBYj5)YMwkJZ{z7S@`CyU`95FVhFFi` zvXVh|uV>t-6zysn`B#FVMV;(W+t%xsq^xI%t~d5h?gpmP|76hw%SJyO{f>XXm7N6t zWi>wdj(Wh*|8KTKnVc=7%Vp-?o=ZD?&sFpCwYLS^12*Qhf6zM9(VVWJ0q5k6Veak_ zWk(mzdzU(Fn$5j?(XaK>JWIi^ssExDr+*EVn+p;GYGUU!d{c)rAd)P8P!Aq=Jk(GZ zKPO!j(`hU_$11Ee*hC;Z;ER9ditMa?-E9T#y18vPUw`KufQB6%Ve#|FtliwYadAiu z`zG#vf5^VR`*XO)LJDo_E=R?m)UImcds>`{yHxJhtd3qzC2WY#xh@g_iF)M$LSL@ z$)It>ZwB88{T>fl^6jNs9@Ygg;#I^jmMGg<43nP zj~>N@&83cJVop^Y@VZ z5il&;FFQVg%TLDubCSEl#I z%a`u^Rt6oWbn#nD8xxRg4wGs{x@?nxcjk$>cKO2e*x$4ouDO>l9Rz;i1n6}<;v&}l z<8RF$+tU5(iI_6AXrw4_yrAxZe@m}07g5@UgEJkl_xfdjBXV58ZQ&i1N~ACsy-F`@ zXNynaaS=W9es}9_{2l3?pO}mmBrD-|hM&N-#{MrI#!|Dn^(5OBB zU(KbP9|PA;a3+~3IsY#Y6iN7!Z}Pa#$SL)CvLgv`xkNK8cKbQ`(sRUI*6zvO%@^GzD)=13_!eeK@7aF)dR}x6fM#xKj&o=~`vQZ9 zxIzNtnd(C8y;%Xrp0#yZ;f3azDVtr=2wmcY5AJwdL%TC4Pj3GH>9;~r?WJc{X6ll) z{1obS#ltkpv0;_>sHxB6K3BvkNI8MwUJOr53g&+s=eiGOG=<;}~prg{)ZGt?TKQ z|8MT5QDY;0{N7CvtrodOZM*sQ2Nylsr+@gq4>HQPp`wejdg+F-T6{k9@XvQYI=gE( zAG~{`o2E}5hiyX6qyPQq{_)?}P-{``6j(t{v)me!q09U6=lK$v+qbT6o_c`ujE{su ze(ZL;y1e0XQ_GDbWd|_HYMhW*HJn5qWy&vg1+XP^lyzQ2Sm^?c% z?WKQu^eDRRSQL&e&C$Wx)AK{qY+iSP79nH&>6BdNA%SZGC^Y_f73cfMLUrfMcXbUB zwj!XG*5TF|De^5z;Fgrl?ymENqjgytcVOd*$#e-3P&XZ?h59zCSn3B2XdCR&2E@R; z(f~d+DiGzgfHmf`w>f*9DIfSY+9tS{vZhj+i`PHu0YJ;C(JqeA9BE}6)m*Q@lZX#L zgt1%F*iI*Lw%_=WwndT&WC4aSXD4lz0;&djf%>2hL6^n-XVrtK@wU14dgyZfniWH7 z{7X&J5!c}Zwh4w5uLFA^2Cu|;9z?d`UpSp~kLEz5v2;Mp$*Gk8l6vr{|D`SLF}7cL zCv*l9Rj%Z3%AD<9LCRP{lRVqx?Qv1WD-zN%Db+C5aUxE;r8iQ;g-=4BS0GI5<7yQeI0^|c{hM!AmR@&0#Ym`FaT$)Kr7@JtDs#X zj0F|sRGh50%XYM+f}sch!FvvDYq}e5kzjhfeUDBl(t~^>^-j0M{{Efooo+L@*-}2R zFI(bGaii2$Pwe(vcfTLE>~>ujAs~W0Ow1Tb@D-j*T(tt^q&{X;AoNMXrpXqI8)F_r zFIme${(My15a$Wq!dj0@JsW&)ZiZ+_0MLkPgn&r05!C=nf~Z&x1X6N>p3^`v6)=lf zjrVj9Sv1rfkZv08yAO?)-j?u^5}@bw>H@NhqxYoCNC-fzmGt%5h3I5ZcH-0QMT)Eh zWfMN3Ewd`1Zz9pn#p@rm**D;h&kYGosd8jly)K|!LpqS6!xo+AhrkW#TsEY;QO@xU zco{C^Ylc4d1qYy4ThS@_$LeZNs{sqE=AIUv&T z=%NW@+S#1oszrTgbja+;qA{GQkCY>LSNiL6LOJg*W;a5|Yc&bfK*(vcW2B-#@*1@p5*|Ur%SV1dARN zNNtZ7`o{r(3?R^Tv2v5N+kWg6Ssg%xY>F*0aygWUU|%u^=VW`vYv*~{I(+fXPvo5C z^+>tM^^IYQ>^Y~G^YoY*Ig`lKWC@UGi^Tl5uctpC#2>w1N85;RCy{-rY`@GOKD_0f zW5>gI$+lUwVAwNKEib3Y9nOLDLAj5+$h8-0@h`qX5#%$CGWv?JJ08wIO*1W7@8!g8 zqQMKxS@RzWq48FYn!J}pOk4Zel|3>(`x(vGHX&v_@~IgkQaKqhsQ zGq6}HdM~y?paXF}U!S5M8?YHHEX$18fMotUyg+oGdw@ubPY3-ir_3 z;{YTH%+Zh##%YKEslZ(_PH|7Vd8q9P#qz|4YD<)(%JJ9$?wE zfIf}+1SgODYqy*f;HhXtY{dmInL-pP=AV&}x>$qomg&= z3j09@F(|pBxmf+6&$B5DR=FI+Ks@F)Y*bEI=2F_p@WFF>QUHI1wUm)K@t}*s4IN^- zdg*|^30a)w(Xu4zV9io?>w0Pi+WHwk&WUHvU@*}E?Vo>rHyc3tEdYozYffJ@7yu-} zLkGP4<1_CDYF&UJO<`p1M=Y9itU;b0xfYkJN258E8WE2B`|r$00yxgkV<3qH&=@^( zAcS|WA7tyn`Ke`~j$M4t_~vd8!hH1Jjcx~qJ4{}q@uCX}jtKxjtXkl7eHmR$5f}OJ zy&K7P#P~7`t+Ef^y$-joe)a9o(A|@( z-M4Y;ZHe`DbAP%EHu?)R1dssi686ukOzVv)-AX@}?v85;nx?eO1Y=V9e#+jd-TsI= z^W08+mY)wAx$`SU9mH|7dD(X_K7&rGH%_vFbF3VM;Q(vQH};#bmLzMK_pjDWG3uDv zn#*j<-GF|U+5pxw_!vbDf_~GhOFN{cqaI@sX}RXYl{+&4C^&z;-ywiq!9Ow} z73`?UAk^#}>)-FQ1F7RZJD>}Yw+nI&hdI4P79wb&De zG5ON@16kbAzuoQ5!vgRB@_p(2ISf3)4i48jY3P3LKDza&M(H`ofkU)#zKQbEoU515 z32Ur2u0q=goZFgjp)K0H^SCx}yR-jmuw!*mgP(sz0)v@zjs?x{bmuNA#x+DYPM50` zg4K2bb(WgvdRaPjXLd!&e2s!!gI$i^iyhB)9XU0i#DV=!I~lXHG@d~_%5v*;SWh&*#6X`I zFQSNZlBg$eb0iiSaEQ0mPQVIuMK$3JqwK7D|G$3uLZWY6>W81>t=~G35%xV}>pDPy ztCDrd>CJ>wxWyHVl;@kHi^DCv-3_~Ke@>iKOx(&m*x-1yk60NfcK+NMZ>QAD?DPJ- z>LZ+D%(H;Bfrc=uXWb7Jie(FzixA4Hqkih7I|F|1d;feu`^-*%Ui1UlU%-Njhz6)l z5P|^2v*g`^BJnJFus^iIb2)jw#DCbR|sw&kC>*CyF%E}S%=h+yx*KXHAi zWj2p`uA)cH`75_u>{z2uU>%X^i!}w&5elGU0A8X?6P42et{CVMK(0U~;K;{j$=8fAeW3PHmm3v&Ya%spTs~~KeZ`1XLII9Eph+f+1c6Ldmx;ZB&`ny z*m3^se0wqioZLkPoqY_?{q4)~mQ_#oG`EDAC2W!Jz{c(u#+Lz)OLunp<4^Z_jDVhJ ziUlYAnGdX7^)5S^#o0D4FZJANo|&e|k7)Wjsu!L>_iI^aA?X4`Hq3_mE3uciKnk62aI%W_4J9zV^{B%D9)0*(GG zb-)+s1I6Gv0lqQcn5%(cvJO%E_SwK$R?6WmRLrNl?|=b7M~SS`A%kAGhH0l3 zy_iUdKoJCn!v3107A1|5escelZV_?Lo17~HK&CE%m>gY&Q5^si_cC;U_LGWj8^4`Y zypbA~DFATTzN8%Iw6FRzH1GvLY0#8zS3X<986J`ulySfOkBi>;f(~vQi;9MGFT=SP z*E0tgo(4??6HvP>$ry(I_=KL})TvX`hgyH&@n-YOuMb7JdUG+$KUkNOLKL?x4l z-4VnbZt#swuJJ&$SL2Otf`;m44#a$sP0=3%4WfzqwApO-_x3k0UcTgkqsH}#i&k-c z;-81O*?fCfhz`+oP&o+uR_7;TNAE~eIH5z1)~pU0@1qrdh@!WgOETH1#WUuQYsCKU zEq4a!{KeQs&U-Z5a7_4v)sOm`*=F7^zfsKxgT!w@; z1mNPiw7Ywvo0m_Yf!kA+2&t}Fp~q`eG`HLjtB!vBxd)lATspub;UA2p*!IueExncw zQjcYTBM3y$ON51UupJe+Ys=?MidmWU>sfLnV}j>ob$~ziX*v5WG)p6^i78kmiX=fh z7#l?bWx8O)4z0dY3jv)C9W>H!B=*~p+BJ?|Mf#E8p0=HKtqV1%n{wM!va|+^k%w4M z>PF;bZH)U%SR=J}y*A%nT-3qEn=O5Yo%rF2z%idq@#X?wCw6=mM7be%Lvn;H0MOGV ztXc+l;N>ObbHjsHQ?1%ZKRl06?%%Zg@_{G2sC~|$n4$VfmSb4pfBez$eWIV3*~AM8>y;vZ%%UpT;g0_f`K zbpX`q7U0Iz0hS|B=_xUhYYV0sNNyH_H}lr6p4a^f?E355yFV%5O0&6f^hC)% zwVAdK#|~e&rLAo@Uw!){1@z=VW>BNWb6RpKH=uoIbxSZb5u7Y`sj=S!LJekF#7B@>hHI{mq&_y6`lX4RK+A7uZt{7zzA;0 zi+}?gZ{VDJbO8npnyAAu=luBd18nJ$)7D4q_3sJ_%xe2>$1k2g3tjr5bGTtj!3cbA zneZg|`#ViD&ClTdodAH^VgKzwa>&-ZWlpIx=8?z?LB+O?|Y6qgOzxKs`AG=y^aX+r4z z-il!`+}2=K)$VVO+}Nc~wVmAr+5_};QXoAHvIjW~4mUg+Air~O)Uw8>(H-TqH>`U& zNE>{dOS&y}Qg23>rVJ$e=AObJ%A})R7h@xNyts!f3(Lh(Hl^tGGPhlJ#)zQhcPqcw zZW|tuk48EWQI!SY9Yj``2t^Sv^r1vG0<5LdsXzTN%@xzDD)o4hW~vr=1_&e&t|uAN zf%h4jNxF#OtQU)F+@x4cMZN}J8S}-;=SrT4G+YeFQTmI*X~ zHA*AFzdw-u6XfR`$d(g5$7W*00_ z70z}V1KK-Lt%nXAnv*_%`eDBRA9eglzn3AtOQBY4ok`WVcRE%z_}Le)YNxN%9|}Oy zu(-dlN}jPkP(pzPw7pXp)VHm|q%;gkT^MrNIX2S1gs3A6mcG-*Pr$6t!G!JFi6W3{>Qu zGf?ou#$y{&CmY!EKw=y|n>y7YTl(=kE5~%jjE&ftBF8bfQM~wd$KGHvug2;9;L({U zxnnV8Rcp7N%IRLCWo^Ie{knCPomSU^=F@}&vAn)z?%PQ$L?@cOma+K8n7)Zh{LuOu zG-cnQ1fVSI{w`ww9p7S~=xeOlH*aYCLnw-J?t&M-OnitVu3)_Hn+2=U}hNHn_izTlRK!&Hn*)Zb#=5@AlMn~JB^}ZWU zzIFBW0&OT$AE~$hEPcAnadZ>@D%z)p3Q%WeC#pk&m?didT6G>W^Q+6vL)a5A8Z#CM z)v`@S0|_S+Dez?&xcj*~qZ zBCX7MtSb(^Bk4KiS}ioI{wiy zs8ts6lPXmc))7DRr^OI~hd3BHRTb>*$PTWven;QOr$x|HrSk8SHmOQnLszUHc8JL20TT9~_2KDkr6qSJk6 zDp}Vparm>bzI`?%yv6$3ul%_4VzyBqV|%`C{*wW4PwwF4)ZLzMxyP~8DV)TE(A-TaHDJ)pX?(#VLDn(NGeD?$*X)0rvYB+4JluW`*F79Utuz-!BC zVa#OHPjxcW4R2UPyesMU!gWe?o)v`fUf0|B^A8P1m?EtTZ`oEQmLmMxUOI3_z0fPa zbH}<|uf*&L@@YXFqdy&So#rJYR2?-u4!UE(5<|rTmv4Xi`^|cq5QUs9m2{)1T5v!E z3=P|X4BWMbU+pXWvt$o?b-~Z6w$WMT;jHI2GlembG_g>?%}1HPwKX4^>Xg0j4j52s zbRKNKDLiD|kmd;HvdfFFM%%<-$Y2!{csK!Mhd0LY`o`s+Z^>0@9$Mpl*0T=p!**g$ z@6R>!ucb~@FTGpGu&Yi|JN;Z@+Qxn(3=&cLIsgVWyACE={#FD2y(l)iq&!ObNtAgy z=Q&it)S-JxaxU@4_4mZR!<0wmtxkr25b6ZySsFT-0LLWIXzd+k_wROeP!hhGo$dQp zD4IVO5~?lI6oUe=M+wewh9EW$2$#1};6z>K;J&oIH%Fuc?e7BZu z#rcFfzmfqCu{WIeX!XiCQ#Bkpf0q+E@B~}>X@t;*=E-rQq)Ti0Op85)GssENNuq^B&s& zRtx#&O}bm@-N~GQXFmNlJe9KX6!emFabf*6dfqVIeRm^sW+t|3=HP+89 zqz`&|PtV`)b2(Yom4+o!UgiBF+Lou}@unCtD*C)v5DGg0S6aVKpGP;16&EVvc7mS@ zzQ)^)a((Bpga=erdJtEbSjY_5y#5}i(p-qGa63qQ4`NQ7xa-98&u9u;GQN086Z$jd zjsVq#8u2Ky(%HQ^DCU+zSKogl*k`Z&GABv*W zPfJiC^F^Im!OI5bS(WxW_<5;Zs zVhW~0D2gl%+_T_;%5#?mi)G);P^2bo0EViWZpUya zB&p~V$TwWD$LdPff_+F5IrNm{oyigYyyJ65xEj|D9WnV{a32&WY;49y_f8)#ik7cF zk`SzP)vn`G4oZY~897Oh*tRwMlQHIm{9Zg+_T>jBIN4cG8tHmA^ca}oE&Gr}*@vY*6ARcltTsKHSDX^o#0 z<_`I1*zHJe-(B%C-1YpDo4~jaX3lmz0!W`~yo&!G{lSfP>K~CJH8JxPIyUFXE8fmJ6lr}X0hSz4&UaFf_Tto@CpzJ^~I zThOe+3W9=74^(BW%iz|1`FtsZ{0qSA!Ro|2O$S*>hOcAHpr21-sbdB-T2~(UU?|xH z2-{X#Iziu8;pxC#Na$F_ev&RV8tOes%7o+n;D(yvZ2(e-f1zG zib%-kDwn!D5Tv+ZCeNHuxrq0RJwJ@LKMvf}(vh~AAf9MIbMP+XRhW+oQn~4gX17oh6xsCK_@2A6y87z+ zOVl&>TrRbqorT%SuFs@O7RGJ29FKxwiupDe->d5|^3wBCH3};7@;!nT-i9(kJP*k+ zx^caaFUrNW`%iE8Nr4~h#0P&{3y%Ky?vL6Gh%QI1p7$MNvr~G!fRl3Ny>Yyr)x2V} z#{Jxi$Fc5&{)fH+L>()=an`k|GQQLZzsIw5qnC^1Ru4lLH{^2kRsx4^#i#qTPYaT0 zaYOucK$h;I#6i&ZHQ-V^T*!QGlD(f*kqd+OBFRGytP;n3hKX2k@bgW**W_k@b+9Ox zp^opCugmuEQNmStkGZbGiEpSVyBi%JF!e^?;4kEFHE4fXnD!(c;_220d?cOb`?U97 zt8Pw5W{t+xM4C#2X-opGs={OE6k-8HpmoJl{^)9cRfmR2Pg%kOd%7~mfnJQb=+;<= z#y78oLS>U^NYA-czo(x+@tLltnf}AE)N3;J=#kzaCY{cPPqr3x!P-|o8m6e#C{~5> zAK#Dee$Ip&_qyAu}Ka zlIccm30XYP@uu*@iD5B9I|d)Pgx(zGYJOj2Zc_^Ux(=mmUX+M19*0*I!|f1Ad8+W; z`{-jlDS`YDa}3I^fZ`^)w8nARtyRR@y%(RHu+L3O3yENkJRaQ@uKZlu_7$;Y?48WO zQ+V}j>(f5l<2?sk;~#mvY5Fr&neL5fM+U1&FX~knsF3`qFuKuOvNLu5wCS zQL+Onc2F*Du)a@tWWL)obu6u+w$+Hg=`r*|c6(DY5XG`J;$`^-4bOoJ@2wP>T^SbTf(J=dY#t-@ImA zeU7H;j&iwMB1J55#yctenp_~rrCREbxlh1^OC-Q^zC_qcG-(D=tj^0Xiy+_CC+Jgi zU0W_)vp6-LAdUpHtI}r6X}U-_B<^kf=oZWHz@++xagRMIy6CPAGI286rz92zFm7W~ zL|_v2Y9lrZ!OwZAi|D8OYq;lpONJZqrXImfBBTy%Yd1NvJj=kq?OMXSRQn*{gEXCR z&6gDU5VIUVpT7k@Xs4HX=h^Z5m=S@vu|PP24IA7o&zKQUW(EMbicLZlvs%HJW{2P< z*Zl|guv$oPl177YFV6yw%7Kn}iT9C4u60Ul1UCzkeR-1w!OoZJB!5{6{ZVe#921c0 zf=mK=9I{+!zczb|Bu+-6Nso%jBwO=KZe?qgm6_m2uZI}Sj!o#P*Ur&ho}tfSP3cYa z%}Oq~gl-PSzaLH<+hmS8;(A60nAQu>`UVq~V+_^H??^SGk2=j>F)zRTZ0{XJJM=`e zYAeg)TM#<<56W_3n#T3h*dd% z&8@s%9It+Jw4*#j9G@y&7kJ%!LfR_$KGizDE>J#x+iXne5oeEew71oOJhOAZ|8}`Y zXBk~thz(2upK-63Y1bXlbJ2>C*d}%|ikWz(eC?=q# zY8R@p_fry=irY=?BnH_S&C?@|hP z6;!&YGzEyz9#+mJgjP#7$Ks_b?*j^GVJCi#Jl|rRUTJTpJy`J_p~J&sQavlqhr*oT z_c%3AA`IbG_kBzbZ1;IM=f6~58GPzN{KjEP!D34t5vK1p^_8E6kKq!8tfSQ}^o!?< zJz*n_r}Ib_fyB9!Ny`1u{EwYnenm1y`Nzn3!cD4QTIjdto`OO?D*x?1)8 z8cbz%7u4m)aFGfw&-kRPz7(~Bb#}YOtY)Bde7);j zU?!@nlK9qi%%k)q3iaNbF4`0R#EYG-fHcB4n~px5@uyme|$mzGJIn>->k&<9c&9e&PC>k1IRF z;CqbQ{X7tb!-a21F#6>p78si~31F`u0_&F-Z<) z-FlhspUtPwvhTjOI_td*^fL>IO}&Lzqxn}SjFvu8vsbv zMKtUNg~K{Z+C*_x-6ng`8}01P?+kE%sno%#jQ&9*-8Rc<^_iVQ@Nni7=Rg$EBVm_f z9BKlPrm=|J5&;m)C!V$9Ub9#lj_J>sv45~x+i!e+>wqHv>5jvmWx~MH zu7PpPH{8}^pDyBpn6F5~@3S#WV?>jcgM)&tx|6>GaU@(Hy^tXEn-W07|2} zCCGcc>W`SmlwF{;ce~G$L&f}hbBh;aYfs_NgT!W9MXc$#fp6XpoOXp%iUS0!x;D^1 zpSkio-fy4ht|t@2+Z^(Q8bmB&4%rPgyW(t}jC5k^nwjn~B2_idI;bRw5VY0eLK+;A zYn^=v=Iwm1P8jZKyaHA*w^8^1l&_m+2VAs{>ws!wgsF|DtxKYDLEmOFZ$?K@2^GZazywlBv7RE!gsV3FlW%UNj)KL!wmp1u3(P>+bS2hiTl(gqTuL=zz}U24mhZX_2Mw1x@mT6AoGC z+(=$^OH%0o)+W>A6Fi7l6}u=8KX-rG8`7)3&3|X@seN>wI7U!kk(&S>M zrKvo9Jx#lz_A1k{11+O#ZWeQ|_t3Q0#-yNh!8}ZGuycm>iPqvhq8_)IMM+}xSfG}- zG~ov_UExWQP(oR&PuQ$z^E3m04p*zpDhGdTMs6lqWIo+ddiUqs9_+FKZ&fJ9=ij61 zles?&-Hy4oVptLl=|p@8rB){;Z*%|nKNiWI{UP6?VdBHIztTu{xbQ1mcf3=?Ys zAL~Agjj?K@MK+I~`#2;=YcoCQCc1ZYtsdJE+Hv82vYfs^9H?N%q)a!+oqZ9%m^xfV#i(WBGW$FH_2Y4Co1x=;R_YU$stOWUd%S z{goEPnej{L@%a$MQ)gCuIIPMo{P$-6^opjEMuF=~T|Of44Lx7d&_E%!5{k*pkHFy* z)iE=_LK&wO|48I{G-wYU-z?>_q3M+%cVuXdT_EL%-K^}Y)IZr~*gGRJ!I~7&J|->A zA*}VMH&HFpgxE1xp+k)et?s@%ISjy{S9BW;Lg<+QE zVUs4cd#Ff_ddFC`*yvr)BCzep{#W(ZEc1v(z zxCPRzR_uTLgNjl-?~JV&r;@&!Ou(Cyr4Egsx)$mq8d^^8=)iErd7?0_SX8a@*4TaE z6>E-U%!{DsoF44k#$o#btEG2xs+S#NZGO^{7D7@^y$ki4 zBDk-~sOkGtf*e$&=^{skT6BIQ2$-SCT@eZ*nQ9~mzKB!Ww~lteyFVsdC13vr&568I zD4>yZahl$E07O&cvR|R73jZ1{%B#)@1EZL`hi&^6zuAt7on39qPParzRQ<5j+J4Ru z`>aV5^WdaMJSD^-eb%|Ejr!7~m%k}p^h?LlsAOd;9l&h%W9E<0dzdX_qU$M2w6JH~@;_sfXy#81an%+|QcmHXcom{&Hx(FHoU^RgqGt)~8eYqdkY_#n;`&^wrE2P7kh}kuOg#a3mc&Bb(6H`rD0fReIGN6--P(Crqa7EhL zW$gP_OZD@ve56U4#Bzv3X<5vcAegg}3XS=Db|!|lx1kV4{HhaWvWaTu1EW_E4_u}W zl9AMC|6QQ@ICUxAr|;L8>vsKr!iZ^ZPguUA0?hFnCVmV+gm9DH{H)Sr7F7Q&5k@0A1;`PVL(P!>Aji<<>k2vMtzV-R>!STiLDw(!=j}y4m0KK1}OR*%G1@)t=mJsFoujeTuo-K&Wa>`PB?ZbdD* z1Sg2so4}Huxn`%mv~=Unc)a<(gce;2N`c8+TIcg4c&PH0d6Kf>aP&#Wg=1?I`PMmD zICqjC@c>$*0Snl!C~A_ZWZd7sH4n%rzPEa2i@^~D6O7@ih%h?0L6_e5*m|*+E^nj$ zNOok2sc-@R7EtvZpQ^h}b-VRBxT8Y&oW=`kftHpd5@Zyh_J|XD+_sh%l-92xPV2W_ z#1hPLRrJNh*tLyP_YL#3?DI8;GlGg$Gtk_j?pM;Q7pkS(q1r7WFte+O=bLLXA&{{G zDjLR_h_wB#e=lTY||8?{!}kKeM3$sKattL)$p&z{~POyfb~N+7`#F*4xv5zHl{ z+H_+Z1Mf#HX_{pF@lSz5HRVeA104YX`RDHx%dGJSO=D=K9}tVkE=GJ`e`%i`8VB~F zyD?_F=Hdd*pQe-1m{YLc&Mi>A$x8-+@x*FFl4(p_#$o#59v3oFOF<3JrN~z`9W_2G zlDs(e-HYXw%{$Rl#z6`Y4!em^X{?hhjd5taUDpJldk>|q(FgNrL@Hdol~_v6vbNpN z4D*grV965HPTwxn%uTVCjITTpx^Ei2&mZSTH?j5vd*S4hxOy=!RfejQ1+(npj3dHn$mqaK)r3pPmKZ-5KieouwBo3V591G zK>_hlCDCGOV~lFgfok*)WSogr+h8o=XPmcRXre0I7@&Uc%V>le@RX3Hb;eli1u^rj zmZPl33J0!*dG^~5Em1&mM3L$VdMVYCE}(i=6WUqn=457C*b#0o%UMnlb4ea{E)RN% zbH0z!5R~S{*`Hm^F8FSgwX%aCi2PqJlc|pGy2Q0#rU+pz#N6_n#xqhpqLbJ*j=bxNmjx3-`sGIs{sL-tUPDn@r!jIfHFJs)`cZ3ClL~hYI5c+N zFi2`iF$}wI9G|+}uL{fPojvAYIBa?r6Ee3mG@cq`OaxzUX$0o9Rrw6{AGqDB`Gqj_ z-##8O6FK^8%6sG4$^Obl2c#V1YWpmGHo{pc{y6y5x}6t28p2leaH;<1aJ+6iji2FL zQIWrbk3yT%kYMP((NC1EkZ%EUWF`(m_mBX*UIkq^(wGSbpI^7Kj@`oRSV&-@H~?9yy%9 zD6eq%+ug?z@X#we56d{}xG>*&Row$#!sXf34S`pD8PyvqCbeC@s4G{cl&5)a($g1+ zhnN#Khz*xJ!O|iafdDeN5js)xW^S9hKAPdAoVVmRwRO6NJ0Xo(Dl-}K%dBHiXj@5w zpw&3~6C6)Ea_+&YIz)=8%%GUMqO>OSq0O$T%&)WXSnaymL_AzusxEgR(DhZ#bnPvv zWBatKrMnZiN_3J28h|=r&c3;p;78-OWv<+H62p+X${Ra-+U?8)XUgQzSl!P1r|A*M z7)-*|N1^5~J?=vXNYY1VxJq3H5CQv}gQN(d_k*Nza(`V}_Jrxhnlr-^P(5KtG!q*m zV~$*7OtO>l$qgSTG)vW>va&+sc6#b*(bJJZ8LJL9jX?&BH6_om2!PB{9L&^a4vfBD zhmN0xJt2jrpTA(`_$3kx7)$@if&s@IPI2C>hfV#;De^H|lFmMSzuAEyT{DATu((rQ z5qf&Sc(?J>AySGFwrK8L^9hvV=XvI1d?-rVDAKUitY46TJ` zXLs{v+7X!qj{fbjrTnl_cX;e*rb&an7Ctq)3g^eDpUsI8+>&9dOkvBK`>7eAcc$p_ zO{JLPco)%wGq!n&|1tjW9E@qZ-A4<%+}ss0R3kjQHx6O5bEim!Ogr=k<#?_YdcnRk zK&(aFYXMYjDAoos#z@2uW2G;XVJ$9f(C`QV6&AE87tiIh476a5okH3p`d&%bu88uq z^&IW@6+raL5pyhlHj;0NGs~RGAWXjLm&wfA)Pz88$et?D(?YM7z6YFGlST(5c%ju^ z*D2|N74Lc#vJBW&4Ad=3v9ti75X3!H`gTzfzh|PQ{KjhC(NyVnl?cwc;&ISIj%N~oy@BBEEOJb)GVnxpY+S`4NC8G zcxGPwQWhBvam!EXb_pG&ci!G1SGZMJB9?sBkqyq75ywx9i|joDi~PLcp`>*sx;&9> z+&*HzuJ5{EVV%77`WeyRD76yNs6``+@Uc_mOGaAHvqRg4R6V_Tz}>(Jcf>}xbWrIu=>!etEf zxxa=1h&6CgV^o1~b4y}%Pv96BrXV@&Snf>+y?LO(`qBZ%;c{*nk&P9HSzHfwwB8Gb z7%7`=9R9vVHaW*IZe^xjji4KD9Vu2Jvw)+pT}e}!|56#={Nhx>h?QijvqCU`V;FkRDN0a6i7Y3@7vqZBQybYcF9Ba zYhp74&?)6wc`5&>v@E|k?F^nJ5VtMZBD(ux-`nc%Jy1Alny7vXM87}pt-{16znnFTcaNi!khwsW4K;ymt%2 z1j}}xZZj_9ZG_^pPfG*XBj*&1LE>gx9S7LaYA<5|oq@Wv9%WbJ>zEVRO&=;I zVTriT#xRsRk3NCm=Y{z`LR3D(9eHlABLhgA=O!_NV`W#5oQnus;J95~S$;2q9Bv>( zMF4^poWUQ^#@J&{NXEtId2s1yF#6O7xFONeg}Ct`Z3Vc`qglg2Q2}2rUaL>@ErWTa zQ5Ggo9TAGT05um7cVd~MGzT=S{BfdNO+cGy^}E9=DVww7VJUz0pU@Zw$q5H8T~@~0 zf%kcn@vCOk`{3{o=(yDxFNccq_%jFrYSq4K+AwLmr?3ugd zC95-gXnY_CFiEobjcl{JkASWPxcU&LOZX#r*RSTln{KA})VK(i`{?YmHMoev3t=R~ zl#`cT!p22LHRjpAp?91HKn26f=(;;!u2+Nx)MwUa(opdp?=da+VyMMWhpP4kTATHv zodG1D@;6?GZS(beb+6Y$k+*uZGy%19*~SvXIi5TsaBXy>Su1o0zrpXQh693@A6_4c zBnw~WCh8?h)t=MPU)yEVX0;MI(JNX>yA>s-8#8~z_tbQ{@xZnIqWe`vh!T0{uz1K2 z;BjU6=$F6oYh2EW)FLoN+Q>ulEV3nl8A!AaV@#EW#t$~rZb3CJd=zU3SZlmg)rk(t zK7#U9Nq;%#7kf#!qnqc9+o6|td})U5p_eBeV+G)^hXKs^9L>97+)&cb)KJjbYg-kZ zF&=zif2^=Z=ngbHrr>NZ_7ZW?^ooADY$*1`gfP$a+*s7Q1_P0`??gH7`g$#5WNpK$cu z$2fr5vtbJPhKi+bjY>3#-4RJ2**B{xwV=q|SQWs5m~;I;-4FXyuBFZP3LnjvgavE` zWiyPLGyXI)20Y%PHg+V+-$?Om%-4UjuhuA2E7@0W-zWPmuKz6uzyfKF zAls)L2{A7-0|~?G6@_Q4gB%EFN`cba^ZP)~FZIIt%JU9@6cg`ND zuVBvvrElL*jl0~FQw01u;K~gC@a7@`FrbZ~>UVPj{e`Bt14#zfvmqHKR7OR#qn$-{gVcp#-vZbv7_J{!F- zF4_k9`9@>OZJRq5MuY&_3M5>^RLI}p( zgCxY2l;*9t@(Bfn(gDxhK2kXASxY~eW<9~Ap{ypWAAlbg0AdsWog#6B_*UGdFW=l| zTZ;yFVvmx~)yvPUo^m{z(qtb`nxiLV%ZfF?9mH?&RX-LuW^r0-X9HCwn^tZ{UlV|) zRsOFp-~du&$&|QM9aK8`m1cEYp)u-w5Z<@Evyjka{8f4QLymh`57Y3<0+B5E9^}+} zVmZqg7a?3k-uUpPNz4=61#F(V8SRK9AZ z5*(3azA7^!pri^A%YdGC$Apw$Ms7Ahvg3-lLmM13yS@mB4skW~)Po;j1>#q6!P`JM zxUEY!XF={yJyBtM4F6Oi5$Y z0T0{A0_+1T>Hr191_z=Rzt3OTXIT?O_g_bOZI-&g6u@;dH( z76-QN=%&K)o|0q1-afm+0^k;{QAw;r-zYo!F`es;#~WAJn1W)|2_kUit~RoEa;)~b z0W`fXnC$6CB&_V8T$T2+^tA7<`xsq%?BACDd2u3^uj10+U-H)LL9lKhG#Iy;?a{2inS0Me zZ;t6CsFk?Y!q+@HV2Qf76>~-xbX@E-cmd_67oVms%CA#{IQEY<{~{nYZjgrjeYi5V z%7*NmT7}*(u$QcyOSBLC6`0}iQC?JxToWqKPpR&bTn=1?h%-v3YVvwkAC9-~5gk!) zNDG|g9##P77rc1`3OY&n$jHyZ?xSeL2FRG?3po#n=zodxv-U(0K=fhIxafhh-7I*w$NIP8Q+o0HEI34-@u zRsAIU9_5Z|0t5dSl^Q>tdxvZ;Xej?&oh3jK$rll7`Wtf~SyKnKibto-Qyr>t)lvb| zSH%7eW4`Sp@PTD_L+TAa>(bs{uOUyWItZ0>k+HP)R;a3tuHSf2rV#X)p>TKCy?7GX zPq5k>mZ1@(*`o$`D+TDjVkRU2xSIB`eFCPS2N+;~ylG?>FpnnnYkj>qLG#b zX+z7D)|OashK!qzfsUEOihtQk=KYnpXyTB-4t;JuOR1Db@SgdsX45F9y>V6PN_h?c zh8X}u9@<+j9BElO&(SMrl5aB z`;Jcmii3Vc@;@bmUbBKZ4TKQ+dL^*-a(Q>HYVKHAFXn90A)(-}T84X0T%uwI2yE*S zGwM_bctN2B7<;A`^l6C5l616$N+B2ceTtiXK2C?nE(@&!113j z^Zx+i|B3wP!EOUonS-(K7J1xZ?_yWO2w9h$XYTm9vc(x$gfI!Hh1agXyY3~0Y1bj4 zE)F?0y{h3(LJt~-g-;#sV2@G(w^<9e#0a`&UqhEx)x~-xMLGmpmH|xu1=IhCx|7-f z<@j5sGC&O(s9fRXV8&au5t*XgoZ zpVHL@#a%b&(p04KFnb#x(FVKxtRh8oqwKFgP6sVSN`{cQk%Vz*gJEVsSs;0 zAbkth(;G!PKQ8b`#avxmNaP_=pJM6wU=*@&zU-nyv10d*2#QuoJLYb+=rgsMe zo0yVexFf6j7}*a)5|O{i!sT#~n+#x#)3y*d1UWg-%Fu(p8?HiAhu+_kn@kAftkTN- zFs`^>_@1I#gCV)XoNVBVYLbJuUuHmO9CYi-sjsR-^)HeCQ!b1igk_BHPZc&q4^tI? zA^kk|;7;QV=gu4=*65&Sa!mP~mVe-3oPHV3h7gll!vhGxg|aQ%F;n^DOTKGKlo%?u z`uFHjD&RBjv=p+llwXa2 z`4GstTg@v|s;1OPs!D55guzL-*ic0;W&(ul6v3fW;?Sk-hKFgpQzk>h&!XW-yTTS= z9_ak1TmPz1^#dkjtKkGsEbvGsVVu)j0ahjApc)FBm)bE24f`m#26=}N8-^Y=iDJy^ zo+AcIsu01Ly#0_5j#|Ql4Hf|}ygccxawk9?r%!8tA5U@xzAZegM5Z@a)qgkqi>$u6 z#7#VUI6S(PO=QmhLNgB~ATc@bc?%z*r|fpsj?pQ{c!zG49FJ*O9_K3QJgUzXQDx;o z8vE#!E(jUZ5R3+ffs z&<+Ivx|HwpsCwrA68nJ#7pDPufH?YIKLp7?)U+ByQ z2-6ajt~HYlrNtzdVrybL;c~A;Lzg9Y%gKaWvbhg2jTW4RLP)IiG)PDQeqjNyv6vxP zp$L_W9MOTrn4(lb@LtgOQV?{>Gno4-Saj6eA5#A$>;E)A%S`n_gkDO+x>jGE8iBY3 z8qFe;0e->vrrxNGV7(W3A03P^UH@Jvx-j9Q1PmsinXMSLQGzr9RZ{^ z&l%_c4`bmiFd5_=h>TDK6Nr>CNK&64E4BHd8LjVMd^9w6<-iooEo&CE`VtgS*lGIa zprDT>&a5gUL1`2!Bf+60NMZQ5Ko{oArAlZ_C8BGtLJ-TfDFIXjvS?r9A30Gm4mlM7 zxxWfFGgEIorW$sEw$&8xz8Nxl;fYL!;s01<&M5|0jP!4!x`hY#X0iM+it5-!oRo|N zGiQ(sRD`sQOW`y#N#oRmP5RR6$`68F6e(0Pf}#B7{vNE0HN^Ey3Zxo`H2H<{y#@!8&Gmp`S7d|~4J^48NtkrH7gU(S(bGCbO^dBJ^!BmE2B zX%ZN)G>`%tI}I)Dg76->H&MxR8c0#PRgSndFtqOfr_7uaG(ewl>J%=XVj_P(ajf3B zpqU1Dp@F1U#mq@7mXZ5R!`-nN0Xr_W5=T|$MB2z4R49K9#cFxlV9RZi4Y%TRNTE_j z&^7CFp&AlunnH$K738gfO+g4})Me`AGC+p~{CQ+t-T*)kUXRI)=-i_hJEGmEXGv2B z_Wi%e{Lh2H*G8fcu9fhAR6`4FKR2Rk(gN#lSlpp%>Q97{%4A!35+u*jeivS8DLijR@e`^nN( ze{a4ng8NjU$t2->J1E2lt%eyxyO2c{jSg|g_3w%M_My;O-wMkABV)*=Zt<>_{J>Xn z2$CKGg*C>oG&2xU$6y{t&=Sz!^}^wtsrIMHYz84CXlR4RXm!M>DX-|6koQ+YeG&D>#j3_N?DiHiNd#K-PesMa-C;{cRE3hw#6R8mX!;(&Dialpk!lvab z5gh#BHeQNH@qcS!84Soj5{!;Z#jv2lVRcz3E|<#{p3O8bLO?o8!Yq*yYY*5t&`Wfd z_|B2&OM{PWYDu-|{uYxZI8$Um7o`Fq{(J5R6yi3p7V6U~5r79!1R+POhUPP4Nz#Lg zMEwQY#3wiKIsfq^FuyOtc>2O~hCCsa@0Hv|ixo!UZ>tr|*8&#)qpwZkL{ z9i`3aFrxTZ=|eJJFyEM82tW+suHwJayb}{o_Myy#(*-hkGO!7pqwm8M6j~vPsVgc~ zY&>7t48YWd5HUMJLMJg3R4SHdT2?_aGEB6m%lMwNu8WBRgZYYaxoZ9?7=uGn7;yq# zt9H^Dx_|-=E0sK92G?l{^C9TP{#*5sMt=xZ z0y5sl9{F)t1Qr5N6%f<%XAhuFgSr46gL;ukP8)8axGp2Y1>=jlv&kr-YN-2;j@#>B z?EN3AzB($dXW4oN7~I_%+}(Z9pn+h)gG+D-Zi5Aa2Y0t%!QI{6-6cSQhy{d)HpwRiU^tLxA9JDVE}Wpk(ec?h^hU^M}wgCm>>|(;KCk*)4he zKaBf0j2gh5Z?NEO;nOCaz-V>>K?^krd*51^U7$|6lc*jUuCY@(e=>KG)=u0hu z!BUb*Xx{_03&F;2xRf*UMAxLTsu5I5r3|M8_zrr{HQ4Y8JSU3HlA`L+shOCam{HZM zS)>M5D98H^ItU@Gw+vuAww4Z(0!ti?bQ9nDpRxTjU&>?v2M>v{31O)6Vfeg~T3BY~ zbdx(;R1Pe<%yF?GBx?hf*hSNYjQf5tr7QWig=;JaXuC~Z)R8_({_nK{#3Cn_UL~AL z<7UMK*ErUWP$9h{$dY=N!j2p=G{-7~CCi0P&O?C)o%+fC_w7_ZMJ=j%8$RR+i5Jk5 zWBWF^G816%@7(D1@8Nfp6LwXCsKfGxbZrU$$!Ru*QA1LMG8o9uTfutUb{YDk<`@i^cH#JW0& zr0Mk1fI01MJhCc$PNoL?R`o&nhwP|_c&y+Owi!ZJF#Dc^)teEifqyibL2p?}y#ds* z@);2*X$XG>>C_?&lH%La{`!EBZq_990`ncq{@UXjDuZI<>P1ko;f; zLNtcU{S*C$IJDX1qIc#GkEh**D}w(;00-ci+k4+SdZwtME%^{tkx-2SNysn*ddS|0 z*&QVYEOt!|)#s1M@wk)qwSSmU-N&MxYts-eB51*s@XqEH=_NEU0*U|u*~JP6-dlV) zoJmfIBobJODv`&RD);Pz43>QZt_)$2KWDuNBt--Dml}vgG?c^LmjMp3*L`6cCOE!i zXenA0g7^p0wnNNZj`iP>{j;3E$AWf6%w6X9&5z`L9n&{(qm-cc4oHr#$X7dG0UKk> zmyA%$BOX;#A=OsFcQ+@agvp}>tYIPwgkK}l=Fmkgs3)S1#!Bc^WuZbj_`_A_j-$R& z;g*L1=$EUjpu%+FQ_>oPp>Y&&&U8ZkiZH>w**37j@nihR;64W=EF}#O=KsBN&0H23 zOn;N;g9%~&PP00QsjaXLaHyLG_oWhro zlus@=g`zICBnJgk#TwC&&Q}a5zN(5>^@(=IZJ{+5ya}!24WbCk%zd6 z3!PFCdk@%Fo0?K7`9G_gc^$LA-D>a?gDxuEAdQ(>lJ3>zBvdY)H6S>h7t(Xncc?kX z#`;EUu$hj8blwYKrmf?Z<@BOR^Z=cvG{2LK0L0G}px(n;rq#$Yom1#vpjF9*%#$3k9yX<22w>0Q}u+2yDpzmm{gZf$t|-iDeD%C{GrP&=_3FsAC-Z< zHeVfq3zkMn%Bkig@s|!P%^Wfd+0QplQ#+uwTZBnd@aJ@yA)^R0LGh-i&;=rig~Iiq zaFXreR{~k@0>ikf_ftZGfUT&pQ!t28&gnZ`3w<{WND>-=Xc?3KeRB|$BLNK{DRH|E z2<8rMg99f3TBs2aLvC{Z3%6>8n>>J_*n|9T4BH>j%X$OsA!8I2GBOt1W|A(bd3vIR zs}mEk$by7BrGN;hVNlK7wtKt>mUU1}7d3s9Wbe|A#@ zZ@*4%wDJwdk$emcDQ!7lW#?Ni_(~lvtF6&fAb6`}o>R$s*?TDdBx!_)kL7=pm7M?!$sor-ik6s`tse26Tta9HQj*4qW5|wT2P^JwRG*zNH z#*=Zrd9K)&AB049!vOEd4C%qfjDDT~bPs%lq8C8I8+|-qxznf|fjjgD|0vPtCYsC2XBGoCR3KL-DqFTsT}_u)}35(XfXvG!}n%4$!mTN(Mfi zDO5~mGidp8JYzlxz(oh8mZRc+-jcEto6kx4{+UBX<0Qb-Wo2#D2{u+0)_F$=Y;33d zN5@ZO?x4Q~Oqu>3O^#uXx(*&m>K~Ck+)?ovOJQr^H^$j#N(7{3YeQ{(8&b9n5I|DY z9|c?>NStF3#||@7v{_=}2a8JOAQlCXAqDI6$2lP&-cwGSbiUO~_@Chvj`GoU0aO{t zup0pvpRcR0rU8`5P;2#+e$d%G*%u4=@$R7MMVV!`qaHNZO-%>I7T5hsnHUtPy_;dWz2( zGMNt!)5@{nF7HHWrp6I4st`!dtMae5|+QXpe95e7d> z>Un-UnO(%Jlu-SpZVuP+pj>C@++e`o$9X^s*AC!Bsv zRjfmUon?{ZQBC#PgM~$OC@#t@vc#$XrEOh#8%kSU<4NM8ABQj)2XN zx#zk9P$nd4R_fxI?t8PnZch?yk|})^zq^Q!H#q!fW*3e!jW9H3fS6dE!@|+ZwIifsdR@pn{78M(RWVad)HI6k_g5vW8gZ}Qh>19=V6QuI)MxRr zV;M_6a0enFGE%w_D3MY)A1#qmOv#NntKZxn`N!4-_3LvT-d_n!@Wy|!VxMoQkl;lK zo`WGVclm1qxd8vlap_?pUO;zkQWv;aMjwTcbhgqe`4?Rxq*!4K6(7ViV>l~5J)Lyv zsIBu3N#AtVap9Y9JEcI$_jey*5hh2vyK9A!(I?Icl0d-mfoxMz0S{H*tBX|O(WB2L?`^iWxCU_(kkPs%#KaHC@JMlG9lqvN0Pl_=hT}$1faHu5w!l!3 z7aZvrw0($w^o8tgKR5J3HTKW_I608i4}-3&$!7!D^RMuCo^dYV_I{fI42W`M9E1vQ zCf0*Njq9`Ns*5|t(GPfKAa6ZGFOHz)HX}2_gb&<-KbyvMgo(?h2)D)y4EmK$EWlv) z>i>F4mZA5C^iUn5qfQLB%-QVOPbh7!K6c*#WE-2XAHR&Sb1A-Z(Co| zKlL;xNjR8R1v!Mg*NUekEEW zTtx)BoeCvQYp?izh=(VVadE36n}11>)ThOc&DVi_l}_QOW<{u$5lp?{=%8~2~^@p5l6JIkaNO{t^=<1&(3SMzelU=kKdWW!tvi&Be-9D!j;kM zya(S)c#6FW3xY6Svu3l}PCq%O2Gq0APZ)!h@2m&x3^#bq7R76v1#_x+Z z32$`#;tz@wtLtVz)8f*R*sl}*9kP(=2(gHm_h;tlKCyk3LF;c0m> z8K-CB?(7slka=-JwA3NEq&C)xHgt2hdB0Com%UD@bbi{I@u{7&BlW6Tz9Thj@cFSW za<+5Uz3I?W@;>kU{?GZbr`DVL_2XyQ@%_^VSsI2x%Nlp{Q|HUw!KojTzn3ro?syX^ z$OK*i-4+R%PKkmI5CP)j4nP$IUrraRz~z`AWw6YoZDb<10l07h=4=G;O(lTgiz6TV z?``F{a+hB|Sbagq*k^AVZOelbfN?4NdM$6wb5y})ZP?~mUU!u|sb{$&QMt<4zS#oB zE@l8f^0p}wcu!?GlGyPCpN}bFG1eGA8)L5W+2_1|7I|M5w+iK2rHRPnLA=(Mv&5+f zTEsz8m=Az{)b)4>=*5#rv7(~ckYysCB)|qY>0M@4@s<g9Up?z1rmJPS$EPOClZx4WEu#5P$#jAn~mz zX6uXy3P-maAm`kdG|Wa5Ok0QzxHydlLI-=SK34vOSNv(1AnY5fq z6ib16kur4gOkA9Zgxnj`tFVpLJEm1suE|Ja)cLa*IX=iUzsU^@#hMt{QGM_oyd@o? zJsoeX>{tgI<{ySY=yCO$UtJ09JX_1*k=ev5jB@GMggD~$X5`V#u7{P{DSI^6P0Y9b!`rm z>XE}>Z;l|>r&(ork?%+a->M?j7VJfss?=v2)Tq4AHO1%3>og=DuJxgPoPhUVm(Q(LvX+`ix>0u4%0&x_%xY-eb z5URP{gAqfW3G@gx?{zvb&U9;DpCN*}>+D=QeQgDNUZbjaj|lftq%G$^=w;3Hiu#bi z^i(R;PQ4VBJyj6G$-vW|hi)7zv~8*~J8q7&kjlnIk$nB}k}GhFIaE}`%*RuqYYtx9 zY(8RqTqLFsS)^jX!Dh;X1-zF4=*q7ad~d}mEQoaCXV|O2I`VI9&L|1qExYOXy2kzO zEGJ814h1&zq%m^R6vu8W%lM#Cxn))1X7&u}Ws2gUWLY~rwql7(wUg6l zAsjXoKAqmpr*(E-_Jn~&u$)#1PJ;~Ig?#T^h2RPLSR<3@#cV}TNK@^u!26}8l2RfO zx0pWf!#H7lvP&@_v^NMx7kW+td(juM_%G=D{cTObwxGFx7fX+_^3;cdZSbL4qo1*4 zl-9q@wL{a1d4fhJ|ewzgx822>W4>_h*H;j!mF?)RgqH6rCM<(ND(wev>$3x0JJPrGVJsu(pO1p5ZN9y@!}Y)DC;c+AxA9)Ib| zq-fDwS>L!H(2uzOby~oShZt^T=L}iID%X~dDQBG}i`%k^UxRCkt2XGTL7|^OhWm7y z9)KqOc~4n8jXrDe`$8(Q;JovC(p9w|k8Z+)w(ZQn)-E-M#D}J`Ynob0TX_`fcrMknS_#{-vTMyqW(HkHlu-rLR`!e&limM?8X05P& z?#r|&sIRm<>SKc5jF0=fu>k?H*|S^cn2F|^0#62)X*GvBhDN6MtL{pI#J zby7BZq{xPmCtRjOJY2^XOBYKLBqbMN%q}P#P>?oY+4J4V--HgkdvP(>Xotib?8Xt~z$ zkJp)XdTDBSVawn-e+TUv4r{IZ{tQhVX8E7RlemJ{;Fr1iRGz!$V94*JHOa$cdwMsr zJ!#syqv*sLJKACg7@sTD8Z;lLFOc$4U8w_UnzhEjOxuvwfB5PfHEPtge}#7 zAN|kj|1a8nJZcyH{zKd+Y9#kApW2`lcb&kCHLlBBd48Z6Rx@kTSNeQ_D5$wM%2Al0 z^8aTC1}zyK<;Vi-NwDExnuK783G6TLYl4!CDc!LFww#>5i7e{A$MjGa{%f}VReLX; znkC1%5G$--AD<-b8zzuClBp!|4{_h;+2^x|*?G3F^w9k+twQo+mhd)uFz!@_#C4uL7DWa9@eJsem5<1j)7(wAHzpHgE-KHzF;{SV^lP1H1YH$!=m}7ahY}EIH z!|}~E?#IqPNN4Woxz*-=g9`tNtT(Yku!WQ&2lb4y3ti6b*x7jo*u~~9CwV_Y@N47j zH^=|F@z^<;CPR*{x`Ai@$ih<2t(oMXd!r)lKUy?|gin%iA4b!;FYVmVl`XXS6dP{; z_bciPIg6ZsVUGVuK2KmKcuxa#=j9Jeaw#6vOg?yfg)lW9T`^u?^W`;~t-LVb|BAVP zJ}H_uw?ETgATQO;35Lv~jrr{XO*3C{hf_mW# zbY2G7F&*z_4Q$XZ>rRr+*581PulUU6fGxtZ{b**jl=m(Sy%W=oePCtA^}>l6z)=U8 z4X;HmR$O{>K@(!NQ!(Ya{>ZYfI#Ad3qfAB+K<&VS3aC(sy+6 zZK{+|cBGu`te;3so*}|k-_E*7q4iSLjcau*E5->2He?f`=JKQ4qL_LJi)wBJLKa`W z@>~sENWCyFD&4+K_#qVoMLd29lqXwxC#N)KVs{1BDYp1mtkAcg*&}Qp6lsXjoK2Xu?>bMiyl-u8&aY@WzRgThE#m`_Z<755E)|Xn#o4vp)}A~) zt?>r6lQh`|L`FIEWs*emI=r;+SdUc9sm3?0Oc|88z2r)(2E&eFw!1x zs$MervZlQ|)IR;EqeF$lytz4`=g9VYtE86u?E82l-RRXpQ53pu-qms98-CR+8M58WFAEC~7ut`QjG6f5Vil2}9}+e79PKFkHKuWhaxj9FzTU89)4@)xBCW_tD>g%1L1o@uvOJ^UBiN_Gc|GH z_=MfQUcI7ws=A`qXS3Iewk~@4P(}NvxQu3gjsq#`?4)axR-g>YgsI7*_H&Qj5>!O( zHhTH*8topur}m7=Y|ebInLx;_@r(S;&@a_#Gg<`mN_|7V;Dt$A{$XW8=jq`qJ!1s- z54++KruZDr>Nz-*hcCM97=PW@XjP>grwy`tnty|i>@$urTp4r_+D)ftwKm*tYS0eF zF7!|FIEW9QVjrX}SL15Z!B)08t5Ma7$6W&l>-sNxr`u_;18W`adEztm7AV(uCI|W8 z&+DfB0ytU8b>Fouw=Y+o0gq-CsT4x!8P)hwKpQMJgK6^RWJQK1)a!~yEIRu+1L7-B zo0uZOu(*L1n;^RaSZLJ#6Bore|Dw~=tD5$S7P8pQU?NR|xNd^-G-1?23ibe+L0$bp z3L!_94_(7z;I}~gi+jnT^Ymk9)80Wf26%S4bV}taz1ZH;XYsic4WtrvVVC_~1p{4w zc@e*(BNyF{U(HBg;sz0nT<|j!QLRUKmz)p)D6bvC23lONwKbU)8V%vFD5y)gW*_>b zH?}a_K&@49Q_SXNNs-(!sK?25sVG)!AAu9aJGQ4prn9ZI;A>qM9p~?P^h!8RNv0u+ zofap}GyK?Ld5KZ5^$j)n3_6x$d^V~gKib=rlx>v8lBn>uK8k?&+!?iX;xPCHm&wc&q06h`tImFR7_43i1D3Q8 z2?dC$QIL%Tg^o-kk_yr^w|IE#Xv)VtmS|7kYYmkfm522BWNg}XV-mmhP|1l4Xh_r< z&^l`e1y!UqH)(Eq6@t?%w7-^B&xPUMyE2_+sTsJJ`f5;-+}IrZh+04UvaGkObsYP_ zo2S>B=0eXlB>DRmz*aW3qIF`#S?YVTq4EfnnBG_6yuKPvm-9)HN1lk)u+x-%k3(il z!@Q=st`s`SypKK?)_v7P0o=QuUDsicuLTrUOe}n<-ZRF09beSFn zX)yTuqO!I-KZ;1Y8D($unQ2k0d`b-kPD6a!E8zfCJt^-QD^_$~r++fmro1lg7jtry z8ZxOZgw$&tk2r9>u*|16q83r&owDR+0PzJh#PW^{EH`W+5*&BdGaU5v&hUvxqGZqu zWIAlQOuUuIVv%hu-)hYqhfl$HniP@ZoVW0_u+++HgQG{8L9#ENt+66RMu>HfBc`XwaV`7$sR9bwh=CYWNG?EtIT=IQwNkr|^$jK&f<^}6v6?&x+;rzpjUx6^WP+`g?a z*2;N2)4`g@8Pz^$QHLLX!bjk371U;+ey#USYr}nBX|x>bY`3+O)GqT-^a=H_PbNU^ z!r~{rf)zGPWz_HZ(@zT$Hu3|&lscL=bc zFepa?`&o-DQzI%1DaM?8^?VE#q2? z8vOe!k^;vt`~Xk9v*yBOtEi?!AC`>s+;YG8-%Oy5#;kXmUUiNtTB!Q=A_$7J^S}5{ zF`Rd#p%1DLqBf>gsec5&XY9(wv9ij<@>EGKf%g&HK{Z=a~ZZxO%!+(xaBp|*)?xUC)brU z`hJ$6Ny{$Iv|K2?Bu~k>x5_Zn?5#T^T$F~HebX4>&fL(>NCOpjb4H}QURnl7O#}*( z{uChN;@V^T?gH3d<>7{P#kKUfuxZ8f%kSbWn8e`~X--uR?(g`=%d zL1t5RI5f}%ZXG5&+RC%g)qP%2-6OZOKDUTM7H5c;%^%@gNTf9DBoQM1jO>@~Z$GnD z0g@B03j!Iy*a$LaVMQ^AWsO^NuWy?in7S)(dqzxPYY*qr6pZS)C?q^f)j!v$CSX2y z9SR4z>ylB&7GG`rnqEz{Ox~S`zu4J=RdvZ@9LD6N)0(+c9K)lz7W@Vr63vT`AuBrd z=%#DcfY<$`qAR$nkR>-5OKbriq+!0L1PSdYsQo0KTyESV6)EEmZ7g}}eLCR0c67_F zdPUbd$ZfyJ$V7>DxJEm8amYEZ45>Drr>*0ACdCnnZYGH%{}oAu=W+e%JHk9QTefQy z(XouFr_@b*Jrb?mA-3!&CmWu^b>knhv zgE6CxuC)#Dmq(UZs3SN7Zt|DT7Ib3zLleR@ykmz1%3Agd&L{R}Sey^D$Es(m; z>QD1uInVE4WZ_%?IVhtKcz()-AFWyl<}FV(xo<}3_Gog+Q3C6V*`Bct#~Vg4biFBU zw3TxDSYFmiFpt>sKjEpvYSRTe=k{7hGn##Nt|*t~u9GbR&WNROLoh)&GR@O(yr2Z< z(ehFlS6Y?`%8LaRkm-xmV7wpOW=u!YP9dy8gBBYWf_2QgQA3?!@rZB9HxK26gBL=( z1lADaWP)=E34UZ8Q(K1v0!RwZ=Pa`PBgXUo?pr^u3d6d|3G#?*Ejs{L|IFJXD8PK2 zgRi=E*#q~Z2%!@NpRYW)vE(Gwln>VezL zLWYa!JMG$HdGVZ0g%rK3y1AcQY^m*RH1a?35<<)j+bp6iy2>{_Ti13T$fkW#DY_0u z93wda@OP{)CNGhJ7FjOu%)Wq8Fys$AjSeCf&>UdZEIAh-EZo3K8KI!Sg>-)8!77T% za(-v)uhMW@vt`oBl!KMD5VfoKe10S>Gm5XVnv8huT0MdFIzO~^##Wz>4^^wWYg*{a zdsQzM(u00#jcOai0$+X|OoJGL=o{39fE z+_t^%%Zw= z`I}}AhTP6UIN}cQtt}?m5Mb}>R+_H({`xwVaTj^+1VU6TiEC8EVK-`=^*7Ts=APIU zDgV{VqNH{tik(LDTcn`r4}VThFkDkCFTeFZI36!WH!NlMzR8Gv(XY~1?>J@o?;!Tk zRWYxFkYf6Whf3GRzJ~H#{2AmU<_ej!?i#P(bsHSABG0C&sg*Eycws~amkO`X0o{EH z$!5`s=0H}h7lLHMAz!B-1}VelRc!1$vA(5geX?a0!ZWwTIF&7DQ7G{7A(mnAE4ufa z`s+t89s`O!B`=lp{tW30FS;+Y83bf$=l+XV;?RXS!gPJbb3}9Dqx34z7e#}^$xfP$ zt|wvxlQv7l@L|v)J+F}jDBi-4pPb%d;m=aFg@q8+j!g%gU(O-TH}jA9mE-j4?akO# zH!8zU_`*{ets^cuzj!UiwSw=gf3o6pJ_3QEOCOnsQL9B_W}cX@q*CqM{H4h8jH0Lo zBN5D(J9-o0Cl4)AhNC`+1HO{(;1d(ocOQg%Yk zH2PT316SBC*cQ-$il^gw$){)uFdY^595|YPWaf>C7)4oJD|qN4_AWXO@0a9o4d_3$ z26$<^@}M&u2(XB((Ib(9^t-MdrZE1tW4zBrrO$q4OptheQ7|^50yNim)`h>48#$4; zqBe^9m!sM(?w|gxy}4dgg4+BAsgpBJ;l+4I6Z|dSx(|s`K(^c{;*yKSV7OvQ&}kmU zbt+G6km#F8le-ee#G&C1@FtkV5;%cP(B^&Cvbn5x7}S2KhH`tX0D4g0HVG%YjFWw| zwX*&(m(6vx?rs?2)Wt#c0T8?HK@iA5&Vd;HzCTNFKd5B5O0rbz+i5dyMQq4&l2)r# zc91s8$z~Pu^Pt)H4DYX@Gw<@irr7WR6mc?wO615$UM$zV?=nUXR=cgIs)#(Bc- zYszyCiPQW^*_Fo^#L{HO{BUOYTGLsGM|ybo_Q^du73J1xp%0xpov0*#WP(;>(xN_= z)jx_Q02v2;8G~r+TXeZ^?D3iklefRD29%Dck8q(5K59K8(Bj;b@81YEAz6pQ>V5Wk zYrR6s9D%9Je;KC+#35$lo_a(s`M y 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

tY~h_iJHf*SBFApc=~{{1tWydPACVMb&9Jv%Q* zUxN1)))Kzm_DtWC87q|GWfJ7WBEir)_wd zks14#{`5Fp2OHst3XEtR_3=MV1FujYA0PX4N&5^Xt17cD|MmpbRR&-zQo=`enT@(E zXuN#QSO9wkHh_zqGPysofoAcKUTYV|sl+o7vTfiM(7PpN zVV`n<9p*OFwNL411nyZI!-uNiU{lRTIp*EX1sNt2(%{l095dAP!(sM8{J8~s*XC3y z)yDPTz^76Jorn?-0RP*x_|9HEi#4G zKtJvWw9+yto%J7JwAH11+-Mqa-pDa+ZTWkvPL0pE@%2!nz4I6eXzJ4)TRSP^e^*Qk z=Ewxl#pk9w{R-JjJa5LI&zE-~Vk-z+91rrQMl0P@PXAckjd0D)>4$^&_xIi17`0`A zj=OC%7y1=j1z4g+FXLN}wqx?ctsvk*4~^W_LCV~(DrfFe9pvKyl?;hC#a_GmFaBFkxE17N_DT(mqZ$rz=L)j4QPM={CkwpentE0tGa0bE>;fL^o$>t zX5G-|k z^?Vv_KK;OPdU|g7b<2A>hL__R`SRb}W(7LcjK*fGZnP!nOWK4tIQ#zl@7V+L`14i# zcbL!o_R&lOLn0X`I7mUpLTHeyWO=py$iQd|$oMIYE-HXw26X)G$&b*l71R@`hKoQ6 zi^Ihmgmh~|&y-0E>2mGZ$KeF|#-#wfXP2`5AHZH_G@be25z6ET&ri|Ma!lYRZ^=&I*9ZcIMz5-T?BE7meEtmYYH!cY zjra?rs4#(WRO{~k0h#r518rDTC*9w_4^a>hU&Vt?ARCeoToZ?2WRA|Tf51>cm3<$h zkQgSnvMmrBrnLs^>`e2a;cZT#zQVlT8Z?9(c2j|J_tTf53Or*|DwVgpF*YS}u4y_Q zX5UX2PjwwvZrGUH|8cKb_c2C5BI90IOlm^y_>0B__goTIQ6PFz8!{cN3OG#uQ0UD188BLUv`r@oVSzyYnm)K%28y2u_ z!~`_wJ;jBlg#HMpbPAwj3j+ToQtB}a#Mx=5=2HFX!_W_b@+)Ym0O$G|K!@KK5Gab@ zZSFH!ef)=LX$hmBf6l0fulQu}}ANfAaI^ z&v2grSZ3?t;l8`qKDc}7K4!r`v$3BM1m*6}4^z2+{4tg@jSuss?!W6E?}l@I?E^mS zxHmrGX$dJuFlYsi1%UEh)zA2_dN>UO^tbnT40wWeiR}Y`f&eTgK)t{_V4$G&?(PJx zb@%>;mxtG%BJ2KLwOP~NM)vhK-{XBKY`N}FX1Cze>D-;hskZic|MnWM4HyagvKAH0 z%nK$cf9XVpV`ag(94M|8)2E9HEE>hYmqq7XGO$3?y8x2wra z-(GBqdDlXDZYyNBY6>=IjLh9mKXgwg^0fI{rxr-Zc}gp1ofdm2_jx*e+5h%yf4xj> zH#nQuct-+3s%-OBAMs^6Rx`ROfOC|7doydz&i{UxHa!WH%_Frpz3SI-=V!K{)BH3K zd|k+A2F#D$GwYEJ74rxJLw{W-%0D*vBLw^4u954PwTPT`!E*Ga8^G;P&~#`_sv=60 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 z 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 T>`Y 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) @@ -541,8 +544,8 @@ def suggestions_scenario(d, out): ('/giv', '/give'), ('/fill ^', '/fill ^ ^'), ('/give @s diamond_sw', '/give @s minecraft:diamond_sword'), - ('/setblock ~ ~ ~ sto', '/setblock ~ ~ ~ minecraft:stone'), - ('/fill ~ ~ ~ ~1 ~1 ~1 sto', '/fill ~ ~ ~ ~1 ~1 ~1 minecraft:stone'), + ('/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'), From a97d8098c7a5ac9ba9c1043035b26a3ad1134606 Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 17:47:29 +0100 Subject: [PATCH 15/22] Fix firework tooltip translations --- .../examples/firework_tooltip_fixture.rs | 7 ++- crates/horizon-client/src/enchant.rs | 2 + crates/horizon-client/src/item_tooltip.rs | 59 +++++++++++++++++++ tools/test_firework_tooltip_parity.py | 3 +- 4 files changed, 67 insertions(+), 4 deletions(-) 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/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/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs index 0fc9910d1..1dbbbf38b 100644 --- a/crates/horizon-client/src/item_tooltip.rs +++ b/crates/horizon-client/src/item_tooltip.rs @@ -591,6 +591,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/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) From 0928c83d4c28fb285c07e5c2404c5a7016cb5d7d Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 18:39:53 +0100 Subject: [PATCH 16/22] Skip provably unchanged native End surface traversal --- .../examples/streaming_bench.rs | 66 ++++++- .../horizon-world/examples/chunkgen_bench.rs | 118 ++++++++++- .../horizon-world/src/worldgen/generator.rs | 184 ++++++++++++++++-- 3 files changed, 341 insertions(+), 27 deletions(-) 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-world/examples/chunkgen_bench.rs b/crates/horizon-world/examples/chunkgen_bench.rs index 4992515c5..2eb433600 100644 --- a/crates/horizon-world/examples/chunkgen_bench.rs +++ b/crates/horizon-world/examples/chunkgen_bench.rs @@ -3,6 +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] [--snapshot PATH] use horizon_core::position::ChunkPos; use horizon_world::{ DATA_VERSION, @@ -274,7 +275,9 @@ 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"); let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None; while let Some(arg) = args.next() { @@ -285,7 +288,11 @@ 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, + "--no-map" => map = false, "--dimension" => { let d = next(); dimension = if d.contains(':') { @@ -326,6 +333,16 @@ fn main() -> Result<(), Error> { dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?; return Ok(()); } + if warmup { + let mut worker = generator.worker(); + for z in -4..=4 { + for x in -4..=4 { + std::hint::black_box( + worker.generate_proto(ChunkPos::new(center.0 + 64 + x, center.1 + 64 + z))?, + ); + } + } + } let (x0, z0) = (center.0 - size / 2, center.1 - size / 2); let count = (size * size) as usize; let next = AtomicUsize::new(0); @@ -353,6 +370,7 @@ fn main() -> Result<(), Error> { handles.into_iter().try_for_each(|h| h.join().unwrap()) })?; let elapsed = start.elapsed(); + let cpu_elapsed = cpu_seconds() - cpu; println!( "generated {count} proto chunks with {threads} threads in {elapsed:.2?}: {:.1} chunks/s ({:.1} ms/chunk/thread)", count as f64 / elapsed.as_secs_f64(), @@ -360,7 +378,7 @@ fn main() -> Result<(), Error> { ); println!( " cpu time {:.1} ms/chunk", - (cpu_seconds() - cpu) * 1000. / count as f64 + cpu_elapsed * 1000. / count as f64 ); let timings = timings.into_inner().unwrap(); let per_chunk = |f: fn(&StageTimings) -> std::time::Duration| { @@ -379,10 +397,23 @@ fn main() -> Result<(), Error> { per_chunk(|t| t.surface), per_chunk(|t| t.carvers) ); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "proto", "chunks": count, + "threads": threads, "wall_s": elapsed.as_secs_f64(), "cpu_s": cpu_elapsed, + "biomes_ms_chunk": per_chunk(|t| t.biomes), "noise_ms_chunk": per_chunk(|t| t.noise), + "structures_ms_chunk": per_chunk(|t| t.structures), + "surface_ms_chunk": per_chunk(|t| t.surface), "carvers_ms_chunk": per_chunk(|t| t.carvers)}) + ); + } let mut chunks: Vec> = slots .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(); @@ -441,6 +472,13 @@ fn main() -> Result<(), Error> { } } let elapsed = start.elapsed(); + if json { + println!( + "BENCH {}", + serde_json::json!({"phase": "decorate", "chunks": decorated, + "wall_s": elapsed.as_secs_f64()}) + ); + } let totals = totals.into_inner().unwrap(); println!( "decorated {decorated} chunks in {elapsed:.2?}: {:.1} chunks/s; feature roots placed {}, unsupported {}, failed {}", @@ -461,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() { @@ -492,6 +533,9 @@ fn main() -> Result<(), Error> { } } } + if !map { + return Ok(()); + } let mut legend = BTreeMap::>::new(); let step = (size * 16 / 96).max(1); for bz in (0..size * 16).step_by(step as usize) { @@ -534,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/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 2d7dd251c..fdba843b0 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,29 @@ 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), + 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| { @@ -2407,6 +2449,108 @@ impl GeneratorWorker { #[cfg(test)] mod tests { use super::*; + #[test] + fn end_identity_surface_matches_normal_surface_and_rejects_custom_rules() { + let root = std::env::var_os("HORIZON_TEST_RESOURCES") + .map(std::path::PathBuf::from) + .unwrap_or_else(|| { + Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3") + }); + if !root.join("worldgen/world_presets.json").exists() { + eprintln!("skipping: no worldgen bundle at {}", root.display()); + return; + } + let registry = Box::leak(Box::new(crate::level::data::load_registry(&root).unwrap())); + let data = GeneratorData::load(&root.join("worldgen"), registry).unwrap(); + let preset: Value = serde_json::from_str(&data.world_presets["minecraft:normal"]).unwrap(); + let settings: Value = serde_json::from_str(&data.settings["minecraft:end"]).unwrap(); + let mut pipeline = Pipeline::new( + data.clone(), + 12345, + LegacyRandom::new(12345), + &preset["dimensions"]["minecraft:the_end"]["generator"], + &settings, + false, + None, + ) + .unwrap(); + let mut worker = OverworldGenerator::for_world( + data.clone(), + 12345, + "minecraft:normal", + "minecraft:the_end", + false, + ) + .unwrap() + .worker(); + assert!(pipeline.identity_end_surface(ChunkPos::new(0, 0))); + for pos in [ + ChunkPos::new(0, 0), + ChunkPos::new(128, 128), + ChunkPos::new(-128, 192), + ChunkPos::new(1_875_000, -1_875_000), + ] { + let actual = pipeline.generate(&mut worker.state, pos).unwrap(); + let rule = pipeline.rule.clone(); + // A singleton sequence evaluates the same block rule through the full surface path. + pipeline.rule = MaterialRule::Sequence(vec![rule.clone()]); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + let expected = pipeline.generate(&mut worker.state, pos).unwrap(); + pipeline.rule = rule; + assert_eq!( + actual.terrain.generation_stage(), + expected.terrain.generation_stage() + ); + for section in 0..actual.terrain.height() as usize / 16 { + assert_eq!( + actual.terrain.section(section).unwrap().to_nbt().unwrap(), + expected.terrain.section(section).unwrap().to_nbt().unwrap() + ); + } + for kind in HeightmapType::ALL { + assert_eq!( + actual.terrain.heightmap(kind).map(|m| m.raw_data()), + expected.terrain.heightmap(kind).map(|m| m.raw_data()) + ); + } + assert_eq!( + actual.terrain.postprocessing(), + expected.terrain.postprocessing() + ); + assert_eq!( + actual.terrain.block_ticks().pack(0), + expected.terrain.block_ticks().pack(0) + ); + assert_eq!( + actual.terrain.fluid_ticks().pack(0), + expected.terrain.fluid_ticks().pack(0) + ); + assert_eq!(actual.block_entities, expected.block_entities); + assert_eq!(actual.entities, expected.entities); + assert_eq!(actual.structures(), expected.structures()); + } + assert!(!pipeline.identity_end_surface(ChunkPos::new(i32::MAX, 0))); + let old_rule = pipeline.rule.clone(); + pipeline.rule = MaterialRule::Block(registry.default_state("minecraft:stone").unwrap()); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + pipeline.rule = old_rule; + let old_fluid = pipeline.settings.default_fluid; + pipeline.settings.default_fluid = registry.default_state("minecraft:stone").unwrap(); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + pipeline.settings.default_fluid = old_fluid; + let old_source = std::mem::replace( + &mut pipeline.source, + ResolvedBiomeSource::Fixed(super::super::biome_source::FixedBiomeSource { + biome: "minecraft:the_end".into(), + }), + ); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + pipeline.source = old_source; + pipeline.aquifer = Some(std::array::from_fn(|_| { + pipeline.router.get(RouterField::Erosion).clone() + })); + assert!(!pipeline.identity_end_surface(ChunkPos::new(0, 0))); + } #[test] fn far_surface_matches_undecorated_land_and_keeps_end_void() { From cd494e74bad04d515d6fedc8b5f6db8f5bf5af1d Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 19:27:45 +0100 Subject: [PATCH 17/22] Cache uniform resident biome cells during surface generation --- .../horizon-world/src/worldgen/generator.rs | 162 +++++++++++++++++- 1 file changed, 159 insertions(+), 3 deletions(-) diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs index 2d7dd251c..28b45ea44 100644 --- a/crates/horizon-world/src/worldgen/generator.rs +++ b/crates/horizon-world/src/worldgen/generator.rs @@ -1114,6 +1114,11 @@ where 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(), @@ -1149,6 +1154,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 +1399,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 +1463,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 +1501,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 +1849,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 +2016,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( @@ -2408,6 +2481,89 @@ impl GeneratorWorker { mod tests { use super::*; + #[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() { let root = std::env::var_os("HORIZON_TEST_RESOURCES") From 4e04e97565575b09c5e012cef61a5ac619bbe81b Mon Sep 17 00:00:00 2001 From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com> Date: Thu, 22 Oct 2026 20:29:00 +0100 Subject: [PATCH 18/22] Reuse eligible End island candidates across bounded density volumes --- .../horizon-core/src/density/end_islands.rs | 140 +++++++++++++++++- 1 file changed, 139 insertions(+), 1 deletion(-) 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() + ); + } + } +} From 16b7e600743006324a1856d357ee1021451cbb59 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 21:33:28 +0200 Subject: [PATCH 19/22] Fix #1222 at the root: vehicles for a server's players Single player on its server thread, LAN guests and dedicated-server players could not board, drive or break boats and minecarts, nor use item frames and armor stands: the client sent Interact/Attack only for mobs, the server aimed only at mobs, and nothing carried riding over the network. Client (remote.rs, remote_vehicles.rs): - Interact/Attack for boats, minecarts, item frames, armor stands and paintings, with the hit location (Minecraft.hitResult). - SetPassengers seats the player; a boat ticks on the rider's client and goes to the server as MoveVehicle and PaddleBoat every tick; a MoveVehicle back puts it where the server says; a minecart moves on the server and the rider sits in it. Server (lan_vehicles.rs, lan_actions.rs, hub.rs): - look_at_entity aims at every pickable object, at the client's hit point. - The guest's vehicle is its Entity.vehicle during its turn; tick_boats and tick_carts leave guest-ridden vehicles to their riders. - handleMoveVehicle with its checks (invalid values kick, too quickly, moved wrongly, colliding with anything new), handlePaddleBoat. - Player.rideTick: sneaking gets out, then SetPassengers and the teleport beside the vehicle (dismountTo); a minecart moves with the rider's input; a passenger's moves only turn it. - SetPassengers for guests through hub.riding; one rider per vehicle. lan_e2e: boats (host and guest board, paddle, the other side sees the boat move, sneak out, break), minecarts and frames (item frame and armor stand) for both, passing with and without --server-thread. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 2 + crates/horizon-client/src/game/boats.rs | 13 +- crates/horizon-client/src/game/lan.rs | 8 +- crates/horizon-client/src/game/lan_actions.rs | 64 +++- .../horizon-client/src/game/lan_entities.rs | 11 +- .../horizon-client/src/game/lan_vehicles.rs | 288 ++++++++++++++++++ crates/horizon-client/src/game/minecarts.rs | 5 +- crates/horizon-client/src/game/remote.rs | 63 +++- .../horizon-client/src/game/remote_objects.rs | 10 + .../src/game/remote_vehicles.rs | 181 +++++++++++ crates/horizon-client/src/lan/guest.rs | 10 + crates/horizon-client/src/lan/hub.rs | 6 + crates/horizon-protocol/src/packets/play.rs | 17 ++ tools/lan_e2e.py | 224 +++++++++++--- 14 files changed, 834 insertions(+), 68 deletions(-) create mode 100644 crates/horizon-client/src/game/lan_vehicles.rs create mode 100644 crates/horizon-client/src/game/remote_vehicles.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index ab150a0d3..48fc141c9 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; 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/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..f433bc06b 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); 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/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 9d1e82e56..f3fe7b28f 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -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, @@ -1367,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); @@ -1753,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() { @@ -2932,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 { @@ -2955,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], @@ -2972,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, @@ -3319,6 +3332,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; }; @@ -3341,9 +3356,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); } @@ -3574,6 +3598,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) { @@ -3953,6 +3992,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) { diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 4cf9cb1a8..101dd981d 100644 --- a/crates/horizon-client/src/game/remote_objects.rs +++ b/crates/horizon-client/src/game/remote_objects.rs @@ -188,7 +188,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 +218,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); 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/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-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/tools/lan_e2e.py b/tools/lan_e2e.py index cc1dc9fcf..3395c01f0 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -116,8 +116,13 @@ 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 with --server-thread) right-clicks a - boat on water and rides it, sneaks out, and breaks it with its fists (#1222). +- 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). - 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). @@ -159,7 +164,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', 'boats'] +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'] class Game: @@ -2312,50 +2317,175 @@ def check_ladder(host, guest, out): guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') +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 single player boards a boat on water with a right click, sneaks out, and breaks it.""" - x, y, z = (int(v // 1) for v in pos_of(host)) - bx = x + 3 - host('command', command='gamemode survival') - host('command', command=f'fill {bx - 1} {y} {z - 1} {bx + 1} {y + 3} {z + 1} minecraft:air') - host('command', command=f'fill {bx - 1} {y - 1} {z - 1} {bx + 1} {y - 1} {z + 1} minecraft:water') - host('command', command=f'summon minecraft:oak_boat {bx + 0.5} {y - 0.1} {z + 0.5}') - host.wait(30) - boats = [o for o in host('status')['objects'] if o['kind'].endswith('oak_boat') - and abs(o['position'][0] - (bx + 0.5)) < 2 and abs(o['position'][2] - (z + 0.5)) < 2] - try: - assert boats, 'the host sees no boat on the water' - boat = boats[0] - bp = boat['position'] - host.raw('look-at', f'{bp[0]:.2f}', f'{bp[1] + 0.3:.2f}', f'{bp[2]:.2f}') - host.raw('mouse', 'right', 'click') - host.wait(10) - riding = host('status').get('riding') - assert riding == boat['id'], f'right-clicking the boat {boat["id"]}: riding {riding}' - host.raw('key', 'shift', 'down') - host.wait(10) - host.raw('key', 'shift', 'up') - host.wait(10) - riding = host('status').get('riding') - assert riding is None, f'sneaking out of the boat: riding {riding}' - host('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') - host.wait(5) - gone = False - for _ in range(10): - here = [o for o in host('status')['objects'] if o['id'] == boat['id']] - if not here: - gone = True - break - bp = here[0]['position'] - host.raw('look-at', f'{bp[0]:.2f}', f'{bp[1] + 0.3:.2f}', f'{bp[2]:.2f}') - host.raw('mouse', 'left', 'click') - # VehicleEntity.tick takes 1 off the damage every tick: hit fast. - host.wait(2) - assert gone, 'ten hits left the boat in place' - return {'boat': boat['id'], 'rode': True, 'broken': True} - finally: - host('command', command=f'kill @e[type=minecraft:oak_boat,x={bx},y={y},z={z},distance=..6]') - host('command', command=f'fill {bx - 1} {y - 1} {z - 1} {bx + 1} {y - 1} {z + 1} minecraft:stone') + """#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 = {} + for label, player, other in (('host', host, guest), ('guest', guest, host)): + x, y, z = (int(v // 1) for v in pos_of(player)) + bx = x + 3 + player('command', command='gamemode survival') + # A pool ten blocks long, with a path beside it to walk back to the boat. + player('command', command=f'fill {bx - 3} {y} {z - 1} {bx + 1} {y + 3} {z + 9} minecraft:air') + player('command', command=f'fill {bx - 3} {y - 1} {z - 1} {bx - 2} {y - 1} {z + 9} 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 = {} + for label, player in (('host', host), ('guest', guest)): + x, y, z = (int(v // 1) for v in pos_of(player)) + 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 = {} + for label, player, other in (('host', host, guest), ('guest', guest, host)): + x, y, z = (int(v // 1) for v in pos_of(player)) + 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_growth(host, guest, out): """Block ticks near a guest 1000 blocks from the host: only the guest's tickets tick them.""" @@ -2669,7 +2799,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, 'boats': check_boats} + '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} def run(ctl, out, resources, checks): From afd38744824ed6a5c3b08bbaf0dd07f7c7742e3b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:15:17 +0200 Subject: [PATCH 20/22] Lightning for a server's players: the bolt and the sky flash With single player on its server thread the window drew no lightning, and LAN guests and dedicated-server players never did: the server never sent the bolt (it lived outside the tracked entities) and the client had nothing to draw for a lightning_bolt AddEntity. The server gives each bolt an entity id and tracks it like the other entities; the client adds a visual-only bolt for it (LightningBolt.tick off the server: sounds, the sky flash, the drawn bolt) and ticks bolts and the flash in its level tick. `status` reports bolts and flashes, and lan_e2e's `lightning` check summons one beside each player and asserts both sides get the bolt and the flash. lan_e2e: the vehicle checks put the players apart first, and run() sets HORIZON_SERVER_THREAD explicitly either way, as #1265 does. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 3 + crates/horizon-client/src/game/control.rs | 2 + .../horizon-client/src/game/lan_entities.rs | 5 ++ crates/horizon-client/src/game/lightning.rs | 27 +++++++- crates/horizon-client/src/game/remote.rs | 3 + .../horizon-client/src/game/remote_objects.rs | 3 + tools/lan_e2e.py | 67 +++++++++++++++---- 7 files changed, 97 insertions(+), 13 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 48fc141c9..6bb86231c 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1324,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, @@ -11615,6 +11617,7 @@ impl<'a> Game<'a> { dragging: false, avatar: Default::default(), flash: 0, + lightning_seen: [0; 2], sleeping: None, sleep_timer: 0, dim: Dim::Overworld, 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/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs index f433bc06b..5f46f7c21 100644 --- a/crates/horizon-client/src/game/lan_entities.rs +++ b/crates/horizon-client/src/game/lan_entities.rs @@ -273,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 @@ -284,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/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 0f43c4c54..476cb5aa4 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -9,7 +9,9 @@ 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, @@ -131,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, @@ -140,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 { @@ -216,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); diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index f3fe7b28f..c482d9728 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -3271,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() { diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs index 101dd981d..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). @@ -284,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/tools/lan_e2e.py b/tools/lan_e2e.py index 3395c01f0..d4f34ff84 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -123,6 +123,8 @@ address. The script then checks, from both sides, what a guest's game used to ge 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). @@ -164,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', 'boats', 'minecarts', 'frames'] +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: @@ -2317,6 +2319,22 @@ 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) @@ -2359,8 +2377,9 @@ def check_boats(host, guest, out): 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 = (int(v // 1) for v in pos_of(player)) + x, y, z = spots[label] bx = x + 3 player('command', command='gamemode survival') # A pool ten blocks long, with a path beside it to walk back to the boat. @@ -2404,8 +2423,9 @@ 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 = (int(v // 1) for v in pos_of(player)) + 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') @@ -2436,8 +2456,9 @@ 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 = (int(v // 1) for v in pos_of(player)) + 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') @@ -2487,6 +2508,33 @@ def check_frames(host, guest, out): 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) @@ -2799,18 +2847,13 @@ 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, 'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames} + '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): host, guest = Game('host', ctl, resources), Game('guest', ctl, resources) - # Without --server-thread the host runs the game's default, the world in the frame, as players - # get it (`boats` fails there if the default goes back to the server thread before it has - # vehicles, #1222). - if SERVER_THREAD: - host.d.env['HORIZON_SERVER_THREAD'] = '1' - else: - host.d.env.pop('HORIZON_SERVER_THREAD', None) + # Either way explicitly: the game's default is the server thread. + host.d.env['HORIZON_SERVER_THREAD'] = '1' if SERVER_THREAD else '0' results = {} try: host.pid = host('launch', wait=False, offscreen=sys.platform == 'darwin')['pid'] From 1a8dae9f2102a361c6e8d3d6e0c490921e00508b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:23:32 +0200 Subject: [PATCH 21/22] lan_e2e boats: the pool in a stone basin, for worlds that float Co-Authored-By: Claude Opus 5.5 --- tools/lan_e2e.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index d4f34ff84..a93115f63 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -2382,9 +2382,10 @@ def check_boats(host, guest, out): x, y, z = spots[label] bx = x + 3 player('command', command='gamemode survival') - # A pool ten blocks long, with a path beside it to walk back to the boat. - player('command', command=f'fill {bx - 3} {y} {z - 1} {bx + 1} {y + 3} {z + 9} minecraft:air') - player('command', command=f'fill {bx - 3} {y - 1} {z - 1} {bx - 2} {y - 1} {z + 9} minecraft:stone') + # 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) From 7f7a05cbd093b87093267bcb88541744d9fd8591 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:49:31 +0200 Subject: [PATCH 22/22] Play with Friends on single player's server thread Sharing a world with an invite code refused with the integrated server on its own thread ("open a singleplayer world first"): the window is a client there. It now shares that server as Open to LAN publishes it: friends_start publishes it when it isn't, the invite tunnel points at its port, stopping sharing unpublishes it again, and the pause menu shows the Friends entry with the players the server lists. test_friends.py --server-thread runs the host's world on its server thread; the host's own move and blocks go through /tp, /fill and /setblock, which the server answers in both modes. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game/friends.rs | 24 +++++++++++++++-------- tools/test_friends.py | 18 ++++++++++++++--- 2 files changed, 31 insertions(+), 11 deletions(-) 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/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: