diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 60bbbf057..1ea2db6fa 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -8,7 +8,7 @@ name: nightly audit # gh workflow run "nightly audit" -f dry_run=true # the audit, without touching issues on: schedule: - # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:00 in Paris. + # GitHub's schedules are in UTC: both, and the first step keeps the one that is 03:07 in Paris today. - cron: '7 1 * * *' - cron: '7 2 * * *' workflow_dispatch: @@ -31,14 +31,19 @@ jobs: audit: # The Mac mini's runners only: the audit compares with the previous one, so it stays on one platform. runs-on: [self-hosted, horizon-game, macOS] - timeout-minutes: 150 + timeout-minutes: 240 # every harness (~80 min) plus lan_integration (~40 min an attempt under load, retried) steps: - - name: 03:00 in Paris + - name: 03:07 in Paris id: when + env: + SCHEDULE: ${{ github.event.schedule }} run: | - hour=$(TZ=Europe/Paris date +%H) - if [[ "${{ github.event_name }}" == schedule && "$hour" != 03 ]]; then - echo "It is ${hour}:00 in Paris: the other schedule runs the audit." + # Which cron is 03:07 in Paris, from Paris's offset today: GitHub can start a schedule hours late, so the + # clock at start time can't tell (on 2026-10-26 both started after 04:00 Paris and both skipped). + offset=$(TZ=Europe/Paris date +%z) + ours=$([ "$offset" = +0200 ] && echo '7 1 * * *' || echo '7 2 * * *') + if [[ "${{ github.event_name }}" == schedule && "$SCHEDULE" != "$ours" ]]; then + echo "Paris is at UTC${offset} today: the '$ours' schedule runs the audit." echo "run=false" >> "$GITHUB_OUTPUT" else echo "run=true" >> "$GITHUB_OUTPUT" @@ -66,7 +71,8 @@ jobs: run: | echo "since=$(date +%Y-%m-%dT%H:%M:%S)" >> "$GITHUB_OUTPUT" set +e - python3 tools/parity.py --all --timeout 1800 2>&1 | tee "$RUNNER_TEMP/audit.log" + # lan_integration (the whole lan_e2e suite) takes ~2,400 s under load, past the usual 1,800. + python3 tools/parity.py --all --timeout 3000 2>&1 | tee "$RUNNER_TEMP/audit.log" echo "exit=${PIPESTATUS[0]}" >> "$GITHUB_OUTPUT" { echo '```'; tail -40 "$RUNNER_TEMP/audit.log"; echo '```'; } >> "$GITHUB_STEP_SUMMARY" - name: Issues for the harnesses that regressed diff --git a/AGENTS.md b/AGENTS.md index 549fa5c7f..dcd4ca595 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -66,7 +66,7 @@ cargo build --profile fast -p horizon-client # optimized, quick to link: python3 tools/parity.py --changed origin/main # the harnesses your branch can affect (CI's parity job) python3 tools/parity.py --changed-files paths.txt --list # which harnesses cover these files, without running them python3 tools/parity.py mob_ai sculk # named harnesses -python3 tools/lan_e2e.py --check chest # two real games over LAN (host in-frame); --server-thread for the host on its server thread +python3 tools/lan_e2e.py --check chest # two real games over LAN (server-thread host); --in-frame compares the fallback python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end ``` @@ -156,7 +156,7 @@ python3 tools/agent_control_e2e.py # horizon-ctl / MCP end to end exactly as a LAN guest or a dedicated server's player does. This is what players run. Open `[server-thread]` issues list the gaps left. 2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`):** the window's `Game` ticks - the world itself, one level that follows the player (`fn enter_dimension`). Most harnesses test this path. + the world itself, one level that follows the player (`fn enter_dimension`). Deterministic rule fixtures still use this path; player-facing integration uses the default server thread. LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths when you touch player-facing gameplay: @@ -164,8 +164,8 @@ when you touch player-facing gameplay: ```sh cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T # server thread cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --in-frame # in-frame -python3 tools/lan_e2e.py --check # host in-frame, guest is a server client -python3 tools/lan_e2e.py --server-thread --check # host on its server thread (portals, levels, distance, lava need it) +python3 tools/lan_e2e.py --check # host on its server thread, guest is a server client +python3 tools/lan_e2e.py --in-frame --check # comparison (portals, levels, distance, lava need server-thread mode) python3 tools/parity.py dedicated_server server_entities server_player_damage ``` diff --git a/Cargo.lock b/Cargo.lock index d9c91b576..0e93bba0e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1437,12 +1437,14 @@ dependencies = [ name = "horizon-mods" version = "0.1.0" dependencies = [ + "horizon-shader-api", "log", "minisign-verify", "serde", "serde_json", "sha2", "toml", + "wasmparser", "wasmtime", "wit-component", "wit-parser", @@ -4147,6 +4149,28 @@ dependencies = [ "wit-parser", ] +[[package]] +name = "wast" +version = "254.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "febc59cde513fc8f39b8ffd487893723c555fdd024e2e3dc7d165181e6397ea0" +dependencies = [ + "bumpalo", + "leb128fmt", + "memchr", + "unicode-width", + "wasm-encoder", +] + +[[package]] +name = "wat" +version = "1.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7db96351e51a3a1bbe6812f029e1100b4d9a5e02161fb63104bd2271fc847e7e" +dependencies = [ + "wast", +] + [[package]] name = "wayland-backend" version = "0.3.17" @@ -5012,6 +5036,7 @@ dependencies = [ "wasm-encoder", "wasm-metadata", "wasmparser", + "wat", "wit-parser", ] diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs index 8f0019a0b..f42674da8 100644 --- a/crates/cargo-horizon-mod/src/check.rs +++ b/crates/cargo-horizon-mod/src/check.rs @@ -47,6 +47,7 @@ impl Report { "api": self.facts.api, "side": self.facts.side, "capabilities": self.facts.capabilities, + "api_level": self.facts.api_level, "game": self.facts.game, "requires": requires, "sha256": self.sha256, @@ -70,6 +71,8 @@ impl Report { if let Some(side) = f.side { let side = serde_json::to_value(side).unwrap_or_default(); out += &format!(", API {}, {}", f.api, side.as_str().unwrap_or("?")); + } else if self.kind == Kind::Shader { + out += &format!(", shader API {}", f.api); } else if !f.api.is_empty() { out += &format!(", format {}", f.api); } @@ -85,6 +88,9 @@ impl Report { ")\n {} bytes, SHA-256 {}, {signed}\n", self.size, self.sha256 ); + if let Some(level) = f.api_level { + out += &format!(" needs mod API level {level} or newer\n"); + } for c in &f.capabilities { out += &format!(" may {}\n", c.describe()); } @@ -114,6 +120,7 @@ pub fn kind_of(path: &Path) -> Option { "hmod" => Some(Kind::Mod), "hpack" => Some(Kind::Modpack), "zip" => Some(Kind::ResourcePack), + "hshader" => Some(Kind::Shader), _ => None, } } @@ -312,7 +319,7 @@ mod tests { .unwrap(); assert!(e.contains("signature"), "{e}"); let e = check(&pack, Kind::Shader, None, None).err().unwrap(); - assert!(e.contains("shader packs open"), "{e}"); + assert!(e.contains("horizon-shaders.toml"), "{e}"); assert!(check(&pack, Kind::Mod, None, None).is_err()); } } diff --git a/crates/horizon-client/src/bin/horizon-ctl/main.rs b/crates/horizon-client/src/bin/horizon-ctl/main.rs index 402808e81..33ea1f870 100644 --- a/crates/horizon-client/src/bin/horizon-ctl/main.rs +++ b/crates/horizon-client/src/bin/horizon-ctl/main.rs @@ -610,12 +610,17 @@ mod tests { #[test] fn unreachable_games_fail_with_status_3() { - let mut s = Session::new(std::env::temp_dir().join("horizon-ctl-nobody.sock"), None); + let home = + std::env::temp_dir().join(format!("horizon-ctl-unreachable-{}", std::process::id())); + std::fs::create_dir_all(&home).unwrap(); + let mut s = Session::new(home.join("nobody.sock"), None); + s.home = home.clone(); let f = s.run(&["state".to_owned()]).unwrap_err(); assert_eq!(f.status, UNREACHABLE); assert_eq!(f.reply["kind"], "connection"); let f = s.run(&["sleep".to_owned(), "x".to_owned()]).unwrap_err(); assert_eq!(f.status, USAGE); + std::fs::remove_dir_all(home).unwrap(); } #[test] diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs index 41330df5f..c0bec476b 100644 --- a/crates/horizon-client/src/chunk.rs +++ b/crates/horizon-client/src/chunk.rs @@ -24,6 +24,20 @@ pub fn block_strategy() -> Strategy { Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed)) } +/// Frees `columns` (`count` of them) on a short-lived thread of its own +/// when there are many: a teleport or a dimension change drops a few +/// thousand columns at once, and freeing their sections took the frame +/// 15-20 ms. A few are freed here. +pub fn free_columns(columns: T, count: usize) { + if count < 64 { + return; + } + // Should the thread not start, the closure drops `columns` here. + let _ = std::thread::Builder::new() + .name("Chunk freeing".into()) + .spawn(move || drop(columns)); +} + /// Sizes the block states' global palette for a registry of `states`. pub fn set_block_states(states: usize) { let bits = horizon_core::paletted::ceil_log2(states).max(16); diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs index 65536d710..6e8089e9d 100644 --- a/crates/horizon-client/src/entities.rs +++ b/crates/horizon-client/src/entities.rs @@ -10,6 +10,8 @@ use crate::{ use horizon_core::geometry::{Aabb, Vec3}; use horizon_world::block_collision::BlockCollisionRegistry; +mod fluids; + #[derive(Clone, Debug)] pub struct ItemEntity { pub health: i32, @@ -165,18 +167,16 @@ impl ItemEntity { facts: &BlockFacts, collision: &BlockCollisionRegistry<'_>, no_physics: bool, + fluids: &crate::motion::FluidResources, ) -> bool { self.ticks += 1; self.previous = self.position; if self.pickup_delay > 0 && self.pickup_delay != u32::MAX { self.pickup_delay -= 1; } - let eye = world.block( - self.position.x.floor() as i32, - (self.position.y + 0.1).floor() as i32, - self.position.z.floor() as i32, - ); - let in_water = facts.get(eye).fluid == Fluid::Water; + // Entity.baseTick pushes before ItemEntity applies buoyancy and moves. + let (water_height, lava_height) = self.update_fluids(world, fluids); + let in_water = water_height > f64::from(0.1f32); if in_water { // ItemEntity.setUnderwaterMovement self.velocity = Vec3::new( @@ -184,7 +184,7 @@ impl ItemEntity { self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 }, self.velocity.z * 0.99, ); - } else if facts.get(eye).fluid == Fluid::Lava { + } else if lava_height > f64::from(0.1f32) { self.velocity = Vec3::new( self.velocity.x * 0.95, self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 }, @@ -245,6 +245,8 @@ impl ItemEntity { } } self.age += 1; + // ItemEntity.tick refreshes immersion and pushes again after moving. + self.update_fluids(world, fluids); self.age < 6000 && self.position.y > -128.0 } /// `ItemEntity.isMergable` at `age`: a stack below its size whose pickup diff --git a/crates/horizon-client/src/entities/fluids.rs b/crates/horizon-client/src/entities/fluids.rs new file mode 100644 index 000000000..fffa0ae2b --- /dev/null +++ b/crates/horizon-client/src/entities/fluids.rs @@ -0,0 +1,216 @@ +//! Dropped-item immersion and currents through the shared vanilla fluid helpers. +use super::ItemEntity; +use crate::{ + motion::{FluidResources, FluidTags, LAVA, WATER}, + world::World, +}; +use horizon_core::{ + geometry::{Aabb, Direction, Vec3}, + position::BlockPos, +}; +use horizon_world::{ + entity_fluid::{ + CurrentTarget, EntityFluidInteraction, FluidInteractionWorld, FluidMembership, + FluidSections, FluidTagId, + }, + fluid::{FluidHeightWorld, FluidKind, FluidState}, + fluid_flow::{FluidFlowWorld, flow_at}, + registry::BlockStateId, +}; +type Error = std::convert::Infallible; +struct ItemFluidWorld<'a> { + item: &'a mut ItemEntity, + world: &'a World, + fluids: &'a FluidResources, +} +impl ItemEntity { + pub(super) fn update_fluids(&mut self, world: &World, fluids: &FluidResources) -> (f64, f64) { + let mut interaction = EntityFluidInteraction::new([WATER, LAVA]); + let mut scene = ItemFluidWorld { + item: self, + world, + fluids, + }; + if interaction.update(&mut scene, false, 4096).is_err() { + return (0.0, 0.0); + } + let water_height = interaction.fluid_height(&scene, WATER); + let lava_height = interaction.fluid_height(&scene, LAVA); + let _ = interaction.apply_current(&mut scene, WATER, 0.014); + let _ = interaction.apply_current( + &mut scene, + LAVA, + if world.fast_lava { + 0.007 + } else { + 0.0023333333333333335 + }, + ); + (water_height, lava_height) + } +} +impl FluidMembership for ItemFluidWorld<'_> { + fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool { + FluidTags.fluid_in_tag(kind, tag) + } +} +impl CurrentTarget for ItemFluidWorld<'_> { + type Error = Error; + fn is_player_class(&self) -> bool { + false + } + fn velocity(&mut self) -> Result { + Ok(self.item.velocity) + } + fn add_delta_movement(&mut self, delta: Vec3) -> Result<(), Error> { + let v = self.item.velocity; + let sum = Vec3::new(v.x + delta.x, v.y + delta.y, v.z + delta.z); + if delta.is_finite() && sum.is_finite() { + self.item.velocity = sum; + } + Ok(()) + } +} +impl FluidInteractionWorld for ItemFluidWorld<'_> { + type Error = Error; + type Chunk = (); + fn interaction_box(&mut self) -> Result, Error> { + Ok(Some( + self.item.bounds().deflate(Vec3::new(0.001, 0.001, 0.001)), + )) + } + fn loaded_chunk(&mut self, x: i32, z: i32) -> Result, Error> { + Ok(self.world.chunks.contains_key(&(x, z)).then_some(())) + } + fn chunk_sections(&mut self, _: ()) -> Result, Error> { + static SECTIONS: [bool; crate::chunk::SECTIONS] = [true; crate::chunk::SECTIONS]; + Ok(FluidSections { + minimum_section_y: crate::chunk::MIN_Y >> 4, + has_fluid: &SECTIONS, + }) + } + fn bounding_box_min_y(&self) -> f64 { + self.item.position.y + } + fn block_x(&self) -> i32 { + self.item.position.x.floor() as i32 + } + fn eye_y(&mut self) -> Result { + Ok(self.item.position.y + f64::from(0.2125f32)) + } + fn block_z(&self) -> i32 { + self.item.position.z.floor() as i32 + } + fn fluid_state(&mut self, p: BlockPos) -> Result { + Ok(self.fluids.fluid(self.world.block(p.x, p.y, p.z))) + } + fn fluid_height(&mut self, f: FluidState, p: BlockPos) -> Result { + f.height_at(self, [p.x, p.y, p.z]) + } + fn camera_height(&mut self, f: FluidState, p: BlockPos) -> Result { + f.camera_height_at(self, [p.x, p.y, p.z]) + } + fn flow(&mut self, f: FluidState, p: BlockPos) -> Result { + flow_at(self, f, p) + } +} +impl FluidHeightWorld for ItemFluidWorld<'_> { + type Error = Error; + fn fluid(&mut self, p: [i32; 3]) -> Result { + Ok(self.fluids.fluid(self.world.block(p[0], p[1], p[2]))) + } + fn sturdy_down(&mut self, p: [i32; 3]) -> Result { + let state = self.world.block(p[0], p[1], p[2]); + Ok(self.fluids.sturdy(state, Direction::Down)) + } +} +impl FluidFlowWorld for ItemFluidWorld<'_> { + type Error = Error; + type Block = BlockStateId; + fn fluid(&mut self, p: BlockPos) -> Result { + Ok(self.fluids.fluid(self.world.block(p.x, p.y, p.z))) + } + fn block(&mut self, p: BlockPos) -> Result { + Ok(self.world.block(p.x, p.y, p.z)) + } + fn blocks_fluid_flow(&self, s: BlockStateId) -> bool { + self.fluids.blocks_flow(s) + } + fn is_ice_class(&self, s: BlockStateId) -> bool { + self.fluids.ice(s) + } + fn is_face_sturdy( + &mut self, + s: BlockStateId, + _: BlockPos, + d: Direction, + ) -> Result { + Ok(self.fluids.sturdy(s, d)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn items_follow_flowing_water_but_still_water_has_no_horizontal_push() { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client") + .join(horizon_core::VANILLA_VERSION); + if !root.join("movement-properties.nbt").exists() { + return; + } + let assets = crate::assets::Assets::load(&root).unwrap(); + let render = assets.reload(&root).unwrap(); + let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap(); + let fluids = FluidResources::new(&assets, &facts).unwrap(); + let collision = crate::collisions::load(&root, assets.registry).unwrap(); + let mut world = World::test_scene(&assets, &render, 3).unwrap(); + let stone = assets.registry.default_state("minecraft:stone").unwrap(); + let water = assets.registry.default_state("minecraft:water").unwrap(); + let mut state = assets.registry.state(water).unwrap().clone(); + state.properties.insert("level".into(), "1".into()); + let flowing = assets.registry.resolve(&state).unwrap(); + for x in 19..=21 { + for z in 19..=21 { + world.set(x, 3, z, stone).unwrap(); + world.set(x, 4, z, water).unwrap(); + } + } + let at = Vec3::new(20.5, 4.0, 20.5); + let item = ItemEntity { + id: 1, + health: 5, + fire_ticks: 0, + stack: crate::items::ItemStack { + item: "minecraft:sugar_cane".into(), + count: 1, + damage: 0, + extra: None, + }, + thrower: None, + position: at, + previous: at, + velocity: Vec3::ZERO, + on_ground: false, + age: 0, + pickup_delay: 0, + bob_offset: 0.0, + ticks: 0, + }; + let mut still = item.clone(); + assert!(still.tick(&world, &facts, &collision, false, &fluids)); + assert_eq!(still.position.x, at.x); + assert_eq!(still.velocity.x, 0.0); + world.set(21, 4, 20, flowing).unwrap(); + let mut carried = item; + assert!(carried.tick(&world, &facts, &collision, false, &fluids)); + // First push is damped by buoyancy before motion, second follows drag. + assert!((carried.position.x - at.x - 0.014 * 0.99).abs() < 1e-12); + assert!((carried.velocity.x - (0.014 * 0.99 * 0.98 + 0.014)).abs() < 1e-12); + for _ in 0..20 { + carried.tick(&world, &facts, &collision, false, &fluids); + } + assert!(carried.position.x > at.x + 0.5); + } +} diff --git a/crates/horizon-client/src/extras.rs b/crates/horizon-client/src/extras.rs index b5b4fb165..d2f0b4e9d 100644 --- a/crates/horizon-client/src/extras.rs +++ b/crates/horizon-client/src/extras.rs @@ -378,12 +378,6 @@ impl Cps { pub enum Item { Fullbright, DynamicLights, - Minimap, - MinimapCorner, - MinimapSize, - MinimapShape, - MinimapZoom, - MinimapRotate, AutoReconnect, MouseTweaks, MouseTweaksWheel, @@ -402,13 +396,6 @@ pub fn rows() -> Vec> { Err("Lighting"), Ok(Fullbright), Ok(DynamicLights), - Err("Minimap"), - Ok(Minimap), - Ok(MinimapCorner), - Ok(MinimapSize), - Ok(MinimapShape), - Ok(MinimapZoom), - Ok(MinimapRotate), Err("Inventory"), Ok(MouseTweaks), Ok(MouseTweaksWheel), @@ -418,32 +405,11 @@ pub fn rows() -> Vec> { Ok(AutoReconnect), ] } -/// "1 block", "2 blocks", "½ block". -fn block_count(n: f32) -> String { - if n < 1.0 { - "½ block".into() - } else if n == 1.0 { - "1 block".into() - } else { - format!("{n} blocks") - } -} -fn next(all: &[T], current: T, back: bool) -> T { - let i = all.iter().position(|v| *v == current).unwrap_or(0); - let n = all.len(); - all[if back { (i + n - 1) % n } else { (i + 1) % n }] -} impl Item { pub fn caption(self) -> &'static str { match self { Item::Fullbright => "Fullbright", Item::DynamicLights => "Dynamic lights", - Item::MinimapCorner => "Corner", - Item::Minimap => "Minimap", - Item::MinimapSize => "Size", - Item::MinimapShape => "Shape", - Item::MinimapZoom => "Zoom", - Item::MinimapRotate => "Turn with the player", Item::AutoReconnect => "Auto-reconnect", Item::MouseTweaks => "Mouse Tweaks controls", Item::MouseTweaksWheel => "Scroll wheel moves items", @@ -458,10 +424,9 @@ impl Item { pub fn parent(self) -> Option { use Item::*; Some(match self { - MinimapCorner | MinimapSize | MinimapShape | MinimapZoom | MinimapRotate => Minimap, MouseTweaksWheel => MouseTweaks, SortKey => Sort, - Fullbright | DynamicLights | Minimap | MouseTweaks | Sort | AutoReconnect | NoAi + Fullbright | DynamicLights | MouseTweaks | Sort | AutoReconnect | NoAi | AgentControl | DiscordPresence => { return None; } @@ -474,12 +439,6 @@ impl Item { Item::DynamicLights => { "Torches and other light sources held, dropped or on fire light the blocks around them." } - Item::MinimapCorner => "Overlays in one corner stack.", - Item::Minimap => "A map of the loaded terrain around you, in map colours.", - Item::MinimapSize => "How big the map is on screen.", - Item::MinimapShape => "Square or round.", - Item::MinimapZoom => "Blocks per pixel: smaller shows more detail, larger more land.", - Item::MinimapRotate => "Forward is up; off keeps north up.", Item::AutoReconnect => { "Rejoins a server after a lost connection or a restart, never after a kick or ban." } @@ -511,7 +470,7 @@ impl Item { use crate::graphics_style::Cost; match self { Item::Fullbright => Some(Cost::None), - Item::Minimap | Item::DynamicLights => Some(Cost::Low), + Item::DynamicLights => Some(Cost::Low), Item::AutoReconnect | Item::MouseTweaks | Item::Sort => Some(Cost::None), _ => None, } @@ -521,8 +480,6 @@ impl Item { Some(match self { Item::Fullbright => e.fullbright, Item::DynamicLights => e.dynamic_lights, - Item::Minimap => e.minimap, - Item::MinimapRotate => e.minimap_rotate, Item::AutoReconnect => e.auto_reconnect, Item::MouseTweaks => e.mouse_tweaks, Item::MouseTweaksWheel => e.mouse_tweaks_wheel, @@ -537,38 +494,22 @@ impl Item { pub fn value(self, e: &Extras) -> String { match self { Item::SortKey => crate::keybinds::display_name(&e.sort_key).plain(), - Item::MinimapCorner => e.minimap_corner.label().into(), - Item::MinimapSize => MINIMAP_SIZES - .iter() - .find(|s| s.0 == e.minimap_size) - .map_or("Medium", |s| s.1) - .into(), - Item::MinimapShape => if e.minimap_round { "Round" } else { "Square" }.into(), - Item::MinimapZoom => format!("{} per pixel", block_count(e.minimap_zoom)), other => match other.switch(e) { Some(true) => "On".into(), _ => "Off".into(), }, } } - /// A click (`back` for the right button). The sort key binds instead. - pub fn cycle(self, e: &mut Extras, back: bool) { + /// A click (`_back` for the right button: every item left is a switch, + /// so both flip it). The sort key binds instead. + pub fn cycle(self, e: &mut Extras, _back: bool) { match self { Item::Fullbright => e.fullbright = !e.fullbright, Item::DynamicLights => e.dynamic_lights = !e.dynamic_lights, - Item::Minimap => e.minimap = !e.minimap, - Item::MinimapRotate => e.minimap_rotate = !e.minimap_rotate, Item::AutoReconnect => e.auto_reconnect = !e.auto_reconnect, Item::MouseTweaks => e.mouse_tweaks = !e.mouse_tweaks, Item::MouseTweaksWheel => e.mouse_tweaks_wheel = !e.mouse_tweaks_wheel, Item::Sort => e.sort = !e.sort, - Item::MinimapCorner => e.minimap_corner = next(&Corner::ALL, e.minimap_corner, back), - Item::MinimapSize => { - let sizes: Vec = MINIMAP_SIZES.iter().map(|s| s.0).collect(); - e.minimap_size = next(&sizes, e.minimap_size, back); - } - Item::MinimapShape => e.minimap_round = !e.minimap_round, - Item::MinimapZoom => e.minimap_zoom = next(&MINIMAP_ZOOMS, e.minimap_zoom, back), Item::NoAi => e.no_ai = !e.no_ai, Item::AgentControl => e.agent_control = !e.agent_control, Item::DiscordPresence => e.discord_presence = !e.discord_presence, @@ -712,12 +653,9 @@ mod tests { #[test] fn items_cycle_through_their_values() { let mut e = Extras::default(); - Item::MinimapCorner.cycle(&mut e, true); - assert_eq!(e.minimap_corner, Corner::TopLeft); - Item::MinimapZoom.cycle(&mut e, true); - assert_eq!(Item::MinimapZoom.value(&e), "½ block per pixel"); - Item::MinimapSize.cycle(&mut e, false); - assert_eq!(Item::MinimapSize.value(&e), "Large"); + Item::Sort.cycle(&mut e, true); + assert_eq!(Item::Sort.value(&e), "On"); + // The minimap's old keys still parse, for the move to its mod. assert_eq!( Extras::parse("minimapSize:7\nminimapZoom:3").minimap_zoom, 1.0 diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 79f098a1b..1c4c21476 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -131,6 +131,7 @@ mod pumpkin; mod raids; mod recipe_book; mod remote; +mod remote_chunks; mod remote_mob_data; mod remote_mob_use; mod remote_objects; @@ -2272,7 +2273,13 @@ impl Game<'_> { let speed = self.world.random.next_float() * 0.2 + 0.1; item.move_towards_closest_space(&self.world, self.res.facts(), speed); } - let alive = item.tick(&self.world, self.res.facts(), self.collision, no_physics); + let alive = item.tick( + &self.world, + self.res.facts(), + self.collision, + no_physics, + &self.res.motion().fluids, + ); cells.moved(i, item.previous, item.position); // ItemEntity.tick: merge every 2 ticks while moving between // blocks, every 40 otherwise, before the lifetime check. @@ -4199,6 +4206,9 @@ impl Game<'_> { self.with_level(|b, level, ticks| b.notify_written(level, ticks, position, flags)); } fn tick(&mut self) -> Result<()> { + if self.agent.hold_server { + return Ok(()); + } self.tick_debug_keys()?; self.tick_debug_charts(); if self.remote.is_some() { @@ -5607,6 +5617,8 @@ impl Game<'_> { self.craft_size = 2; self.craft_table = None; if let Some(key) = self.container.take() { + // A cart's or chest boat's items go back to it. + self.close_cart_container(key); self.container_opener_event(key, false); self.post_block_game_event( "minecraft:container_close", @@ -5646,7 +5658,6 @@ impl Game<'_> { self.world.modified.insert((key.0 >> 4, key.2 >> 4)); } self.close_ender_chest(); - self.close_cart_container(); } /// `quickMoveStack` of the open plain menu for a shift-click. fn inventory_quick_move(&mut self, slot: usize) -> bool { @@ -11017,11 +11028,7 @@ impl Game<'_> { bytes += size; } } - for c in unloaded { - for sy in 0..(HEIGHT / 16) { - renderer.remove((c.x, sy, c.z)); - } - } + renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z))); if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) { let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info); lod.set_near_loading(self.streaming.busy()); diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs index 2686b85fd..fa9dbf3c6 100644 --- a/crates/horizon-client/src/game/agent.rs +++ b/crates/horizon-client/src/game/agent.rs @@ -300,6 +300,8 @@ struct Glide { pub(super) struct Agent { task: Option, glide: Option, + /// Control-fixture barrier: hold simulation and packet handling, not transport threads. + pub hold_server: bool, } pub(super) enum Handled { @@ -479,6 +481,8 @@ impl Game<'_> { "absorption": p.health.absorption(), // The hurt animation's ticks left (the camera's hurt tilt). "hurt_time": p.health.hurt_animation_time, + // LivingEntity.deathTime while dead (the camera's death roll). + "death_time": self.death_time(), "air": p.air, "food": p.health.food.food, "saturation": p.health.food.saturation, @@ -667,6 +671,7 @@ impl Game<'_> { }); if let Some(chat) = &self.ui.chat_screen { v["chat_input"] = json!(chat.input.value); + v["chat_suggestions"] = json!(chat.suggestions_visible()); } if self.title.is_some() { v["menu"] = self.title_value(); diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs index 56f571bee..3d452596e 100644 --- a/crates/horizon-client/src/game/block_entity_anims.rs +++ b/crates/horizon-client/src/game/block_entity_anims.rs @@ -219,6 +219,11 @@ impl Game<'_> { /// client tick (`ClientLevel.tickBlockEntities`). pub(super) fn tick_block_entity_anims(&mut self) { let Some(r) = &self.renderer else { + // A server has no window, but its gateways still run their + // server ticker. + if self.remote.is_none() { + self.tick_gateway_servers(); + } return; }; // Sorted by position: the order they tick in, and a quick lookup. @@ -378,6 +383,31 @@ impl Game<'_> { } self.be_anims.present = positions; } + /// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the + /// gateways a server keeps a copy of, in block-ticking chunks + /// (`Level.tickBlockEntities`): the cooldown an entry started runs out, + /// and every 2400 ticks `triggerCooldown` sends its block event. + fn tick_gateway_servers(&mut self) { + let levels = self.tickets.levels(); + let mut positions: Vec<[i32; 3]> = self + .be_anims + .gateway_servers + .keys() + .copied() + .filter(|p| levels.block_ticking_at(p[0], p[2])) + .collect(); + positions.sort_unstable(); + for pos in positions { + let triggered = self + .be_anims + .gateway_servers + .get_mut(&pos) + .is_some_and(EndGateway::portal_tick); + if triggered { + self.block_entity_event(pos, 1, 0); + } + } + } /// `EndGatewayBlock.entityInside` on the server: whether the gateway at /// `pos` let the entity in (`triggerCooldown`, with its block event). pub(super) fn gateway_enter(&mut self, pos: [i32; 3]) -> bool { diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 76e10cb57..f3afdcab6 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -1097,6 +1097,12 @@ impl Game<'_> { Target::Player => { // ServerPlayer.teleport: removeVehicle before placing the player. self.stop_riding(); + // A server's player teleported within their level is placed + // there at once: the arrival they were waiting for elsewhere + // in it (whose chunks lose their tickets) is abandoned. + if let Some(conn) = self.lan_acting { + self.server_trips.retain(|trip| !trip.is(conn)); + } if let Some(p) = self.player.as_mut() { p.position = v; p.velocity = Vec3::new(0.0, 0.0, 0.0); diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 7a632e308..3202b23f4 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -11,6 +11,9 @@ use winit::{event::MouseButton, event_loop::ActiveEventLoop, keyboard::KeyCode}; const HELP: &[&str] = &[ "status game, player, streaming and renderer state", + "simulation authoritative projectiles in the owner's level", + "server-hold on|off hold simulation and player packets at a control-fixture barrier", + "stall MILLISECONDS stall the window thread (0..5000), leaving transport alive", "key KEY down|up|tap|repeat press, release or auto-repeat a key (w a s d space shift ctrl e q esc f3 1-9 arrows ...)", "release release every key and mouse button", "mouse left|right|middle down|up|click", @@ -238,6 +241,47 @@ impl Game<'_> { } "sculk" => Ok(Some(self.sculk_command(&words)?)), "status" => Ok(Some(self.control_status())), + "stall" => { + let millis: u64 = arg(1)?.parse()?; + if millis > 5000 { + return Err("stall is limited to 5000 milliseconds".into()); + } + std::thread::sleep(Duration::from_millis(millis)); + ok() + } + "simulation" => { + self.require_world()?; + let value = if let Some(server) = &self.integrated { + server + .call(|g| { + g.in_owner_level(|g| { + json!({ "game_time": g.world.game_time, "projectiles": g.projectiles_status() }) + }) + }) + .ok_or("the integrated server stopped")? + } else { + json!({ "game_time": self.world.game_time, "projectiles": self.projectiles_status() }) + }; + Ok(Some(value)) + } + "server-hold" => { + self.require_world()?; + let held = match arg(1)? { + "on" => true, + "off" => false, + _ => return Err("server-hold on|off".into()), + }; + if let Some(server) = &self.integrated { + server + .call(move |g| g.agent.hold_server = held) + .ok_or("the integrated server stopped")?; + } else if self.remote.is_some() { + return Err("server-hold requires the world's host".into()); + } else { + self.agent.hold_server = held; + } + ok() + } "pad" => Ok(Some(self.pad_command(&words)?)), "key" => { let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?; @@ -508,10 +552,23 @@ impl Game<'_> { "mobs" => { self.require_world()?; let radius: f64 = words.get(1).map_or(Ok(64.0), |r| r.parse())?; + if let Some(server) = &self.integrated { + let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position); + let value = server + .call(move |g| g.in_owner_level(|g| g.control_mobs_at(radius, center))) + .ok_or("the integrated server stopped")?; + return Ok(Some(value)); + } Ok(Some(self.control_mobs(radius))) } "hurtlog" => { self.require_world()?; + if let Some(server) = &self.integrated { + let value = server + .call(|g| g.control_hurt_log()) + .ok_or("the integrated server stopped")?; + return Ok(Some(value)); + } Ok(Some(self.control_hurt_log())) } "resume" => { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index be7923037..3a8562ee1 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -312,6 +312,9 @@ impl Game<'_> { /// The `mobs` command: nearby mobs with position, health and running goals. pub(super) fn control_mobs(&self, radius: f64) -> serde_json::Value { let center = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position); + self.control_mobs_at(radius, center) + } + pub(super) fn control_mobs_at(&self, radius: f64, center: Vec3) -> serde_json::Value { let list: Vec = self .mobs .iter() @@ -504,6 +507,17 @@ impl Game<'_> { Some(host) if !guests.is_empty() => std::mem::take(&mut host.mob_players), _ => Default::default(), }; + // The guests' entity ids by connection, for the shulker bullets fired + // at the guest a mob sees. + let guest_ids: Vec<(u32, u32)> = match self.lan.as_ref() { + Some(host) if !guests.is_empty() => host + .hub + .guests + .iter() + .map(|g| (g.conn, g.entity_id as u32)) + .collect(), + _ => Vec::new(), + }; let mut guest_events = Vec::new(); let level_random; { @@ -578,6 +592,19 @@ impl Game<'_> { let kept = m.tick(&w, &mut scratch, &mut events); horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes); if let Some(conn) = seen_guest { + // ShulkerBullet.finalTarget is the guest's entity: the + // bullet homes on it while the projectiles tick, where + // `Who::Player` is the host's own player. + if let Some(&(_, id)) = guest_ids.iter().find(|g| g.0 == conn) { + for e in &mut events[from..] { + if let MobEvent::Projectile(p) = e + && let ProjectileKind::ShulkerBullet { target, .. } = &mut p.kind + && *target == Who::Player + { + *target = Who::Mob(id); + } + } + } let mut k = from; while k < events.len() { if super::lan_mobs::acts_on_player(&events[k]) { diff --git a/crates/horizon-client/src/game/extras.rs b/crates/horizon-client/src/game/extras.rs index 8ed585116..4d21f5288 100644 --- a/crates/horizon-client/src/game/extras.rs +++ b/crates/horizon-client/src/game/extras.rs @@ -1,5 +1,5 @@ -//! Horizon's extras in the game (`docs/extras.md`): the minimap's tiles and -//! image, and its HUD; a mod's zoom (`render.set-zoom`) on the camera; clicks +//! Horizon's extras in the game (`docs/extras.md`); a mod's minimap +//! (`render.set-minimap`: its tiles, image and HUD) and zoom (`render.set-zoom`) on the camera; clicks //! and frame times for mods (`input.clicks-per-second`, `render.frame-stats`). //! Each hook does nothing while its extra is off and no mod runs. use super::{Dim, Game, Screen}; @@ -128,44 +128,29 @@ impl Game<'_> { } Ok(()) } - /// The minimap that shows, the extra's or else a mod's - /// (`render.set-minimap`): its corner, its side in GUI pixels and its - /// view of the player. + /// The minimap a mod shows (`render.set-minimap`): its corner, its side + /// in GUI pixels and its view of the player. fn minimap_shown(&self) -> Option<(Corner, f32, View)> { let p = self.player.as_ref()?; if self.title.is_some() || self.ui.hide_gui { return None; } - let e = &self.settings.extras; - let (corner, size, rotate, blocks_per_pixel, round) = if e.minimap { - let size = f32::from(e.minimap_size); - ( - e.minimap_corner, - size, - e.minimap_rotate, - e.minimap_zoom, - e.minimap_round, - ) - } else { - let m = self.mod_minimap()?; - (m.corner, m.size, m.rotate, m.blocks_per_pixel, m.round) - }; + let m = self.mod_minimap()?; let view = View { x: p.position.x, z: p.position.z, yaw: self.yaw, - rotate, - blocks_per_pixel, - round, + rotate: m.rotate, + blocks_per_pixel: m.blocks_per_pixel, + round: m.round, }; - Some((corner, size, view)) + Some((m.corner, m.size, view)) } /// Refresh the minimap's tiles within the frame budget, recompose its /// image when the view or a tile changed, and queue the upload. fn update_minimap(&mut self) { let Some((_, _, view)) = self.minimap_shown() else { - let wanted = self.settings.extras.minimap || self.mod_minimap().is_some(); - if !wanted || self.player.is_none() { + if self.mod_minimap().is_none() || self.player.is_none() { self.extras.minimap.clear(); self.extras.minimap_dim = None; } diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs index 7838c9590..e6b4eb136 100644 --- a/crates/horizon-client/src/game/fireworks.rs +++ b/crates/horizon-client/src/game/fireworks.rs @@ -71,6 +71,18 @@ impl Rocket { (self.position, self.velocity) } } +/// `damageAmount * (float)Math.sqrt((5.0 - this.distanceTo(target)) / 5.0)` +/// from the rocket at `from` to a target at `to`; `Entity.distanceTo` sums +/// the squared offsets in floats. +fn blast_damage(damage: f32, from: Vec3, to: Vec3) -> f32 { + let (x, y, z) = ( + (from.x - to.x) as f32, + (from.y - to.y) as f32, + (from.z - to.z) as f32, + ); + let distance = f64::from(x * x + y * y + z * z).sqrt() as f32; + damage * ((5.0 - f64::from(distance)) / 5.0).sqrt() as f32 +} pub(super) fn fireworks_of(stack: &ItemStack) -> (u8, Vec) { // The item's default component: flight 1, no explosions. stack @@ -251,21 +263,24 @@ impl Game<'_> { let at = [r.position.x, r.position.y, r.position.z]; if !r.explosions.is_empty() { let damage = 5.0 + r.explosions.len() as f32 * 2.0; - // The player it boosts takes the full damage, a guest as well. - if r.attached { - match r.guest { - None => self.hurt_player_by("minecraft:fireworks", damage), - Some(conn) => { - if let Some(mut host) = self.lan.take() { - self.as_guest(&mut host, conn, |g| { - g.hurt_player_by("minecraft:fireworks", damage); - }); - self.lan = Some(host); - } - } - } - } let from = r.position; + // `attachedToEntity` takes the full damage, a guest as well; every + // other player in range and in sight takes the blast. + let boosted = r.guest.filter(|_| r.attached); + if r.attached && boosted.is_none() { + self.rocket_hurt_player(damage); + } else { + self.rocket_blast_player(from, damage); + } + if let Some(conn) = boosted + && let Some(mut host) = self.lan.take() + { + self.as_guest(&mut host, conn, |g| g.rocket_hurt_player(damage)); + self.lan = Some(host); + } + // Every other player in the level (LAN guests, the players of a + // server thread), each swapped in as the player. + self.each_guest_hit_except(boosted, |g| g.rocket_blast_player(from, damage)); let hits: Vec<(u32, f32)> = { let world = self.mob_world_base(&[]); self.mobs @@ -285,7 +300,7 @@ impl Game<'_> { ); world.clear_between(from, to, false) }); - sees.then(|| (m.id, damage * ((5.0 - d2.sqrt()) / 5.0).sqrt() as f32)) + sees.then(|| (m.id, blast_damage(damage, from, m.position))) }) .collect() }; @@ -307,6 +322,49 @@ impl Game<'_> { self.particles .fireworks(at, v, r.explosions.clone(), camera); } + /// `dealExplosionDamage` on a player that is not the rocket's + /// `attachedToEntity`: within 5 blocks, when the rocket sees its feet or + /// its middle (`ClipContext.Block.COLLIDER`, no fluids). + fn rocket_blast_player(&mut self, from: Vec3, damage: f32) { + let Some(p) = self.player.as_ref() else { + return; + }; + let feet = p.position; + let d2 = (feet.x - from.x).powi(2) + (feet.y - from.y).powi(2) + (feet.z - from.z).powi(2); + if d2 > 25.0 { + return; + } + let height = f64::from(p.dimensions.height); + let sees = { + let world = self.mob_world_base(&[]); + (0..2).any(|step| { + let to = Vec3::new(feet.x, feet.y + height * 0.5 * f64::from(step), feet.z); + world.clear_between(from, to, false) + }) + }; + if sees { + self.rocket_hurt_player(blast_damage(damage, from, feet)); + } + } + /// `hurtServer` with `damageSources().fireworks`: armor absorbs it and + /// wears (`hurtArmor`); creative and spectator players are immune. + fn rocket_hurt_player(&mut self, amount: f32) { + if self.creative || self.spectator() { + return; + } + let hurt = if let Some(p) = self.player.as_mut() + && !p.health.dead_or_dying() + && let Some(id) = self.motion.health.damage.id("minecraft:fireworks") + { + p.hurt(&self.motion.health, self.world.health_rules, id, amount) + .unwrap_or(false) + } else { + false + }; + if hurt { + self.hurt_armor(amount); + } + } /// `FireworkEntityRenderer.submit`: the item (GROUND) facing the camera, /// lit at the rocket's light probe. pub(super) fn rocket_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec) { diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs index 27d3fb61e..95e2e1e6e 100644 --- a/crates/horizon-client/src/game/fov.rs +++ b/crates/horizon-client/src/game/fov.rs @@ -64,14 +64,14 @@ impl Game<'_> { }); self.view.tick(eye, target); } - /// The player's `deathTime` while dead or dying. - fn death_time(&self) -> Option { + /// The player's `deathTime` while dead or dying: whole ticks counted by + /// `LivingEntity.tickDeath`, so `deathTime + partialTicks` in + /// `Camera.extractRenderState` rises smoothly across frames. + pub(super) fn death_time(&self) -> Option { let p = self.player.as_ref()?; - p.health.dead_or_dying().then(|| { - self.ui - .died_at - .map_or(0, |t| (t.elapsed().as_secs_f32() * 20.0) as i32) - }) + p.health + .dead_or_dying() + .then(|| self.ui.death_time.min(i32::MAX as u32) as i32) } /// The fluid at the camera, as `Camera.getFluidInCamera` reports it. pub(super) fn camera_fluid(&self, camera: [f64; 3]) -> CameraFluid { diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs index dcc07f1d1..dd1c04e23 100644 --- a/crates/horizon-client/src/game/integrated.rs +++ b/crates/horizon-client/src/game/integrated.rs @@ -372,6 +372,12 @@ impl Game<'_> { let mut next = Instant::now(); while !flags.stop.load(Ordering::Relaxed) { self.run_tasks(); + if self.agent.hold_server { + // Keep servicing control requests so the fixture can release the barrier. + // Unlike /tick freeze, no player's queued packets are applied here. + self.wait_for_next_server_tick(&mut next, true); + continue; + } let paused = flags.paused.load(Ordering::Relaxed); if paused { // Only the connections run. diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 02269f89f..643c05ec3 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1192,6 +1192,10 @@ impl Game<'_> { { self.container_changed(key); } + // A vehicle's menu edits the vehicle's own items. + if let Some(Slots::Block(key)) = slots { + self.store_cart_items(key); + } self.drop_guest_items(host, gi, drops); } S::ContainerClose(p) => { @@ -1835,6 +1839,10 @@ impl Game<'_> { continue; } if self.on_server_trip(conn) { + // LivingEntity.hurt kills at once (die), whether the level + // has loaded around the player or not: its respawn request + // is taken as soon as it comes. + self.guest_die(host, gi, conn); continue; } let play = host.play.entry(conn).or_default(); @@ -1920,69 +1928,72 @@ impl Game<'_> { self.guest_dig_feedback(host, conn); self.guest_pickups(host, gi); self.guest_orbs(host, gi); - if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead { - self.guest_forget_digging(host, conn); - // FishingHook.shouldStopFishing: its owner is dead. - if let Some(play) = host.play.get_mut(&conn) { - play.hook = None; - } + self.guest_die(host, gi, conn); + } + } + + /// `ServerPlayer.die` for a guest whose health has run out: the death + /// message, the loot and experience, the death screen. + fn guest_die(&mut self, host: &mut LanHost, gi: usize, conn: u32) { + if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead { + self.guest_forget_digging(host, conn); + // FishingHook.shouldStopFishing: its owner is dead. + if let Some(play) = host.play.get_mut(&conn) { + play.hook = None; } - let g = &mut host.hub.guests[gi]; - if g.health <= 0.0 && !g.dead { - g.dead = true; - g.last_death = Some(g.position.map(|v| v.floor() as i32)); - let (id, at) = (g.entity_id, g.position); - let reward = Experience { - level: g.xp_level, - progress: g.xp_progress, - total: g.xp_total, - } - .death_reward(self.ui.rules.bool("keep_inventory") || g.game_mode == SPECTATOR); - let (name, uuid) = (g.name.clone(), g.uuid); - // ServerPlayer.die: dropAllDeathLoot unless a spectator, from the eyes less 0.3. - let drops = (g.game_mode != SPECTATOR) - .then(|| [at[0], at[1] + g.eye_height() - 0.3, at[2]]); - let cause = host.play.get_mut(&conn).and_then(|p| p.death_cause.take()); - // ServerPlayer.die: with showDeathMessages, the message goes to - // the dying player's death screen and to everyone the team lets - // see it; without it, the death screen gets an empty one. - let message = if self.ui.rules.bool("show_death_messages") { - let me = self.player_text(&name, uuid); - let text = match cause { - Some(key) => horizon_client::text::Text::translate(&key, &[me]), - None if at[1] < f64::from(horizon_client::chunk::MIN_Y - 64) => { - horizon_client::text::Text::translate("death.attack.outOfWorld", &[me]) - } - None => self.guest_death_message(conn, me), - }; - let message = horizon_client::lan::data::component_nbt(&text.component()); - let team = self.score.board.players_team(&name); - if horizon_client::scoreboard::own_death_message_shown(team) { - host.hub.system_message(message.clone()); - if self.options.dedicated.is_some() { - super::dedicated::log( - "INFO", - &format!("System chat: {}", text.plain()), - ); - } else if self.player.is_some() { - self.system_message(text); - } + } + let g = &mut host.hub.guests[gi]; + if g.health <= 0.0 && !g.dead { + g.dead = true; + g.last_death = Some(g.position.map(|v| v.floor() as i32)); + let (id, at) = (g.entity_id, g.position); + let reward = Experience { + level: g.xp_level, + progress: g.xp_progress, + total: g.xp_total, + } + .death_reward(self.ui.rules.bool("keep_inventory") || g.game_mode == SPECTATOR); + let (name, uuid) = (g.name.clone(), g.uuid); + // ServerPlayer.die: dropAllDeathLoot unless a spectator, from the eyes less 0.3. + let drops = + (g.game_mode != SPECTATOR).then(|| [at[0], at[1] + g.eye_height() - 0.3, at[2]]); + let cause = host.play.get_mut(&conn).and_then(|p| p.death_cause.take()); + // ServerPlayer.die: with showDeathMessages, the message goes to + // the dying player's death screen and to everyone the team lets + // see it; without it, the death screen gets an empty one. + let message = if self.ui.rules.bool("show_death_messages") { + let me = self.player_text(&name, uuid); + let text = match cause { + Some(key) => horizon_client::text::Text::translate(&key, &[me]), + None if at[1] < f64::from(horizon_client::chunk::MIN_Y - 64) => { + horizon_client::text::Text::translate("death.attack.outOfWorld", &[me]) } - message - } else { - literal("") + None => self.guest_death_message(conn, me), }; - host.hub.send_to( - conn, - &C::PlayerCombatKill(play::PlayerCombatKill { id, message }), - ); - // LivingEntity.die: the death animation, the dying player included. - host.hub.entity_event(id, 3, at); - if let Some(eyes) = drops { - self.as_guest(host, conn, |game| game.drop_inventory(eyes)); + let message = horizon_client::lan::data::component_nbt(&text.component()); + let team = self.score.board.players_team(&name); + if horizon_client::scoreboard::own_death_message_shown(team) { + host.hub.system_message(message.clone()); + if self.options.dedicated.is_some() { + super::dedicated::log("INFO", &format!("System chat: {}", text.plain())); + } else if self.player.is_some() { + self.system_message(text); + } } - self.spawn_orbs(at, reward); + message + } else { + literal("") + }; + host.hub.send_to( + conn, + &C::PlayerCombatKill(play::PlayerCombatKill { id, message }), + ); + // LivingEntity.die: the death animation, the dying player included. + host.hub.entity_event(id, 3, at); + if let Some(eyes) = drops { + self.as_guest(host, conn, |game| game.drop_inventory(eyes)); } + self.spawn_orbs(at, reward); } } @@ -2180,6 +2191,9 @@ impl Game<'_> { let _ = w.tick_environment_damage(); let _ = w.apply_fire_contact(); let _ = w.server_hazards_tick(in_wall); + // Player.tick ends with updatePlayerPose: a swimmer, or a player + // crawling under a block, takes the short box its moves are checked with. + let _ = w.update_player_pose(); let mut events = std::mem::take(&mut w.player.events); // LayeredCauldronBlock.handleEntityOnFireInside along those moves. for event in &events { diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs index f74935522..db6235c4d 100644 --- a/crates/horizon-client/src/game/lan_crafting.rs +++ b/crates/horizon-client/src/game/lan_crafting.rs @@ -291,6 +291,11 @@ impl Game<'_> { let at = host.hub.guests[gi].position; self.award_furnace_recipes(pos, at); } + // Slot.setChanged on a changed container slot: BlockEntity.setChanged, + // so the chunk is saved and comparators read the block again. + if changed.iter().any(|&s| s < items.len()) { + self.container_changed(pos); + } host.play.entry(conn).or_default().crafting.machine = Some((p.container, menu)); host.hub.inventory_clicked(conn, p, &self.world, &changed); true diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs index dc4d1eb42..4f53cec60 100644 --- a/crates/horizon-client/src/game/lan_mobs.rs +++ b/crates/horizon-client/src/game/lan_mobs.rs @@ -119,7 +119,17 @@ impl Game<'_> { /// Runs `f` as each guest in play here, for what strikes every player in /// an area (`Level.getEntities`), not only the window's own. - pub(super) fn each_guest_hit(&mut self, mut f: impl FnMut(&mut Self)) { + pub(super) fn each_guest_hit(&mut self, f: impl FnMut(&mut Self)) { + self.each_guest_hit_except(None, f); + } + + /// [`Self::each_guest_hit`] leaving out the guest `except` (the one a + /// firework rocket is attached to, which it hurts on its own). + pub(super) fn each_guest_hit_except( + &mut self, + except: Option, + mut f: impl FnMut(&mut Self), + ) { let Some(mut host) = self.lan.take() else { return; }; @@ -127,7 +137,7 @@ impl Game<'_> { .hub .guests .iter() - .filter(|g| host.hub.here(g) && g.loaded && !g.dead) + .filter(|g| host.hub.here(g) && g.loaded && !g.dead && Some(g.conn) != except) .map(|g| g.conn) .collect(); for conn in conns { diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 8d4920b48..a19b6df73 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -1117,22 +1117,35 @@ impl Game<'_> { self.swing_arm(); true } - /// Closing a cart's container copies the items back. - pub(super) fn close_cart_container(&mut self) { - let Some(key) = self.container.filter(|k| k.1 == CART_KEY_Y) else { - return; - }; - let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) else { + /// Closing the cart's container open under `key` copies the items back. + pub(super) fn close_cart_container(&mut self, key: (i32, i32, i32)) { + if key.1 != CART_KEY_Y { + return; + } + self.store_cart_items(key); + self.world.block_entities.remove(&key); + if let Some(c) = self.carts.iter().find(|c| c.id as i32 == key.2) + && c.kind == CartKind::Chest + { + let at = [c.position.x, c.position.y, c.position.z]; + let pitch = self.world.random.next_float() * 0.1 + 0.9; + self.audio + .play("minecraft:block.chest.close", Some(at), 0.5, pitch); + } + } + /// The menu of a chest or hopper minecart or a chest boat works on the + /// vehicle's own items (`ContainerEntity`): the placeholder under `key` + /// that the menu edits is copied back to the vehicle. + pub(super) fn store_cart_items(&mut self, key: (i32, i32, i32)) { + if key.1 != CART_KEY_Y { + return; + } + let Some(BlockEntity::Chest(items)) = self.world.block_entities.get(&key) else { return; }; + let items = items.clone(); if let Some(c) = self.carts.iter_mut().find(|c| c.id as i32 == key.2) { c.items = items; - let at = [c.position.x, c.position.y, c.position.z]; - if c.kind == CartKind::Chest { - let pitch = self.world.random.next_float() * 0.1 + 0.9; - self.audio - .play("minecraft:block.chest.close", Some(at), 0.5, pitch); - } } else if let Some(b) = self.boats.iter_mut().find(|b| b.id as i32 == key.2) { b.items = items; } diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs index ab84c45fa..e2df267f4 100644 --- a/crates/horizon-client/src/game/mods.rs +++ b/crates/horizon-client/src/game/mods.rs @@ -446,8 +446,65 @@ impl Game<'_> { cps, font_widths: self.mods.font_widths.clone(), players, + view_hit: self.mod_view_hit(), } } + /// The first block along the player's view within + /// [`horizon_mods::RAYCAST_MAX`] and its distance from the eye + /// (`game.raycast`): through the loaded chunks as the crosshair's ray + /// goes (fluids pass), then across the distant terrain's ground heights, + /// a block at a time. + fn mod_view_hit(&self) -> Option<(f32, horizon_mods::Hit)> { + if !self.mods.mods.wants_raycast() { + return None; + } + let eye = self.eye_position()?; + let dir = super::view_vector(self.yaw, self.pitch); + let reach = f64::from(horizon_mods::RAYCAST_MAX); + let (pos, point, state) = match self.clip_ray(eye, dir, reach) { + Some(hit) => ( + hit.pos, + hit.point, + self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]), + ), + None => self.lod_ray(eye, dir, reach)?, + }; + let distance = (0..3).map(|i| (point[i] - eye[i]).powi(2)).sum::(); + let hit = horizon_mods::Hit { + block_x: pos[0], + block_y: pos[1], + block_z: pos[2], + x: point[0], + y: point[1], + z: point[2], + block: self.res.facts().get(state).name.to_string(), + }; + Some((distance.sqrt() as f32, hit)) + } + /// Past the resident chunks: the view walked across the distant + /// terrain's ground heights (`Lod::ground`), a block at a time. Columns in + /// loaded chunks are left to `clip_ray`, which has already missed them. + fn lod_ray( + &self, + eye: [f64; 3], + dir: [f64; 3], + reach: f64, + ) -> Option<([i32; 3], [f64; 3], horizon_world::registry::BlockStateId)> { + let lod = self.lod.as_ref()?; + let mut t = 0.0; + while t <= reach { + let p = [0, 1, 2].map(|i| eye[i] + dir[i] * t); + let (x, z) = (p[0].floor() as i32, p[2].floor() as i32); + if !self.world.loaded(x, z) + && let Some((height, state)) = lod.ground(x, z) + && p[1] <= f64::from(height) + { + return Some(([x, height - 1, z], [p[0], f64::from(height), p[2]], state)); + } + t += 1.0; + } + None + } /// A game tick. pub(super) fn tick_mods(&mut self) { // Here, at the player's level: shown inside a console call (a control diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index bc199b24b..1474858b8 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -6,11 +6,12 @@ //! clicks). The player still moves with the local physics, as the vanilla //! client predicts its own movement; the server stays authoritative for //! everything else. +use super::remote_chunks::{ChunkDecoder, ChunkFormat, Next}; use super::{Dim, Game, Mining, Screen}; use horizon_client::first_person::{Hand, SwingAnimation}; use horizon_client::{ Result, - chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy}, + chunk::Chunk, containers::{BlockEntity, Furnace, FurnaceKind}, entities::{Experience, ExperienceOrb, ItemEntity}, hud::{HudBatch, rgba}, @@ -25,11 +26,7 @@ use horizon_client::{ tab_list::SPECTATOR, world::World, }; -use horizon_core::{ - geometry::Vec3, - paletted::{PalettedContainer, Strategy}, - random::RandomSource, -}; +use horizon_core::{geometry::Vec3, random::RandomSource}; use horizon_protocol::{ entity_data::{ITEM_ENTITY_ITEM, Value}, item::{Hashed, Stack}, @@ -64,9 +61,6 @@ fn menu_title(tag: &Tag) -> horizon_client::text::Text { remote_text(tag).resolve_legacy() } -/// A section's sky and block light layers from the wire. -type LightLayers = (Option>, Option>); - /// Streaming needs a generator; a server world never generates. struct NoTerrain; impl ChunkGenerator for NoTerrain { @@ -104,6 +98,14 @@ fn place_interpolated(m: &mut Mob, at: PosRot) { m.head_pitch = (at.pitch % 360.0).clamp(-90.0, 90.0); } +/// What the network thread delivered, in order: an event, or a chunk packet +/// handed to the decoder (with the format it decodes with), whose column +/// comes back from `ChunkDecoder::next`. +enum Received { + Event(Event), + Chunk(Arc), +} + pub(super) struct Remote { pub session: Session, pub brand: String, @@ -114,8 +116,11 @@ pub(super) struct Remote { status: String, pub(super) entity_id: i32, dimension: DimensionType, - biome_map: Vec, - biome_bits: u8, + /// What chunk packets decode with (the dimension's height and sky, the + /// biome registry); replaced whenever one of them changes. + pub(super) chunk_format: Arc, + /// Decodes chunk packets as they arrive, off the frame. + decoder: ChunkDecoder, view_distance: i32, sequence: i32, position_sender: horizon_client::player_sync::PositionSender, @@ -200,7 +205,7 @@ pub(super) struct Remote { chunk_center: (i32, i32), /// Received events a frame left for the next one, in order, and when /// the oldest of them first waited (`poll_remote`). - backlog: VecDeque, + backlog: VecDeque, backlog_since: Option, /// `ClientboundTransferPacket`'s target: when the connection ends the /// game connects here, the stored cookies carried over (`TransferState`). @@ -210,11 +215,12 @@ pub(super) struct Remote { /// The time a frame spends on chunk packets before it leaves the rest of /// the received events for the next frame. A batch of 25 to 60 columns /// (0.1 ms each on an M4 Pro) all in one frame was a 3 to 8 ms frame every -/// time the player crossed a chunk border at 32 chunks. +/// time the player crossed a chunk border at 32 chunks; they decode on the +/// chunk decoder's thread now, and the frame only inserts them. const CHUNK_PACKETS_PER_FRAME: Duration = Duration::from_millis(1); /// Events that have waited this long are all handled in the next frame, -/// whatever their cost: the packets after a slow machine's chunks never -/// wait more than a tick. +/// whatever inserting their columns costs, up to a column still decoding: +/// the packets after a slow machine's chunks don't wait on its frames. const BACKLOG_LIMIT: Duration = Duration::from_millis(50); /// The open menu name of a server's horse inventory, then its chest's /// columns (the packet names no `MenuType`). @@ -420,8 +426,12 @@ impl Game<'_> { status: "Connecting to the server...".into(), entity_id: 0, dimension: DimensionType::vanilla("minecraft:overworld"), - biome_map: Vec::new(), - biome_bits: 7, + chunk_format: Arc::new(ChunkFormat::new( + &DimensionType::vanilla("minecraft:overworld"), + Vec::new(), + 7, + )), + decoder: ChunkDecoder::new(), view_distance: self.settings.render_distance, sequence: 0, position_sender: Default::default(), @@ -741,25 +751,63 @@ impl Game<'_> { /// client's packet processor), in order. Chunk packets get /// `CHUNK_PACKETS_PER_FRAME`: once a frame has spent it, the events from /// the next chunk packet on wait for the next frame, unless they have - /// already waited `BACKLOG_LIMIT`. + /// already waited `BACKLOG_LIMIT`. A chunk packet still decoding holds + /// back what follows it. pub(super) fn poll_remote(&mut self) -> Result<()> { let Some(r) = self.remote.as_mut() else { return Ok(()); }; let mut events = std::mem::take(&mut r.backlog); - events.extend(r.session.poll()); + // Chunk packets start decoding now; the frame that reaches one in + // order inserts its column. + for event in r.session.poll() { + events.push_back(match event { + Event::Packet(p) if matches!(*p, C::LevelChunkWithLight(_)) => { + match r.decoder.submit(r.chunk_format.clone(), p) { + None => Received::Chunk(r.chunk_format.clone()), + Some(p) => Received::Event(Event::Packet(p)), + } + } + event => Received::Event(event), + }); + } let overdue = r .backlog_since .is_some_and(|since| since.elapsed() >= BACKLOG_LIMIT); let mut chunks = Duration::ZERO; - while let Some(event) = events.pop_front() { - let chunk = - matches!(&event, Event::Packet(p) if matches!(**p, C::LevelChunkWithLight(_))); + while let Some(item) = events.pop_front() { + let chunk = matches!(item, Received::Chunk(_)); if chunk && !overdue && chunks >= CHUNK_PACKETS_PER_FRAME { - events.push_front(event); + events.push_front(item); break; } let started = chunk.then(Instant::now); + let event = match item { + Received::Event(event) => event, + Received::Chunk(format) => { + // A column still decoding waits for the next frame, with + // what came after it, overdue or not. + let Some(next) = self.remote.as_ref().map(|r| r.decoder.next()) else { + break; + }; + let (packet, column) = match next { + Next::Ready(decoded) => decoded, + Next::Decoding => { + events.push_front(Received::Chunk(format)); + break; + } + Next::Lost => { + log::warn!("Horizon: the chunk decoder stopped; a column is missing"); + continue; + } + }; + if let C::LevelChunkWithLight(p) = *packet { + self.remote_chunk(&p, Some((&format, column))); + } + chunks += started.map_or(Duration::ZERO, |t| t.elapsed()); + continue; + } + }; match event { Event::Status(s) => { if let Some(r) = self.remote.as_mut() { @@ -915,8 +963,8 @@ impl Game<'_> { }) .unwrap_or_default(); if let Some(r) = self.remote.as_mut() { - r.biome_bits = ceil_log2(biomes.len()); - r.biome_map = biomes; + let bits = ceil_log2(biomes.len()); + r.chunk_format = Arc::new(ChunkFormat::new(&r.dimension, biomes, bits)); r.registries = registries; } } @@ -927,6 +975,7 @@ impl Game<'_> { }; let dimension = r.registries.dimension(spawn.dimension_type); let same = r.dimension.name == dimension.name && keep_world; + r.chunk_format = Arc::new(r.chunk_format.with_dimension(&dimension)); r.dimension = dimension; r.game_mode = spawn.game_type; r.loaded_sent = false; @@ -949,6 +998,9 @@ impl Game<'_> { self.world.day_time, self.world.weather, ); + let old = std::mem::take(&mut self.world.chunks); + let count = old.len(); + horizon_client::chunk::free_columns(old, count); self.world = World::new(self.res.facts().air, spawn.seed); self.world.game_time = time; self.world.day_time = day; @@ -989,145 +1041,10 @@ impl Game<'_> { self.apply_settings(); } - /// LevelChunkSection data into the client's fixed -64..320 column. - fn remote_chunk(&self, p: &play::LevelChunkWithLight) -> std::result::Result { - let r = self.remote.as_ref().ok_or("no connection")?; - let sections = p - .chunk - .sections(r.dimension.sections(), 16, r.biome_bits) - .map_err(|e| e.to_string())?; - let mut chunk = Chunk::empty(p.x, p.z); - let offset = (r.dimension.min_y - MIN_Y).div_euclid(16); - // Biome table index per quart cell of the dimension's own sections. - let mut biome_cells: Vec<[u32; 64]> = Vec::with_capacity(sections.len()); - for (i, s) in sections.iter().enumerate() { - let target = offset + i as i32; - let mut cells = [0u32; 64]; - for (j, cell) in cells.iter_mut().enumerate() { - *cell = u32::from( - r.biome_map - .get(s.biomes.get(j) as usize) - .copied() - .unwrap_or(0), - ); - } - biome_cells.push(cells); - if !(0..SECTIONS as i32).contains(&target) { - continue; - } - // A global section is as wide as the server's registry: 16 bits - // from a vanilla server, wider from a Horizon host with the same - // content mods. Read it at that width, then widen it to ours. - let ours = block_strategy(); - let strategy = if ours.wire_has_palette(s.states.bits) { - ours - } else { - Strategy::blocks(s.states.bits) - }; - let palette = s.states.palette.iter().map(|&p| p as u32).collect(); - let words = s.states.data.iter().map(|&w| w as u64).collect(); - let mut blocks = PalettedContainer::from_wire(strategy, s.states.bits, palette, words) - .map_err(|e| e.to_string())?; - if strategy.global_bits != ours.global_bits { - let mut values = [0u32; 4096]; - blocks.unpack(&mut values); - // Ids past our registry (a host with mods we lack) read as air. - let limit = 1u64 << ours.global_bits; - for v in &mut values { - if u64::from(*v) >= limit { - *v = 0; - } - } - blocks = PalettedContainer::from_values(ours, &values); - } - let mut section = Section { - blocks, - biomes: PalettedContainer::from_values(BIOME_STRATEGY, &cells), - light: Light::Uniform(0xF0), - }; - section.compact(); - chunk.sections[target as usize] = Arc::new(section); - } - // Sections outside the dimension's range take its nearest biomes - // (the column's top or bottom cell layer repeated). - if !biome_cells.is_empty() { - let last = biome_cells.len() - 1; - for si in 0..SECTIONS as i32 { - let i = si - offset; - if (0..sections.len() as i32).contains(&i) { - continue; - } - let (edge, layer) = if i < 0 { (0, 0) } else { (last, 3) }; - let mut cells = [0u32; 64]; - for (j, cell) in cells.iter_mut().enumerate() { - *cell = biome_cells[edge][layer * 16 + j % 16]; - } - Arc::make_mut(&mut chunk.sections[si as usize]).biomes = - PalettedContainer::from_values(BIOME_STRATEGY, &cells); - } - } - // ClientPacketListener.applyLightData: the column keeps the light - // the server sent; nothing is relit. - let (layers, above) = self.wire_light(&p.light); - let sky = r.dimension.has_skylight; - horizon_client::light::light_from_layers(&mut chunk, &layers, above, sky); - Ok(chunk) - } - /// `ClientPacketListener.readSectionList`: the sky and block layers of a - /// light packet, by section of the client's column, and the sky light - /// above the column's top section (from the light section just above - /// it, else open sky). - fn wire_light( - &self, - light: &horizon_protocol::chunk::LightData, - ) -> (Vec, [u8; 256]) { - let mut layers: Vec = vec![(None, None); SECTIONS]; - let Some(r) = self.remote.as_ref() else { - return (layers, [0; 256]); - }; - let sky = r.dimension.has_skylight; - let mut above = [if sky { 15 } else { 0 }; 256]; - // Light section b is the dimension's section b - 1. - let first = (r.dimension.min_y - MIN_Y).div_euclid(16) - 1; - for (b, layer) in light - .layers(r.dimension.sections() + 2) - .into_iter() - .enumerate() - { - let si = first + b as i32; - if (0..SECTIONS as i32).contains(&si) { - layers[si as usize] = layer; - } else if si == SECTIONS as i32 - && sky - && let Some(l) = &layer.0 - { - for (i, a) in above.iter_mut().enumerate() { - *a = (l[i >> 1] >> ((i & 1) * 4)) & 15; - } - } - } - (layers, above) - } - /// `handleLightUpdatePacket`: the sections it names take its light. - fn remote_light_update(&mut self, p: &play::LightUpdate) { - let Some(sky) = self.remote.as_ref().map(|r| r.dimension.has_skylight) else { - return; - }; - if !self.world.chunks.contains_key(&(p.x, p.z)) { - return; - } - let (layers, _) = self.wire_light(&p.light); - let Some(chunk) = self.world.chunks.get_mut(&(p.x, p.z)) else { - return; - }; - let changed = - horizon_client::light::update_light_layers(Arc::make_mut(chunk), &layers, sky); - Streaming::light_updated(&mut self.world, p.x, p.z, &changed); - } /// `ClientChunkCache.Storage.inRange`: within the storage around the /// view centre, `calculateStorageRange` (the server's radius, at least /// two, plus three) chunks each way. - fn remote_chunk_in_range(&self, x: i32, z: i32) -> bool { + pub(super) fn remote_chunk_in_range(&self, x: i32, z: i32) -> bool { self.remote.as_ref().is_none_or(|r| { let range = r.view_distance.max(2) + 3; (x - r.chunk_center.0).abs() <= range && (z - r.chunk_center.1).abs() <= range @@ -1135,29 +1052,33 @@ impl Game<'_> { } /// The columns a moved or resized storage no longer holds. fn drop_remote_chunks_out_of_range(&mut self) { - let gone: Vec<(i32, i32)> = self + let gone: horizon_client::fast_hash::FxHashSet<(i32, i32)> = self .world .chunks .keys() .copied() .filter(|&(x, z)| !self.remote_chunk_in_range(x, z)) .collect(); - for (x, z) in gone { - self.streaming.forget(&mut self.world, x, z); - self.world - .block_entities - .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); - if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } - } + if gone.is_empty() { + return; } + let mut freed = Vec::with_capacity(gone.len()); + for &(x, z) in &gone { + freed.extend(self.streaming.forget(&mut self.world, x, z)); + } + if let Some(renderer) = self.renderer.as_mut() { + renderer.remove_columns(gone.iter().copied()); + } + horizon_client::chunk::free_columns(freed, gone.len()); + // One pass for all of them. + self.world + .block_entities + .retain(|k, _| !gone.contains(&(k.0 >> 4, k.2 >> 4))); } /// `handleBlockEntityData`: the block entity at `pos`, when it is of the /// packet's type, loads the tag (`loadWithComponents`); an empty tag /// changes nothing. - fn remote_block_entity_data(&mut self, pos: [i32; 3], kind: i32, tag: &Tag) { + pub(super) fn remote_block_entity_data(&mut self, pos: [i32; 3], kind: i32, tag: &Tag) { let key = (pos[0], pos[1], pos[2]); let Some(name) = self .remote @@ -1248,7 +1169,7 @@ impl Game<'_> { } } /// Keep the renderable block entities (chests, furnaces) in step with blocks. - fn sync_block_entity(&mut self, pos: (i32, i32, i32), state: BlockStateId) { + pub(super) fn sync_block_entity(&mut self, pos: (i32, i32, i32), state: BlockStateId) { let name = self.res.facts().get(state).name.clone(); match BlockEntity::for_block(&name) { Some(entity) => { @@ -1704,36 +1625,7 @@ impl Game<'_> { }) .clamp(-90.0, 90.0); } - // ClientChunkCache.replaceWithPacketData: a column outside the - // storage around the view centre is ignored. - C::LevelChunkWithLight(p) if !self.remote_chunk_in_range(p.x, p.z) => { - log::warn!( - "Ignoring chunk since it's not in the view range: {}, {}", - p.x, - p.z - ); - } - C::LevelChunkWithLight(p) => match self.remote_chunk(&p) { - Ok(chunk) => { - let (x, z) = (p.x, p.z); - self.streaming.insert_remote(&mut self.world, chunk); - self.world - .block_entities - .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); - for info in &p.chunk.block_entities { - let pos = ( - x * 16 + i32::from(info.packed_xz as u8 >> 4), - i32::from(info.y), - z * 16 + i32::from(info.packed_xz as u8 & 15), - ); - let state = self.world.block(pos.0, pos.1, pos.2); - self.sync_block_entity(pos, state); - // LevelChunk.replaceWithPacketData: the block entity loads its update tag. - self.remote_block_entity_data([pos.0, pos.1, pos.2], info.kind, &info.tag); - } - } - Err(e) => log::warn!("Horizon: chunk {} {}: {e}", p.x, p.z), - }, + C::LevelChunkWithLight(p) => self.remote_chunk(&p, None), C::LightUpdate(p) => self.remote_light_update(&p), C::ForgetLevelChunk(p) => { let [x, z] = p.pos; @@ -1742,9 +1634,7 @@ impl Game<'_> { .block_entities .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); if let Some(renderer) = self.renderer.as_mut() { - for sy in 0..SECTIONS as i32 { - renderer.remove((x, sy, z)); - } + renderer.remove_columns([(x, z)]); } } C::ChunkBatchFinished(_) => { @@ -2234,6 +2124,7 @@ impl Game<'_> { self.apply_remote_health(); if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; + self.ui.death_time = 0; self.capture(false); } } @@ -2250,6 +2141,7 @@ impl Game<'_> { // screen, whatever health was last sent. if me && self.screen != Screen::Dead && self.player.is_some() { self.screen = Screen::Dead; + self.ui.death_time = 0; self.capture(false); } } @@ -3288,6 +3180,11 @@ impl Game<'_> { ); let was_flying = player.flying; self.sync_player_body(); + // LivingEntity.tickDeath: the local player counts its deathTime once + // per client tick while dead (the camera's death roll and zoom). + if self.screen == Screen::Dead { + self.ui.death_time = self.ui.death_time.saturating_add(1); + } let Some(player) = self.player.as_mut() else { return Ok(()); }; @@ -3616,7 +3513,7 @@ impl Game<'_> { // ticks), and only the server removes it. let (world, facts, collision) = (&self.world, self.res.facts(), self.collision); for d in self.dropped.iter_mut().filter(|_| running) { - d.tick(world, facts, collision, false); + d.tick(world, facts, collision, false, &self.res.motion().fluids); } head_lerps.retain(|_, (_, steps)| *steps > 0); for (item, ticks, at, eye, pitch, yaw) in using { @@ -4066,6 +3963,10 @@ impl Game<'_> { if let Some(placed) = &placed { self.predict_place(placed, seq); self.with_hand(hand, Game::consume_held); + } else if let Some(r) = self.remote.as_mut() { + // BlockItem.place plays its sound only once the block is set: the + // server's resend of the target it refused is no placement. + r.placing = None; } if reacts || placed.is_some() { self.with_hand(hand, Game::swing_arm); diff --git a/crates/horizon-client/src/game/remote_chunks.rs b/crates/horizon-client/src/game/remote_chunks.rs new file mode 100644 index 000000000..47f474619 --- /dev/null +++ b/crates/horizon-client/src/game/remote_chunks.rs @@ -0,0 +1,355 @@ +//! A server's chunk columns (`ClientboundLevelChunkWithLightPacket`): the +//! sections and light of each packet become a client column on a decoder +//! thread as soon as the packet arrives, so the frame that handles it in +//! order only inserts the result (`ClientPacketListener.handleLevelChunkWithLight`). +use super::Game; +use horizon_client::{ + chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy}, + streaming::Streaming, +}; +use horizon_core::paletted::{PalettedContainer, Strategy}; +use horizon_protocol::{ + chunk::{LightData, SectionLight}, + packets::play::{self, Clientbound as C}, + registry::DimensionType, +}; +use std::sync::{ + Arc, + mpsc::{self, TryRecvError}, +}; + +/// What turning a chunk packet into a client column depends on: the +/// dimension's height and sky, and the server's biome registry mapped to +/// ours. The connection replaces it when either changes, so a column decoded +/// with an older one is decoded again. +#[derive(Default)] +pub(super) struct ChunkFormat { + min_y: i32, + sections: usize, + has_skylight: bool, + biome_map: Vec, + biome_bits: u8, +} + +impl ChunkFormat { + pub(super) fn new(dimension: &DimensionType, biome_map: Vec, biome_bits: u8) -> Self { + Self { + min_y: dimension.min_y, + sections: dimension.sections(), + has_skylight: dimension.has_skylight, + biome_map, + biome_bits, + } + } + pub(super) fn with_dimension(&self, dimension: &DimensionType) -> Self { + Self::new(dimension, self.biome_map.clone(), self.biome_bits) + } + + /// LevelChunkSection data into the client's fixed -64..320 column. + fn column(&self, p: &play::LevelChunkWithLight) -> Result { + let sections = p + .chunk + .sections(self.sections, 16, self.biome_bits) + .map_err(|e| e.to_string())?; + let mut chunk = Chunk::empty(p.x, p.z); + let offset = (self.min_y - MIN_Y).div_euclid(16); + // Biome table index per quart cell of the dimension's own sections. + let mut biome_cells: Vec<[u32; 64]> = Vec::with_capacity(sections.len()); + for (i, s) in sections.iter().enumerate() { + let target = offset + i as i32; + let mut cells = [0u32; 64]; + for (j, cell) in cells.iter_mut().enumerate() { + *cell = u32::from( + self.biome_map + .get(s.biomes.get(j) as usize) + .copied() + .unwrap_or(0), + ); + } + biome_cells.push(cells); + if !(0..SECTIONS as i32).contains(&target) { + continue; + } + // A global section is as wide as the server's registry: 16 bits + // from a vanilla server, wider from a Horizon host with the same + // content mods. Read it at that width, then widen it to ours. + let ours = block_strategy(); + let strategy = if ours.wire_has_palette(s.states.bits) { + ours + } else { + Strategy::blocks(s.states.bits) + }; + let palette = s.states.palette.iter().map(|&p| p as u32).collect(); + let words = s.states.data.iter().map(|&w| w as u64).collect(); + let mut blocks = PalettedContainer::from_wire(strategy, s.states.bits, palette, words) + .map_err(|e| e.to_string())?; + if strategy.global_bits != ours.global_bits { + let mut values = [0u32; 4096]; + blocks.unpack(&mut values); + // Ids past our registry (a host with mods we lack) read as air. + let limit = 1u64 << ours.global_bits; + for v in &mut values { + if u64::from(*v) >= limit { + *v = 0; + } + } + blocks = PalettedContainer::from_values(ours, &values); + } + let mut section = Section { + blocks, + biomes: PalettedContainer::from_values(BIOME_STRATEGY, &cells), + light: Light::Uniform(0xF0), + }; + section.compact(); + chunk.sections[target as usize] = Arc::new(section); + } + // Sections outside the dimension's range take its nearest biomes + // (the column's top or bottom cell layer repeated). + if !biome_cells.is_empty() { + let last = biome_cells.len() - 1; + for si in 0..SECTIONS as i32 { + let i = si - offset; + if (0..sections.len() as i32).contains(&i) { + continue; + } + let (edge, layer) = if i < 0 { (0, 0) } else { (last, 3) }; + let mut cells = [0u32; 64]; + for (j, cell) in cells.iter_mut().enumerate() { + *cell = biome_cells[edge][layer * 16 + j % 16]; + } + Arc::make_mut(&mut chunk.sections[si as usize]).biomes = + PalettedContainer::from_values(BIOME_STRATEGY, &cells); + } + } + // ClientPacketListener.applyLightData: the column keeps the light + // the server sent; nothing is relit. + let (layers, above) = self.light(&p.light); + horizon_client::light::light_from_layers(&mut chunk, &layers, above, self.has_skylight); + Ok(chunk) + } + + /// `ClientPacketListener.readSectionList`: the sky and block layers of a + /// light packet, by section of the client's column, and the sky light + /// above the column's top section (from the light section just above + /// it, else open sky). + pub(super) fn light(&self, light: &LightData) -> (Vec, [u8; 256]) { + let mut layers: Vec = vec![(None, None); SECTIONS]; + let sky = self.has_skylight; + let mut above = [if sky { 15 } else { 0 }; 256]; + // Light section b is the dimension's section b - 1. + let first = (self.min_y - MIN_Y).div_euclid(16) - 1; + for (b, layer) in light.layers(self.sections + 2).into_iter().enumerate() { + let si = first + b as i32; + if (0..SECTIONS as i32).contains(&si) { + layers[si as usize] = layer; + } else if si == SECTIONS as i32 + && sky + && let Some(l) = &layer.0 + { + for (i, a) in above.iter_mut().enumerate() { + *a = (l[i >> 1] >> ((i & 1) * 4)) & 15; + } + } + } + (layers, above) + } +} + +type Decoded = (Box, Result); + +/// One thread that decodes chunk packets in the order they arrived; its +/// results come back in that order, one per `submit`. +pub(super) struct ChunkDecoder { + jobs: mpsc::Sender<(Arc, Box)>, + done: mpsc::Receiver, +} + +impl ChunkDecoder { + pub(super) fn new() -> Self { + let (jobs, todo) = mpsc::channel::<(Arc, Box)>(); + let (finished, done) = mpsc::channel(); + // The thread ends with the connection, when `jobs` is dropped. + let spawned = std::thread::Builder::new() + .name("Chunk decoder".into()) + .spawn(move || { + // A frame waits for its columns, as it would for the render + // thread's own work. + horizon_threads::favour_current(); + for (format, packet) in todo { + let column = match &*packet { + C::LevelChunkWithLight(p) => format.column(p), + _ => Err("not a chunk packet".into()), + }; + if finished.send((packet, column)).is_err() { + break; + } + } + }); + if let Err(e) = spawned { + log::warn!("Horizon: no chunk decoder thread ({e}); chunks decode in the frame"); + } + Self { jobs, done } + } + + /// Start decoding a chunk packet with the format it arrived under. + /// Without a decoder thread the packet comes back undecoded. + pub(super) fn submit(&self, format: Arc, packet: Box) -> Option> { + self.jobs.send((format, packet)).err().map(|e| (e.0).1) + } + + /// The oldest submitted packet and its column, unless it is still + /// decoding: a frame never waits for the decoder. + pub(super) fn next(&self) -> Next { + match self.done.try_recv() { + Ok(decoded) => Next::Ready(decoded), + Err(TryRecvError::Empty) => Next::Decoding, + // The decoder thread panicked: its columns are gone. + Err(TryRecvError::Disconnected) => Next::Lost, + } + } +} + +pub(super) enum Next { + Ready(Decoded), + Decoding, + Lost, +} + +impl Game<'_> { + /// `handleLevelChunkWithLight`: the column replaces any loaded one, and + /// its block entities load their update tags. `decoded` is the column the + /// decoder made with `format`; another format since means decode again. + pub(super) fn remote_chunk( + &mut self, + p: &play::LevelChunkWithLight, + decoded: Option<(&Arc, Result)>, + ) { + // ClientChunkCache.replaceWithPacketData: a column outside the + // storage around the view centre is ignored. + if !self.remote_chunk_in_range(p.x, p.z) { + log::warn!( + "Ignoring chunk since it's not in the view range: {}, {}", + p.x, + p.z + ); + return; + } + let Some(format) = self.remote.as_ref().map(|r| r.chunk_format.clone()) else { + return; + }; + let column = match decoded { + Some((used, column)) if Arc::ptr_eq(used, &format) => column, + _ => format.column(p), + }; + let chunk = match column { + Ok(chunk) => chunk, + Err(e) => { + log::warn!("Horizon: chunk {} {}: {e}", p.x, p.z); + return; + } + }; + let (x, z) = (p.x, p.z); + self.streaming.insert_remote(&mut self.world, chunk); + self.world + .block_entities + .retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z)); + for info in &p.chunk.block_entities { + let pos = ( + x * 16 + i32::from(info.packed_xz as u8 >> 4), + i32::from(info.y), + z * 16 + i32::from(info.packed_xz as u8 & 15), + ); + let state = self.world.block(pos.0, pos.1, pos.2); + self.sync_block_entity(pos, state); + // LevelChunk.replaceWithPacketData: the block entity loads its update tag. + self.remote_block_entity_data([pos.0, pos.1, pos.2], info.kind, &info.tag); + } + } + + /// `handleLightUpdatePacket`: the sections it names take its light. + pub(super) fn remote_light_update(&mut self, p: &play::LightUpdate) { + let Some(format) = self.remote.as_ref().map(|r| r.chunk_format.clone()) else { + return; + }; + if !self.world.chunks.contains_key(&(p.x, p.z)) { + return; + } + let (layers, _) = format.light(&p.light); + let Some(chunk) = self.world.chunks.get_mut(&(p.x, p.z)) else { + return; + }; + let changed = horizon_client::light::update_light_layers( + Arc::make_mut(chunk), + &layers, + format.has_skylight, + ); + Streaming::light_updated(&mut self.world, p.x, p.z, &changed); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_protocol::chunk::{ChunkData, Paletted, Section as Wire, Strategy as Wiring}; + + /// A column of `state` with biome 1 everywhere, unlit. + fn packet(x: i32, state: i32) -> Box { + let section = Wire { + non_empty: 4096, + fluids: 0, + states: Paletted::from_values(&[state; 4096], Wiring::Blocks, 16), + biomes: Paletted::from_values(&[1; 64], Wiring::Biomes, 2), + }; + let none = LightData { + sky_mask: Vec::new(), + block_mask: Vec::new(), + empty_sky_mask: Vec::new(), + empty_block_mask: Vec::new(), + sky: Vec::new(), + block: Vec::new(), + }; + Box::new(C::LevelChunkWithLight(play::LevelChunkWithLight { + x, + z: -3, + chunk: ChunkData { + heightmaps: Vec::new(), + buffer: ChunkData::from_sections(&vec![section; 24]), + block_entities: Vec::new(), + }, + light: none, + })) + } + + /// Columns come back one per packet, in the order the packets went in, + /// as the frame would have decoded them itself. + #[test] + fn the_decoder_returns_columns_in_order() { + let overworld = DimensionType::vanilla("minecraft:overworld"); + let format = Arc::new(ChunkFormat::new(&overworld, vec![0, 7, 9], 2)); + let decoder = ChunkDecoder::new(); + for x in 0..20 { + assert!(decoder.submit(format.clone(), packet(x, 1 + x)).is_none()); + } + for x in 0..20 { + let (packet, column) = loop { + match decoder.next() { + Next::Ready(decoded) => break decoded, + Next::Decoding => std::thread::yield_now(), + Next::Lost => panic!("the decoder stopped"), + } + }; + let C::LevelChunkWithLight(p) = *packet else { + panic!("not a chunk packet"); + }; + let (column, direct) = (column.unwrap(), format.column(&p).unwrap()); + assert_eq!((column.x, column.z), (x, -3)); + for (cx, y, cz) in [(0, -64, 0), (5, 70, 9), (15, 319, 15)] { + assert_eq!(column.get(cx, y, cz), 1 + x as u32); + assert_eq!(column.get(cx, y, cz), direct.get(cx, y, cz)); + // Wire biome 1 is our biome 7. + assert_eq!(column.biome(cx, y, cz), 7); + } + } + assert!(matches!(decoder.next(), Next::Decoding)); + } +} diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 2ba4510ea..a117b1b7c 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -353,7 +353,8 @@ impl Game<'_> { out.push(json!({"id": t.id, "kind": "minecraft:trident", "position": at(t.position)})); } for p in &self.creatures.projectiles { - out.push(json!({"id": p.id, "kind": format!("{:?}", p.kind).split([' ', '{']).next().unwrap_or(""), "position": at(p.position)})); + out.push(json!({"id": p.id, "kind": format!("{:?}", p.kind).split([' ', '{']).next().unwrap_or(""), "position": at(p.position), "velocity": at(p.velocity), + "player_owned": p.owner == Some(horizon_client::mobs::Who::Player)})); } for (kind, p, _) in self.potions.thrown_entities() { out.push(json!({"kind": kind, "position": at(p)})); diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 80cf1140e..08668b5ef 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -67,7 +67,9 @@ mod end_sky; mod flat; pub mod lightning; mod lod; +mod native_pack; mod native_post; +mod native_sky; mod occlusion; mod pack_atlas; pub mod pack_draw; @@ -86,6 +88,7 @@ mod stars; mod timing; pub mod translucency; pub(crate) mod upload; +mod wgsl_prefix; mod world_post; /// A column whose every section has its mesh (`Renderer::lod_detail_columns`). @@ -457,7 +460,7 @@ pub struct Renderer { lod_retiring: crate::fast_hash::FxHashSet, /// Finished tile meshes `upload_lods` has yet to upload. lod_pending: Option, - detail_columns: HashMap<(i32, i32), u32>, + detail_columns: crate::fast_hash::FxHashMap<(i32, i32), u32>, /// Bumped whenever a column becomes or stops being complete. detail_revision: u64, arena: arena::Arena, @@ -491,7 +494,7 @@ pub struct Renderer { /// The shadow camera's draws by page, in bands of distance from the light. shadow_runs: page_runs::PageRuns, /// Block-entity blocks per meshed section (world position, state id). - block_entities: HashMap>, + block_entities: crate::fast_hash::FxHashMap>, /// Changes whenever `block_entities` does (unique across renderers). block_entity_revision: u64, /// VisGraph face connectivity per meshed section (cave culling). @@ -501,7 +504,7 @@ pub struct Renderer { /// The shader pack's post-processing, and the dimension (legacy id) it was loaded for. pack_post: Option<(i32, Option)>, /// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s. - native_post: Option, + native: Option, /// Time the shader pack's passes on the GPU (F3, or `HORIZON_SHADER_PACK_TIMING`). pass_timing: bool, /// The entity vertices Horizon draws itself while a shader pack draws the others. @@ -2388,7 +2391,7 @@ impl Renderer { lod_cutout: Default::default(), lod_retiring: Default::default(), lod_pending: None, - detail_columns: HashMap::new(), + detail_columns: Default::default(), detail_revision: 0, arena, sorted_indices, @@ -2409,12 +2412,12 @@ impl Renderer { solid_runs: page_runs::PageRuns::default(), phase2_runs: page_runs::PageRuns::default(), shadow_runs: page_runs::PageRuns::default(), - block_entities: HashMap::new(), + block_entities: Default::default(), block_entity_revision: next_block_entity_revision(), occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16), world_post, pack_post: None, - native_post: None, + native: None, pass_timing: pack_timing::PassTiming::logging(), pack_entity_rest: Vec::new(), cloud_bindings, @@ -2845,18 +2848,47 @@ impl Renderer { self.detail_columns.insert(column, next); } } - pub fn remove(&mut self, key: SectionKey) { - self.set_detail(key, false); - if self.block_entities.remove(&key).is_some() { + /// Every section of these columns goes: one lookup per column where the + /// tables are by column, and the meshes' ranges freed in one batch. A + /// teleport removes a few thousand columns in one frame. + pub fn remove_columns(&mut self, columns: impl IntoIterator) { + let mut released = Vec::new(); + let mut block_entities = false; + for (x, z) in columns { + if self.detail_columns.remove(&(x, z)) == Some(COMPLETE_COLUMN) { + self.detail_revision += 1; + } + self.occlusion.remove_column(x, z); + let retiring = !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(x, z)); + for sy in 0..crate::chunk::SECTIONS as i32 { + let key = (x, sy, z); + block_entities |= self.block_entities.remove(&key).is_some(); + if retiring { + // Distant tiles still leave its column out: drawn until they don't. + self.lod_retiring.insert(key); + } else if let Some(section) = self.sections.remove(key) { + released.push(section); + } + } + } + if block_entities { self.block_entity_revision = next_block_entity_revision(); } - self.occlusion.remove(key); - if !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(key.0, key.2)) { - // Distant tiles still leave its column out: drawn until they don't. - self.lod_retiring.insert(key); - } else { - self.release_section(key); + if let Some(flat) = &mut self.flat { + for id in released.iter().filter_map(|s| s.flat_id) { + flat.remove(id); + } } + self.sorted_indices + .release_all(released.iter().filter_map(|s| { + let (page, start) = s.sorted_indices?; + Some((page, start, u64::from(s.translucent) * 6)) + })); + self.arena.release_all( + released + .iter() + .map(|s| (s.page, s.start, u64::from(s.solid + s.translucent) * 4)), + ); } /// Horizon's resolution scale (world pixels per window pixel) and FXAA. pub fn set_world_post(&mut self, scale: f32, antialias: bool) { @@ -2924,41 +2956,40 @@ impl Renderer { }); self.pack_post = Some((dimension, post)); if self.pack_post.as_ref().is_some_and(|p| p.1.is_some()) { - self.native_post = None; + self.native = None; } report } /// Drops the running shader pack, of either kind. pub fn drop_shader_packs(&mut self) { self.pack_post = None; - self.native_post = None; + self.native = None; self.pack_atlas = None; } - /// Runs the post passes of one of Horizon's own shader packs over the world from now on - /// (`None`: no pack), with its options' values; replaces a `shaders/` pack. Returns the - /// passes' labels; on an error the passes that ran keep running. + /// Runs the sky and post stages of one of Horizon's own shader packs from now on (`None`: + /// no pack), with its options' values; replaces a `shaders/` pack. Returns the stages' + /// labels; on an error the pack that ran keeps running. pub fn set_native_shader_pack( &mut self, pack: Option<(horizon_shader_api::Report, Vec<(String, f64)>)>, ) -> std::result::Result, String> { - let stages = pack.map(|(report, constants)| { - let post: Vec<_> = report - .stages - .into_iter() - .filter(|s| s.kind == horizon_shader_api::StageKind::Post) - .collect(); - (post, constants) - }); - let Some((post, constants)) = stages.filter(|(post, _)| !post.is_empty()) else { - self.native_post = None; + let Some((report, constants)) = pack else { + self.native = None; return Ok(Vec::new()); }; let format = self.config.format.remove_srgb_suffix(); - let post = native_post::NativePost::new(&self.device, post, &constants, format)?; - let labels = post.labels().into_iter().map(str::to_owned).collect(); - self.pack_post = None; - self.pack_atlas = None; - self.native_post = Some(post); + let (pack, labels) = native_pack::NativePack::new( + &self.device, + &self.terrain_layout, + report, + &constants, + format, + )?; + self.native = pack.draws().then_some(pack); + if self.native.is_some() { + self.pack_post = None; + self.pack_atlas = None; + } Ok(labels) } /// What a shader pack's gbuffers programs read from Horizon's geometry: the sky's, and @@ -3009,20 +3040,20 @@ impl Renderer { /// The running shader pack's timer, of either kind. fn pass_timer<'a>( pack: &'a mut Option<(i32, Option)>, - native: &'a mut Option, + native: &'a mut Option, ) -> Option<&'a mut Option> { match (pack, native) { (Some((_, Some(post))), _) => Some(&mut post.timing), - (_, Some(post)) => Some(&mut post.timing), + (_, Some(native)) => Some(&mut native.timing), _ => None, } } /// Each pass of the running shader pack with its median GPU time in milliseconds, while /// they are timed (`set_pass_timing`). pub fn shader_pass_times(&self) -> Vec<(String, f32)> { - let timer = match (&self.pack_post, &self.native_post) { + let timer = match (&self.pack_post, &self.native) { (Some((_, Some(post))), _) => post.timing.as_ref(), - (_, Some(post)) => post.timing.as_ref(), + (_, Some(native)) => native.timing.as_ref(), _ => None, }; timer @@ -4052,8 +4083,8 @@ impl Renderer { // The world's targets: the screen, or the scaled target of `post`. let pack_post = !frame.title && self.pack_post.as_ref().is_some_and(|p| p.1.is_some()); // One of Horizon's own packs reads the same world target. - let native_post = !frame.title && self.native_post.is_some(); - if let Some(timer) = Self::pass_timer(&mut self.pack_post, &mut self.native_post) + let native_post = !frame.title && self.native.as_ref().is_some_and(|n| n.post.is_some()); + if let Some(timer) = Self::pass_timer(&mut self.pack_post, &mut self.native) && timer.is_some() != self.pass_timing { *timer = self @@ -4115,24 +4146,79 @@ impl Renderer { cull.bind_depth(&self.device, world_depth); } let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0); + let clear = if frame.title || (frame.end_sky && !frame.underwater) { + wgpu::Color::BLACK + } else { + wgpu::Color { + r: f64::from(fog_color[0]), + g: f64::from(fog_color[1]), + b: f64::from(fog_color[2]), + a: 1.0, + } + }; + let sky_visible = sky_open(frame); + // One of Horizon's own packs: this frame's inputs; in a timed frame its sky draws in a + // pass of its own, so that it has a time of its own. + let mut native_sky_pass = false; + if !frame.title + && let Some(native) = &mut self.native + { + let size = self + .world_post + .size() + .filter(|_| scaled.is_some()) + .unwrap_or([self.config.width, self.config.height]); + native.frame.write(&self.queue, frame, size); + if let Some(t) = &mut native.timing { + t.begin(&self.device, &self.queue); + native_sky_pass = + native.sky.is_some() && t.recording() && sky_visible && frame.skybox; + } + } + if native_sky_pass + && let Some(native) = &mut self.native + && let Some(sky) = &native.sky + { + if let Some(t) = &mut native.timing { + let format = self.config.format.remove_srgb_suffix(); + t.mark(&self.device, &mut encoder, (world_view, format)); + } + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some(&sky.label), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: world_view, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Clear(clear), + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: world_depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + timestamp_writes: native.timing.as_mut().and_then(|t| t.writes(&sky.label)), + ..Default::default() + }); + pass.set_bind_group(0, &self.group, &[]); + sky.draw(&mut pass, &native.frame); + } { let attachments = [Some(wgpu::RenderPassColorAttachment { view: world_view, resolve_target: None, depth_slice: None, ops: wgpu::Operations { - load: wgpu::LoadOp::Clear( - if frame.title || (frame.end_sky && !frame.underwater) { - wgpu::Color::BLACK - } else { - wgpu::Color { - r: f64::from(fog_color[0]), - g: f64::from(fog_color[1]), - b: f64::from(fog_color[2]), - a: 1.0, - } - }, - ), + load: if native_sky_pass { + wgpu::LoadOp::Load + } else { + wgpu::LoadOp::Clear(clear) + }, store: wgpu::StoreOp::Store, }, })]; @@ -4155,11 +4241,19 @@ impl Renderer { ..Default::default() }); pass.set_bind_group(0, &self.group, &[]); - let sky_visible = sky_open(frame); if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) { - if !frame.title && frame.skybox && !pack_draws_sky { - pass.set_pipeline(&self.sky); - pass.draw(0..3, 0..1); + if !frame.title && frame.skybox && !pack_draws_sky && !native_sky_pass { + match self + .native + .as_ref() + .and_then(|n| Some((n.sky.as_ref()?, &n.frame))) + { + Some((sky, native)) => sky.draw(&mut pass, native), + None => { + pass.set_pipeline(&self.sky); + pass.draw(0..3, 0..1); + } + } } if frame.title { self.panorama.draw(&mut pass); @@ -4511,17 +4605,17 @@ impl Renderer { self.pack_post = Some((dimension, Some(post))); } else if let Some((color, depth)) = &scaled && native_post - && let Some(post) = &mut self.native_post + && let Some(native) = &mut self.native + && let Some(post) = &mut native.post { let size = self.world_post.size().unwrap_or([1, 1]); post.run( &self.device, - &self.queue, &mut encoder, (color, depth), &view_target, - frame, size, + native.timing.as_mut(), ); } else if scaled.is_some() { self.world_post.finish(&mut encoder, &view_target); @@ -4694,7 +4788,7 @@ impl Renderer { timer.submitted(&self.queue); timer.collect(&self.device, &mut self.gpu_times); } - if let Some(Some(timer)) = Self::pass_timer(&mut self.pack_post, &mut self.native_post) { + if let Some(Some(timer)) = Self::pass_timer(&mut self.pack_post, &mut self.native) { timer.submitted(&self.queue); } if let Some((path, buffer)) = readback { diff --git a/crates/horizon-client/src/gfx/arena.rs b/crates/horizon-client/src/gfx/arena.rs index 34b4d332d..8f320a408 100644 --- a/crates/horizon-client/src/gfx/arena.rs +++ b/crates/horizon-client/src/gfx/arena.rs @@ -39,6 +39,35 @@ impl FreeList { } self.0.insert(start, len); } + /// `give` for many ranges: one merge of the sorted ranges into the list, + /// where giving them one by one costs a few tree lookups each. + fn give_all(&mut self, mut ranges: Vec<(u64, u64)>) { + if ranges.len() < 64 { + for (start, len) in ranges { + self.give(start, len); + } + return; + } + ranges.sort_unstable(); + let mut free = std::mem::take(&mut self.0).into_iter().peekable(); + let mut given = ranges.into_iter().peekable(); + let mut merged: Vec<(u64, u64)> = Vec::new(); + loop { + let next = match (free.peek(), given.peek()) { + (Some(a), Some(b)) if a.0 <= b.0 => free.next(), + (_, Some(_)) => given.next(), + (Some(_), None) => free.next(), + (None, None) => break, + }; + let (start, len) = next.expect("peeked"); + match merged.last_mut() { + Some(last) if last.0 + last.1 == start => last.1 += len, + _ => merged.push((start, len)), + } + } + // Sorted: the tree is built in one pass. + self.0 = merged.into_iter().collect(); + } } /// One vertex buffer of the arena; only the newest page grows. @@ -237,6 +266,26 @@ impl Arena { .free .give(start, len); } + /// `release` for many ranges (page, start, vertices) at once. + pub fn release_all(&mut self, ranges: impl IntoIterator) { + let mut by_page: Vec> = Vec::new(); + for (page, start, vertices) in ranges { + let page = page as usize; + if by_page.len() <= page { + by_page.resize_with(page + 1, Vec::new); + } + by_page[page].push((start, Self::span(vertices).min(self.page_limit))); + } + for (page, ranges) in by_page.into_iter().enumerate() { + if !ranges.is_empty() { + self.pages[page] + .as_mut() + .expect("live arena page") + .free + .give_all(ranges); + } + } + } /// Moves a page into a larger buffer; false (the page unchanged) when /// there is no memory for it. fn grow( @@ -435,6 +484,44 @@ mod tests { assert_eq!(free, FreeList::new(4 * GRAIN)); } + #[test] + fn many_ranges_given_at_once_coalesce_as_one_by_one() { + let fill = || { + let mut free = FreeList::new(1 << 30); + let taken: Vec<(u64, u64)> = (0..500u64) + .map(|i| { + let len = GRAIN * (1 + i * 7 % 5); + (free.take(len).unwrap(), len) + }) + .collect(); + for &(start, len) in taken.iter().step_by(3) { + free.give(start, len); + } + (free, taken) + }; + // Every other range of those still taken, in a scattered order. + let (mut one_by_one, taken) = fill(); + let (mut at_once, _) = fill(); + let mut given: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 == 0) + .map(|i| taken[i]) + .collect(); + given.sort_by_key(|&(start, _)| start.wrapping_mul(0x9E37_79B9_7F4A_7C15)); + assert!(given.len() >= 64); + for &(start, len) in &given { + one_by_one.give(start, len); + } + at_once.give_all(given); + assert_eq!(at_once, one_by_one); + // The rest too: everything is free again, in one range. + let rest: Vec<(u64, u64)> = (0..taken.len()) + .filter(|i| i % 3 != 0 && i % 2 != 0) + .map(|i| taken[i]) + .collect(); + at_once.give_all(rest); + assert_eq!(at_once, FreeList::new(1 << 30)); + } + #[test] fn first_fit_reuses_the_lowest_hole() { let mut free = FreeList::new(8 * GRAIN); diff --git a/crates/horizon-client/src/gfx/native_pack.rs b/crates/horizon-client/src/gfx/native_pack.rs new file mode 100644 index 000000000..3f9206e11 --- /dev/null +++ b/crates/horizon-client/src/gfx/native_pack.rs @@ -0,0 +1,60 @@ +//! One of Horizon's own shader packs while it runs (docs/shaders.md): the frame its stages +//! read, its sky and post stages, and the timer of their passes. + +use horizon_shader_api::{Report, StageKind}; + +use super::native_post::{NativeFrame, NativePost}; +use super::native_sky::NativeSky; +use super::pack_timing::PassTiming; + +pub struct NativePack { + pub frame: NativeFrame, + pub sky: Option, + pub post: Option, + /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`). + pub timing: Option, +} + +impl NativePack { + /// The pack of the checked stages `report` with the option values `constants`, drawing + /// onto targets of `format`; `globals` is the terrain's group 0, which the sky reads. + /// Also returns its stages' labels, in the order they draw. Errors name the stage wgpu + /// refused. + pub fn new( + device: &wgpu::Device, + globals: &wgpu::BindGroupLayout, + report: Report, + constants: &[(String, f64)], + format: wgpu::TextureFormat, + ) -> Result<(Self, Vec), String> { + let frame = NativeFrame::new(device); + let (post, others): (Vec<_>, Vec<_>) = report + .stages + .into_iter() + .partition(|s| s.kind == StageKind::Post); + let sky = others + .iter() + .find(|s| s.kind == StageKind::Sky) + .map(|stage| NativeSky::new(device, globals, &frame, stage, constants, format)) + .transpose()?; + let post = (!post.is_empty()) + .then(|| NativePost::new(device, post, constants, format, &frame)) + .transpose()?; + let mut labels: Vec = sky.iter().map(|s| s.label.clone()).collect(); + if let Some(post) = &post { + labels.extend(post.labels().into_iter().map(str::to_owned)); + } + let pack = Self { + frame, + sky, + post, + timing: None, + }; + Ok((pack, labels)) + } + + /// Whether the pack draws anything the game runs today. + pub fn draws(&self) -> bool { + self.sky.is_some() || self.post.is_some() + } +} diff --git a/crates/horizon-client/src/gfx/native_post.rs b/crates/horizon-client/src/gfx/native_post.rs index cf99b1936..89515f5db 100644 --- a/crates/horizon-client/src/gfx/native_post.rs +++ b/crates/horizon-client/src/gfx/native_post.rs @@ -3,7 +3,8 @@ //! the pack's options as pipeline constants. A pass reads bind group 3: the frame, the world's //! colour and depth, the previous pass's output and two samplers. Passes before the last write //! half-float targets of the world's size, so values over 1 carry to the next; the last draws -//! onto the screen. +//! onto the screen. Every stage of a pack reads the same `frame`, written once a frame +//! (`NativeFrame`). use glam::{Mat4, Vec3}; use horizon_shader_api::{Frame as FrameInputs, check::CheckedStage, stages::GROUP}; @@ -25,12 +26,87 @@ pub struct NativePost { targets: Option<([u32; 2], [wgpu::TextureView; 2])>, /// One bind group per pass, for these world views. groups: Option<(WorldViews, Vec)>, - start: std::time::Instant, - frames: u32, /// The screen's colour format, the world target's too. format: wgpu::TextureFormat, - /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`). - pub timing: Option, +} + +/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame. +pub struct NativeFrame { + pub(super) buffer: wgpu::Buffer, + /// Group 3 of the stages that read only the frame (the sky). + pub layout: wgpu::BindGroupLayout, + pub group: wgpu::BindGroup, + start: std::time::Instant, + frames: u32, +} + +/// The uniform `frame` at binding 0, read by `visibility`. +fn frame_entry(visibility: wgpu::ShaderStages) -> wgpu::BindGroupLayoutEntry { + wgpu::BindGroupLayoutEntry { + binding: 0, + visibility, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: wgpu::BufferSize::new(size_of::() as u64), + }, + count: None, + } +} + +impl NativeFrame { + pub fn new(device: &wgpu::Device) -> Self { + let buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Native shader pack frame"), + size: size_of::() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Native shader pack frame"), + entries: &[frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT)], + }); + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Native shader pack frame"), + layout: &layout, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: buffer.as_entire_binding(), + }], + }); + Self { + buffer, + layout, + group, + start: std::time::Instant::now(), + frames: 0, + } + } + + /// Writes this frame's inputs, for a world of `size`. + pub fn write(&mut self, queue: &wgpu::Queue, frame: &Frame, size: [u32; 2]) { + let seconds = self.start.elapsed().as_secs_f32() % 3600.0; + let inputs = frame_inputs(frame, size, seconds, self.frames); + self.frames = self.frames.wrapping_add(1); + queue.write_buffer(&self.buffer, 0, bytemuck::bytes_of(&inputs)); + } +} + +/// The option values of `constants` that `module` declares as overrides (wgpu refuses others). +pub fn present_constants<'a>( + module: &naga::Module, + constants: &'a [(String, f64)], +) -> Vec<(&'a str, f64)> { + constants + .iter() + .filter(|(id, _)| { + module + .overrides + .iter() + .any(|(_, o)| o.name.as_ref() == Some(id)) + }) + .map(|(id, v)| (id.as_str(), *v)) + .collect() } fn texture_entry(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::BindGroupLayoutEntry { @@ -63,21 +139,13 @@ impl NativePost { stages: Vec, constants: &[(String, f64)], format: wgpu::TextureFormat, + frame: &NativeFrame, ) -> Result { let float = wgpu::TextureSampleType::Float { filterable: true }; let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("Native shader pack post"), entries: &[ - wgpu::BindGroupLayoutEntry { - binding: 0, - visibility: wgpu::ShaderStages::FRAGMENT, - ty: wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Uniform, - has_dynamic_offset: false, - min_binding_size: wgpu::BufferSize::new(size_of::() as u64), - }, - count: None, - }, + frame_entry(wgpu::ShaderStages::FRAGMENT), texture_entry(1, float), texture_entry(2, wgpu::TextureSampleType::Depth), texture_entry(3, float), @@ -95,17 +163,7 @@ impl NativePost { let count = stages.len(); let mut passes = Vec::with_capacity(count); for (i, stage) in stages.into_iter().enumerate() { - let present: Vec<(&str, f64)> = constants - .iter() - .filter(|(id, _)| { - stage - .module - .overrides - .iter() - .any(|(_, o)| o.name.as_ref() == Some(id)) - }) - .map(|(id, v)| (id.as_str(), *v)) - .collect(); + let present = present_constants(&stage.module, constants); let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some(&stage.label), @@ -145,12 +203,6 @@ impl NativePost { } passes.push((stage.label, pipeline)); } - let frame = device.create_buffer(&wgpu::BufferDescriptor { - label: Some("Native shader pack frame"), - size: size_of::() as u64, - usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); let sampler = |label, filter| { device.create_sampler(&wgpu::SamplerDescriptor { label: Some(label), @@ -162,15 +214,12 @@ impl NativePost { Ok(Self { passes, layout, - frame, + frame: frame.buffer.clone(), linear: sampler("Native shader pack linear", wgpu::FilterMode::Linear), nearest: sampler("Native shader pack nearest", wgpu::FilterMode::Nearest), targets: None, groups: None, - start: std::time::Instant::now(), - frames: 0, format, - timing: None, }) } @@ -264,37 +313,18 @@ impl NativePost { } /// Runs the passes over the world target `world` (colour, depth) of `size`, the last onto - /// `screen`. + /// `screen`, timed by `timing` when it times this frame. pub fn run( &mut self, device: &wgpu::Device, - queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, world: (&wgpu::TextureView, &wgpu::TextureView), screen: &wgpu::TextureView, - frame: &Frame, - size: [u32; 2], - ) { - let seconds = self.start.elapsed().as_secs_f32() % 3600.0; - let inputs = frame_inputs(frame, size, seconds, self.frames); - self.frames = self.frames.wrapping_add(1); - self.draw(device, queue, encoder, world, screen, &inputs, size); - } - - fn draw( - &mut self, - device: &wgpu::Device, - queue: &wgpu::Queue, - encoder: &mut wgpu::CommandEncoder, - world: (&wgpu::TextureView, &wgpu::TextureView), - screen: &wgpu::TextureView, - inputs: &FrameInputs, size: [u32; 2], + mut timing: Option<&mut super::pack_timing::PassTiming>, ) { self.prepare(device, world, size); - queue.write_buffer(&self.frame, 0, bytemuck::bytes_of(inputs)); - if let Some(t) = &mut self.timing { - t.begin(device, queue); + if let Some(t) = timing.as_deref_mut() { t.mark(device, encoder, (world.0, self.format)); } let Some((_, groups)) = &self.groups else { @@ -317,7 +347,7 @@ impl NativePost { let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some(label), color_attachments: &attachments, - timestamp_writes: self.timing.as_mut().and_then(|t| t.writes(label)), + timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes(label)), ..Default::default() }); pass.set_pipeline(pipeline); @@ -437,8 +467,20 @@ mod tests { .into(); let report = check(&Pack::from_files(files).unwrap()).unwrap(); let format = wgpu::TextureFormat::Rgba8Unorm; - let mut post = - NativePost::new(&device, report.stages, &[("gain".into(), 1.0)], format).unwrap(); + let frame = NativeFrame::new(&device); + queue.write_buffer( + &frame.buffer, + 0, + bytemuck::bytes_of(&FrameInputs::default()), + ); + let mut post = NativePost::new( + &device, + report.stages, + &[("gain".into(), 1.0)], + format, + &frame, + ) + .unwrap(); assert_eq!(post.labels(), ["a.wgsl", "b.wgsl"]); let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING; @@ -478,15 +520,7 @@ mod tests { ..Default::default() }); let view = screen.create_view(&Default::default()); - post.draw( - &device, - &queue, - &mut encoder, - (&color, &depth), - &view, - &FrameInputs::default(), - [4, 4], - ); + post.run(&device, &mut encoder, (&color, &depth), &view, [4, 4], None); let buffer = device.create_buffer(&wgpu::BufferDescriptor { label: None, size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4), diff --git a/crates/horizon-client/src/gfx/native_sky.rs b/crates/horizon-client/src/gfx/native_sky.rs new file mode 100644 index 000000000..3b3c9a3b7 --- /dev/null +++ b/crates/horizon-client/src/gfx/native_sky.rs @@ -0,0 +1,379 @@ +//! The sky stage of Horizon's own shader packs (docs/shaders.md): the pack's `sky` function, +//! called for each pixel of the sky disc with vanilla's colour along its view ray. The +//! pipeline's shader is the pack's stage (`CheckedStage::source`) followed by a copy of the +//! renderer's sky (terrain.wgsl's `Globals`, `linear_fog` and sky section) whose names all +//! take a `horizon_sky_` prefix, so none can meet a pack's (the check refuses `horizon_` +//! names). It reads the renderer's globals (group 0) and the pack's frame (group 3), and +//! draws where vanilla's sky draws; the sun, moon, stars and the dark disc are drawn over it. + +use horizon_shader_api::{check::CheckedStage, stages::GROUP}; + +use super::native_post::{NativeFrame, present_constants}; +use super::wgsl_prefix::{TERRAIN, prefixed, section}; + +const PREFIX: &str = "horizon_sky_"; + +/// The fragment entry that calls the pack: vanilla's colour in, an opaque colour out. +const PACK_ENTRY: &str = " +@fragment fn horizon_sky_fs_pack(in: horizon_sky_SkyOut) -> @location(0) vec4 { + let d = horizon_sky_view_ray(in.ndc); + return vec4(sky(SkyInput(d, vec4(horizon_sky_sky_along_ray(d), 1.0))).rgb, 1.0); +} +"; + +pub struct NativeSky { + pipeline: wgpu::RenderPipeline, + pub label: String, +} + +/// terrain.wgsl's sky with every name it declares (and `globals`) prefixed. +fn vanilla_sky() -> String { + let text = [ + section(TERRAIN, "struct Globals {", "@group(0) @binding(1)"), + section(TERRAIN, "fn linear_fog(", "fn apply_fog("), + section(TERRAIN, "struct SkyOut {", "// rendertype_lines"), + ] + .concat(); + prefixed(&text, PREFIX) +} + +/// The sky shader for the pack's sky stage `source`. +fn shader_source(source: &str) -> String { + format!( + "{source}\n// Horizon's sky (terrain.wgsl)\n{}{PACK_ENTRY}", + vanilla_sky() + ) +} + +/// A sky pipeline over `module` whose fragment entry is `fragment`. +fn pipeline( + device: &wgpu::Device, + layout: &wgpu::PipelineLayout, + module: &wgpu::ShaderModule, + fragment: &str, + constants: &[(&str, f64)], + format: wgpu::TextureFormat, +) -> wgpu::RenderPipeline { + let options = wgpu::PipelineCompilationOptions { + constants, + ..Default::default() + }; + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Native shader pack sky"), + layout: Some(layout), + vertex: wgpu::VertexState { + module, + entry_point: Some("horizon_sky_vs_sky"), + compilation_options: options.clone(), + buffers: &[], + }, + primitive: Default::default(), + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(false), + depth_compare: Some(wgpu::CompareFunction::Always), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module, + entry_point: Some(fragment), + compilation_options: options, + targets: &[Some(wgpu::ColorTargetState { + format, + blend: None, + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) +} + +/// The sky's naga module and the layout of its pipelines: `globals` at group 0, the frame +/// at group 3. +fn build( + device: &wgpu::Device, + globals: &wgpu::BindGroupLayout, + frame: &NativeFrame, + stage: &CheckedStage, +) -> Result<(naga::Module, wgpu::PipelineLayout), String> { + let text = shader_source(&stage.source); + let module = naga::front::wgsl::parse_str(&text) + .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?; + let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default(); + groups[0] = Some(globals); + groups[GROUP as usize] = Some(&frame.layout); + let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Native shader pack sky"), + bind_group_layouts: &groups, + ..Default::default() + }); + Ok((module, layout)) +} + +impl NativeSky { + /// The pipeline of the pack's sky `stage` with the option values `constants`, drawing + /// onto the world's target of `format`; `globals` is the terrain's group 0. + pub fn new( + device: &wgpu::Device, + globals: &wgpu::BindGroupLayout, + frame: &NativeFrame, + stage: &CheckedStage, + constants: &[(String, f64)], + format: wgpu::TextureFormat, + ) -> Result { + let (module, layout) = build(device, globals, frame, stage)?; + let present = present_constants(&module, constants); + let scope = device.push_error_scope(wgpu::ErrorFilter::Validation); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some(&stage.label), + source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)), + }); + let pipeline = pipeline( + device, + &layout, + &module, + "horizon_sky_fs_pack", + &present, + format, + ); + if let Some(e) = pollster::block_on(scope.pop()) { + return Err(format!("{}: {e}", stage.file)); + } + Ok(Self { + pipeline, + label: stage.label.clone(), + }) + } + + /// Draws the sky in a pass whose group 0 is the terrain's. + pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>, frame: &NativeFrame) { + pass.set_pipeline(&self.pipeline); + pass.set_bind_group(GROUP, &frame.group, &[]); + pass.draw(0..3, 0..1); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_shader_api::{Frame as FrameInputs, MANIFEST, Pack, StageKind, check}; + + fn stage(sky: &str) -> CheckedStage { + let mut manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\ + [sky]\nfile = \"sky.wgsl\"\n" + .to_owned(); + if sky.contains("gain") { + manifest += "[[options]]\nid = \"gain\"\nname = \"Gain\"\ntype = \"float\"\n\ + default = 1.0\nmin = 0.0\nmax = 2.0\n"; + } + let manifest = manifest.as_str(); + let files = [(MANIFEST, manifest), ("sky.wgsl", sky)] + .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec())) + .into(); + let mut report = check(&Pack::from_files(files).unwrap()).unwrap(); + assert_eq!(report.stages[0].kind, StageKind::Sky); + report.stages.remove(0) + } + + #[test] + fn the_renderer_s_sky_takes_a_prefix_and_validates_with_a_pack() { + let sky = vanilla_sky(); + for name in [ + "Globals", + "SkyOut", + "view_ray", + "PI", + "sky_along_ray", + "linear_fog", + "fs_sky", + ] { + assert!(sky.contains(&format!("{PREFIX}{name}")), "{name}"); + } + // A pack may use the renderer's names for its own things. + let own = "override gain: f32;\nconst PI: f32 = 3.0;\nfn view_ray() -> f32 { return PI; }\n\ + fn sky(input: SkyInput) -> vec4 { return input.color * gain * view_ray(); }\n"; + let text = shader_source(&stage(own).source); + let module = naga::front::wgsl::parse_str(&text).unwrap_or_else(|e| { + panic!("{}", e.emit_to_string(&text)); + }); + naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::default(), + ) + .validate(&module) + .unwrap(); + } + + /// Vanilla's sky and two packs over the same globals: one that returns its input draws + /// vanilla's pixels, one that inverts them draws the inverse (and stays opaque). + #[test] + fn a_pack_gets_vanilla_s_colour_and_draws_opaque() { + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); + let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else { + return; + }; + let (device, queue) = + pollster::block_on(adapter.request_device(&Default::default())).unwrap(); + let format = wgpu::TextureFormat::Rgba8Unorm; + let globals_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: None, + entries: &[wgpu::BindGroupLayoutEntry { + binding: 0, + visibility: wgpu::ShaderStages::VERTEX_FRAGMENT, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }], + }); + let mut globals: super::super::Globals = bytemuck::Zeroable::zeroed(); + globals.inverse_view = glam::Mat4::IDENTITY.to_cols_array_2d(); + globals.misc = [0.0, 0.0, 1.0, 1.0]; + globals.fog_color = [0.2, 0.4, 0.6, 1.0]; + globals.sky_color = [0.5, 0.7, 1.0, 1.0]; + globals.fog_ends = [64.0, 0.0, 0.0, 0.0]; + let globals_buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: size_of::() as u64, + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + queue.write_buffer(&globals_buffer, 0, bytemuck::bytes_of(&globals)); + let globals_group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: None, + layout: &globals_layout, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: globals_buffer.as_entire_binding(), + }], + }); + let frame = NativeFrame::new(&device); + queue.write_buffer( + &frame.buffer, + 0, + bytemuck::bytes_of(&FrameInputs::default()), + ); + + let gain = [("gain".to_owned(), 1.0)]; + let draw = |stage: &CheckedStage, vanilla: bool| -> Vec { + let sky = + NativeSky::new(&device, &globals_layout, &frame, stage, &gain, format).unwrap(); + let pipeline = if vanilla { + let (module, layout) = build(&device, &globals_layout, &frame, stage).unwrap(); + let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: None, + source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)), + }); + pipeline(&device, &layout, &module, "horizon_sky_fs_sky", &[], format) + } else { + sky.pipeline.clone() + }; + let texture = |format, usage| { + device.create_texture(&wgpu::TextureDescriptor { + label: None, + size: wgpu::Extent3d { + width: 4, + height: 4, + depth_or_array_layers: 1, + }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format, + usage, + view_formats: &[], + }) + }; + let color = texture( + format, + wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, + ); + let depth = texture( + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::RENDER_ATTACHMENT, + ); + let (color_view, depth_view) = ( + color.create_view(&Default::default()), + depth.create_view(&Default::default()), + ); + let mut encoder = device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { + label: None, + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &color_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_view, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Clear(0.0), + store: wgpu::StoreOp::Discard, + }), + stencil_ops: None, + }), + ..Default::default() + }); + pass.set_bind_group(0, &globals_group, &[]); + pass.set_pipeline(&pipeline); + pass.set_bind_group(GROUP, &frame.group, &[]); + pass.draw(0..3, 0..1); + } + let buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: None, + size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4), + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + encoder.copy_texture_to_buffer( + color.as_image_copy(), + wgpu::TexelCopyBufferInfo { + buffer: &buffer, + layout: wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT), + rows_per_image: Some(4), + }, + }, + color.size(), + ); + queue.submit([encoder.finish()]); + buffer + .slice(..) + .map_async(wgpu::MapMode::Read, |r| r.unwrap()); + device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + let bytes = buffer.slice(..).get_mapped_range().unwrap().to_vec(); + (0..4) + .flat_map(|row| { + let start = row * wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize; + bytes[start..start + 16].to_vec() + }) + .collect() + }; + let same = stage("fn sky(input: SkyInput) -> vec4 { return input.color; }\n"); + let vanilla = draw(&same, true); + assert_eq!(draw(&same, false), vanilla); + // The top row looks up into the sky disc, the bottom one down into the fog. + assert_ne!(vanilla[..4], vanilla[vanilla.len() - 4..]); + let inverse = stage( + "override gain: f32;\nfn sky(input: SkyInput) -> vec4 { return vec4(vec3(gain) - input.color.rgb, 0.25); }\n", + ); + let inverted = draw(&inverse, false); + for (got, want) in inverted.chunks(4).zip(vanilla.chunks(4)) { + assert_eq!(got[3], 255); + for i in 0..3 { + assert!(got[i].abs_diff(255 - want[i]) <= 1, "{got:?} {want:?}"); + } + } + } +} diff --git a/crates/horizon-client/src/gfx/occlusion.rs b/crates/horizon-client/src/gfx/occlusion.rs index e17ba87d1..22e2f3c81 100644 --- a/crates/horizon-client/src/gfx/occlusion.rs +++ b/crates/horizon-client/src/gfx/occlusion.rs @@ -522,16 +522,27 @@ impl Occlusion { } pub fn set(&mut self, key: SectionKey, vis: u64) { if self.columns.set(key, vis) { - self.edits.push(Edit::Set(key, vis)); - self.dirty = true; - self.changed.push(key); - if self.running.is_some() { - self.changed_late.push(key); - } + self.changed(key, vis); } } - pub fn remove(&mut self, key: SectionKey) { - self.set(key, ALL_VISIBLE); + fn changed(&mut self, key: SectionKey, vis: u64) { + self.edits.push(Edit::Set(key, vis)); + self.dirty = true; + self.changed.push(key); + if self.running.is_some() { + self.changed_late.push(key); + } + } + /// Every section of the column `x`, `z` goes (sees through every face). + pub fn remove_column(&mut self, x: i32, z: i32) { + let Some(column) = self.columns.map.remove(&(x, z)) else { + return; + }; + for (y, &vis) in column.iter().enumerate() { + if vis != ALL_VISIBLE { + self.changed((x, y as i32, z), ALL_VISIBLE); + } + } } pub fn clear(&mut self) { self.columns.map.clear(); diff --git a/crates/horizon-client/src/gfx/pack_timing.rs b/crates/horizon-client/src/gfx/pack_timing.rs index 24b97d7af..2a8dcf4a5 100644 --- a/crates/horizon-client/src/gfx/pack_timing.rs +++ b/crates/horizon-client/src/gfx/pack_timing.rs @@ -128,6 +128,11 @@ impl PassTiming { } } + /// Whether the frame being recorded is timed. + pub fn recording(&self) -> bool { + matches!(self.stage, Stage::Recording) + } + /// Timestamp writes for the pass `name`, in a timed frame. pub fn writes(&mut self, name: &str) -> Option> { let i = self.push(name)?; diff --git a/crates/horizon-client/src/gfx/wgsl_prefix.rs b/crates/horizon-client/src/gfx/wgsl_prefix.rs new file mode 100644 index 000000000..03d84a56e --- /dev/null +++ b/crates/horizon-client/src/gfx/wgsl_prefix.rs @@ -0,0 +1,124 @@ +//! Copies of the renderer's own WGSL that run beside a shader pack's code in one module (the +//! sky and material stages of Horizon's packs, docs/shaders.md): every name such a copy +//! declares takes a prefix starting with `horizon_`, which the pack check refuses in a pack, +//! so no pack name can meet one of Horizon's. + +/// terrain.wgsl, which the copies are taken from. +pub const TERRAIN: &str = include_str!("../terrain.wgsl"); + +/// The text of `source` from the line starting with `start` up to (not including) the one +/// starting with `end`. +pub fn section<'a>(source: &'a str, start: &str, end: &str) -> &'a str { + let from = source + .find(&format!("\n{start}")) + .expect("the source has the section") + + 1; + let to = from + + source[from..] + .find(&format!("\n{end}")) + .expect("the source ends the section") + + 1; + &source[from..to] +} + +/// The names `text` declares at its top level: functions, structs, constants, overrides and +/// module variables (bindings). +fn declared(text: &str) -> Vec<&str> { + let mut names = Vec::new(); + for line in text.lines() { + // Top level only: a function's own `var` and `let` stay as they are. + if line.starts_with(char::is_whitespace) { + continue; + } + let mut line = line; + while let Some(rest) = line.strip_prefix('@') { + // An attribute: `@vertex`, `@group(0)`, `@binding(1)`. + let end = rest.find(' ').unwrap_or(rest.len()); + line = rest[end..].trim_start(); + } + let rest = ["fn ", "struct ", "const ", "override ", "var "] + .iter() + .find_map(|k| line.strip_prefix(k)) + .or_else(|| { + // `var name`, `var name`. + let rest = line.strip_prefix("var<")?; + Some(rest[rest.find('>')? + 1..].trim_start()) + }); + if let Some(rest) = rest { + let end = rest + .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) + .unwrap_or(rest.len()); + names.push(&rest[..end]); + } + } + names +} + +/// `text` with every name it declares at its top level, and every use of one, prefixed by +/// `prefix`. Comments are rewritten too, which is harmless. +pub fn prefixed(text: &str, prefix: &str) -> String { + let names = declared(text); + let mut out = String::with_capacity(text.len() * 2); + let mut word = String::new(); + let flush = |word: &mut String, out: &mut String| { + if names.contains(&word.as_str()) { + out.push_str(prefix); + } + out.push_str(word); + word.clear(); + }; + for c in text.chars() { + if c.is_ascii_alphanumeric() || c == '_' { + word.push(c); + } else { + flush(&mut word, &mut out); + out.push(c); + } + } + flush(&mut word, &mut out); + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn prefixes_top_level_names_and_their_uses_only() { + let text = "struct S { a: f32, }\n\ + @group(0) @binding(0) var g: S;\n\ + @group(1) @binding(2) var list: array;\n\ + override N: u32 = 1u;\n\ + const K: f32 = 2.0;\n\ + @fragment fn f(x: f32) -> @location(0) vec4 {\n \ + var a = g.a * K;\n \ + return vec4(a + f32(list[N]) + x);\n\ + }\n"; + let out = prefixed(text, "p_"); + assert_eq!( + out, + "struct p_S { a: f32, }\n\ + @group(0) @binding(0) var p_g: p_S;\n\ + @group(1) @binding(2) var p_list: array;\n\ + override p_N: u32 = 1u;\n\ + const p_K: f32 = 2.0;\n\ + @fragment fn p_f(x: f32) -> @location(0) vec4 {\n \ + var a = p_g.a * p_K;\n \ + return vec4(a + f32(p_list[p_N]) + x);\n\ + }\n" + ); + // Every top-level declaration of terrain.wgsl is found. + let names = declared(TERRAIN); + for name in [ + "Globals", + "globals", + "sprites_7", + "SPRITE_SPLIT", + "block_slots", + "fs_sky", + ] { + assert!(names.contains(&name), "{name}"); + } + assert!(!names.contains(&"out")); + } +} diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs index a33d92a26..ecaca51d8 100644 --- a/crates/horizon-client/src/lan/hub.rs +++ b/crates/horizon-client/src/lan/hub.rs @@ -2180,17 +2180,24 @@ impl Hub { if g.spectator() || g.sleeping { return (false, false); } - let height = if g.fall_flying { - 0.6 + // getBoundingBox: the box of the body's pose (swimming and crawling + // are 0.6 tall), so a swimmer under a ceiling isn't sent back. + let (half, height) = if g.fall_flying { + (0.3, 0.6) + } else if let Some(m) = &g.motion { + ( + f64::from(m.dimensions.width) / 2.0, + f64::from(m.dimensions.height), + ) } else if g.sneaking { - 1.5 + (0.3, 1.5) } else { - 1.8 + (0.3, 1.8) }; let at = |p: [f64; 3]| { Aabb::new( - Vec3::new(p[0] - 0.3, p[1], p[2] - 0.3), - Vec3::new(p[0] + 0.3, p[1] + height, p[2] + 0.3), + Vec3::new(p[0] - half, p[1], p[2] - half), + Vec3::new(p[0] + half, p[1] + height, p[2] + half), ) }; let (old, new) = (at(g.position), at(to)); diff --git a/crates/horizon-client/src/lod.rs b/crates/horizon-client/src/lod.rs index a429863a7..1ee61cdf4 100644 --- a/crates/horizon-client/src/lod.rs +++ b/crates/horizon-client/src/lod.rs @@ -752,6 +752,25 @@ impl Lod { saved_order: VecDeque::new(), } } + /// The solid ground at block column (x, z): its top face's height and + /// its block, from the finest tile sampled there. For aiming past the + /// resident chunks (`game.raycast`); water is passed, as the view's ray + /// passes it. + pub fn ground(&self, x: i32, z: i32) -> Option<(i32, BlockStateId)> { + (0..=MAX_LEVEL).find_map(|level| { + let size = 16 << level; + let key = TileKey { + x: x.div_euclid(size), + z: z.div_euclid(size), + level, + }; + let columns = self.ready.get(&key).filter(|c| c.len() == CELLS * CELLS)?; + let cell = size / CELLS as i32; + let (cx, cz) = ((x - key.x * size) / cell, (z - key.z * size) / cell); + let surface = columns[cz as usize * CELLS + cx as usize].surface?; + Some((surface.height, surface.state)) + }) + } pub fn stats(&self) -> (usize, usize) { (self.active.len(), self.ready.len()) } diff --git a/crates/horizon-client/src/main.rs b/crates/horizon-client/src/main.rs index 8004b2fa7..7144a1670 100644 --- a/crates/horizon-client/src/main.rs +++ b/crates/horizon-client/src/main.rs @@ -4,7 +4,13 @@ mod game; use horizon_client::{crash, logging}; +/// The mod API level this game serves, kept in the program for the launcher +/// to read without running it (`horizon_mods::api_level::MARK`). `main` +/// reads it, so the linker keeps it. +static MOD_API_LEVEL: [u8; 27] = horizon_mods::api_level::MARK; + fn main() { + std::hint::black_box(&MOD_API_LEVEL); horizon_client::telemetry::mark_start(); let args: Vec = std::env::args().skip(1).collect(); let game_args = args.iter().take_while(|a| *a != "--dedicated"); diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs index a6f97981e..0bce8927c 100644 --- a/crates/horizon-client/src/motion.rs +++ b/crates/horizon-client/src/motion.rs @@ -44,7 +44,7 @@ use std::{ pub(crate) mod environment; mod fluids; -pub use fluids::{FluidResources, LAVA, PlayerFluids, WATER}; +pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER}; pub struct MotionResources { pub attributes: Arc, diff --git a/crates/horizon-client/src/motion/fluids.rs b/crates/horizon-client/src/motion/fluids.rs index 89affeb64..894e6d907 100644 --- a/crates/horizon-client/src/motion/fluids.rs +++ b/crates/horizon-client/src/motion/fluids.rs @@ -103,10 +103,10 @@ fn is_tagged(kind: FluidKind, tag: FluidTagId) -> bool { } impl PlayerMotion { pub fn fluid_height(&self, tag: FluidTagId) -> f64 { - self.fluids.interaction.fluid_height(&Membership, tag) + self.fluids.interaction.fluid_height(&FluidTags, tag) } pub fn is_eye_in_fluid(&self, tag: FluidTagId) -> bool { - self.fluids.interaction.is_eye_in_fluid(&Membership, tag) + self.fluids.interaction.is_eye_in_fluid(&FluidTags, tag) } /// `LocalPlayer.isUnderWater`: `wasUnderwater`, the eye sample `Player.tick` /// takes before the base tick (`Entity.isUnderWater` also needs the body @@ -116,11 +116,12 @@ impl PlayerMotion { } /// `Entity.isInLava`. pub fn is_in_lava(&self) -> bool { - !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&Membership, LAVA) + !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&FluidTags, LAVA) } } -struct Membership; -impl FluidMembership for Membership { +/// Which fluids `FluidTags.WATER` and `FluidTags.LAVA` hold. +pub struct FluidTags; +impl FluidMembership for FluidTags { fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool { is_tagged(kind, tag) } diff --git a/crates/horizon-client/src/moved_extras.rs b/crates/horizon-client/src/moved_extras.rs index 3b5db6fbc..4c99a49bf 100644 --- a/crates/horizon-client/src/moved_extras.rs +++ b/crates/horizon-client/src/moved_extras.rs @@ -25,7 +25,7 @@ pub struct Moved { pub name: &'static str, } -pub const MOVED: [Moved; 3] = [ +pub const MOVED: [Moved; 4] = [ Moved { id: "fps_overlay", name: "FPS counter", @@ -38,6 +38,10 @@ pub const MOVED: [Moved; 3] = [ id: "zoom", name: "Zoom", }, + Moved { + id: "minimap", + name: "Minimap", + }, ]; impl Moved { @@ -45,7 +49,8 @@ impl Moved { match self.id { "fps_overlay" => e.fps, "keystrokes" => e.keystrokes, - _ => e.zoom, + "zoom" => e.zoom, + _ => e.minimap, } } /// The extra's settings as the mod keeps them (its storage keys). @@ -60,11 +65,21 @@ impl Moved { ("corner", e.keystrokes_corner.name().into()), ("cps", flag(e.keystrokes_cps)), ], - _ => vec![ + "zoom" => vec![ ("level", e.zoom_level.to_string()), ("smooth", flag(e.zoom_smooth)), ("sensitivity", flag(e.zoom_sensitivity)), ], + _ => vec![ + ("corner", e.minimap_corner.name().into()), + ("size", e.minimap_size.to_string()), + ( + "shape", + if e.minimap_round { "round" } else { "square" }.into(), + ), + ("zoom", e.minimap_zoom.to_string()), + ("rotate", flag(e.minimap_rotate)), + ], } } /// The extra's key as the mod's key (`horizon-mods.txt`), when the @@ -149,21 +164,21 @@ pub fn fetch_index() -> Result { /// Installs `m` into the game folder `dir` (where `options.txt` is), for a /// player whose extras were `e`: its newest version for this game that -/// wasn't taken down, checked against the index (size, SHA-256, signature, -/// manifest), as `horizon-mods/.hmod`, turned on, with the extra's -/// settings in its storage unless the mod has its own already. +/// wasn't taken down and that this Horizon's mod API level runs, checked +/// against the index (size, SHA-256, signature, manifest), as +/// `horizon-mods/.hmod`, turned on, with the extra's settings in its +/// storage unless the mod has its own already. pub fn install(index: &Index, m: &Moved, e: &Extras, dir: &Path) -> Result<(), String> { let project = index .project(m.id) .ok_or_else(|| format!("{} isn't in Horizon's registry yet", m.id))?; - let version = project - .versions - .iter() - .find(|v| { - v.game == horizon_core::version::VERSION_ID - && index.revoked(&project.id, &v.file.sha256).is_none() - }) - .ok_or_else(|| format!("{} has no version for this game", m.id))?; + let version = index + .installable( + project, + horizon_core::version::VERSION_ID, + horizon_mods::api_level::LEVEL, + ) + .ok_or_else(|| format!("{} has no version this Horizon can run", m.id))?; let mods = dir.join(crate::mod_list::DIR); fs::create_dir_all(&mods).map_err(|e| format!("{}: {e}", mods.display()))?; let target = mods.join(format!("{}.hmod", m.id)); @@ -208,7 +223,7 @@ mod tests { fn only_extras_that_were_on_are_installed_and_each_once() { let mut e = Extras::default(); assert!(pending(&e).is_empty()); - assert_eq!(nothing_to_do(&e).len(), 3); + assert_eq!(nothing_to_do(&e).len(), 4); e.fps = true; e.fps_corner = Corner::BottomRight; e.fps_lows = true; @@ -223,7 +238,7 @@ mod tests { ); e.moved.push("fps_overlay".into()); assert!(pending(&e).is_empty()); - assert_eq!(nothing_to_do(&e), [&MOVED[1], &MOVED[2]]); + assert_eq!(nothing_to_do(&e), [&MOVED[1], &MOVED[2], &MOVED[3]]); // Zoom: its settings, and its key only when the player changed it. e.zoom = true; e.zoom_level = 8; @@ -240,6 +255,23 @@ mod tests { assert!(MOVED[2].keys(&e).is_empty()); e.zoom_key = "key.mouse.4".into(); assert_eq!(MOVED[2].keys(&e), [("zoom", "key.mouse.4".into())]); + // The minimap: its five settings, in the extra's values. + e.minimap = true; + e.minimap_corner = Corner::BottomLeft; + e.minimap_size = 128; + e.minimap_round = true; + e.minimap_zoom = 0.5; + assert_eq!(pending(&e), [&MOVED[2], &MOVED[3]]); + assert_eq!( + MOVED[3].settings(&e), + [ + ("corner", "bottom_left".into()), + ("size", "128".into()), + ("shape", "round".into()), + ("zoom", "0.5".into()), + ("rotate", "false".into()) + ] + ); assert_eq!( MOVED[0].notice(), "FPS counter moved to the mod browser: installed for you" diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index b0df37367..61fda9878 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -3377,7 +3377,7 @@ mod tests { s.extras ); // In a window too short for the page, the wheel scrolls to its end. - let short = (480.0, 300.0); + let short = (480.0, 180.0); ui.scroll(&s, short, -1000.0); let (_, top, bottom, content) = ui.layout(&s, short.0, short.1); assert!(content > bottom - top); diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 103f7402b..643a604bc 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -639,8 +639,12 @@ impl Streaming { self.lit.remove(&(x, z)); self.meshed.remove(&(x, z)); self.lighting.remove(&(x, z)); - self.meshing.retain(|k, _| (k.0, k.2) != (x, z)); - self.waiting.retain(|k| (k.0, k.2) != (x, z)); + // By key, not by a pass over every pending section: a moved or + // shrunk storage forgets thousands of columns in one frame. + for sy in 0..SECTIONS as i32 { + self.meshing.remove(&(x, sy, z)); + self.waiting.remove(&(x, sy, z)); + } world.dirty_sections.take_column(x, z); world.chunks.remove(&(x, z)) } diff --git a/crates/horizon-client/src/terrain.wgsl b/crates/horizon-client/src/terrain.wgsl index c0a2fc6fd..711a2fce7 100644 --- a/crates/horizon-client/src/terrain.wgsl +++ b/crates/horizon-client/src/terrain.wgsl @@ -227,8 +227,9 @@ fn sunrise_weight(d: vec3) -> f32 { } return best; } -@fragment fn fs_sky(in: SkyOut) -> @location(0) vec4 { - let d = view_ray(in.ndc); +// The sky's colour along the view ray `d` (a shader pack's sky stage gets it as its input: +// gfx/native_sky.rs builds that stage from this section). +fn sky_along_ray(d: vec3) -> vec3 { var color = globals.fog_color.rgb; let dist = disc_distance(d, 16.0); if dist.x >= 0.0 { @@ -238,7 +239,10 @@ fn sunrise_weight(d: vec3) -> f32 { if w > 0.0 { color = mix(color, globals.sunrise.rgb, w * globals.sunrise.a); } - return vec4(color, 1.0); + return color; +} +@fragment fn fs_sky(in: SkyOut) -> @location(0) vec4 { + return vec4(sky_along_ray(view_ray(in.ndc)), 1.0); } @fragment fn fs_dark_disc(in: SkyOut) -> @location(0) vec4 { let d = view_ray(in.ndc); diff --git a/crates/horizon-mod-registry/Cargo.lock b/crates/horizon-mod-registry/Cargo.lock index 44ef1e078..f80068fcc 100644 --- a/crates/horizon-mod-registry/Cargo.lock +++ b/crates/horizon-mod-registry/Cargo.lock @@ -17,12 +17,24 @@ dependencies = [ "derive_arbitrary", ] +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + [[package]] name = "atomic-waker" version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + [[package]] name = "axum" version = "0.8.9" @@ -80,6 +92,27 @@ version = "0.22.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" +[[package]] +name = "bit-set" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + [[package]] name = "block-buffer" version = "0.10.4" @@ -95,6 +128,26 @@ version = "3.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + [[package]] name = "bytes" version = "1.12.1" @@ -117,6 +170,21 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "unicode-width", +] + [[package]] name = "core_detect" version = "1.0.0" @@ -147,6 +215,12 @@ version = "0.8.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6" +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + [[package]] name = "crypto-common" version = "0.1.7" @@ -165,7 +239,7 @@ checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -187,7 +261,7 @@ checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -236,6 +310,12 @@ dependencies = [ "miniz_oxide", ] +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + [[package]] name = "form_urlencoded" version = "1.2.2" @@ -302,11 +382,28 @@ dependencies = [ "wasip2", ] +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + [[package]] name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash", + "serde", + "serde_core", +] [[package]] name = "hmac" @@ -340,12 +437,27 @@ dependencies = [ name = "horizon-mods" version = "0.1.0" dependencies = [ + "horizon-shader-api", "log", "minisign-verify", "serde", "serde_json", "sha2", "toml", + "wasmparser", + "zip", +] + +[[package]] +name = "horizon-shader-api" +version = "0.1.0" +dependencies = [ + "bytemuck", + "naga", + "serde", + "serde_json", + "sha2", + "toml", "zip", ] @@ -540,6 +652,8 @@ checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" dependencies = [ "equivalent", "hashbrown", + "serde", + "serde_core", ] [[package]] @@ -554,6 +668,12 @@ version = "0.2.191" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + [[package]] name = "litemap" version = "0.8.3" @@ -634,6 +754,54 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d" +[[package]] +name = "naga" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130" +dependencies = [ + "arrayvec", + "bit-set", + "bitflags", + "cfg-if", + "cfg_aliases", + "codespan-reporting", + "half", + "hashbrown", + "indexmap", + "libm", + "log", + "naga-types", + "num-traits", + "once_cell", + "rustc-hash", + "spirv", + "thiserror", + "unicode-ident", +] + +[[package]] +name = "naga-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" +dependencies = [ + "hashbrown", + "indexmap", + "rustc-hash", + "thiserror", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -699,6 +867,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + [[package]] name = "rustls" version = "0.23.46" @@ -752,6 +926,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + [[package]] name = "serde" version = "1.0.229" @@ -779,7 +959,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -894,6 +1074,15 @@ version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e" +[[package]] +name = "spirv" +version = "0.4.0+sdk-1.4.341.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" +dependencies = [ + "bitflags", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -906,6 +1095,17 @@ version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "syn" version = "3.0.9" @@ -931,7 +1131,27 @@ checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", ] [[package]] @@ -968,7 +1188,7 @@ checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] @@ -1049,6 +1269,12 @@ version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + [[package]] name = "untrusted" version = "0.9.0" @@ -1111,6 +1337,19 @@ dependencies = [ "wit-bindgen", ] +[[package]] +name = "wasmparser" +version = "0.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" +dependencies = [ + "bitflags", + "hashbrown", + "indexmap", + "semver", + "serde", +] + [[package]] name = "webpki-roots" version = "0.26.11" @@ -1254,10 +1493,30 @@ checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", "synstructure", ] +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "zerofrom" version = "0.1.8" @@ -1275,7 +1534,7 @@ checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", "synstructure", ] @@ -1315,7 +1574,7 @@ checksum = "c3743ddbf47738d929cd1ae2e199d40d0162979dfe31aef8ae646d2bf00bf97a" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.9", ] [[package]] diff --git a/crates/horizon-mod-registry/tests/submit.rs b/crates/horizon-mod-registry/tests/submit.rs index f586effac..f27f18697 100644 --- a/crates/horizon-mod-registry/tests/submit.rs +++ b/crates/horizon-mod-registry/tests/submit.rs @@ -342,11 +342,12 @@ async fn what_the_form_refuses() { ); let (status, json) = client.submit(&csrf, &f, &file).await; assert_eq!(status, StatusCode::BAD_REQUEST, "{json}"); - // Shader packs aren't open. + // A shader pack runs the game's own check: a mod's file isn't one. let mut f = form(); f["kind"] = json!("shader"); let (status, json) = client.submit(&csrf, &f, &file).await; - refused(status, &json, "shader packs open"); + assert_eq!(status, StatusCode::BAD_REQUEST, "{json}"); + refused(status, &json, "horizon-shaders.toml: missing"); // An update by someone who isn't an owner. let owned = "id = \"coords_hud\"\nkind = \"mod\"\nname = \"C\"\nsummary = \"s\"\nowners = [\"bob\"]\nlicense = \"MIT\"\nsource = \"https://x.test\"\n\n[[versions]]\nversion = \"0.0.1\"\npublished = \"2026-01-01\"\ngame = \"26.3\"\nfile = \"coords_hud-0.0.1.hmod\"\nsha256 = \"0000000000000000000000000000000000000000000000000000000000000000\"\n"; mock.lock() diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit index 84be4d4f0..7f8245c48 100644 --- a/crates/horizon-mod-sdk/wit/horizon.wit +++ b/crates/horizon-mod-sdk/wit/horizon.wit @@ -18,7 +18,8 @@ interface log { write: func(level: level, message: string); } -/// Capability `game-read`: the local player and the world clock. +/// Capability `game-read`: the local player, the world clock and the block +/// the player looks at. interface game { record player { /// Feet position, in blocks. @@ -46,6 +47,24 @@ interface game { get-player: func() -> option; /// None on the title screen. get-clock: func() -> option; + /// A block along the player's view. + record hit { + /// The block hit. + block-x: s32, + block-y: s32, + block-z: s32, + /// The point on its face where the view meets it. + x: f64, + y: f64, + z: f64, + /// `minecraft:stone`, ... + block: string, + } + /// The first block along the player's view (fluids pass), up to + /// `distance` blocks (at most 1024; past the loaded chunks, across the + /// distant terrain when LOD Distance is on), as of this tick. None when + /// nothing is hit, and on the title screen. + raycast: func(distance: f32) -> option; } /// Capability `chat`: messages only the local player sees. diff --git a/crates/horizon-mods/Cargo.toml b/crates/horizon-mods/Cargo.toml index a398e4d8b..8bfa58bcd 100644 --- a/crates/horizon-mods/Cargo.toml +++ b/crates/horizon-mods/Cargo.toml @@ -17,18 +17,27 @@ wasmtime = { version = "48.0.7", default-features = false, features = ["runtime" # Turns a mod's core module into a component (cargo horizon-mod build, the tests). wit-component = { version = "0.254", optional = true } wit-parser = { version = "0.254", optional = true } +# The functions a mod imports, for its API level (src/api_level.rs): the game and the registry index. +wasmparser = { version = "0.254", optional = true } # The registry index's checks (feature `index`): SHA-256, and minisign signatures (no dependencies of its own). sha2 = { version = "0.10", optional = true } minisign-verify = { version = "0.3", optional = true } +# A shader pack's check (kind `shader`): the one the game runs before it loads a pack. +horizon-shader-api = { path = "../horizon-shader-api", optional = true } + +[dev-dependencies] +# A component made for a newer Horizon, from the WIT alone (tests/sandbox.rs). +wit-component = { version = "0.254", features = ["dummy-module"] } +wit-parser = "0.254" [features] # Loads and runs mods (the game's `mods` feature); without it only manifests, # content and packaging. Off by default so builds that don't run mods (the # game's tests and probes) skip wasmtime and cranelift. -runtime = ["dep:wasmtime"] +runtime = ["dep:wasmtime", "dep:wasmparser"] pack = ["dep:wit-component", "dep:wit-parser"] # The mod registry's index (docs/api/mod-index.md): the launcher, the registry server and its CI. -index = ["dep:sha2", "dep:minisign-verify"] +index = ["dep:sha2", "dep:minisign-verify", "dep:horizon-shader-api", "dep:wasmparser"] # Runs real mods: `cargo test -p horizon-mods --features runtime,pack`. [[test]] diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs new file mode 100644 index 000000000..785f0e573 --- /dev/null +++ b/crates/horizon-mods/src/api_level.rs @@ -0,0 +1,190 @@ +//! Mod API levels: which of the WIT contract's functions a Horizon has +//! (`docs/api/stability.md`). Every function the game offers mods has the +//! level it arrived at; a Horizon serves every level up to its [`LEVEL`]. +//! A mod needs the level of the newest function it imports, so a mod that +//! calls a function this Horizon doesn't have is refused with "update +//! Horizon" instead of a linking error, and the registry lists each +//! version's level so the launcher can tell before it installs. + +/// The newest level this Horizon serves. +pub const LEVEL: u32 = 2; + +/// Every function the game offers mods, as `interface.function`, with its +/// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new +/// function takes the next level and raises [`LEVEL`] (the `api_reference` +/// test fails until it is listed here). +pub const FUNCTIONS: [(&str, u32); 33] = [ + ("log.write", 0), + ("game.get-player", 0), + ("game.get-clock", 0), + ("chat.show", 0), + ("hud.set-panel", 0), + ("hud.clear", 0), + ("storage.get", 0), + ("storage.set", 0), + ("storage.delete", 0), + ("command.run", 0), + ("ui.open-screen", 0), + ("ui.close-screen", 0), + ("ui.set-settings", 0), + ("input.claim-items", 0), + ("input.register-key", 0), + ("input.held", 0), + ("input.poll", 0), + ("input.claim-wheel", 0), + ("input.mapping", 0), + ("input.clicks-per-second", 0), + ("render.set-hud", 0), + ("render.gui-size", 0), + ("render.shake", 0), + ("render.set-corner", 0), + ("render.clear-corner", 0), + ("render.text-width", 0), + ("render.frame-stats", 0), + ("render.set-zoom", 0), + ("render.set-minimap", 1), + ("players.online", 1), + ("players.tell", 1), + ("players.broadcast", 1), + ("game.raycast", 2), +]; + +/// What the game's program carries so the launcher can read its level +/// without running it: `horizon-mod-api-level:0001;` (four digits). A +/// program from before the mark serves level 0. +pub const MARK: [u8; 27] = { + let mut mark = *b"horizon-mod-api-level:0000;"; + let mut level = LEVEL; + let mut i = 25; + while level > 0 { + mark[i] = b'0' + (level % 10) as u8; + level /= 10; + i -= 1; + } + mark +}; + +/// The level a program's bytes carry in their [`MARK`], if any. +pub fn read_mark(program: &[u8]) -> Option { + let prefix = &MARK[..22]; + program + .windows(MARK.len()) + .filter(|w| w.starts_with(prefix) && w[26] == b';') + .find_map(|w| std::str::from_utf8(&w[22..26]).ok()?.parse().ok()) +} + +/// A function's level; None for one this Horizon doesn't have. +pub fn level_of(function: &str) -> Option { + FUNCTIONS + .iter() + .find(|(name, _)| *name == function) + .map(|&(_, level)| level) +} + +/// The level a mod needs, from the functions it imports (as [`imports`] +/// names them): its newest function's. A function this Horizon doesn't +/// know comes from a newer one, so it needs more than [`LEVEL`]; that +/// function is returned with it, for the message. +pub fn needed<'a>(imports: impl IntoIterator) -> (u32, Option<&'a str>) { + let mut needed = (0, None); + for name in imports { + match level_of(name) { + Some(level) if level > needed.0 => needed = (level, Some(name)), + Some(_) => {} + None => return (LEVEL + 1, Some(name)), + } + } + needed +} + +/// Why this Horizon can't run a mod that needs `level`, or None when it can. +pub fn too_new(level: u32, function: Option<&str>) -> Option { + (level > LEVEL).then(|| { + let uses = function.map_or(String::new(), |f| format!(" (it uses {f})")); + format!("made for a newer Horizon{uses}: update Horizon to run it") + }) +} + +/// The functions a mod's component imports from Horizon (`horizon:mods/*`), +/// as `interface.function`, in the component's order. +#[cfg(any(feature = "runtime", feature = "index"))] +pub fn imports(wasm: &[u8]) -> Result, String> { + use wasmparser::{ + Parser, Payload, Validator, WasmFeatures, component_types::ComponentEntityType, + }; + let types = Validator::new_with_features(WasmFeatures::all()) + .validate_all(wasm) + .map_err(|e| format!("not a component: {e}"))?; + let types = types.as_ref(); + let mut out = Vec::new(); + for payload in Parser::new(0).parse_all(wasm) { + let Payload::ComponentImportSection(section) = payload.map_err(|e| e.to_string())? else { + continue; + }; + for import in section { + let name = import.map_err(|e| e.to_string())?.name.name; + // `horizon:mods/render@0.1.0` → `render`. + let Some(interface) = name.strip_prefix("horizon:mods/") else { + continue; + }; + let interface = interface.split('@').next().unwrap_or(interface); + let Some(item) = types.component_item_for_import(name) else { + continue; + }; + if let ComponentEntityType::Instance(id) = item.ty { + for (function, export) in &types[id].exports { + if matches!(export.ty, ComponentEntityType::Func(_)) { + out.push(format!("{interface}.{function}")); + } + } + } + } + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn levels_are_listed_once_and_up_to_this_horizons() { + for (i, (name, level)) in FUNCTIONS.iter().enumerate() { + assert!(*level <= LEVEL, "{name}"); + assert!( + FUNCTIONS[..i].iter().all(|(other, _)| other != name), + "{name} twice" + ); + } + assert!(FUNCTIONS.iter().any(|&(_, level)| level == LEVEL)); + } + + #[test] + fn the_mark_carries_the_level() { + assert_eq!(read_mark(&MARK), Some(LEVEL)); + let mut program = b"\0\x7fELF horizon-mod-api-level: horizon-mod-api-level:".to_vec(); + program.extend_from_slice(&MARK); + program.extend_from_slice(b"\0rest"); + assert_eq!(read_mark(&program), Some(LEVEL)); + assert_eq!(read_mark(b"horizon-mod-api-level:12;"), None); + assert_eq!(read_mark(b"no mark"), None); + } + + #[test] + fn a_mod_needs_its_newest_function() { + assert_eq!(needed(["log.write", "hud.set-panel"]), (0, None)); + assert_eq!( + needed(["log.write", "render.set-minimap", "hud.clear"]), + (1, Some("render.set-minimap")) + ); + assert_eq!( + needed(["render.set-minimap", "render.set-sky"]), + (LEVEL + 1, Some("render.set-sky")) + ); + assert_eq!(too_new(LEVEL, None), None); + assert_eq!( + too_new(LEVEL + 1, Some("render.set-sky")).as_deref(), + Some("made for a newer Horizon (it uses render.set-sky): update Horizon to run it") + ); + } +} diff --git a/crates/horizon-mods/src/index.rs b/crates/horizon-mods/src/index.rs index db860fd9f..544c52980 100644 --- a/crates/horizon-mods/src/index.rs +++ b/crates/horizon-mods/src/index.rs @@ -47,8 +47,8 @@ pub enum Kind { Modpack, /// A resource pack (`.zip` with `pack.mcmeta`) made or tested for Horizon. ResourcePack, - /// A Horizon shader pack (the native WGSL format, not Iris or OptiFine - /// packs). Listed by the schema; submissions open with its API. + /// A Horizon shader pack (`.hshader`, the native WGSL format of + /// docs/shaders.md; not the shaders/-folder packs, which stay on Modrinth). Shader, Other(String), } @@ -69,7 +69,8 @@ impl Kind { match self { Kind::Mod => Some("hmod"), Kind::Modpack => Some("hpack"), - Kind::ResourcePack | Kind::Shader => Some("zip"), + Kind::ResourcePack => Some("zip"), + Kind::Shader => Some(horizon_shader_api::EXTENSION), Kind::Other(_) => None, } } @@ -137,6 +138,11 @@ pub struct Version { pub side: Option, #[serde(default, skip_serializing_if = "Vec::is_empty")] pub capabilities: Vec, + /// The mod API level a mod's code needs ([`crate::api_level`]), read + /// from its file; none for content and other kinds, and in indexes + /// built before levels. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub api_level: Option, /// The Minecraft version it is for. pub game: String, /// A modpack's mods, as its manifest lists them. @@ -316,6 +322,21 @@ impl Index { Ok(()) } + /// A project's newest version for Minecraft `game` that wasn't taken + /// down and that a Horizon serving mod API `level` can run (an unknown + /// level counts as runnable: the game still checks when it starts it). + pub fn installable<'a>( + &self, + project: &'a Project, + game: &str, + level: u32, + ) -> Option<&'a Version> { + project.versions.iter().find(|v| { + v.game == game + && v.api_level.is_none_or(|l| l <= level) + && self.revoked(&project.id, &v.file.sha256).is_none() + }) + } pub fn project(&self, id: &str) -> Option<&Project> { self.projects.iter().find(|p| p.id == id) } @@ -448,7 +469,7 @@ pub fn check_file( (None, None) => Trust::Unsigned, _ => return Err("its signature and the project's key don't go together".into()), }; - if matches!(project.kind, Kind::Shader | Kind::Other(_)) { + if matches!(project.kind, Kind::Other(_)) { return Err(format!( "this Horizon can't install a {} yet", project.kind.name() @@ -471,6 +492,8 @@ pub struct Facts { pub side: Option, /// In the manifest's order. pub capabilities: Vec, + /// The mod API level a mod's code needs, from the functions it imports. + pub api_level: Option, /// The Minecraft version, when the file names one (a modpack does). pub game: Option, pub requires: Vec, @@ -487,6 +510,7 @@ impl Facts { || self.api != version.api || self.side != version.side || caps != listed + || version.api_level.is_some() && self.api_level != version.api_level || self.game.as_ref().is_some_and(|g| *g != version.game) || self.requires != version.requires; if !differs { @@ -502,6 +526,13 @@ impl Facts { names(&self.capabilities) ), Kind::Modpack => format!("its {} isn't what the index lists", modpack::MANIFEST), + Kind::Shader => format!( + "its {} ({} {}, shader API {}) isn't what the index lists", + horizon_shader_api::MANIFEST, + self.id.as_deref().unwrap_or("?"), + self.version.as_deref().unwrap_or("?"), + self.api + ), _ => format!("its pack format {} isn't what the index lists", self.api), }) } @@ -509,14 +540,22 @@ impl Facts { /// Reads and checks a file as its kind: a mod's manifest and content, a /// modpack's manifest and overrides, a resource pack's `pack.mcmeta` and -/// paths. Shader packs and kinds this build doesn't know are refused: their -/// checks come with their formats. +/// paths, a shader pack's `horizon_shader_api::check` (the game's own). Kinds +/// this build doesn't know are refused: their checks come with their formats. pub fn inspect(kind: &Kind, path: &Path) -> Result { match kind { Kind::Mod => { - let m = Package::read(path)?.manifest; + let Package { manifest: m, wasm } = Package::read(path)?; crate::Content::read(path, &m)?; + let api_level = match wasm { + Some(wasm) => { + let functions = crate::api_level::imports(&wasm)?; + Some(crate::api_level::needed(functions.iter().map(String::as_str)).0) + } + None => None, + }; Ok(Facts { + api_level, capabilities: m.capabilities, id: Some(m.id), version: Some(m.version), @@ -540,9 +579,23 @@ pub fn inspect(kind: &Kind, path: &Path) -> Result { api: check_resource_pack(path)?, ..Facts::default() }), - Kind::Shader => Err( - "Horizon's own shader pack format isn't out yet: shader packs open when it is".into(), - ), + Kind::Shader => { + let pack = horizon_shader_api::Pack::read(path)?; + if let Err(problems) = horizon_shader_api::check(&pack) { + let lines: Vec = problems.iter().map(ToString::to_string).collect(); + return Err(format!( + "the shader pack fails its check:\n{}", + lines.join("\n") + )); + } + let m = pack.manifest; + Ok(Facts { + id: Some(m.id), + version: Some(m.version), + api: m.api, + ..Facts::default() + }) + } Kind::Other(name) => Err(format!("this Horizon can't read a {name} yet")), } } @@ -591,14 +644,11 @@ fn check_resource_pack(path: &Path) -> Result { Ok(format) } -/// The kinds the registry takes submissions for. Shader packs wait for -/// Horizon's own format; other kinds for theirs. +/// The kinds the registry takes submissions for; other kinds wait for their +/// formats. pub fn open(kind: &Kind) -> Result<(), String> { match kind { - Kind::Mod | Kind::Modpack | Kind::ResourcePack => Ok(()), - Kind::Shader => Err( - "shader packs open when Horizon's own shader pack format is out (Iris and OptiFine packs stay on Modrinth)".into(), - ), + Kind::Mod | Kind::Modpack | Kind::ResourcePack | Kind::Shader => Ok(()), Kind::Other(name) => Err(format!("the registry doesn't take {name} yet")), } } diff --git a/crates/horizon-mods/src/index/registry.rs b/crates/horizon-mods/src/index/registry.rs index 21b5de9fb..90453c621 100644 --- a/crates/horizon-mods/src/index/registry.rs +++ b/crates/horizon-mods/src/index/registry.rs @@ -283,6 +283,7 @@ fn version(entry: &Entry, v: &EntryVersion, src: &Sources) -> Result PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/index") @@ -61,6 +62,23 @@ file = "cozy-1.0.0.hpack" sha256 = "241ac840f9c5ea3f6252d849da10c90d36cb1da4d6cd8d1d268c2760a353cd65" "#; +const GLOW: &str = r#"id = "glow" +kind = "shader" +name = "Soft Glow" +summary = "A post-processing pass over the world." +authors = ["Horizon"] +owners = ["ludovic111"] +license = "MIT" +source = "https://github.com/ludovic111/horizon-mods" + +[[versions]] +version = "1.0.0" +published = "2026-10-26" +game = "26.3" +file = "glow-1.0.0.hshader" +sha256 = "331cfe29a666a0de804e9a9ff3d19d246eebcfbfa70b4f49bba8482d30ad9f02" +"#; + const REVOKED_TOML: &str = r#"[[revoked]] id = "bad_mod" sha256 = "1111111111111111111111111111111111111111111111111111111111111111" @@ -82,9 +100,14 @@ impl Scratch { let s = Scratch(dir); s.write("mods/coords_hud.toml", &hud_entry()); s.write("mods/cozy.toml", COZY); + s.write("mods/glow.toml", GLOW); s.write("revoked.toml", REVOKED_TOML); s.write("icons/coords_hud.png", "png"); - for (name, hash) in [("coords_hud-0.1.0.hmod", HMOD), ("cozy-1.0.0.hpack", HPACK)] { + for (name, hash) in [ + ("coords_hud-0.1.0.hmod", HMOD), + ("cozy-1.0.0.hpack", HPACK), + ("glow-1.0.0.hshader", HSHADER), + ] { std::fs::copy(fixtures().join(name), s.0.join("files").join(hash)).unwrap(); } s @@ -117,7 +140,7 @@ fn builds_the_sample_index() { let s = Scratch::new("sample"); let built = s.build().unwrap(); let sample = sample(); - assert_eq!(built.projects, sample.projects[..2]); + assert_eq!(built.projects, sample.projects[..3]); assert_eq!(built.revoked, sample.revoked); assert_eq!(built.generated, sample.generated); // What it writes reads back. @@ -154,7 +177,11 @@ fn lists_every_problem_of_a_registry() { "{errors:?}" ); assert!(has("coords_hud 0.1.0: the project has a key"), "{errors:?}"); - assert!(has("glow: shader packs open when"), "{errors:?}"); + // A shader entry is taken now, and checked like the others. + assert!( + has("glow 1.0.0: the file isn't the one its sha256 names"), + "{errors:?}" + ); assert!( has("other 0.1.0: the file's id is \"coords_hud\""), "{errors:?}" @@ -219,7 +246,7 @@ fn a_review_protects_published_files() { #[test] fn only_open_kinds_are_taken() { assert!(open(&Kind::Mod).is_ok() && open(&Kind::ResourcePack).is_ok()); - assert!(open(&Kind::Shader).unwrap_err().contains("Iris")); + assert!(open(&Kind::Shader).is_ok()); assert!(open(&Kind::Other("world".into())).is_err()); let mut submit: Entry = toml::from_str(COZY).unwrap(); submit.id = "submit".into(); diff --git a/crates/horizon-mods/src/index/tests.rs b/crates/horizon-mods/src/index/tests.rs index e3883f79e..ef0299ad9 100644 --- a/crates/horizon-mods/src/index/tests.rs +++ b/crates/horizon-mods/src/index/tests.rs @@ -1,7 +1,8 @@ //! The sample index (`tests/index/index-v1.json`, the one docs/api/mod-index.md //! shows) and its files: `coords_hud-0.1.0.hmod`, signed with the throwaway -//! key `test.pub` by minisign 0.12 (its secret key was deleted), and -//! `cozy-1.0.0.hpack`, unsigned. +//! key `test.pub` by minisign 0.12 (its secret key was deleted), +//! `cozy-1.0.0.hpack`, unsigned, and `glow-1.0.0.hshader`, unsigned +//! (`horizon-shader new --template post`, then `horizon-shader pack`). use super::*; use std::path::PathBuf; @@ -25,8 +26,8 @@ fn reads_the_sample_and_keeps_unknown_kinds() { let index = sample(); assert_eq!(index.schema, SCHEMA); let kinds: Vec<&str> = index.projects.iter().map(|p| p.kind.name()).collect(); - assert_eq!(kinds, ["mod", "modpack", "world"]); - assert_eq!(index.projects[2].kind, Kind::Other("world".into())); + assert_eq!(kinds, ["mod", "modpack", "shader", "world"]); + assert_eq!(index.projects[3].kind, Kind::Other("world".into())); let hud = index.project("coords_hud").unwrap(); assert_eq!( hud.versions[0].capabilities, @@ -44,6 +45,8 @@ fn files_pass_against_their_entries() { assert_eq!(check(&index, "coords_hud", &hmod), Ok(Trust::Verified)); let hpack = fixtures().join("cozy-1.0.0.hpack"); assert_eq!(check(&index, "cozy", &hpack), Ok(Trust::Unsigned)); + let hshader = fixtures().join("glow-1.0.0.hshader"); + assert_eq!(check(&index, "glow", &hshader), Ok(Trust::Unsigned)); let world = index.project("skyblock_start").unwrap(); let e = check_file(&index, world, &world.versions[0], &hpack).unwrap_err(); assert!(e.contains("bytes"), "{e}"); @@ -73,6 +76,15 @@ fn a_changed_file_key_or_manifest_is_refused() { let e = check(&more_caps, "coords_hud", &hmod).unwrap_err(); assert!(e.contains("isn't what the index lists"), "{e}"); + let mut other_level = index.clone(); + other_level.projects[0].versions[0].api_level = Some(1); + let e = check(&other_level, "coords_hud", &hmod).unwrap_err(); + assert!(e.contains("isn't what the index lists"), "{e}"); + // An index built before levels lists none: the file still passes. + let mut no_level = index.clone(); + no_level.projects[0].versions[0].api_level = None; + assert_eq!(check(&no_level, "coords_hud", &hmod), Ok(Trust::Verified)); + let mut revoked = index.clone(); revoked.revoked.push(Revoked { id: "coords_hud".into(), @@ -163,3 +175,79 @@ fn resource_packs_need_a_pack_mcmeta() { assert!(e.contains("plain path"), "{e}"); std::fs::remove_dir_all(&dir).unwrap(); } + +#[test] +fn the_newest_version_this_horizon_runs_is_installed() { + let mut index = sample(); + let mut newer = index.projects[0].versions[0].clone(); + newer.version = "0.2.0".into(); + newer.file.sha256 = "2".repeat(64); + newer.api_level = Some(crate::api_level::LEVEL + 1); + index.projects[0].versions.insert(0, newer); + let p = index.project("coords_hud").unwrap(); + let pick = |level| { + index + .installable(p, "26.3", level) + .map(|v| v.version.as_str()) + }; + assert_eq!(pick(crate::api_level::LEVEL), Some("0.1.0")); + assert_eq!(pick(crate::api_level::LEVEL + 1), Some("0.2.0")); + assert_eq!(index.installable(p, "26.4", crate::api_level::LEVEL), None); + // No level listed: runnable as far as the index knows. + index.projects[0].versions[0].api_level = None; + let p = index.project("coords_hud").unwrap(); + let v = index.installable(p, "26.3", 0).unwrap(); + assert_eq!(v.version, "0.2.0"); +} + +#[test] +fn shader_packs_pass_the_game_s_own_check() { + let manifest = "schema = 1\nid = \"glow\"\nname = \"Glow\"\nversion = \"1.0.0\"\napi = \"0.1\"\n\ + [[post]]\nfile = \"post.wgsl\"\n"; + let pack = |post: &str| { + let files = [ + (horizon_shader_api::MANIFEST, manifest), + ("post.wgsl", post), + ] + .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec())) + .into(); + horizon_shader_api::Pack::from_files(files) + .unwrap() + .package() + .unwrap() + }; + let dir = std::env::temp_dir().join(format!("horizon-mods-shader-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let good = dir.join("glow-1.0.0.hshader"); + std::fs::write( + &good, + pack("fn post(input: PostInput) -> vec4 { return input.color; }\n"), + ) + .unwrap(); + let bad = dir.join("bad.hshader"); + std::fs::write( + &bad, + pack("fn post(input: PostInput) -> vec4 { return input.color }\n"), + ) + .unwrap(); + let facts = inspect(&Kind::Shader, &good); + let refused = inspect(&Kind::Shader, &bad).unwrap_err(); + let not_a_pack = inspect(&Kind::Shader, &fixtures().join("cozy-1.0.0.hpack")).unwrap_err(); + std::fs::remove_dir_all(&dir).unwrap(); + let facts = facts.unwrap(); + assert_eq!( + ( + facts.id.as_deref(), + facts.version.as_deref(), + facts.api.as_str() + ), + (Some("glow"), Some("1.0.0"), "0.1") + ); + assert!(refused.contains("post.wgsl:1:"), "{refused}"); + assert!( + not_a_pack.contains(horizon_shader_api::MANIFEST), + "{not_a_pack}" + ); + assert_eq!(Kind::Shader.extension(), Some("hshader")); + assert!(open(&Kind::Shader).is_ok()); +} diff --git a/crates/horizon-mods/src/lib.rs b/crates/horizon-mods/src/lib.rs index 3c5fe74f6..20f475165 100644 --- a/crates/horizon-mods/src/lib.rs +++ b/crates/horizon-mods/src/lib.rs @@ -5,6 +5,7 @@ //! //! Nothing here runs unless a mod is installed and turned on: an empty //! [`Mods`] makes no engine and every hook returns at once. +pub mod api_level; pub mod content; #[cfg(feature = "index")] pub mod index; diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs index 119343de5..ea603ee31 100644 --- a/crates/horizon-mods/src/runtime.rs +++ b/crates/horizon-mods/src/runtime.rs @@ -41,7 +41,7 @@ mod ui_bindings { }); } pub use bindings::horizon::mods::{ - game::{Clock, Player}, + game::{Clock, Hit, Player}, hud::{Corner, Line}, }; use bindings::{ @@ -89,6 +89,8 @@ const FUEL_FRAME: u64 = 10_000_000; const FUEL_EVENT: u64 = 100_000_000; /// Chat lines a mod may show per call, HUD lines and their length. const CHAT_PER_CALL: usize = 8; +/// How far `game.raycast` sees, in blocks. +pub const RAYCAST_MAX: f32 = 1024.0; const HUD_LINES: usize = 16; const LINE_CHARS: usize = 256; /// Total bytes a mod's `storage` may hold on disk, across all its keys. @@ -124,6 +126,10 @@ pub struct Snapshot { pub font_widths: Arc<[f32]>, /// The players on the server, for server mods. pub players: Vec, + /// The first block along the player's view within [`RAYCAST_MAX`] and + /// its distance from the eye, for `game.raycast`; the game works it out + /// only while a mod calls it ([`Mods::wants_raycast`]). + pub view_hit: Option<(f32, Hit)>, } /// Which mods a game starts: the window's game the client mods, the game @@ -227,6 +233,8 @@ struct Running { /// server mod. ui: Option, hooks: Hooks, + /// It imports `game.raycast`. + raycasts: bool, } /// A running mod's exports and the hooks its `init` asked for. @@ -424,6 +432,12 @@ impl Mods { .map(|(name, _)| name.to_string()) .collect(); m.check_imports(imports.iter().map(String::as_str))?; + // A function this Horizon doesn't have: say so, not wasmtime's linking error. + let functions = crate::api_level::imports(wasm)?; + let (level, function) = crate::api_level::needed(functions.iter().map(String::as_str)); + if let Some(why) = crate::api_level::too_new(level, function) { + return Err(why); + } let data_dir = path .parent() .unwrap_or(Path::new(".")) @@ -484,7 +498,12 @@ impl Mods { free }); self.out.append(&mut store.data_mut().out); - Ok(Some(Running { store, ui, hooks })) + Ok(Some(Running { + store, + ui, + hooks, + raycasts: functions.iter().any(|f| f == "game.raycast"), + })) } /// True when at least one mod runs: the game skips its mod work otherwise. @@ -737,6 +756,13 @@ impl Mods { .iter() .filter_map(|e| e.run.as_ref()?.store.data().corner.as_ref()) } + /// Some running mod calls `game.raycast`: the snapshot needs a + /// [`Snapshot::view_hit`]. + pub fn wants_raycast(&self) -> bool { + self.entries + .iter() + .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts)) + } /// Some running mod has a `frame` hook: the game refreshes the snapshot /// every frame for it. pub fn wants_frames(&self) -> bool { @@ -1087,6 +1113,11 @@ impl game::Host for State { fn get_clock(&mut self) -> Option { self.snapshot.clock } + fn raycast(&mut self, distance: f32) -> Option { + let (at, hit) = self.snapshot.view_hit.as_ref()?; + // NaN compares false: no hit. + (*at <= distance.min(RAYCAST_MAX) && !distance.is_nan()).then(|| hit.clone()) + } } impl State { /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`]. diff --git a/crates/horizon-mods/tests/api_reference.rs b/crates/horizon-mods/tests/api_reference.rs index b3d2363a9..6e9a92c85 100644 --- a/crates/horizon-mods/tests/api_reference.rs +++ b/crates/horizon-mods/tests/api_reference.rs @@ -302,3 +302,38 @@ fn every_capability_with_an_interface_is_in_the_contract() { } } } + +/// Every function the game offers (an interface some world imports and none +/// exports) has an API level, and the levels list nothing else. +#[test] +fn every_function_has_an_api_level() { + let mut resolve = Resolve::default(); + let package = resolve.push_file(root().join(WIT)).unwrap(); + let package = &resolve.packages[package]; + let exported: Vec<_> = package + .worlds + .values() + .flat_map(|&w| resolve.worlds[w].exports.values()) + .filter_map(|item| match item { + WorldItem::Interface { id, .. } => Some(*id), + _ => None, + }) + .collect(); + let mut offered = Vec::new(); + for (name, &id) in &package.interfaces { + if !exported.contains(&id) { + for function in resolve.interfaces[id].functions.keys() { + offered.push(format!("{name}.{function}")); + } + } + } + for f in &offered { + assert!( + horizon_mods::api_level::level_of(f).is_some(), + "{f} has no level in crates/horizon-mods/src/api_level.rs: add it at the next level" + ); + } + for (f, _) in horizon_mods::api_level::FUNCTIONS { + assert!(offered.iter().any(|o| o == f), "{f} isn't in the WIT"); + } +} diff --git a/crates/horizon-mods/tests/index/glow-1.0.0.hshader b/crates/horizon-mods/tests/index/glow-1.0.0.hshader new file mode 100644 index 000000000..dda1651f8 Binary files /dev/null and b/crates/horizon-mods/tests/index/glow-1.0.0.hshader differ diff --git a/crates/horizon-mods/tests/index/index-v1.json b/crates/horizon-mods/tests/index/index-v1.json index 215c94667..4f92c7c1d 100644 --- a/crates/horizon-mods/tests/index/index-v1.json +++ b/crates/horizon-mods/tests/index/index-v1.json @@ -29,6 +29,7 @@ "hud", "chat" ], + "api_level": 0, "game": "26.3", "file": { "name": "coords_hud-0.1.0.hmod", @@ -75,6 +76,34 @@ } ] }, + { + "id": "glow", + "kind": "shader", + "name": "Soft Glow", + "summary": "A post-processing pass over the world.", + "authors": [ + "Horizon" + ], + "owners": [ + "ludovic111" + ], + "license": "MIT", + "source": "https://github.com/ludovic111/horizon-mods", + "versions": [ + { + "version": "1.0.0", + "published": "2026-10-26", + "api": "0.1", + "game": "26.3", + "file": { + "name": "glow-1.0.0.hshader", + "url": "https://github.com/ludovic111/horizon-mods/releases/download/glow-1.0.0/glow-1.0.0.hshader", + "size": 689, + "sha256": "331cfe29a666a0de804e9a9ff3d19d246eebcfbfa70b4f49bba8482d30ad9f02" + } + } + ] + }, { "id": "skyblock_start", "kind": "world", diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs index 91adc6489..5b673583d 100644 --- a/crates/horizon-mods/tests/sandbox.rs +++ b/crates/horizon-mods/tests/sandbox.rs @@ -2,8 +2,8 @@ //! examples and a guest //! that misbehaves on command. Needs `rustup target add wasm32-unknown-unknown`. use horizon_mods::{ - BlockPos, Clock, Corner, GameMode, HeldItem, Mods, Output, Package, Player, Runs, ServerPlayer, - Shape, Snapshot, Status, + BlockPos, Clock, Corner, GameMode, HeldItem, Hit, Mods, Output, Package, Player, Runs, + ServerPlayer, Shape, Snapshot, Status, manifest::componentize, testing::{Script, TestGame}, }; @@ -26,7 +26,7 @@ id = "test_ui_guest" name = "Test UI Guest" version = "0.1.0" api = "0.1" -capabilities = ["chat", "ui", "render", "input"] +capabilities = ["game-read", "chat", "ui", "render", "input"] experimental = ["ui", "render", "input"] "#; @@ -197,6 +197,65 @@ fn undeclared_capabilities_are_refused() { assert_eq!(mods.entries()[0].status, refused); } +/// A mod calling a function this Horizon doesn't have is refused with +/// "update Horizon", not a linking error; the test mods' levels are read +/// from the functions they import. +#[test] +fn a_mod_for_a_newer_horizon_is_refused() { + use horizon_mods::api_level::{LEVEL, imports, needed}; + use wit_parser::{ManglingAndAbi, Resolve}; + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + let wit = std::fs::read_to_string(root.join("crates/horizon-mod-sdk/wit/horizon.wit")) + .unwrap() + .replace( + " set-minimap: func(minimap: option);", + " set-minimap: func(minimap: option);\n set-sky: func(on: bool);", + ); + let mut resolve = Resolve::default(); + let package = resolve.push_str("horizon.wit", &wit).unwrap(); + let world = resolve + .select_world(&[package], Some("horizon-ui-mod")) + .unwrap(); + let mut module = wit_component::dummy_module(&resolve, world, ManglingAndAbi::Standard32); + wit_component::embed_component_metadata( + &mut module, + &resolve, + world, + wit_component::StringEncoding::UTF8, + ) + .unwrap(); + let wasm = wit_component::ComponentEncoder::default() + .module(&module) + .unwrap() + .encode() + .unwrap(); + let functions = imports(&wasm).unwrap(); + assert!(functions.iter().any(|f| f == "render.set-sky")); + let dir = mods_dir().join("too_new"); + std::fs::create_dir_all(&dir).unwrap(); + let manifest = r#" +id = "too_new" +name = "Too New" +version = "0.1.0" +api = "0.1" +capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"] +experimental = ["ui", "render", "input"] +"#; + std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap(); + std::fs::write(dir.join("mod.wasm"), wasm).unwrap(); + let mods = Mods::load(&[dir], |_| true, |_| false); + let refused = "made for a newer Horizon (it uses render.set-sky): update Horizon to run it"; + assert_eq!(mods.entries()[0].status, Status::Failed(refused.into())); + + let level = |file: &str| { + let wasm = Package::read(&mods_dir().join(file)).unwrap().wasm.unwrap(); + needed(imports(&wasm).unwrap().iter().map(String::as_str)).0 + }; + assert_eq!(level("coords_hud.hmod"), 0); + // The UI guest shows a minimap (`render.set-minimap`). + assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL); +} + #[test] fn vanilla_commands_win() { let mods = Mods::load( @@ -663,6 +722,47 @@ fn render_minimap_is_clamped_and_hidden() { assert_eq!(map(&mut mods, "off"), None); } +/// `game.raycast`: the view's hit the game worked out, up to the distance +/// asked for; the game works it out only while a mod imports the call. +#[test] +fn game_raycast_sees_the_view_hit_within_its_distance() { + let mut mods = load("horizon_mods_test_ui_guest.hmod"); + assert!(mods.wants_raycast()); + assert!(!load("coords_hud.hmod").wants_raycast()); + let said = |mods: &mut Mods, args: &str| -> Vec { + assert!(mods.command(&format!("raycast {args}"))); + mods.drain() + .into_iter() + .filter_map(|o| match o { + Output::Chat { text, .. } => Some(text), + _ => None, + }) + .collect() + }; + assert_eq!(said(&mut mods, "100"), ["no hit"]); + mods.set_snapshot(Snapshot { + view_hit: Some(( + 40.5, + Hit { + block_x: 12, + block_y: 63, + block_z: -44, + x: 12.5, + y: 64.0, + z: -43.75, + block: "minecraft:grass_block".into(), + }, + )), + ..player() + }); + let hit = "hit minecraft:grass_block at 12 63 -44 (12.5 64.0 -43.8)"; + assert_eq!(said(&mut mods, "100"), [hit]); + assert_eq!(said(&mut mods, "40"), ["no hit"]); + // NaN asks for nothing; past 1024 is 1024. + assert_eq!(said(&mut mods, "x"), ["no hit"]); + assert_eq!(said(&mut mods, "1e9"), [hit]); +} + #[test] fn corner_panels_text_width_and_readings() { let mut mods = load("horizon_mods_test_ui_guest.hmod"); diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs index 3d4c66076..32e811fc7 100644 --- a/crates/horizon-mods/tests/ui_guest/src/lib.rs +++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs @@ -4,9 +4,10 @@ //! `/render_hud`, `/render_clear` and `/render_shake` test `render`; //! `/input_claim`, `/input_poll`, `/input_held` and `/input_wheel` test //! `input`; `/zoom FACTOR SMOOTH TURN` tests `render.set-zoom`; -//! `/corner` and `/readings` the calls the official extras mods use. +//! `/corner` and `/readings` the calls the official extras mods use; +//! `/raycast DISTANCE` says what `game.raycast` sees. use horizon_mod_sdk::{ - Mod, Registration, chat, + Mod, Registration, chat, game, input::{self, Event}, render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape}, ui::{self, ItemWidget, ListWidget, Screen, TextWidget, Widget}, @@ -97,6 +98,7 @@ impl Mod for Guest { "input_wheel", "zoom", "minimap", + "raycast", "corner", "readings", ] @@ -217,6 +219,16 @@ impl Mod for Guest { }); render::set_minimap(map); } + "raycast" => { + let distance = args.parse().unwrap_or(f32::NAN); + chat::show(&match game::raycast(distance) { + Some(h) => format!( + "hit {} at {} {} {} ({:.1} {:.1} {:.1})", + h.block, h.block_x, h.block_y, h.block_z, h.x, h.y, h.z + ), + None => "no hit".into(), + }); + } // Clamped to (1, 10); the two after it shake nothing. "render_shake" => { render::shake(2.0, 99.0); diff --git a/crates/horizon-port-pack/src/carry.rs b/crates/horizon-port-pack/src/carry.rs index 82dbf11af..a87f92ede 100644 --- a/crates/horizon-port-pack/src/carry.rs +++ b/crates/horizon-port-pack/src/carry.rs @@ -828,9 +828,9 @@ pub fn carry( // Additions to other sets and pools, as files the game merges. let modifier = serde_json::from_slice::(&bytes).ok(); let types = &mut report.worldgen_types; - if let Some((kind, mut added)) = modifier.and_then(|v| { - crate::legacy_structure_mods::lithostitched::modifier(&v, loaded, types) - }) { + if let Some((kind, mut added)) = + modifier.and_then(|v| crate::lithostitched::modifier(&v, loaded, types)) + { crate::processors::carry( kind, &mut added, diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs index af46174ae..62c25739f 100644 --- a/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs +++ b/crates/horizon-port-pack/src/legacy_structure_mods/ctov.rs @@ -157,6 +157,7 @@ mod tests { } #[test] + #[ignore = "modular compat is crate::lithostitched's now (its tests)"] fn modular_compat_runs_its_list_only_with_its_mod() { let mut data = ProcessorData::default(); let swap = json!({"processor_type": "minecraft:rule", "rules": []}); diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs b/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs deleted file mode 100644 index 54415a76a..000000000 --- a/crates/horizon-port-pack/src/legacy_structure_mods/lithostitched.rs +++ /dev/null @@ -1,503 +0,0 @@ -//! Lithostitched: its jigsaw structure, its worldgen modifiers and its -//! processors. -use super::ctov; -use crate::processors::{ProcessorData, carry_all, processors, referenced}; -use crate::worldgen::{ENHANCED_TERRAIN, Upgrade, start_checks}; -use serde_json::{Value, json}; -use std::collections::BTreeMap; - -/// A `structure` file of Lithostitched's jigsaw type as vanilla's, with the -/// start rules it shares with the other libraries' jigsaws (`worldgen`'s -/// `start_checks`). `None` for any other file. -pub(crate) fn upgrade( - kind: &str, - v: &mut Value, - lost: &mut BTreeMap, -) -> Option { - if kind != "structure" || v["type"] != "lithostitched:jigsaw" { - return None; - } - start_checks(v, "lowest", lost, false); - if v.as_object_mut() - .and_then(|o| o.remove(ENHANCED_TERRAIN)) - .is_some() - { - *lost.entry(ENHANCED_TERRAIN.into()).or_default() += 1; - } - v["type"] = "minecraft:jigsaw".into(); - Some(true) -} - -/// A lithostitched worldgen modifier -/// (`data//lithostitched/worldgen_modifier/`) that adds to structure -/// sets or template pools, as a file the game merges into them (the key -/// `horizon:add_to`, `horizon_client::mod_content`): (kind, file). The -/// modifier's conditions are checked against `loaded`, the mods ported -/// along: a compat addition for a mod that is not would place that mod's -/// blocks, which the game does not have. Other modifier types are left out. -/// Both are counted in `report`. -pub(crate) fn modifier( - v: &Value, - loaded: &dyn Fn(&str) -> bool, - report: &mut Upgrade, -) -> Option<(&'static str, Value)> { - let t = v["type"].as_str().unwrap_or_default(); - let mut left = |why: &str| *report.modifiers_left.entry(why.to_owned()).or_default() += 1; - let (kind, targets, from, to) = match t { - "lithostitched:add_structure_set_entries" => { - ("structure_set", "structure_sets", "entries", "structures") - } - "lithostitched:add_template_pool_elements" => { - ("template_pool", "template_pools", "elements", "elements") - } - _ => { - left(t); - return None; - } - }; - if !conditions_hold(v, loaded) { - left("conditions"); - return None; - } - let targets: Option> = match &v[targets] { - Value::String(s) => Some(vec![s.as_str()]), - Value::Array(a) => a.iter().map(Value::as_str).collect(), - _ => None, - }; - let Some(targets) = targets.filter(|t| !t.is_empty() && t.iter().all(|t| !t.starts_with('#'))) - else { - left("target"); - return None; - }; - let entries = v[from].as_array().cloned().unwrap_or_default(); - for target in &targets { - *report.added_to.entry((*target).to_owned()).or_default() += entries.len(); - } - Some(( - kind, - serde_json::json!({"horizon:add_to": targets, to: entries}), - )) -} - -/// Whether a modifier's load conditions hold: lithostitched's `predicate`, -/// and the loader's conditions (NeoForge's, else Fabric's). A condition -/// type not known here does not hold. -fn conditions_hold(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let all = |list: &Value, test: &dyn Fn(&Value) -> bool| { - list.as_array().is_some_and(|a| a.iter().all(test)) - }; - fn predicate(p: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| predicate(q, loaded); - let list = &p["predicates"]; - match p["type"] - .as_str() - .map(|t| t.trim_start_matches("lithostitched:")) - { - Some("true") => true, - Some("mod_loaded") => p["mod_id"].as_str().is_some_and(loaded), - Some("not") => !predicate(&p["predicate"], loaded), - Some("all_of") => list.as_array().is_some_and(|a| a.iter().all(test)), - Some("any_of") => list.as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - fn neoforge(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| neoforge(q, loaded); - match c["type"].as_str() { - Some("neoforge:true") => true, - Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded), - Some("neoforge:not") => !neoforge(&c["value"], loaded), - Some("neoforge:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)), - Some("neoforge:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - fn fabric(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { - let test = |q: &Value| fabric(q, loaded); - let mods = || { - c["values"] - .as_array() - .into_iter() - .flatten() - .map(Value::as_str) - }; - match c["condition"].as_str() { - Some("fabric:true") => true, - Some("fabric:all_mods_loaded") => mods().all(|m| m.is_some_and(loaded)), - Some("fabric:any_mods_loaded") => mods().any(|m| m.is_some_and(loaded)), - Some("fabric:not") => !fabric(&c["value"], loaded), - Some("fabric:and") => c["values"].as_array().is_some_and(|a| a.iter().all(test)), - Some("fabric:or") => c["values"].as_array().is_some_and(|a| a.iter().any(test)), - _ => false, - } - } - let litho = v.get("predicate").is_none_or(|p| predicate(p, loaded)); - let loader = match ( - v.get("neoforge:conditions"), - v.get("fabric:load_conditions"), - ) { - (Some(c), _) => all(c, &|c| neoforge(c, loaded)), - // One condition or a list of them. - (None, Some(c)) if c.is_array() => all(c, &|c| fabric(c, loaded)), - (None, Some(c)) => fabric(c, loaded), - (None, None) => true, - }; - litho && loader -} - -/// The data form of one of Lithostitched's processors: the processors to put -/// in its place, or `None` when it has none (or is not Lithostitched's). -pub(crate) fn processor( - kind: &str, - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option> { - match kind { - "lithostitched:apply_random" => apply_random(p, data, carried).map(|p| vec![p]), - "lithostitched:condition" => condition(p, data, carried).map(|p| vec![p]), - "lithostitched:block_swap" => { - // The same map; the game's swap keeps the properties both have. - p["blocks"].as_object()?; - Some(vec![ - json!({"processor_type": "horizon:block_swap", "blocks": p["blocks"]}), - ]) - } - "lithostitched:set_block" => { - // A simple or weighted state provider, the block entity left as - // it is. - let provider = p["state_provider"]["type"].as_str()?; - let modifier = p["block_entity_modifier"]["type"].as_str(); - let plain = - modifier.is_none_or(|m| m.trim_start_matches("minecraft:") == "passthrough"); - if !plain - || !matches!( - provider, - "minecraft:simple_state_provider" | "minecraft:weighted_state_provider" - ) - { - return None; - } - let mut out = p.clone(); - out["processor_type"] = "horizon:set_block".into(); - if let Some(o) = out.as_object_mut() { - o.remove("block_entity_modifier"); - } - Some(vec![out]) - } - _ => None, - } -} - -/// The references (Lithostitched's, and CTOV's compat processors) in a -/// processor list written in; whether any was. -pub(crate) fn expand_references( - list: Vec, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> (Vec, bool) { - references(list, data, carried, 0) -} - -/// A processor list inside a carried processor: an id stays (the game reads -/// that file, carried on its own); an inline one is carried here. -fn nested(list: &Value, data: &ProcessorData, carried: &mut BTreeMap) -> Value { - let mut list = list.clone(); - if let Some(ps) = processors(&mut list) { - *ps = carry_all(std::mem::take(ps), data, carried).0; - } - list -} - -/// Lithostitched's `apply_random` as `horizon:apply_random`: its weighted -/// lists, or its set of lists at weight 1. A tag is not carried. -fn apply_random( - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option { - let lists = &p["processor_lists"]; - let weighted = lists.as_array().is_some_and(|a| { - a.iter() - .all(|e| e.get("weight").is_some() && e.get("data").is_some()) - }); - let entries: Vec<(Value, Value)> = if weighted { - lists - .as_array()? - .iter() - .map(|e| (e["weight"].clone(), e["data"].clone())) - .collect() - } else { - match lists { - Value::String(id) if !id.starts_with('#') => vec![(1.into(), lists.clone())], - Value::Array(a) if a.iter().any(|x| x.get("processor_type").is_some()) => { - vec![(1.into(), lists.clone())] - } - Value::Array(a) - if a.iter() - .all(|x| x.as_str().is_some_and(|s| !s.starts_with('#')) || x.is_object()) => - { - a.iter().map(|x| (1.into(), x.clone())).collect() - } - Value::Object(_) => vec![(1.into(), lists.clone())], - _ => return None, - } - }; - let lists: Vec = entries - .into_iter() - .map(|(weight, list)| json!({"weight": weight, "data": nested(&list, data, carried)})) - .collect(); - let mut out = json!({"processor_type": "horizon:apply_random", "processor_lists": lists}); - if let Some(mode) = p.get("mode") { - out["mode"] = mode.clone(); - } - Some(out) -} - -/// Lithostitched's `condition` as `horizon:condition`, when the game runs -/// every condition in it (true, all_of, any_of, not, random_chance, -/// matching_blocks with plain property values); else it stays Java. -fn condition( - p: &Value, - data: &ProcessorData, - carried: &mut BTreeMap, -) -> Option { - fn runs(c: &Value) -> bool { - if let Some(all) = c.as_array() { - return all.iter().all(runs); - } - let kind = c["type"].as_str().unwrap_or_default(); - match kind.strip_prefix("lithostitched:").unwrap_or(kind) { - "true" | "random_chance" => true, - "all_of" | "any_of" => c["conditions"] - .as_array() - .is_some_and(|a| a.iter().all(runs)), - "not" => runs(&c["condition"]), - "matching_blocks" => c.get("properties").is_none_or(|p| { - p.as_object() - .is_some_and(|o| o.values().all(Value::is_string)) - }), - _ => false, - } - } - if !runs(&p["if_true"]) { - return None; - } - // One processor or a list of them. - let mut branch = |key: &str| -> Value { - let list = match p.get(key) { - None => Vec::new(), - Some(Value::Array(a)) => a.clone(), - Some(one) => vec![one.clone()], - }; - carry_all(list, data, carried).0.into() - }; - let (then, otherwise) = (branch("then"), branch("else")); - let mut out = json!({"processor_type": "horizon:condition", "if_true": p["if_true"], - "then": then, "else": otherwise}); - if let Some(mode) = p.get("random_mode") { - out["random_mode"] = mode.clone(); - } - Some(out) -} - -/// Lithostitched's references in a list, each replaced by the processors of -/// the lists it names, in order (references in them too, to a depth of 8). -/// One naming a tag or a list the mod does not have stays, to be dropped. -/// Whether any was replaced. -fn references( - list: Vec, - data: &ProcessorData, - carried: &mut BTreeMap, - depth: usize, -) -> (Vec, bool) { - let mut out = Vec::with_capacity(list.len()); - let mut changed = false; - for p in list { - if let Some(inner) = ctov::modular_compat(&p, data, carried, depth) { - changed = true; - out.extend(references(inner, data, carried, depth + 1).0); - continue; - } - let named = (p["processor_type"] == "lithostitched:reference" && depth < 8) - .then(|| referenced(&p["processor_lists"], data)) - .flatten(); - match named { - Some(inner) => { - *carried.entry("lithostitched:reference".into()).or_default() += 1; - out.extend(references(inner, data, carried, depth + 1).0); - changed = true; - } - None => out.push(p), - } - } - (out, changed) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::legacy_structure_mods::data; - use crate::processors::carry; - - #[test] - fn modifiers_add_to_sets_and_pools() { - let mut report = Upgrade::default(); - let only_fd = |m: &str| m == "farmersdelight"; - let set = json!({"type": "lithostitched:add_structure_set_entries", - "structure_sets": "minecraft:villages", - "entries": [{"structure": "x:village", "weight": 4}]}); - let (kind, added) = modifier(&set, &only_fd, &mut report).unwrap(); - assert_eq!(kind, "structure_set"); - assert_eq!( - added, - json!({"horizon:add_to": ["minecraft:villages"], - "structures": [{"structure": "x:village", "weight": 4}]}) - ); - // A compat addition holds only when its mod is ported along. - let pool = |modid: &str| { - json!({"type": "lithostitched:add_template_pool_elements", - "neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}], - "fabric:load_conditions": {"condition": "fabric:all_mods_loaded", "values": ["other"]}, - "template_pools": ["x:houses", "y:houses"], - "elements": [{"weight": 5, "element": {"element_type": "minecraft:single_pool_element", - "location": "x:fd_farm", "projection": "rigid", "processors": "minecraft:empty"}}]}) - }; - let (kind, added) = modifier(&pool("farmersdelight"), &only_fd, &mut report).unwrap(); - assert_eq!(kind, "template_pool"); - assert_eq!(added["horizon:add_to"], json!(["x:houses", "y:houses"])); - assert_eq!(added["elements"][0]["weight"], 5); - assert!(modifier(&pool("create"), &only_fd, &mut report).is_none()); - // Fabric's conditions when there are no NeoForge ones; lithostitched's own. - let fabric = json!({"type": "lithostitched:add_structure_set_entries", - "fabric:load_conditions": [{"condition": "fabric:not", - "value": {"condition": "fabric:any_mods_loaded", "values": ["create"]}}], - "predicate": {"type": "lithostitched:all_of", "predicates": [ - {"type": "lithostitched:mod_loaded", "mod_id": "farmersdelight"}, - {"type": "lithostitched:true"}]}, - "structure_sets": "minecraft:villages", "entries": []}); - assert!(modifier(&fabric, &only_fd, &mut report).is_some()); - let tagged = json!({"type": "lithostitched:add_structure_set_entries", - "structure_sets": "#x:sets", "entries": []}); - assert!(modifier(&tagged, &only_fd, &mut report).is_none()); - let features = json!({"type": "lithostitched:add_features"}); - assert!(modifier(&features, &only_fd, &mut report).is_none()); - assert_eq!( - report.added_to, - BTreeMap::from([ - ("minecraft:villages".into(), 1), - ("x:houses".into(), 1), - ("y:houses".into(), 1), - ]) - ); - assert_eq!( - report.modifiers_left, - BTreeMap::from([ - ("conditions".into(), 1), - ("lithostitched:add_features".into(), 1), - ("target".into(), 1), - ]) - ); - } - - #[test] - fn lithostitched_block_swaps_become_the_games() { - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:block_swap", - "blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}}, - {"processor_type": "lithostitched:block_swap", "blocks": []}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data(), &mut carried)); - let p = list["processors"].as_array().unwrap(); - assert_eq!( - p[0], - json!({"processor_type": "horizon:block_swap", - "blocks": {"minecraft:cobblestone": "minecraft:mossy_cobblestone"}}) - ); - // A map that is not one stays Java (dropped later). - assert_eq!(p[1]["processor_type"], "lithostitched:block_swap"); - } - - #[test] - fn lithostitched_references_are_written_in() { - let mut data = data(); - let gravity = json!({"processor_type": "minecraft:gravity", "heightmap": "WORLD_SURFACE_WG", "offset": 0}); - data.lists - .insert("v:road".into(), json!({"processors": [gravity.clone()]})); - data.lists.insert( - "v:house".into(), - json!({"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": "v:road"}, - {"processor_type": "lithostitched:block_swap", "blocks": {"minecraft:dirt": "minecraft:grass_block"}}]}), - ); - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": ["v:house", "v:road"]}, - {"processor_type": "lithostitched:reference", "processor_lists": "#v:roads"}, - {"processor_type": "lithostitched:reference", "processor_lists": ["v:nowhere"]}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data, &mut carried)); - let p = list["processors"].as_array().unwrap(); - // House (its own reference to road first, then its swap), then road; - // the swap inside is carried too. - assert_eq!(p[0], gravity); - assert_eq!(p[1]["processor_type"], "horizon:block_swap"); - assert_eq!(p[2], gravity); - // A tag or a list the mod lacks stays, to be dropped. - assert_eq!(p[3]["processor_lists"], "#v:roads"); - assert_eq!(p[4]["processor_lists"], json!(["v:nowhere"])); - assert_eq!(carried["lithostitched:reference"], 2); - } - - #[test] - fn lithostitched_random_and_condition_become_the_games() { - let mut data = data(); - let swap = json!({"processor_type": "lithostitched:block_swap", - "blocks": {"minecraft:dirt": "minecraft:grass_block"}}); - data.lists - .insert("v:green".into(), json!({"processors": [swap.clone()]})); - let mut list = json!({"processors": [ - {"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [ - {"weight": 3, "data": "minecraft:empty"}, - {"weight": 1, "data": {"processors": [ - {"processor_type": "lithostitched:reference", "processor_lists": "v:green"}, - {"processor_type": "v:java"}]}}]}, - {"processor_type": "lithostitched:apply_random", "mode": "per_block", - "processor_lists": ["v:green", "v:red"]}, - {"processor_type": "lithostitched:apply_random", "mode": "per_block", - "processor_lists": "#v:colours"}, - {"processor_type": "lithostitched:condition", - "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], - "then": swap, "else": {"processor_type": "lithostitched:set_block", "state_provider": - {"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}}, - {"processor_type": "lithostitched:condition", - "if_true": {"type": "lithostitched:matching_biomes", "biomes": "#c:is_cold"}, - "then": []}]}); - let mut carried = BTreeMap::new(); - assert!(carry("processor_list", &mut list, &data, &mut carried)); - let p = list["processors"].as_array().unwrap(); - let green = json!({"processor_type": "horizon:block_swap", - "blocks": {"minecraft:dirt": "minecraft:grass_block"}}); - // Inline lists are carried; Java left in them is dropped later. - assert_eq!( - p[0], - json!({"processor_type": "horizon:apply_random", "mode": "per_piece", "processor_lists": [ - {"weight": 3, "data": "minecraft:empty"}, - {"weight": 1, "data": {"processors": [green.clone(), {"processor_type": "v:java"}]}}]}) - ); - assert_eq!( - p[1]["processor_lists"], - json!([{"weight": 1, "data": "v:green"}, {"weight": 1, "data": "v:red"}]) - ); - assert_eq!(p[2]["processor_type"], "lithostitched:apply_random"); - assert_eq!( - p[3], - json!({"processor_type": "horizon:condition", - "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], - "then": [green], "else": [{"processor_type": "horizon:set_block", "state_provider": - {"type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:stone"}}}]}) - ); - assert_eq!(p[4]["processor_type"], "lithostitched:condition"); - assert_eq!(carried["lithostitched:apply_random"], 2); - assert_eq!(carried["lithostitched:condition"], 1); - } -} diff --git a/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs index 1faa1b39f..980798720 100644 --- a/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs +++ b/crates/horizon-port-pack/src/legacy_structure_mods/mod.rs @@ -13,10 +13,11 @@ //! The general code reaches them only through the `pub(crate)` entry points //! of these three modules. Nothing in them is used by another mod's //! conversion. +#[allow(dead_code)] // its modular compat is `crate::lithostitched`'s now; the rest goes with C1 pub(crate) mod ctov; -pub(crate) mod lithostitched; #[cfg(test)] +#[allow(dead_code)] // the old Lithostitched tests used it fn data() -> crate::processors::ProcessorData { let mut d = crate::processors::ProcessorData::default(); d.spawners.insert( diff --git a/crates/horizon-port-pack/src/lib.rs b/crates/horizon-port-pack/src/lib.rs index 3b17f1c9c..b47c93754 100644 --- a/crates/horizon-port-pack/src/lib.rs +++ b/crates/horizon-port-pack/src/lib.rs @@ -14,6 +14,7 @@ pub mod import; pub mod inventory; pub mod jar; pub(crate) mod legacy_structure_mods; +mod lithostitched; pub mod modrinth; pub mod oracle; pub mod pipeline; diff --git a/crates/horizon-port-pack/src/lithostitched.rs b/crates/horizon-port-pack/src/lithostitched.rs new file mode 100644 index 000000000..e65efcf0e --- /dev/null +++ b/crates/horizon-port-pack/src/lithostitched.rs @@ -0,0 +1,434 @@ +//! Lithostitched's worldgen, carried as the game reads it (clean room: +//! `cleanroom/structures/spec-lithostitched.md`; CTOV's processor: +//! `spec-ctov.md` §4). +//! +//! - `lithostitched:jigsaw` structures become vanilla's jigsaw. Lithostitched +//! lays jigsaws out its own way (OPEN-L5): Horizon keeps vanilla's layouts. +//! - Its processors (`block_swap`, `reference`, `apply_random`, `condition`, +//! `set_block`, `discard_input`) are the game's own types +//! (`horizon_world`'s `structure::processor`): they are carried as written, +//! the processors nested in them carried in turn. CTOV's +//! `ctov:modular_compat` (a reference that runs only when its mod is loaded) +//! becomes a `reference` when the mod is ported along, else nothing. +//! - `add_template_pool_elements` modifiers become `horizon:add_to` pool files +//! (`docs/mods.md`), when their load conditions pass. Lithostitched's own +//! pool elements (`limited`, `guaranteed`, `delegating`) place their +//! `delegate`; what they add to it is counted as lost. +use crate::{processors::ProcessorData, worldgen::Upgrade}; +use serde_json::{Value, json}; +use std::collections::BTreeMap; + +const JIGSAW: &str = "lithostitched:jigsaw"; +/// Vanilla's JigsawStructure.MAX_DEPTH. +const MAX_SIZE: i64 = 20; +const MODULAR_COMPAT: &str = "ctov:modular_compat"; +/// The processor types the game reads. +const PROCESSORS: [&str; 6] = [ + "lithostitched:block_swap", + "lithostitched:reference", + "lithostitched:apply_random", + "lithostitched:condition", + "lithostitched:set_block", + "lithostitched:discard_input", +]; + +fn count(map: &mut BTreeMap, name: &str) { + *map.entry(name.to_owned()).or_default() += 1; +} + +/// A `lithostitched:jigsaw` structure as vanilla's jigsaw: `Some(true)`, else +/// `None`. +pub(crate) fn upgrade( + kind: &str, + v: &mut Value, + lost: &mut BTreeMap, +) -> Option { + if kind != "structure" || v["type"] != JIGSAW { + return None; + } + v["type"] = "minecraft:jigsaw".into(); + // `size` may be an int provider (sampled per start): its largest value. + let size = match &v["size"] { + Value::Null => None, + Value::Number(n) => n.as_i64(), + provider => { + count(lost, "lithostitched:jigsaw size provider"); + ["max_inclusive", "value"] + .iter() + .find_map(|k| provider[k].as_i64()) + } + }; + if let Some(size) = size { + if size > MAX_SIZE { + count(lost, "lithostitched:jigsaw size over 20"); + } + v["size"] = size.clamp(0, MAX_SIZE).into(); + } + let o = v.as_object_mut()?; + match o.remove("start_projection") { + Some(Value::String(heightmap)) if heightmap != "floor" && heightmap != "ceiling" => { + o.entry("project_start_to_heightmap") + .or_insert(heightmap.into()); + } + Some(_) => count(lost, "lithostitched:jigsaw start_projection"), + None => {} + } + if o.remove("fixed_rotation").is_some_and(|f| f == true) { + count(lost, "lithostitched:jigsaw fixed_rotation"); + } + Some(true) +} + +/// Lithostitched's pool elements as the element they wrap; whether `element` +/// was one. +pub(crate) fn upgrade_pool_element( + element: &mut Value, + lost: &mut BTreeMap, +) -> bool { + let Some(kind) = element["element_type"].as_str() else { + return false; + }; + match kind { + "lithostitched:limited" | "lithostitched:guaranteed" | "lithostitched:delegating" => { + count(lost, kind); + let delegate = element["delegate"].take(); + *element = delegate; + // A delegate wrapping another (only `delegating` allows it). + upgrade_pool_element(element, lost); + true + } + _ => false, + } +} + +/// The ids a modifier targets: an id or a list of ids (`None` for tags and +/// Lithostitched's object forms). +fn ids(v: &Value) -> Option> { + let id = |v: &Value| { + v.as_str() + .filter(|s| !s.starts_with('#')) + .map(str::to_owned) + }; + match v { + Value::Array(a) => a.iter().map(id).collect(), + other => Some(vec![id(other)?]), + } +} + +/// NeoForge's load conditions (`neoforge:conditions`): all must pass. +fn conditions_pass(v: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { + fn pass(c: &Value, loaded: &dyn Fn(&str) -> bool) -> bool { + let all = |key: &str| { + c[key] + .as_array() + .into_iter() + .flatten() + .all(|c| pass(c, loaded)) + }; + match c["type"].as_str() { + Some("neoforge:mod_loaded") => c["modid"].as_str().is_some_and(loaded), + Some("neoforge:true") => true, + Some("neoforge:not") => !pass(&c["value"], loaded), + Some("neoforge:and") => all("values"), + Some("neoforge:or") => { + (c["values"].as_array().into_iter().flatten()).any(|c| pass(c, loaded)) + } + _ => false, + } + } + (v["neoforge:conditions"].as_array().into_iter().flatten()).all(|c| pass(c, loaded)) +} + +/// A worldgen modifier as a file the game merges: `("template_pool", file)` +/// for `add_template_pool_elements`; the others are counted in +/// `report.modifiers_left`. +pub(crate) fn modifier( + v: &Value, + loaded: &dyn Fn(&str) -> bool, + report: &mut Upgrade, +) -> Option<(&'static str, Value)> { + let kind = v["type"].as_str().unwrap_or("no type"); + if !conditions_pass(v, loaded) { + count(&mut report.modifiers_left, "conditions"); + return None; + } + if kind != "lithostitched:add_template_pool_elements" { + count(&mut report.modifiers_left, kind); + return None; + } + let (Some(targets), Some(elements)) = (ids(&v["template_pools"]), v["elements"].as_array()) + else { + count(&mut report.modifiers_left, "target"); + return None; + }; + for target in &targets { + *report.added_to.entry(target.clone()).or_default() += elements.len(); + } + Some(( + "template_pool", + json!({"horizon:add_to": targets, "elements": elements}), + )) +} + +/// Whether the game reads a Lithostitched processor as it is: one of its +/// types, with no processor list named by tag (the game has no processor +/// list tags) and a state provider it runs. +pub(crate) fn game_reads(p: &Value) -> bool { + let Some(kind) = p["processor_type"] + .as_str() + .filter(|t| PROCESSORS.contains(t)) + else { + return false; + }; + let tag = |v: &Value| v.as_str().is_some_and(|s| s.starts_with('#')); + match kind { + "lithostitched:reference" => match &p["processor_lists"] { + Value::Array(a) => !a.iter().any(tag), + other => other.is_string() && !tag(other), + }, + "lithostitched:apply_random" => p["processor_lists"] + .as_array() + .is_some_and(|a| a.iter().all(|e| !tag(e) && !tag(&e["data"]))), + "lithostitched:set_block" => matches!( + p["state_provider"]["type"].as_str(), + Some("minecraft:simple_state_provider" | "minecraft:weighted_state_provider") + ), + "lithostitched:block_swap" => p["blocks"].is_object(), + "lithostitched:condition" => !p["if_true"].is_null(), + _ => true, + } +} + +/// The processor lists inside a Lithostitched processor, for the general +/// code that walks lists (`then`, `else`, `apply_random`'s inline data). +pub(crate) fn inner_lists(p: &mut Value) -> Vec<&mut Value> { + match p["processor_type"].as_str() { + Some("lithostitched:apply_random") => (p["processor_lists"].as_array_mut().into_iter()) + .flatten() + .filter_map(|e| e.get_mut("data").filter(|d| !d.is_string())) + .collect(), + Some("lithostitched:condition") => (p.as_object_mut().into_iter()) + .flat_map(|o| o.iter_mut()) + .filter(|(k, _)| *k == "then" || *k == "else") + .map(|(_, v)| v) + .collect(), + _ => Vec::new(), + } +} + +/// A Lithostitched processor with the processors nested in it carried +/// (`Some`, when one of them changed); `None` for any other processor. +pub(crate) fn processor( + kind: &str, + p: &Value, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> Option> { + if !PROCESSORS.contains(&kind) { + return None; + } + let mut out = p.clone(); + let mut changed = false; + for list in inner_lists(&mut out) { + // One processor alone is a list of one. + if list.get("processor_type").is_some() { + *list = Value::Array(vec![list.take()]); + changed = true; + } + if let Some(processors) = crate::processors::processors(list) { + let (inner, inner_changed) = + crate::processors::carry_all(std::mem::take(processors), data, carried); + *processors = inner; + changed |= inner_changed; + } + } + changed.then(|| vec![out]) +} + +/// The list with CTOV's modular compat processors written as the game's +/// `reference` (its mod is ported along) or taken out; whether any was. +pub(crate) fn expand_references( + list: Vec, + data: &ProcessorData, + carried: &mut BTreeMap, +) -> (Vec, bool) { + let mut changed = false; + let mut out = Vec::with_capacity(list.len()); + for p in list { + if p["processor_type"] != MODULAR_COMPAT { + out.push(p); + continue; + } + changed = true; + count(carried, MODULAR_COMPAT); + let loaded = p["modid"] + .as_str() + .is_some_and(|m| data.compat_loaded.contains(m)); + if loaded { + out.push(json!({"processor_type": "lithostitched:reference", + "processor_lists": p["reference"].clone()})); + } + } + (out, changed) +} + +/// Notes which mods CTOV's modular compat processors name are `loaded`. +pub(crate) fn mark_loaded(data: &mut ProcessorData, loaded: &dyn Fn(&str) -> bool) { + fn visit(v: &Value, out: &mut Vec) { + match v { + Value::Object(o) => { + if o.get("processor_type").and_then(Value::as_str) == Some(MODULAR_COMPAT) + && let Some(m) = o.get("modid").and_then(Value::as_str) + { + out.push(m.to_owned()); + } + o.values().for_each(|v| visit(v, out)); + } + Value::Array(a) => a.iter().for_each(|v| visit(v, out)), + _ => {} + } + } + let mut named = Vec::new(); + data.lists.values().for_each(|l| visit(l, &mut named)); + data.compat_loaded + .extend(named.into_iter().filter(|m| loaded(m))); +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::worldgen::upgrade as upgrade_file; + + #[test] + fn jigsaws_become_vanillas() { + let mut lost = BTreeMap::new(); + let mut s = json!({"type": JIGSAW, "size": {"type": "uniform", "min_inclusive": 3, + "max_inclusive": 40}, "start_projection": "WORLD_SURFACE_WG", "fixed_rotation": true}); + assert_eq!(upgrade("structure", &mut s, &mut lost), Some(true)); + assert_eq!( + s, + json!({"type": "minecraft:jigsaw", "size": 20, + "project_start_to_heightmap": "WORLD_SURFACE_WG"}) + ); + assert_eq!(lost.len(), 3); + assert_eq!( + upgrade( + "structure", + &mut json!({"type": "minecraft:jigsaw"}), + &mut lost + ), + None + ); + } + + #[test] + fn wrapped_elements_place_their_delegate() { + let mut lost = BTreeMap::new(); + let delegate = json!({"element_type": "minecraft:single_pool_element", "location": "a:b", + "projection": "rigid", "processors": "minecraft:empty"}); + let mut e = + json!({"element_type": "lithostitched:limited", "limit": 1, "delegate": delegate}); + assert!(upgrade_pool_element(&mut e, &mut lost)); + assert_eq!(e, delegate); + assert_eq!(lost["lithostitched:limited"], 1); + assert!(!upgrade_pool_element(&mut e, &mut lost)); + } + + #[test] + fn modifiers_add_to_pools_when_their_mods_are_loaded() { + let mut report = Upgrade::default(); + let loaded = |m: &str| m == "waystones"; + let add = |modid: &str, pools: Value| { + json!({"type": "lithostitched:add_template_pool_elements", "template_pools": pools, + "elements": [{"weight": 2, "element": {"element_type": "minecraft:empty_pool_element"}}], + "neoforge:conditions": [{"type": "neoforge:mod_loaded", "modid": modid}]}) + }; + let (kind, file) = modifier( + &add("waystones", json!("ctov:village/plains/house")), + &loaded, + &mut report, + ) + .unwrap(); + assert_eq!(kind, "template_pool"); + assert_eq!(file["horizon:add_to"], json!(["ctov:village/plains/house"])); + assert_eq!(file["elements"][0]["weight"], 2); + assert_eq!(report.added_to["ctov:village/plains/house"], 1); + assert!(modifier(&add("sawmill", json!("a:b")), &loaded, &mut report).is_none()); + assert!(modifier(&add("waystones", json!("#a:pools")), &loaded, &mut report).is_none()); + let aliases = json!({"type": "lithostitched:set_pool_aliases"}); + assert!(modifier(&aliases, &loaded, &mut report).is_none()); + assert_eq!( + report.modifiers_left, + BTreeMap::from([ + ("conditions".into(), 1), + ("lithostitched:set_pool_aliases".into(), 1), + ("target".into(), 1), + ]) + ); + } + + /// A CTOV list (spec-ctov §4): references, a condition with a single + /// processor and a nested condition, a random list holding the compat + /// hook, and processors the game cannot read. + #[test] + fn processors_stay_lithostitcheds_with_their_insides_carried() { + let hook = json!({"processor_type": MODULAR_COMPAT, "modid": "natures_spirit", + "reference": "ctov:village/mesa/house_wisteria"}); + let list = json!({"processors": [ + {"processor_type": "lithostitched:reference", "processor_lists": ["ctov:village/mesa/house"]}, + {"processor_type": "lithostitched:condition", "random_mode": "per_block", + "if_true": {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", + "match_type": "location"}, + "then": {"processor_type": "lithostitched:set_block", "state_provider": { + "type": "minecraft:simple_state_provider", "state": {"Name": "minecraft:spruce_planks"}}}, + "else": [{"processor_type": "somemod:java_processor"}]}, + {"processor_type": "lithostitched:apply_random", "mode": "per_piece", "processor_lists": [ + {"weight": 1, "data": "minecraft:empty"}, + {"weight": 1, "data": {"processors": [hook]}}]}, + {"processor_type": "lithostitched:reference", "processor_lists": "#ctov:palettes"}, + {"processor_type": "lithostitched:set_block", "state_provider": { + "type": "minecraft:noise_provider"}}]}); + for (loaded, wisteria) in [ + (false, json!([])), + ( + true, + json!([{"processor_type": + "lithostitched:reference", "processor_lists": "ctov:village/mesa/house_wisteria"}]), + ), + ] { + let mut data = ProcessorData::default(); + data.lists + .insert("ctov:village/mesa/house".into(), list.clone()); + mark_loaded(&mut data, &|m| loaded && m == "natures_spirit"); + let mut v = list.clone(); + let mut report = Upgrade::default(); + crate::processors::carry( + "processor_list", + &mut v, + &data, + &mut report.processors_carried, + ); + upgrade_file("processor_list", &mut v, &mut report, &BTreeMap::new()); + let p = &v["processors"]; + assert_eq!(p.as_array().unwrap().len(), 3, "{p}"); + assert_eq!(p[0], list["processors"][0]); + // One processor is a list of one; the Java one is taken out. + assert_eq!( + p[1]["then"][0]["state_provider"]["state"]["id"], + "minecraft:spruce_planks" + ); + assert_eq!(p[1]["else"], json!([])); + assert_eq!(p[2]["processor_lists"][0]["data"], "minecraft:empty"); + assert_eq!(p[2]["processor_lists"][1]["data"]["processors"], wisteria); + assert_eq!(report.processors_carried[MODULAR_COMPAT], 1); + assert_eq!( + report.processors_dropped, + BTreeMap::from([ + ("lithostitched:reference".into(), 1), + ("lithostitched:set_block".into(), 1), + ("somemod:java_processor".into(), 1), + ]) + ); + } + } +} diff --git a/crates/horizon-port-pack/src/processors.rs b/crates/horizon-port-pack/src/processors.rs index af1595f92..046eaa0bf 100644 --- a/crates/horizon-port-pack/src/processors.rs +++ b/crates/horizon-port-pack/src/processors.rs @@ -10,13 +10,13 @@ //! - Repurposed Structures' mineshaft sky view becomes the game's //! `horizon:mineshaft_sky_view`. //! -//! The processors of YUNG's mods, Lithostitched and Choice Theorem's Overhauled -//! Village are carried by `legacy_structure_mods`, called from [`carry`]. +//! Lithostitched's processors and Choice Theorem's Overhauled Village's +//! compat hook are carried by `crate::lithostitched`, called from [`carry`]. //! //! What is not here is taken out of its list later and counted //! (`worldgen::upgrade`). The entity NBT is written in 26.3's shape (an //! `equipment` map, not 1.21.1's `HandItems` and `ArmorItems`). -use crate::legacy_structure_mods::{ctov, lithostitched}; +use crate::lithostitched; use serde_json::{Value, json}; use std::{ collections::{BTreeMap, BTreeSet}, @@ -42,7 +42,7 @@ pub struct ProcessorData { impl ProcessorData { /// Notes which mods its compat processors name are `loaded`. pub fn mark_loaded(&mut self, loaded: &dyn Fn(&str) -> bool) { - ctov::mark_loaded(self, loaded); + lithostitched::mark_loaded(self, loaded); } pub fn read(zip: &mut zip::ZipArchive) -> Self { @@ -177,8 +177,7 @@ fn carry_at( let mut out = Vec::with_capacity(expanded.len()); for p in expanded { let kind = p["processor_type"].as_str().unwrap_or_default().to_owned(); - // Lithostitched's processors are carried apart from this code - // (`legacy_structure_mods`). + // Lithostitched's processors stay theirs, with what they hold carried. let replacement = lithostitched::processor(&kind, &p, data, carried).or_else(|| { match pillar_type(&kind) { Some(to) => Some(vec![pillar(&p, to, data, carried, depth)]), diff --git a/crates/horizon-port-pack/src/worldgen.rs b/crates/horizon-port-pack/src/worldgen.rs index 298179acf..0e3d968e3 100644 --- a/crates/horizon-port-pack/src/worldgen.rs +++ b/crates/horizon-port-pack/src/worldgen.rs @@ -15,10 +15,10 @@ //! closely. //! //! YUNG's API's files are carried as written ([`crate::yung`]). -//! Lithostitched's and CTOV's worldgen files are converted by -//! `legacy_structure_mods`, called from [`upgrade`], [`crate::carry`] and the -//! processors. -use crate::{legacy_structure_mods::lithostitched, yung}; +//! Lithostitched's jigsaws, elements, modifiers and processors are carried by +//! [`crate::lithostitched`]; the entries CTOV adds to vanilla's structure sets +//! by `legacy_structure_mods`, called from [`crate::carry`]. +use crate::{lithostitched, yung}; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet}, @@ -191,28 +191,19 @@ fn drop_java_processors(list: &mut Value, dropped: &mut BTreeMap) let before = processors.len(); processors.retain(|p| { let t = p["processor_type"].as_str().unwrap_or_default(); - let java = !t.starts_with("minecraft:") && !t.starts_with("horizon:"); + let java = !t.starts_with("minecraft:") + && !t.starts_with("horizon:") + && !lithostitched::game_reads(p); if java { *dropped.entry(t.to_owned()).or_default() += 1; } !java }); let mut changed = processors.len() != before; - // The inline lists inside the game's apply_random and condition. + // The inline lists inside Lithostitched's apply_random and condition. for p in processors.iter_mut() { let inner: Vec<&mut Value> = match p["processor_type"].as_str() { - Some("horizon:apply_random") => p["processor_lists"] - .as_array_mut() - .into_iter() - .flatten() - .map(|e| &mut e["data"]) - .collect(), - Some("horizon:condition") => { - let o = p.as_object_mut().into_iter().flat_map(|o| o.iter_mut()); - o.filter(|(k, _)| *k == "then" || *k == "else") - .map(|(_, v)| v) - .collect() - } + Some(t) if t.starts_with("lithostitched:") => lithostitched::inner_lists(p), Some("horizon:pillar" | "horizon:bottom_pillar") => { p.get_mut("pillar_processor_list").into_iter().collect() } @@ -398,7 +389,9 @@ fn upgrade_types( } } for element in elements { - if yung::upgrade_pool_element(element, lost) { + if yung::upgrade_pool_element(element, lost) + || lithostitched::upgrade_pool_element(element, lost) + { changed = true; continue; } diff --git a/crates/horizon-shader-api/src/check.rs b/crates/horizon-shader-api/src/check.rs index 6c43718f7..c3ecdd158 100644 --- a/crates/horizon-shader-api/src/check.rs +++ b/crates/horizon-shader-api/src/check.rs @@ -60,6 +60,10 @@ pub struct CheckedStage { pub label: String, pub module: naga::Module, pub info: ModuleInfo, + /// The stage's WGSL without the entry points (the prelude, the shared + /// files, the file), for a renderer that calls the stage function from + /// its own shader (the sky). + pub source: String, pub expressions: usize, pub texture_reads: usize, } @@ -169,6 +173,7 @@ pub fn check_stage(pack: &Pack, kind: StageKind, file: &str) -> Result, random: &mut impl ProcessorRandom) -> Option { + match self { + Self::Passthrough => nbt.cloned(), + Self::Clear => Some(Compound::new()), + Self::AppendLoot(table) => { + let mut nbt = nbt.cloned().unwrap_or_default(); + nbt.insert("LootTable".into(), Tag::String(table.as_str().into())); + nbt.insert("LootTableSeed".into(), Tag::Long(random.long())); + Some(nbt) + } + Self::AppendStatic(data) => Some(edited(nbt, &[], data)), + Self::Edit { remove, data } => Some(edited(nbt, remove, data)), + } + } +} /// A block entity with `remove`'s keys taken out and `data` merged in /// (append_static is the one with nothing to remove). fn edited(nbt: Option<&Compound>, remove: &[String], data: &Compound) -> Compound { @@ -292,17 +309,21 @@ pub enum Processor { SpawnerMobs(Box), Pick(Box), CountCap(Box), - /// `horizon:block_swap` (Lithostitched's `block_swap`): blocks by name - /// become others, keeping the properties both have. + /// `lithostitched:block_swap`: blocks by name become others, keeping + /// the properties both have (a block the game lacks is left alone). BlockSwap(std::collections::BTreeMap), - /// `horizon:apply_random` (Lithostitched's `apply_random`): a processor - /// list drawn by weight runs on the block. - ApplyRandom(Box), - /// `horizon:condition` (Lithostitched's `condition`): `then` or `else` + /// `lithostitched:apply_random`: a processor list drawn by weight runs + /// on the block. + ApplyRandom(Box), + /// `lithostitched:reference`: the named lists run on the block in turn. + Reference(Vec), + /// `lithostitched:discard_input`: the world's block stays. + DiscardInput, + /// `lithostitched:condition`: `then` or `else` /// runs on the block, by a test of it. - Condition(Box), - /// `horizon:set_block` (Lithostitched's `set_block`). - SetBlock(Box), + Condition(Box), + /// `lithostitched:set_block`: the block from a state provider. + SetBlock(Box), /// `horizon:pillar` (Repurposed Structures' and Moog's pillars): a /// trigger block starts a column down to the ground. Pillar(Box), @@ -786,7 +807,7 @@ impl Processor { })?)) } "horizon:pick" => Self::Pick(Box::new(Pick::decode(value, state)?)), - "horizon:block_swap" => Self::BlockSwap( + "lithostitched:block_swap" => Self::BlockSwap( value["blocks"] .as_object() .ok_or(DecodeError::Field("blocks"))? @@ -801,12 +822,16 @@ impl Processor { .collect::>()?, ), "horizon:count_cap" => Self::CountCap(Box::new(CountCap::decode(value, state)?)), - "horizon:apply_random" => Self::ApplyRandom(Box::new( - lithostitched::ApplyRandom::decode(value, resources, bindings)?, + "lithostitched:apply_random" => Self::ApplyRandom(Box::new( + litho::ApplyRandom::decode(value, resources, bindings)?, )), - "horizon:set_block" => { - Self::SetBlock(Box::new(lithostitched::SetBlock::decode(value, state)?)) + "lithostitched:set_block" => { + Self::SetBlock(Box::new(litho::SetBlock::decode(value, state)?)) } + "lithostitched:reference" => { + Self::Reference(litho::reference(value, resources, bindings)?) + } + "lithostitched:discard_input" => Self::DiscardInput, "horizon:pillar" => Self::Pillar(Box::new(pillars::Pillar::decode( value, resources, bindings, state, )?)), @@ -834,7 +859,7 @@ impl Processor { "horizon:keep_world_block" => { Self::KeepWorldBlock(Box::new(sea_level::KeepWorldBlock::decode(value)?)) } - "horizon:condition" => Self::Condition(Box::new(lithostitched::Conditional::decode( + "lithostitched:condition" => Self::Condition(Box::new(litho::Conditional::decode( value, resources, bindings, )?)), _ => return Err(DecodeError::Field("structure processor type")), @@ -1115,24 +1140,10 @@ fn process_block( if !position_ok { continue; } - let nbt = match &rule.modifier { - Modifier::Passthrough => info.nbt.clone(), - Modifier::Clear => Some(Compound::new()), - Modifier::AppendLoot(table) => { - let mut nbt = info.nbt.clone().unwrap_or_default(); - nbt.insert("LootTable".into(), Tag::String(table.as_str().into())); - nbt.insert("LootTableSeed".into(), Tag::Long(random.next_long())); - Some(nbt) - } - Modifier::AppendStatic(data) => Some(edited(info.nbt.as_ref(), &[], data)), - Modifier::Edit { remove, data } => { - Some(edited(info.nbt.as_ref(), remove, data)) - } - }; return Ok(Some(BlockInfo { pos: info.pos, state: rule.output, - nbt, + nbt: rule.modifier.apply(info.nbt.as_ref(), &mut random), })); } Some(info) @@ -1165,8 +1176,7 @@ fn process_block( false => Some(info), }, Processor::ApplyRandom(apply) => { - let seed = world.world_seed()?; - let mut random = apply.random.create(seed, position, reference, info.pos); + let mut random = apply.draws.random(world.world_seed()?, position, info.pos); match apply.pick(&mut random) { Some(list) => { return process_list( @@ -1176,21 +1186,34 @@ fn process_block( None => Some(info), } } + Processor::Reference(lists) => { + let mut current = info; + for list in lists { + match process_list( + list, world, resources, position, reference, relative, current, settings, + )? { + Some(next) => current = next, + None => return Ok(None), + } + } + Some(current) + } + Processor::DiscardInput => None, Processor::SetBlock(set) => { - let seed = world.world_seed()?; - let state = set.state(seed, position, reference, info.pos); - let state = match set.preserves() { + let mut random = set.draws.random(world.world_seed()?, position, info.pos); + let state = set.state(&mut random); + let state = match set.preserve { true => registry .state(state) .and_then(|s| with_properties_of(registry, &s.name, info.state)) .unwrap_or(state), false => state, }; - Some(BlockInfo { state, ..info }) + let nbt = set.modifier.apply(info.nbt.as_ref(), &mut random); + Some(BlockInfo { state, nbt, ..info }) } Processor::Condition(c) => { - let seed = world.world_seed()?; - let mut random = c.random.create(seed, position, reference, info.pos); + let mut random = c.draws.random(world.world_seed()?, position, info.pos); let location = world.block_state(info.pos)?; let passed = c .condition diff --git a/crates/horizon-world/src/worldgen/structure/processor/litho.rs b/crates/horizon-world/src/worldgen/structure/processor/litho.rs new file mode 100644 index 000000000..6ba006fd6 --- /dev/null +++ b/crates/horizon-world/src/worldgen/structure/processor/litho.rs @@ -0,0 +1,841 @@ +//! Lithostitched's processors (spec-lithostitched §5), read as its data +//! writes them: `lithostitched:block_swap` (in `processor.rs`), `reference`, +//! `apply_random`, `condition`, `set_block` and `discard_input`. +//! +//! The draws of `random_chance`, `apply_random` and `set_block` follow +//! Lithostitched's `random_mode` (per block or per piece), but its seeding is +//! not known (OPEN-L6): a positional random of the world seed, the block's or +//! the piece's position and the processor itself, so the shares match while +//! the blocks chosen do not. +use super::{BlockStateId, DecodeError, Modifier, ProcessorList, ProcessorRandom}; +use crate::worldgen::{block_feature::FeatureBlockBindings, structure::StructureResources}; +use horizon_core::{ + position::BlockPos, + random::{LegacyRandom, position_seed}, +}; +use serde_json::Value; +use std::collections::BTreeSet; + +/// `random_mode` (`condition`, `set_block`) or `mode` (`apply_random`). +#[derive(Clone, Copy, Debug)] +pub(super) struct Draws { + per_piece: bool, + /// The processor's own salt, so two processors on a block draw apart. + salt: i64, +} +impl Draws { + fn decode(mode: Option<&Value>, processor: &Value) -> Result { + let per_piece = match mode.and_then(Value::as_str) { + None | Some("per_block") => false, + Some("per_piece") => true, + _ => return Err(DecodeError::Field("random_mode")), + }; + // FNV-1a over the processor's JSON: the same in every run. + let salt = (processor.to_string().bytes()).fold(0xcbf2_9ce4_8422_2325_u64, |h, b| { + (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3) + }) as i64; + Ok(Self { per_piece, salt }) + } + /// The random for the block at `pos` of the piece at `piece`. + pub(super) fn random(self, world_seed: i64, piece: [i32; 3], pos: [i32; 3]) -> LegacyRandom { + let [x, y, z] = if self.per_piece { piece } else { pos }; + LegacyRandom::new(world_seed ^ self.salt ^ position_seed(BlockPos::new(x, y, z))) + } +} + +/// A processor or a list of them (`then`, `else`, `apply_random`'s data): +/// a list holder (`ProcessorList::decode`), or one processor object. +fn processors( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, +) -> Result { + let one = value.get("processor_type").is_some(); + let holder = if one { + Value::Array(vec![value.clone()]) + } else { + value.clone() + }; + ProcessorList::decode(&holder.to_string(), resources, bindings) +} + +/// `reference`: the named lists, run in turn on the block. +pub(super) fn reference( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, +) -> Result, DecodeError> { + let names = match &value["processor_lists"] { + Value::Array(a) => a.clone(), + other => vec![other.clone()], + }; + (names.iter()) + .map(|name| match name.as_str() { + Some(n) if n.starts_with('#') => Err(DecodeError::Field("processor list tag")), + Some(_) => ProcessorList::decode(&name.to_string(), resources, bindings), + None => Err(DecodeError::Field("processor_lists")), + }) + .collect() +} + +/// `apply_random`: one list drawn by weight runs on the block. +#[derive(Clone, Debug)] +pub struct ApplyRandom { + pub(super) draws: Draws, + lists: Vec<(i32, ProcessorList)>, + total: i32, +} +impl ApplyRandom { + pub(super) fn decode( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let entries = value["processor_lists"] + .as_array() + .ok_or(DecodeError::Field("apply_random processor_lists"))?; + let lists = (entries.iter()) + .map(|e| match e.get("data") { + Some(data) => { + let weight = e["weight"] + .as_i64() + .unwrap_or(1) + .clamp(0, i64::from(i32::MAX)); + Ok((weight as i32, processors(data, resources, bindings)?)) + } + None => Ok((1, processors(e, resources, bindings)?)), + }) + .collect::, DecodeError>>()?; + let total = lists + .iter() + .map(|(w, _)| *w) + .fold(0i32, i32::saturating_add); + Ok(Self { + draws: Draws::decode(value.get("mode"), value)?, + lists, + total, + }) + } + /// The list drawn: one bounded draw over the total weight. + pub(super) fn pick(&self, random: &mut impl ProcessorRandom) -> Option<&ProcessorList> { + if self.total <= 0 { + return None; + } + let mut at = random.int(self.total); + for (weight, list) in &self.lists { + at -= weight; + if at < 0 { + return Some(list); + } + } + None + } +} + +/// Lithostitched's processor conditions. +#[derive(Clone, Debug)] +pub(super) enum Condition { + True, + AllOf(Vec), + AnyOf(Vec), + Not(Box), + Chance(f32), + /// `matching_blocks`: the template's block (`input`) or the world's + /// (`location`) is one of `blocks`, with `properties`. + Matching { + blocks: BTreeSet, + properties: Vec<(String, String)>, + location: bool, + }, +} +impl Condition { + /// One condition, or a list of them that must all pass (`if_true`). + pub(super) fn decode( + value: &Value, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let list = |v: &Value| -> Result, DecodeError> { + (v.as_array().ok_or(DecodeError::Field("conditions"))?.iter()) + .map(|c| Self::decode(c, bindings)) + .collect() + }; + if value.is_array() { + return Ok(Self::AllOf(list(value)?)); + } + let kind = value["type"].as_str().unwrap_or_default(); + Ok(match crate::worldgen::tags::identifier(kind)?.as_str() { + "lithostitched:true" => Self::True, + "lithostitched:all_of" => Self::AllOf(list(&value["conditions"])?), + "lithostitched:any_of" => Self::AnyOf(list(&value["conditions"])?), + "lithostitched:not" => { + Self::Not(Box::new(Self::decode(&value["condition"], bindings)?)) + } + "lithostitched:random_chance" => Self::Chance( + value["chance"] + .as_f64() + .ok_or(DecodeError::Field("random_chance chance"))? as f32, + ), + "lithostitched:matching_blocks" => Self::Matching { + blocks: blocks(&value["blocks"], bindings)?, + properties: (value + .get("properties") + .and_then(Value::as_object) + .into_iter()) + .flatten() + .map(|(k, v)| { + ( + k.clone(), + v.as_str().map_or_else(|| v.to_string(), str::to_owned), + ) + }) + .collect(), + location: match value.get("match_type").and_then(Value::as_str) { + None | Some("input") => false, + Some("location") => true, + _ => return Err(DecodeError::Field("matching_blocks match_type")), + }, + }, + _ => return Err(DecodeError::Field("lithostitched condition type")), + }) + } + pub(super) fn test( + &self, + input: BlockStateId, + location: BlockStateId, + registry: &crate::registry::BlockRegistry, + random: &mut impl ProcessorRandom, + ) -> bool { + match self { + Self::True => true, + Self::AllOf(all) => all + .iter() + .all(|c| c.test(input, location, registry, random)), + Self::AnyOf(any) => any + .iter() + .any(|c| c.test(input, location, registry, random)), + Self::Not(c) => !c.test(input, location, registry, random), + Self::Chance(chance) => random.float() < *chance, + Self::Matching { + blocks, + properties, + location: at_location, + } => { + let Some(state) = registry.state(if *at_location { location } else { input }) + else { + return false; + }; + blocks.contains(&state.name) + && (properties.iter()).all(|(k, v)| state.properties.get(k) == Some(v)) + } + } + } +} +/// A block set (an id, a list, `#tag`) by block name. Blocks the game does +/// not have are left out: no template block can be one. +fn blocks( + value: &Value, + bindings: &FeatureBlockBindings<'_>, +) -> Result, DecodeError> { + let names: Vec<&str> = match value { + Value::String(s) => vec![s.as_str()], + Value::Array(a) => a.iter().filter_map(Value::as_str).collect(), + _ => return Err(DecodeError::Field("matching_blocks blocks")), + }; + let registry = bindings.registry(); + let mut out = BTreeSet::new(); + for name in names { + match name.strip_prefix('#') { + Some(tag) => { + let tag = crate::worldgen::tags::identifier(tag)?; + let states = bindings.tags.get(&tag).into_iter().flat_map(|s| s.iter()); + out.extend(states.filter_map(|s| Some(registry.state(*s)?.name.clone()))); + } + None => { + out.insert(crate::worldgen::tags::identifier(name)?.to_string()); + } + } + } + Ok(out) +} + +/// `condition`: `then` when the conditions pass, else `else` (none: the +/// block as it is). +#[derive(Clone, Debug)] +pub struct Conditional { + pub(super) draws: Draws, + pub(super) condition: Condition, + pub(super) then: ProcessorList, + pub(super) otherwise: ProcessorList, +} +impl Conditional { + pub(super) fn decode( + value: &Value, + resources: &StructureResources, + bindings: &FeatureBlockBindings<'_>, + ) -> Result { + let branch = |key| match value.get(key) { + Some(v) => processors(v, resources, bindings), + None => Ok(ProcessorList(Vec::new())), + }; + Ok(Self { + draws: Draws::decode(value.get("random_mode"), value)?, + condition: Condition::decode(&value["if_true"], bindings)?, + then: branch("then")?, + otherwise: branch("else")?, + }) + } +} + +/// `set_block`: the block from a state provider (simple or weighted). +#[derive(Clone, Debug)] +pub struct SetBlock { + pub(super) draws: Draws, + states: Vec<(i32, BlockStateId)>, + total: i32, + /// `preserve_state` (true by default): the template block's properties + /// the new block has too are kept. + pub(super) preserve: bool, + pub(super) modifier: Modifier, +} +impl SetBlock { + pub(super) fn decode( + value: &Value, + state: impl Fn(&Value) -> Result, + ) -> Result { + let provider = &value["state_provider"]; + let kind = provider["type"].as_str().unwrap_or_default(); + let states = match crate::worldgen::tags::identifier(kind)?.as_str() { + "minecraft:simple_state_provider" => vec![(1, state(&provider["state"])?)], + "minecraft:weighted_state_provider" => (provider["entries"].as_array().into_iter()) + .flatten() + .map(|e| { + Ok(( + e["weight"].as_i64().unwrap_or(1).clamp(0, 1 << 30) as i32, + state(&e["data"])?, + )) + }) + .collect::>()?, + _ => return Err(DecodeError::Field("set_block state_provider")), + }; + let total = states.iter().map(|(w, _)| *w).sum(); + if total <= 0 { + return Err(DecodeError::Field("set_block state_provider")); + } + Ok(Self { + draws: Draws::decode(value.get("random_mode"), value)?, + states, + total, + preserve: value + .get("preserve_state") + .and_then(Value::as_bool) + .unwrap_or(true), + modifier: Modifier::decode(value.get("block_entity_modifier"))?, + }) + } + /// The provider's state: WeightedList.getRandom, one bounded draw. + pub(super) fn state(&self, random: &mut impl ProcessorRandom) -> BlockStateId { + let mut at = random.int(self.total); + for (weight, state) in &self.states { + at -= weight; + if at < 0 { + return *state; + } + } + self.states[0].1 + } +} + +#[cfg(test)] +mod tests { + use super::super::{BlockInfo, PlaceSettings, ProcessorList, process_list}; + use crate::{ + heightmap::HeightmapType, + nbt::{JavaString, Tag}, + registry::{BlockRegistry, BlockStateId}, + worldgen::{ + anchor::WorldGenerationContext, + block_feature::FeatureBlockBindings, + placement::{PlacementContext, PlacementQueryError}, + structure::{ + Rotation, StateTransforms, StructureResources, template::parse_state_string, + }, + }, + }; + use serde_json::{Value, json}; + use std::collections::{BTreeMap, BTreeSet}; + + /// Every combination of `properties`' values, the first one the default. + fn states(name: &str, properties: &[(&str, &[&str])]) -> Vec { + let mut out = vec![serde_json::Map::new()]; + for (key, values) in properties { + out = (out.iter()) + .flat_map(|o| { + values.iter().map(move |v| { + let mut o = o.clone(); + o.insert((*key).into(), (*v).into()); + o + }) + }) + .collect(); + } + (out.into_iter()) + .map(|p| json!([name, name.ends_with("air"), false, "", {"id": name, "properties": p}])) + .collect() + } + + /// A registry of the blocks CTOV's lists and the probe pack use. + fn registry() -> &'static BlockRegistry { + let ages: Vec = (0..8).map(|a| a.to_string()).collect(); + let ages: Vec<&str> = ages.iter().map(String::as_str).collect(); + let levels: Vec = (0..16).map(|a| a.to_string()).collect(); + let levels: Vec<&str> = levels.iter().map(String::as_str).collect(); + let water = [("level", &levels[..])]; + let stairs: &[(&str, &[&str])] = + &[("facing", &["north", "east"]), ("half", &["bottom", "top"])]; + let blocks: Vec<(&str, &[(&str, &[&str])])> = vec![ + ("minecraft:air", &[]), + ("minecraft:cave_air", &[]), + ("minecraft:void_air", &[]), + ("minecraft:lava", &water), + ("minecraft:cobblestone", &[]), + ("minecraft:blackstone", &[]), + ("minecraft:deepslate", &[]), + ("minecraft:water", &water), + ("minecraft:spruce_planks", &[]), + ("minecraft:chest", &[]), + ("minecraft:oak_log", &[("axis", &["y", "x"])]), + ("minecraft:stripped_cherry_log", &[("axis", &["y", "x"])]), + ("minecraft:oak_stairs", stairs), + ("minecraft:warped_stairs", stairs), + ]; + let wheat = [("age", &ages[..])]; + let beetroots = [("age", &ages[..4])]; + let mut rows = Vec::new(); + let mut defaults = BTreeMap::new(); + let crops: [(&str, &[(&str, &[&str])]); 3] = [ + ("minecraft:wheat", &wheat), + ("minecraft:carrots", &wheat), + ("minecraft:beetroots", &beetroots), + ]; + for (name, properties) in blocks.into_iter().chain(crops) { + defaults.insert(name, rows.len()); + rows.extend(states(name, properties)); + } + let facts = json!({"states": rows, "defaults": defaults}); + let registry = BlockRegistry::from_facts_json(facts.to_string().as_bytes()).unwrap(); + Box::leak(Box::new(registry)) + } + + /// The world a piece is placed in: one block everywhere. + struct World { + seed: i64, + block: BlockStateId, + } + impl PlacementContext for World { + fn world_seed(&mut self) -> Result { + Ok(self.seed) + } + fn block_state(&mut self, _: [i32; 3]) -> Result { + Ok(self.block) + } + fn generation(&self) -> WorldGenerationContext { + WorldGenerationContext::new(-64, 384, 63) + } + fn min_y(&mut self) -> Result { + Ok(-64) + } + fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result { + Err(PlacementQueryError::Unavailable) + } + } + + struct Lists { + registry: &'static BlockRegistry, + resources: StructureResources, + } + impl Lists { + fn new(lists: &[(&str, Value)]) -> Self { + let registry = registry(); + let lists = (lists.iter()) + .map(|(id, list)| ((*id).to_owned(), list.to_string())) + .collect(); + let resources = StructureResources::new( + registry, + StateTransforms::default(), + std::path::Path::new("/nonexistent"), + lists, + &BTreeMap::new(), + ); + Self { + registry, + resources, + } + } + fn id(&self, state: &str) -> BlockStateId { + parse_state_string(self.registry, state).unwrap() + } + fn decode(&self, processors: Value) -> Result { + let bindings = FeatureBlockBindings::new(self.registry, BTreeSet::new()).unwrap(); + ProcessorList::decode(&processors.to_string(), &self.resources, &bindings) + } + /// The block the list makes of template block `state` at `pos` of the + /// piece at `piece`, in a world of `world`: None when it is not placed. + fn run( + &self, + list: &ProcessorList, + world: (i64, &str), + piece: [i32; 3], + pos: [i32; 3], + state: &str, + ) -> Option { + let mut world = World { + seed: world.0, + block: self.id(world.1), + }; + let info = BlockInfo { + pos, + state: self.id(state), + nbt: None, + }; + let mut settings = PlaceSettings::new(Rotation::None); + process_list( + list, + &mut world, + &self.resources, + piece, + piece, + [0; 3], + info, + &mut settings, + ) + .unwrap() + } + fn name(&self, info: Option) -> String { + match info { + None => "none".into(), + Some(info) => { + let s = self.registry.state(info.state).unwrap(); + let props: Vec = s + .properties + .iter() + .map(|(k, v)| format!("{k}={v}")) + .collect(); + match props.is_empty() { + true => s.name.clone(), + false => format!("{}[{}]", s.name, props.join(",")), + } + } + } + } + /// `name(run(...))` for one template block in an air world of seed 0. + fn out(&self, list: &ProcessorList, state: &str) -> String { + self.name(self.run(list, (0, "minecraft:air"), [0; 3], [0; 3], state)) + } + } + + fn swap(blocks: Value) -> Value { + json!({"processor_type": "lithostitched:block_swap", "blocks": blocks}) + } + fn set_block(provider: Value) -> Value { + json!({"processor_type": "lithostitched:set_block", "state_provider": provider}) + } + fn simple(name: &str) -> Value { + json!({"type": "minecraft:simple_state_provider", "state": {"id": name}}) + } + + #[test] + fn block_swap_keeps_the_properties_the_new_block_can_have() { + let t = Lists::new(&[]); + let list = t + .decode(json!([swap(json!({ + "minecraft:wheat": "minecraft:carrots", + "oak_stairs": "minecraft:warped_stairs", + "minecraft:cobblestone": "natures_spirit:missing"}))])) + .unwrap(); + assert_eq!( + t.out(&list, "minecraft:wheat[age=7]"), + "minecraft:carrots[age=7]" + ); + assert_eq!( + t.out(&list, "minecraft:oak_stairs[facing=east,half=top]"), + "minecraft:warped_stairs[facing=east,half=top]" + ); + // A block the game lacks leaves the template's; others pass. + assert_eq!( + t.out(&list, "minecraft:cobblestone"), + "minecraft:cobblestone" + ); + assert_eq!( + t.out(&list, "minecraft:oak_log[axis=x]"), + "minecraft:oak_log[axis=x]" + ); + // Beetroots' age stops at 3: ripe wheat gives the default (spec-ctov §4). + let beet = t + .decode(json!([swap( + json!({"minecraft:wheat": "minecraft:beetroots"}) + )])) + .unwrap(); + assert_eq!( + t.out(&beet, "minecraft:wheat[age=7]"), + "minecraft:beetroots[age=0]" + ); + assert_eq!( + t.out(&beet, "minecraft:wheat[age=2]"), + "minecraft:beetroots[age=2]" + ); + } + + #[test] + fn references_run_the_named_lists_in_turn() { + let t = Lists::new(&[ + ( + "t:logs", + json!({"processors": [swap(json!({"minecraft:oak_log": "minecraft:stripped_cherry_log"}))]}), + ), + ( + "t:stone", + json!([swap( + json!({"minecraft:stripped_cherry_log": "minecraft:cobblestone"}) + )]), + ), + ( + "t:discard", + json!([{"processor_type": "lithostitched:discard_input"}]), + ), + ]); + let reference = |lists: Value| json!([{"processor_type": "lithostitched:reference", "processor_lists": lists}]); + let one = t.decode(reference(json!("t:logs"))).unwrap(); + assert_eq!( + t.out(&one, "minecraft:oak_log[axis=x]"), + "minecraft:stripped_cherry_log[axis=x]" + ); + let both = t.decode(reference(json!(["t:logs", "t:stone"]))).unwrap(); + assert_eq!(t.out(&both, "minecraft:oak_log"), "minecraft:cobblestone"); + let reversed = t.decode(reference(json!(["t:stone", "t:logs"]))).unwrap(); + assert_eq!( + t.out(&reversed, "minecraft:oak_log"), + "minecraft:stripped_cherry_log[axis=y]" + ); + // discard_input: the template block is not placed, and the lists after it do not run. + let discard = t.decode(reference(json!(["t:discard", "t:logs"]))).unwrap(); + assert_eq!(t.out(&discard, "minecraft:oak_log"), "none"); + // The game has no processor list tags; unknown lists are errors. + assert!(t.decode(reference(json!(["#t:palettes"]))).is_err()); + assert!(t.decode(reference(json!("t:missing"))).is_err()); + } + + /// The probe pack's nested condition (spec-lithostitched §7.3): template + /// cobblestone becomes blackstone or deepslate, half each. + #[test] + fn conditions_run_then_or_else() { + let t = Lists::new(&[]); + let inner = json!({"processor_type": "lithostitched:condition", "random_mode": "per_block", + "if_true": {"type": "lithostitched:random_chance", "chance": 0.5}, + "then": set_block(simple("minecraft:blackstone")), + "else": [set_block(simple("minecraft:deepslate"))]}); + let list = t + .decode(json!([{"processor_type": "lithostitched:condition", + "if_true": [{"type": "lithostitched:matching_blocks", "blocks": "minecraft:cobblestone"}], + "then": [inner]}])) + .unwrap(); + let mut counts = BTreeMap::::new(); + for i in 0..4000 { + let out = t.run( + &list, + (1234, "minecraft:air"), + [0; 3], + [i % 64, i / 64, 7], + "minecraft:cobblestone", + ); + *counts.entry(t.name(out)).or_default() += 1; + } + assert_eq!(counts.len(), 2, "{counts:?}"); + assert!( + (1850..2150).contains(&counts["minecraft:blackstone"]), + "{counts:?}" + ); + // Not cobblestone, and no `else`: the block as it is. + assert_eq!( + t.out(&list, "minecraft:oak_log"), + "minecraft:oak_log[axis=y]" + ); + + // `location` tests the world's block, with properties on the input. + let water = t + .decode( + json!([{"processor_type": "lithostitched:condition", "random_mode": "per_piece", + "if_true": {"type": "lithostitched:matching_blocks", "blocks": ["minecraft:water"], + "match_type": "location"}, + "then": set_block(simple("minecraft:spruce_planks"))}]), + ) + .unwrap(); + let at = |world| { + t.name(t.run( + &water, + (0, world), + [0; 3], + [1, 2, 3], + "minecraft:cobblestone", + )) + }; + assert_eq!(at("minecraft:water"), "minecraft:spruce_planks"); + assert_eq!(at("minecraft:air"), "minecraft:cobblestone"); + let ripe = t + .decode(json!([{"processor_type": "lithostitched:condition", + "if_true": {"type": "lithostitched:all_of", "conditions": [ + {"type": "lithostitched:true"}, + {"type": "lithostitched:matching_blocks", "blocks": "minecraft:wheat", "properties": {"age": "7"}}, + {"type": "lithostitched:not", "condition": {"type": "lithostitched:any_of", "conditions": [ + {"type": "lithostitched:random_chance", "chance": 0.0}, + {"type": "lithostitched:matching_blocks", "blocks": "minecraft:water", "match_type": "location"}]}}]}, + "then": swap(json!({"minecraft:wheat": "minecraft:carrots"}))}])) + .unwrap(); + assert_eq!( + t.out(&ripe, "minecraft:wheat[age=7]"), + "minecraft:carrots[age=7]" + ); + assert_eq!( + t.out(&ripe, "minecraft:wheat[age=6]"), + "minecraft:wheat[age=6]" + ); + let bad = json!([{"processor_type": "lithostitched:condition", "random_mode": "per_chunk", + "if_true": {"type": "lithostitched:true"}}]); + assert!(t.decode(bad).is_err()); + } + + /// `apply_random` (spec-lithostitched §7.3: crimson 1 : birch 3, one + /// choice per piece): here blackstone 1 : deepslate 3. + #[test] + fn apply_random_draws_per_piece_or_per_block() { + let t = Lists::new(&[( + "t:deepslate", + json!([swap( + json!({"minecraft:cobblestone": "minecraft:deepslate"}) + )]), + )]); + let random = |mode: &str| { + t.decode(json!([{"processor_type": "lithostitched:apply_random", "mode": mode, + "processor_lists": [ + {"weight": 1, "data": [swap(json!({"minecraft:cobblestone": "minecraft:blackstone"}))]}, + {"weight": 3, "data": "t:deepslate"}]}])) + .unwrap() + }; + let (per_piece, per_block) = (random("per_piece"), random("per_block")); + let outcomes = |list: &ProcessorList, seed: i64, piece: [i32; 3]| -> Vec { + (0..20) + .map(|i| { + let pos = [piece[0] + i, piece[1], piece[2] + 3 * i]; + t.name(t.run( + list, + (seed, "minecraft:air"), + piece, + pos, + "minecraft:cobblestone", + )) + }) + .collect() + }; + let mut blackstone_pieces = 0; + for p in 0..400 { + let piece = [16 * p, 70, -40 * p]; + let blocks = outcomes(&per_piece, 1234, piece); + assert!(blocks.iter().all(|b| *b == blocks[0]), "{blocks:?}"); + blackstone_pieces += u32::from(blocks[0] == "minecraft:blackstone"); + // The same piece and seed give the same blocks. + assert_eq!(outcomes(&per_piece, 1234, piece), blocks); + } + assert!( + (70..130).contains(&blackstone_pieces), + "{blackstone_pieces}" + ); + // Per block, one piece mixes both. + let mixed: BTreeSet = (0..10) + .flat_map(|p| outcomes(&per_block, 1234, [p, 0, 0])) + .collect(); + assert_eq!(mixed.len(), 2, "{mixed:?}"); + // A plain list: every entry weight 1. An entry list holding nothing is a no-op. + let plain = t + .decode( + json!([{"processor_type": "lithostitched:apply_random", "mode": "per_block", + "processor_lists": ["t:deepslate", []]}]), + ) + .unwrap(); + let seen: BTreeSet = (0..10) + .flat_map(|p| outcomes(&plain, 9, [p, 0, 0])) + .collect(); + assert_eq!( + seen, + BTreeSet::from(["minecraft:cobblestone".into(), "minecraft:deepslate".into()]) + ); + } + + #[test] + fn set_block_runs_its_provider() { + let t = Lists::new(&[]); + let stairs = "minecraft:oak_stairs[facing=east,half=top]"; + let warped = |preserve: Value| { + let mut p = set_block(simple("minecraft:warped_stairs")); + if !preserve.is_null() { + p["preserve_state"] = preserve; + } + t.decode(json!([p])).unwrap() + }; + // preserve_state (true by default) keeps the properties both blocks have. + assert_eq!( + t.out(&warped(Value::Null), stairs), + "minecraft:warped_stairs[facing=east,half=top]" + ); + assert_eq!( + t.out(&warped(json!(false)), stairs), + "minecraft:warped_stairs[facing=north,half=bottom]" + ); + + let weighted = t + .decode(json!([set_block( + json!({"type": "minecraft:weighted_state_provider", "entries": [ + {"weight": 1, "data": {"id": "minecraft:blackstone"}}, + {"weight": 3, "data": {"id": "minecraft:deepslate"}}]}) + )])) + .unwrap(); + let blackstone = (0..2000) + .filter(|i| { + let out = t.run( + &weighted, + (42, "minecraft:air"), + [0; 3], + [*i, 0, -*i], + "minecraft:cobblestone", + ); + t.name(out) == "minecraft:blackstone" + }) + .count(); + assert!((420..580).contains(&blackstone), "{blackstone}"); + + // block_entity_modifier gives the output its block entity. + let mut loot = set_block(simple("minecraft:chest")); + loot["block_entity_modifier"] = + json!({"type": "minecraft:append_loot", "loot_table": "t:chests/house"}); + let out = t + .run( + &t.decode(json!([loot])).unwrap(), + (0, "minecraft:air"), + [0; 3], + [0; 3], + "minecraft:air", + ) + .unwrap(); + let table = out + .nbt + .as_ref() + .and_then(|n| n.get(&JavaString::from("LootTable"))); + assert_eq!(table, Some(&Tag::String("t:chests/house".into()))); + + // Providers the game does not run are refused. + assert!( + t.decode(json!([set_block( + json!({"type": "minecraft:noise_provider"}) + )])) + .is_err() + ); + } +} diff --git a/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs b/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs deleted file mode 100644 index f0bb1c6ba..000000000 --- a/crates/horizon-world/src/worldgen/structure/processor/lithostitched.rs +++ /dev/null @@ -1,434 +0,0 @@ -//! Lithostitched's processors that pick processors, carried as data -//! (`horizon:apply_random` and `horizon:condition`): one runs a processor -//! list drawn by weight, the other one list or another by a test of the -//! block. Both draw from Lithostitched's RandomSettings: a random seeded from -//! the world seed and a name, at the block, the piece or the structure. -//! `horizon:set_block` is its `set_block`, which the conditions mostly run. -use super::{Processor, ProcessorList}; -use crate::{ - registry::{BlockRegistry, BlockStateId}, - worldgen::{DecodeError, block_feature::FeatureBlockBindings, structure::StructureResources}, -}; -use horizon_core::{ - position::BlockPos, - random::{LegacyRandom, PositionalRandom, RandomSource}, -}; -use serde_json::Value; -use std::{collections::BTreeSet, sync::Arc}; - -/// RandomSettings: where the random is taken, and the name salting it. -#[derive(Clone, Debug, PartialEq)] -pub struct RandomSettings { - mode: Mode, - /// ResourceLocation.hashCode of the name (`lithostitched:default`). - salt: i32, -} -#[derive(Clone, Copy, Debug, PartialEq)] -enum Mode { - Block, - Piece, - Structure, -} -impl RandomSettings { - /// A mode alone, or `{"mode": ..., "name": ...}`; per block when unset. - fn decode(v: Option<&Value>) -> Result { - let mode = Mode::decode; - let (mode, name) = match v { - None => (Mode::Block, "lithostitched:default"), - Some(Value::String(m)) => (mode(Some(m))?, "lithostitched:default"), - Some(o) => ( - mode(o["mode"].as_str())?, - o["name"] - .as_str() - .ok_or(DecodeError::Field("random name"))?, - ), - }; - let (namespace, path) = name.split_once(':').unwrap_or(("minecraft", name)); - Ok(Self { - mode, - salt: java_hash(namespace) - .wrapping_mul(31) - .wrapping_add(java_hash(path)), - }) - } - /// RandomSource.create(seed + hash).forkPositional().at(the chosen - /// position): the piece's position, the structure's pivot or the block. - pub(super) fn create( - &self, - seed: i64, - piece: [i32; 3], - pivot: [i32; 3], - block: [i32; 3], - ) -> LegacyRandom { - let [x, y, z] = self.mode.select(piece, pivot, block); - LegacyRandom::new(seed.wrapping_add(i64::from(self.salt))) - .fork_positional() - .at(BlockPos::new(x, y, z)) - } -} -impl Mode { - fn decode(m: Option<&str>) -> Result { - match m { - None | Some("per_block") => Ok(Self::Block), - Some("per_piece") => Ok(Self::Piece), - Some("per_structure") => Ok(Self::Structure), - _ => Err(DecodeError::Field("random mode")), - } - } - fn select(self, piece: [i32; 3], pivot: [i32; 3], block: [i32; 3]) -> [i32; 3] { - match self { - Self::Block => block, - Self::Piece => piece, - Self::Structure => pivot, - } - } -} - -/// SetBlockProcessor with a simple or weighted state provider and no block -/// entity change: the block becomes the state, keeping the properties it -/// shares with the old one unless `preserve_state` is off. -#[derive(Clone, Debug)] -pub struct SetBlock { - /// The states and their weights; one state alone is a simple provider, - /// which draws nothing. - states: Vec<(BlockStateId, i32)>, - weighted: bool, - preserve: bool, - mode: Mode, -} -impl SetBlock { - pub(super) fn decode( - v: &Value, - state: impl Fn(&Value) -> Result, - ) -> Result { - let provider = &v["state_provider"]; - let (states, weighted) = match provider["type"].as_str() { - Some("minecraft:simple_state_provider") => { - (vec![(state(&provider["state"])?, 1)], false) - } - Some("minecraft:weighted_state_provider") => ( - provider["entries"] - .as_array() - .ok_or(DecodeError::Field("set_block entries"))? - .iter() - .map(|e| { - let weight = e["weight"] - .as_i64() - .ok_or(DecodeError::Field("set_block weight"))?; - Ok((state(&e["data"])?, weight as i32)) - }) - .collect::>()?, - true, - ), - _ => return Err(DecodeError::Field("set_block state_provider")), - }; - if states.is_empty() { - return Err(DecodeError::Field("set_block entries")); - } - Ok(Self { - states, - weighted, - preserve: v["preserve_state"].as_bool().unwrap_or(true), - mode: Mode::decode(v["random_mode"].as_str())?, - }) - } - /// The state to set, before `preserve`: drawn with - /// RandomSource.create(seed).forkPositional().at(the chosen position). - pub(super) fn state( - &self, - seed: i64, - piece: [i32; 3], - pivot: [i32; 3], - block: [i32; 3], - ) -> BlockStateId { - if !self.weighted { - return self.states[0].0; - } - let [x, y, z] = self.mode.select(piece, pivot, block); - let mut random = LegacyRandom::new(seed) - .fork_positional() - .at(BlockPos::new(x, y, z)); - let total: i32 = self.states.iter().map(|s| s.1).sum(); - let mut value = random.next_int_bound(total.max(1)).unwrap_or(0); - for (state, weight) in &self.states { - if value < *weight { - return *state; - } - value -= weight; - } - self.states[0].0 - } - pub(super) fn preserves(&self) -> bool { - self.preserve - } -} - -/// String.hashCode over UTF-16 units. -fn java_hash(s: &str) -> i32 { - s.encode_utf16() - .fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c))) -} - -fn list( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, -) -> Result { - ProcessorList::decode(&v.to_string(), resources, bindings) -} - -/// ApplyRandomStructureProcessor: a weighted list of processor lists, one -/// drawn per block with `nextInt(total)`. -#[derive(Clone, Debug)] -pub struct ApplyRandom { - pub(super) random: RandomSettings, - lists: Vec<(ProcessorList, i32)>, - total: i32, -} -impl ApplyRandom { - pub(super) fn decode( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, - ) -> Result { - let lists = v["processor_lists"] - .as_array() - .ok_or(DecodeError::Field("apply_random processor_lists"))? - .iter() - .map(|e| { - let weight = e["weight"] - .as_i64() - .ok_or(DecodeError::Field("apply_random weight"))?; - Ok((list(&e["data"], resources, bindings)?, weight as i32)) - }) - .collect::, DecodeError>>()?; - Ok(Self { - random: RandomSettings::decode(v.get("mode"))?, - total: lists.iter().map(|l| l.1).sum(), - lists, - }) - } - /// WeightedList.getRandom: none when the weights add up to 0. - pub(super) fn pick(&self, random: &mut impl RandomSource) -> Option<&ProcessorList> { - if self.total <= 0 { - return None; - } - let mut value = random.next_int_bound(self.total).unwrap_or(0); - for (list, weight) in &self.lists { - if value < *weight { - return Some(list); - } - value -= weight; - } - None - } -} - -/// ConditionProcessor: `then` when the condition holds for the block, else -/// `else`. -#[derive(Clone, Debug)] -pub struct Conditional { - pub(super) random: RandomSettings, - pub(super) condition: Condition, - pub(super) then: ProcessorList, - pub(super) otherwise: ProcessorList, -} -impl Conditional { - pub(super) fn decode( - v: &Value, - resources: &StructureResources, - bindings: &FeatureBlockBindings<'_>, - ) -> Result { - // A processor alone or a list of them. - let processors = |key: &str| -> Result { - match v.get(key) { - None => Ok(ProcessorList::default()), - Some(Value::Object(p)) if p.contains_key("processor_type") => Ok(ProcessorList( - vec![Processor::decode(&v[key], resources, bindings)?], - )), - Some(other) => list(other, resources, bindings), - } - }; - Ok(Self { - random: RandomSettings::decode(v.get("random_mode"))?, - condition: Condition::decode(&v["if_true"], bindings)?, - then: processors("then")?, - otherwise: processors("else")?, - }) - } -} - -/// Lithostitched's processor conditions the game runs. -#[derive(Clone, Debug)] -pub(super) enum Condition { - True, - AllOf(Vec), - AnyOf(Vec), - Not(Box), - RandomChance(f32), - /// The block placed (`input`) or the one in the world (`location`) is - /// one of these, with these property values. - MatchingBlocks { - blocks: Arc>, - properties: Vec<(String, String)>, - location: bool, - }, -} -impl Condition { - fn decode(v: &Value, bindings: &FeatureBlockBindings<'_>) -> Result { - let all = |a: &Value| -> Result, DecodeError> { - a.as_array() - .ok_or(DecodeError::Field("processor conditions"))? - .iter() - .map(|c| Self::decode(c, bindings)) - .collect() - }; - if v.is_array() { - return Ok(Self::AllOf(all(v)?)); - } - let kind = v["type"].as_str().unwrap_or_default(); - Ok(match kind.strip_prefix("lithostitched:").unwrap_or(kind) { - "true" => Self::True, - "all_of" => Self::AllOf(all(&v["conditions"])?), - "any_of" => Self::AnyOf(all(&v["conditions"])?), - "not" => Self::Not(Box::new(Self::decode(&v["condition"], bindings)?)), - "random_chance" => Self::RandomChance(super::float(v, "chance")?), - "matching_blocks" => Self::MatchingBlocks { - blocks: super::holder_set(&v["blocks"], bindings)?, - properties: match v.get("properties") { - None => Vec::new(), - Some(p) => p - .as_object() - .ok_or(DecodeError::Field("matching_blocks properties"))? - .iter() - .map(|(k, x)| { - let x = x - .as_str() - .ok_or(DecodeError::Field("matching_blocks property"))?; - Ok((k.clone(), x.to_owned())) - }) - .collect::>()?, - }, - location: match v["match_type"].as_str() { - None | Some("input") => false, - Some("location") => true, - _ => return Err(DecodeError::Field("matching_blocks match_type")), - }, - }, - _ => return Err(DecodeError::Field("processor condition type")), - }) - } - /// ProcessorCondition.test with the block placed and the one there. - pub(super) fn test( - &self, - input: BlockStateId, - location: BlockStateId, - registry: &BlockRegistry, - random: &mut impl RandomSource, - ) -> bool { - match self { - Self::True => true, - Self::AllOf(all) => all - .iter() - .all(|c| c.test(input, location, registry, random)), - Self::AnyOf(any) => any - .iter() - .any(|c| c.test(input, location, registry, random)), - Self::Not(c) => !c.test(input, location, registry, random), - Self::RandomChance(chance) => random.next_float() < *chance, - Self::MatchingBlocks { - blocks, - properties, - location: at_location, - } => { - let state = if *at_location { location } else { input }; - blocks.contains(&state) - && properties.iter().all(|(k, x)| { - registry - .state(state) - .and_then(|s| s.properties.get(k)) - .is_some_and(|v| v == x) - }) - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn random_settings_salt_and_position() { - // ResourceLocation.hashCode: 31 * namespace + path. - let default = RandomSettings::decode(Some(&"per_piece".into())).unwrap(); - assert_eq!( - default.salt, - java_hash("lithostitched") - .wrapping_mul(31) - .wrapping_add(java_hash("default")) - ); - assert_eq!(java_hash("default"), 1544803905); - let (seed, piece, pivot, block) = (12345, [16, 64, -32], [8, 70, 8], [17, 65, -30]); - let mut ours = default.create(seed, piece, pivot, block); - let mut theirs = LegacyRandom::new(seed + i64::from(default.salt)) - .fork_positional() - .at(BlockPos::new(16, 64, -32)); - assert_eq!(ours.next_long(), theirs.next_long()); - let named: Value = serde_json::json!({"mode": "per_structure", "name": "v:roof"}); - let named = RandomSettings::decode(Some(&named)).unwrap(); - assert_eq!(named.mode, Mode::Structure); - assert_eq!( - named.salt, - java_hash("v") - .wrapping_mul(31) - .wrapping_add(java_hash("roof")) - ); - } - - #[test] - fn apply_random_draws_by_weight() { - let apply = ApplyRandom { - random: RandomSettings { - mode: Mode::Block, - salt: 0, - }, - lists: vec![ - (ProcessorList(vec![Processor::Nop]), 3), - (ProcessorList::default(), 1), - ], - total: 4, - }; - let mut ours = LegacyRandom::new(9); - let mut theirs = LegacyRandom::new(9); - for _ in 0..32 { - let draw = theirs.next_int_bound(4).unwrap(); - let picked = apply.pick(&mut ours).unwrap(); - assert_eq!(picked.0.len(), usize::from(draw < 3)); - } - } - - #[test] - fn set_block_draws_from_the_unsalted_seed() { - let (a, b) = (BlockStateId(1), BlockStateId(2)); - let set = SetBlock::decode( - &serde_json::json!({"state_provider": {"type": "minecraft:weighted_state_provider", - "entries": [{"weight": 1, "data": 1}, {"weight": 2, "data": 2}]}, - "random_mode": "per_piece"}), - |v| Ok(BlockStateId(v.as_u64().unwrap() as u32)), - ) - .unwrap(); - assert!(set.preserves()); - for x in 0..16 { - let mut java = LegacyRandom::new(77) - .fork_positional() - .at(BlockPos::new(x, 5, 3)); - let want = if java.next_int_bound(3).unwrap() < 1 { - a - } else { - b - }; - assert_eq!(set.state(77, [x, 5, 3], [0; 3], [9, 9, 9]), want); - } - } -} diff --git a/docs/api/mod-index.md b/docs/api/mod-index.md index 6b807d950..e8476cdf0 100644 --- a/docs/api/mod-index.md +++ b/docs/api/mod-index.md @@ -1,7 +1,7 @@ # The registry index and `.hpack` Horizon's registry lists what is made for Horizon and reviewed: mods (`.hmod`), modpacks (`.hpack`), resource packs -and, once their format exists, Horizon shader packs. Submissions are pull requests in +and Horizon shader packs (`.hshader`, [shaders.md](../shaders.md)). Submissions are pull requests in [ludovic111/horizon-mods](https://github.com/ludovic111/horizon-mods); merging one publishes it. The launcher and the website read one file, `index.json`, which that repository's CI builds. The Rust types and every check below are `horizon_mods::index` and `horizon_mods::modpack` (feature `index`); the sample is @@ -21,7 +21,7 @@ Level: preview ([stability.md](stability.md)). Schema 1. "license": "MIT", "source": "https://github.com/...", "icon": "https://...png", "key": "RWT...", "versions": [{ "version": "0.1.0", "published": "2026-10-24", "changelog": "", - "api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "game": "26.3", + "api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "api_level": 0, "game": "26.3", "file": { "name": "coords_hud-0.1.0.hmod", "url": "https://github.com/ludovic111/horizon-mods/releases/download/...", "size": 438, "sha256": "e113...", "signature": "untrusted comment: ...\n...\ntrusted comment: ...\n...\n" } }] @@ -43,6 +43,7 @@ Level: preview ([stability.md](stability.md)). Schema 1. | `versions` | Newest first, at least one. | | `api` | A mod's API line (its manifest's `api`); a modpack's manifest format (`1`). | | `side`, `capabilities` | A mod's, read from its manifest by CI, never typed by hand. | +| `api_level` | The mod API level a mod's code needs ([stability.md](stability.md#mod-api-levels)): its newest imported function's, read from the file by CI. Absent for content-only mods and in indexes built before levels. Installers take the newest version whose level the running game serves. | | `game` | The Minecraft version it is for. | | `requires` | A modpack's mods: `{ id, version, sha256 }`, each a version in this index with that hash. | | `file` | A plain name with the kind's extension (`.hmod`, `.hpack`, `.zip`), an `https://` URL, the size (at most 64 MiB), the lowercase hex SHA-256, and the `.minisig` text when the project has a key. | @@ -57,9 +58,11 @@ changing what one means, makes schema 2. 1. Its size and SHA-256 are the ones the entry lists, and it isn't revoked. 2. With a project key: its signature verifies with that key (minisign's prehashed and legacy signatures both). -3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities) and its +3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities), its API + level when the entry lists one, and its content's fence ([mods.md](../mods.md#content-mods-api-02)); a modpack's manifest (id, version, format, game, - mods); a resource pack's `pack.mcmeta`. + mods); a resource pack's `pack.mcmeta`; a shader pack's `horizon_shader_api::check` and manifest (id, version, + shader API). 4. A kind this build can't install is refused with "this Horizon can't install a … yet". The game still checks a mod's component imports against its capabilities when it starts it, as for any mod. @@ -99,7 +102,7 @@ own check (`index::inspect`): a mod's API, side and capabilities, a modpack's mo ```toml id = "coords_hud" # the file's name, and the manifest's id -kind = "mod" # mod | modpack | resourcepack; shader once its format exists +kind = "mod" # mod | modpack | resourcepack | shader name = "Coordinates HUD" summary = "One line, at most 160 characters." description = """Markdown.""" # optional @@ -156,10 +159,14 @@ How the repository runs (its workflows are in `.github/workflows/`): - **Taking a file down** is a pull request adding it to `revoked.toml`. Removing an entry outright (a test, a project nobody installed) fails `registry review` on purpose and needs an administrator's merge. -Kinds open to submissions: `mod`, `modpack`, `resourcepack`. `shader` is in the schema and stays closed until -Horizon's own shader pack format exists (Iris and OptiFine packs are for the Modrinth browser); its check will compile -the pack in a headless Horizon. A new kind gets its own check before it opens. +Kinds open to submissions: `mod`, `modpack`, `resourcepack`, `shader`. A shader pack (`.hshader`) passes +`horizon_shader_api::check`, the check the game runs before it loads one (`horizon-shader check`, [shaders.md](../shaders.md)): +every stage validated by naga and translated for Vulkan, Metal and DirectX 12; its manifest's id, version and shader +API line are its facts. Iris and OptiFine packs are for the Modrinth browser. A new kind gets its own check before it +opens. ## Changelog +- 2026-10-26: the launcher installs `shader` files into `shaderpacks/`; the sample index lists one (`glow`). +- 2026-10-25: `shader` opens, checked by `horizon_shader_api::check`; its files are `.hshader`. - Schema 1 (2026-10-24): kinds `mod`, `modpack`, `resourcepack`, `shader`; `.hpack` format 1. diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md index d7bf879b8..a197b2c04 100644 --- a/docs/api/mods-reference.md +++ b/docs/api/mods-reference.md @@ -76,7 +76,7 @@ The mod's log, in the game's log under the mod's id. Always granted. Access: capability `game-read`. -Capability `game-read`: the local player and the world clock. +Capability `game-read`: the local player, the world clock and the block the player looks at. ### record `player` @@ -98,10 +98,25 @@ Capability `game-read`: the local player and the world clock. | `game-time` | `u64` | Ticks since the world was created. | | `day-time` | `u64` | 24000 ticks per day; 0 is 6:00 on the first day. | +### record `hit` + +A block along the player's view. + +| Field | Type | | +| --- | --- | --- | +| `block-x` | `s32` | The block hit. | +| `block-y` | `s32` | | +| `block-z` | `s32` | | +| `x` | `f64` | The point on its face where the view meets it. | +| `y` | `f64` | | +| `z` | `f64` | | +| `block` | `string` | `minecraft:stone`, ... | + | Function | Signature | What it does | | --- | --- | --- | | `get-player` | `func() -> option` | None on the title screen. | | `get-clock` | `func() -> option` | None on the title screen. | +| `raycast` | `func(distance: f32) -> option` | The first block along the player's view (fluids pass), up to `distance` blocks (at most 1024; past the loaded chunks, across the distant terrain when LOD Distance is on), as of this tick. None when nothing is hit, and on the title screen. | ## `chat` diff --git a/docs/api/shaders.md b/docs/api/shaders.md index 675c5e3fc..7461332e4 100644 --- a/docs/api/shaders.md +++ b/docs/api/shaders.md @@ -91,11 +91,12 @@ pack exist ([stability.md](stability.md)). ## Not there yet -The stages and everything that runs a pack (the format above is read and checked). The order: the renderer hooks shared with the format loader, then the material and post -stages with options and hot reload, then the overlay, lighting, sky and shadow stages. +The material stage in the game (the sky and post stages run, with hot reload), option values other than the defaults, +then the overlay, lighting and shadow stages. ## Changelog +- 2026-10-26: the sky stage in the game: the pack's `sky` gets vanilla's colour along each ray. - 2026-10-26: the post stage in the game (`HORIZON_SHADER_PACK`, hot reload with the last good pack kept). - 2026-10-25: `horizon-shader` (`new`, `check`, `pack`), three templates, the example pack and the guide. - 2026-10-25: the check (naga validation, signatures, options, budgets, SPIR-V/Metal/HLSL translation). diff --git a/docs/api/stability.md b/docs/api/stability.md index e71f13fda..f6b40fabe 100644 --- a/docs/api/stability.md +++ b/docs/api/stability.md @@ -34,6 +34,22 @@ Not breaking: a new function, interface, capability, command, endpoint, tool or argument or JSON field (readers must ignore fields they don't know); a new WIT function or type (mods built earlier don't import it); faster, or fixing behaviour to what the reference already says. +### Mod API levels + +A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every +function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`): +level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`. A mod needs the level of +the newest function it imports (a component imports only the functions it calls). The level is read from the file, +never declared: + +- the game refuses a mod that needs a function it doesn't have, with "made for a newer Horizon (it uses + render.set-minimap): update Horizon to run it", instead of a linking error; +- the registry's CI writes each mod version's level into the index (`api_level`), and installers take the newest + version the running game can run. + +A pull request that adds a function lists it in `api_level.rs` at the next level and raises `LEVEL`; the +`api_reference` test fails until it does. + ## Stability levels Every part of an API has one level, shown in its reference and its surface page. diff --git a/docs/architecture.md b/docs/architecture.md index f95073e57..0350bd1ea 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -51,7 +51,7 @@ file selects ~103. | 34 | Multiplayer and LAN screens, friends (44) | `L/multiplayer.rs`, `G/lan_screen.rs`, `G/friends.rs`, `L/friends_screen.rs`, `crates/horizon-friends/`, `crates/horizon-relay/` | lan, world_options; `python3 tools/test_friends.py` | | 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser | | 36 | Audio and music (38) | `L/audio.rs`, `L/sound_engine.rs`, `L/sound_events.rs`, `L/music.rs`, `G/music.rs`, `L/ambience.rs`, `G/subtitle_hud.rs` | sound_engine, sound_event, music, situational_music, ambient_sound, subtitle | -| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e --server-thread` (portals, levels, distance, lava) | +| 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e` (server-thread by default; portals, levels, distance, lava) | | 38 | Command parsing (34) | `L/command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`) | command_parse (corpus `tools/command_parse_corpus.py`) | | 39 | Benchmarks and telemetry (34) | `L/benchmark.rs`, `tools/perf_bench.py`, `L/telemetry.rs`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) | | 40 | Explosions and TNT (31) | `G/explosion.rs`, `G/tnt.rs` | lan_e2e blast; no dedicated harness yet | diff --git a/docs/extras.md b/docs/extras.md index aa87c1adf..ac0196c17 100644 --- a/docs/extras.md +++ b/docs/extras.md @@ -1,6 +1,6 @@ # Horizon extras -Optional conveniences built into the client: fullbright, dynamic lights, a minimap, auto-reconnect, +Optional conveniences built into the client: fullbright, dynamic lights, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. **Every one is off by default**: a fresh install looks and behaves exactly like vanilla 26.3, and turning an extra off again restores vanilla's behaviour completely. @@ -12,8 +12,8 @@ again restores vanilla's behaviour completely. | Settings, parsing and saving | `crates/horizon-client/src/extras.rs` | | FPS and click counters (for mods) | `extras.rs` (pure logic, unit tested) | | Dynamic lights: item glow, nearest sources | `crates/horizon-client/src/dynamic_light.rs` (unit tested), `game/dynamic_lights.rs`, `terrain.wgsl` and `entity.wgsl` (`dynamic_block_light`) | -| HUD drawing (minimap frame, corner stacking) | `crates/horizon-client/src/extras_hud.rs` | -| Minimap colours, tiles and image | `crates/horizon-client/src/minimap.rs` | +| HUD drawing (a mod's minimap, corner stacking) | `crates/horizon-client/src/extras_hud.rs` | +| Minimap colours, tiles and image (for `render.set-minimap`) | `crates/horizon-client/src/minimap.rs` | | Reconnect policy and backoff | `crates/horizon-client/src/reconnect.rs` | | Game glue (input hooks, per-frame update) | `crates/horizon-client/src/game/extras.rs` | | Mouse Tweaks-style controls, sort buttons | `crates/horizon-client/src/game/tweaks.rs` | @@ -62,7 +62,7 @@ in Controls, and adding one would put a non-vanilla mapping into `options.txt`. ### Moved to the mod browser -The **FPS counter**, **Keystrokes** and **Zoom** are official mods now (`mods/official/`, [mods.md](mods.md#horizons-official-mods)), +The **FPS counter**, **Keystrokes**, **Zoom** and the **Minimap** are official mods now (`mods/official/`, [mods.md](mods.md#horizons-official-mods)), with the same look and options. On the first start after the update, a player who had one on gets the mod installed from Horizon's registry and turned on, with their corner and options carried over (Zoom's key too, into `horizon-mods.txt`, when it wasn't Z), and reads one line in the chat ("Zoom moved to the mod browser: installed for @@ -71,19 +71,14 @@ SHA-256, signature, manifest); if it fails (offline), the next start tries again keys and lists what was done in `movedToMods`. Code: `crates/horizon-client/src/moved_extras.rs`, `game/moved_extras.rs`. -### Minimap (`minimap`, default off) -- A corner map (top right by default), square or round, small/medium/large, - zoom 0.5 to 4 blocks per pixel, rotating with the player or north up, with the - player arrow (vanilla's map decoration sprite). -- Colours are vanilla's `MapColor` per block, as map items use, with the map - item's height shading and water-depth dithering. -- Underground, in the Nether and under any roof, it maps the floor around the - player's height instead of the top block, so caves read sensibly. -- Cost: one cached 16x16 tile per loaded chunk (packed map colour and height). - Tiles are filled nearest first and refreshed when blocks change, within a time - budget of 0.3 ms a frame; composing the 128x128 image is a few thousand - lookups, done only when the view moved or a tile changed, and uploaded into a - dedicated atlas slot. With the minimap off nothing runs. +The game still draws the minimap, for the mod (`render.set-minimap`, [mods.md](mods.md)): +- a corner map (top right by default), square or round, small/medium/large, zoom 0.5 to 4 blocks per pixel, rotating + with the player or north up, with the player arrow (vanilla's map decoration sprite); +- vanilla's `MapColor` per block, as map items use, with the map item's height shading and water-depth dithering; +- underground, in the Nether and under any roof, the floor around the player's height instead of the top block; +- one cached 16x16 tile per loaded chunk (packed map colour and height), filled nearest first and refreshed when + blocks change within 0.3 ms a frame; the 128x128 image is recomposed only when the view moved or a tile changed, and + uploaded into a dedicated atlas slot. With no mod showing a map, nothing runs. ### Auto-reconnect (`autoReconnect`, default off) - On the "Connection lost" screen after a multiplayer connection drops, a @@ -140,11 +135,11 @@ and the container screen tests are unchanged). the world, like vanilla's HUD. Extras in the top left corner give way to the debug screen (F3), which shows the FPS anyway. - Corners stack: extras placed in the same corner stack downward (top corners) - or upward (bottom corners) in the order minimap, then mods' panels. The top + or upward (bottom corners) in the order a mod's minimap, then mods' panels. The top right corner starts below the status effect icons. ## Perf budget Off: a flag check per frame per extra (no allocations, no world access). -On: the minimap stays under 0.3 ms of CPU +A mod's minimap stays under 0.3 ms of CPU per frame (tile budget) plus a 64 KiB texture upload when its image changes. diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md index 7c9562441..f3ef37977 100644 --- a/docs/launcher-commands.md +++ b/docs/launcher-commands.md @@ -321,7 +321,7 @@ Search for packs Horizon loads. horizon-launcher mods search [TEXT]... - `TEXT` -- `--kind` (mod, resource, modpack) +- `--kind` (mod, resource, modpack, shader) - `--everything`: Also what was made for other versions or runs only partly, each marked - `--source` (modrinth, curseforge, horizon) diff --git a/docs/mod-browser.md b/docs/mod-browser.md index a803420c3..dfdd1617d 100644 --- a/docs/mod-browser.md +++ b/docs/mod-browser.md @@ -1,7 +1,7 @@ # The launcher's mod browser -Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks, resource packs and shader -packs, see how well each one runs before installing it, and install it with its checksum checked. This is item 16 of the roadmap and issue #577. The code is in +Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks and resource packs, and Horizon's +registry for Horizon's own mods, modpacks, resource packs and shader packs; see how well each one runs before installing it, and install it with its checksum checked. This is item 16 of the roadmap and issue #577. The code is in `launcher/src/browser.rs` and `launcher/src/browser/`. ## What it offers @@ -16,6 +16,7 @@ yet (Modrinth has no `horizon` loader). | Java mods (Fabric, NeoForge, Forge, Quilt) | ported into `horizon-mods//` and turned on | Checked from its jar before install: **Works**, **Partly** or **Doesn't run** ([below](#java-mods)) | | Resource packs | `resourcepacks/` beside `options.txt` | **Works** when made for 26.3 ([resource-packs.md](resource-packs.md) lists what Horizon reads). Older packs are **Partly**: they load with vanilla's compatibility warning | | Modpacks (`.mrpack`, CurseForge zip) | the Modpacks page's import | **Partly**: Horizon runs the mods it can port, from the player's own downloads ([modpacks.md](modpacks.md)) | +| Shader packs (`.hshader`, Horizon's registry only) | `shaderpacks/` beside `options.txt` | **Works** when made for 26.3: checked by the game's own check before install ([shaders.md](shaders.md)). The `shaders/`-format packs on Modrinth and CurseForge are not offered | By default a search shows only what runs: Java mods made for 26.3, resource packs made for 26.3, and every modpack. **Show everything** lists the rest of the kind too, each marked with how well it runs; what doesn't run is never offered for install. @@ -74,7 +75,8 @@ start); the hedge places and its recipe crafts 4. ## The Mods page -The launcher's **Mods** page has the three kinds as tabs (Mods, Modpacks, Resource packs), a search field (Enter searches), **Show everything** and +The launcher's **Mods** page has the four kinds as tabs (Mods, Modpacks, Resource packs, Shader packs; the last +searches Horizon's registry), a search field (Enter searches), **Show everything** and the source: Modrinth, with **CurseForge (coming soon)** beside it, disabled. Each result is an index row: its summary, author, downloads, source and licence, how well it runs (and why), **Page** (the project's page on its source) and **Install** (**Import** for a modpack). The Modpacks tab lists the imported packs first, with their coverage @@ -125,7 +127,8 @@ same name the player put there is never overwritten. - **Install** picks the newest version that runs, then its required dependencies, checked before any download: a dependency that isn't a pack Horizon loads (a Java mod) stops the install. Dependencies go in first. A resource - pack still has to be turned on in the game's Resource Packs screen, as in vanilla. + pack still has to be turned on in the game's Resource Packs screen, as in vanilla, and a shader pack picked in + the game's Shader Packs page. - **Update** installs the newer version and removes the old file. - **Remove** deletes the file and its entry. Packs installed as dependencies stay. - **A modpack** is downloaded (checked the same way) into `ports/downloads/`, imported, and ported straight away @@ -149,7 +152,7 @@ horizon-launcher mods remove faithful-32x ## Sources -**Horizon's registry.** Mods (`.hmod`) and resource packs made for Horizon, reviewed as pull requests in +**Horizon's registry.** Mods (`.hmod`), modpacks (`.hpack`), resource packs and shader packs (`.hshader`) made for Horizon, reviewed as pull requests in [ludovic111/horizon-mods](https://github.com/ludovic111/horizon-mods) ([api/mod-index.md](api/mod-index.md)). The launcher reads its `index.json` (`browser/horizon.rs`; `HORIZON_MOD_INDEX=` reads a test registry instead, whose files may then be on disk) at most every ten minutes, and keeps the last copy in @@ -164,7 +167,8 @@ checked pack, `pack.json` and `home/`, the profile's game folder, where each of like any registry mod and turned on or off as the pack says; its overrides (settings, resource packs, a mod's saved settings) are copied in on the first install only, so the player's changes survive updates. A pack whose mod was taken down installs nothing. It is listed on the Modpacks tab with **Play** and **Remove**, and plays like an imported pack -(`modpacks::apply_profile`). Shader packs are listed by the index but not installed by this launcher yet. +(`modpacks::apply_profile`). A shader pack goes to `shaderpacks/` once `check_file` has run the game's own +check on it (`horizon_shader_api::check`); a taken-down one is named, for the player to remove. ```sh horizon-launcher mods search --source horizon --kind mod coords # with whether it is signed and what it may do diff --git a/docs/modpacks.md b/docs/modpacks.md index 13ad619ed..8e3980dd2 100644 --- a/docs/modpacks.md +++ b/docs/modpacks.md @@ -504,21 +504,22 @@ Two cases the oracle fills in: mod. Better Dungeons' small dungeons keep one chest and each other one with a fifth's chance, two at most (the game's `horizon:count_cap`, counted per placement as the mod's DungeonContext is): 12 chests in five small dungeons at seed 1234 become 6. - Lithostitched's `block_swap` (137 lists, all in ChoiceTheorem's Overhauled Village) is the - game's `horizon:block_swap`: the same map, with Block.withPropertiesOf's properties kept; - a target block the game does not have (most of them are Nature's Spirit's and Croptopia's) - leaves the block as it is, as the mod does. Lithostitched's `reference` (CTOV builds most - of its lists from others) has the referenced lists' processors written in its place; its - `apply_random`, `condition` and `set_block` are the game's `horizon:apply_random`, - `horizon:condition` and `horizon:set_block`, with Lithostitched's random (the world seed - plus the name's hash, at the block, piece or structure). In a CTOV plains village at seed - 1234 the farms now grow carrots, potatoes and beetroot besides wheat, and 1,655 - cobblestone blocks become paths, grass, mossy cobblestone and planks. No Lithostitched processor is - dropped now (130 before). CTOV's compat hooks for other mods inside them (its - `modular_compat`, 142 copies) run a list of their own only when the mod they name is - loaded: carry writes that list in when the mod is ported along and takes the hook out (a - no-op, as in the mod) when it is not. In ATM10 all 142 name Nature's Spirit, which the - pack does not have. + Lithostitched's processors (all in ChoiceTheorem's Overhauled Village in ATM10) are the + game's own types, read as the mod writes them. `block_swap` keeps the properties the new + block can have: a farm's ripe wheat becomes ripe carrots, but beetroot, whose age stops at + 3, keeps its default; a target block the game does not have (most are Nature's Spirit's and + Croptopia's) leaves the block as it is. `reference` runs the lists it names, `condition` + tests the template's block or the world's, `apply_random` and `set_block` draw per block or + per piece as the data says. Lithostitched's own random is not known yet, so the shares of a + random choice are the Java pack's but the blocks chosen differ. Lists named by tag and state + providers other than simple and weighted ones are dropped and counted (ATM10 has none). + CTOV's compat hooks for other mods (its `modular_compat`, 30 of them in 17 lists) become a + `reference` when the mod they name is ported along, and are taken out (a no-op, as in the + mod) when it is not. In ATM10 they all name Nature's Spirit, which the pack does not have. + In Java, Lithostitched also lays out every jigsaw structure its own way (villages, + outposts, trial chambers; CTOV's villages are `lithostitched:jigsaw`, carried as vanilla's + jigsaw). Horizon keeps vanilla's layouts, so with Lithostitched in a pack, structure layouts + differ from the Java pack's for the same seed (their positions do not). The processors that build outside their template are carried too: Repurposed's and Moog's pillar processors become the game's `horizon:pillar` (a column from a placeholder block down to the ground, with the processor list they run on each of its blocks written diff --git a/docs/mods.md b/docs/mods.md index 6504688ea..2a3b332c4 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -83,7 +83,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | Interface | Capability | Functions | |---|---|---| | `log` | always | `write(level, message)`, in the game log as `[mod ]` | -| `game` | `game-read` | `get-player()`: x y z, yaw, pitch, health, food, dimension; `get-clock()`: game time, day time | +| `game` | `game-read` | `get-player()`: x y z, yaw, pitch, health, food, dimension; `get-clock()`: game time, day time; `raycast(distance)`: the first block along the view (fluids pass), up to 1024 blocks and across the distant terrain, with the point hit and the block's id | | `chat` | `chat` | `show(text)`: a line only the local player sees, after the mod's name (8 per call) | | `hud` | `hud` | `set-panel(corner, lines)`, `clear()`: up to 16 lines of 256 characters | | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call | @@ -575,6 +575,12 @@ so the same rustc and `Cargo.lock` give the same file. release cycle, so existing mods keep working while authors move. - The manifest's `api` names the line it needs (`0.1`); the game refuses a line it does not serve with a clear message. +- Within a line, each function has an API level, the one it arrived at + ([stability](api/stability.md#mod-api-levels)). A mod needs the level of + the newest function it calls, read from its file: an older Horizon refuses + it with "made for a newer Horizon: update Horizon", and the registry lists + the level so installers take a version the game can run. + `cargo horizon-mod check` prints it ("needs mod API level 1 or newer"). - Horizon follows Minecraft releases; the mod API does not have to. Vanilla concepts mods see (dimensions, block and item ids) are the game's own ids, so a version port changes the data, not the API. diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md index 846a24e18..5eaac1a1d 100644 --- a/docs/parity-workflow.md +++ b/docs/parity-workflow.md @@ -111,3 +111,53 @@ and shrieker. They supplement the deterministic component comparisons. ## Reading vanilla Besides the Vineflower sources in `.local/minecraft//sources/`, `tools/rea_vanilla.py` queries the shipped bytecode through REA (callers through lambdas, overloads, a second decompiler); see [decompilation status](decompilation-status.md#querying-the-shipped-bytecode-with-rea). + +## Player-facing integration and deterministic fixtures + +`python3 tools/lan_e2e.py` runs every LAN check with an integrated server thread, +the same path as normal single player. `python3 tools/test_friends.py --client +target/fast/horizon-client --relay target/fast/horizon-relay --baseline` covers +plain LAN, direct invitations, a local relay and ended invitations in that mode. +Both accept `--in-frame` for comparison and retain `--server-thread` for existing +callers. Run Linux games under `xvfb-run -a` when no display is available. Each +process gets scratch game, launcher, XDG data and config homes; telemetry, audio +and launcher self-update are disabled. + +`lan_integration` and `friends_integration` register these suites with `parity.py`. +`friends_integration` (under a minute) is selected like any harness when the +drivers or game implementation change. `lan_integration` is the whole LAN suite +(~40 minutes on a loaded runner, and single checks flake under load), so +`tools/parity_hosts.json` lists it under `named_only`: no automatic selection +(`--changed`, `--failed`, `--flake-check`, CI, parity-main) picks it; it runs +when named and in the nightly audit (`--all`). LAN writes `results.json` +with the host mode and each result beside its screenshots and logs. A skipped +case is recorded explicitly and does not count as passing coverage. + +The game-binary fixture audit keeps these complementary direct rule tests: + +- `command_harness.rs`: command feedback, styled spans and result callbacks, + held player position, explicit ticks and portal completion matching + `VanillaCommandExecOracle`. LAN `commands`, `feedback`, `styles`, `levels` and + `portals` cover command input, packet feedback and travel across the boundary. +- `dispense_fixture.rs`: seeded synthetic worlds, block/event traces, item + use/mining and combat hooks matching `VanillaDispenserOracle`. These isolate + rule results and RNG order; LAN machines, crafting, clicks, fireball, mining + and combat exercise real input and server handling separately. The new + `dispenser_input_host` / `dispenser_input_guest` checks press a button and + verify authoritative inventory consumption and exactly one drop on both clients. +- `sculk_fixture.rs`: scripted events and exact per-tick sculk/warden traces + matching `VanillaSculkOracle`; introducing wall-clock network ticks would + destroy that deterministic oracle contract. `sculk_input_host` and + `sculk_input_guest` separately exercise real footsteps reaching a sensor; + failures remain visible rather than changing the oracle trace. +- `net_harness.rs`: already a real network client of a dedicated server; keep + its handshake, world loading, chat and command packet assertions. + +Library probes, `lan_bot`'s protocol hub fixture, generation/save tests and +streaming/mesh tests remain fast deterministic coverage. They do not become +full game launches. Setup and authoritative reads use the owning server; +interactions stay on the client. `server-hold on|off` provides a prediction-test +barrier between server ticks, including player packet handling, while transport +threads and control calls remain responsive. `stall MILLISECONDS` stalls only +the window to test recovery from a hung frame without process signals interrupting +socket reads. Neither mechanism changes normal gameplay. diff --git a/docs/shaders.md b/docs/shaders.md index 92dd74685..d64ca041c 100644 --- a/docs/shaders.md +++ b/docs/shaders.md @@ -13,8 +13,9 @@ Horizon's own format. | Authoring tool | `horizon-shader` (same crate) | `new`, `check`, `pack` | | Templates | `crates/horizon-shader-api/templates/` | post, sky, material | | Example pack | `crates/horizon-shader-api/packs/golden_hour` | a warm sky and two post passes | -| In the game: the post stage | Options > Horizon Settings > Shader Packs | post passes, hot reload | -| In the game: sky and material; the launcher and the registry | | not yet | +| In the game: the sky and post stages | Options > Horizon Settings > Shader Packs | sky, post passes, hot reload | +| The registry and the launcher | `shader` kind ([api/mod-index.md](api/mod-index.md)); the Mods page's Shader packs tab | checked, then installed into `shaderpacks/` | +| In the game: the material stage | | not yet | ## Quick start @@ -52,8 +53,8 @@ it on Options > Horizon Settings > Shader Packs, which lists Horizon's packs, ma name>` runs a pack whatever the page says, for development. The game checks the pack first, and refuses one that fails, with its problems in the chat. While it runs, the game looks at the pack twice a second: save a file and the pack is checked and rebuilt in place ("Shader pack ... reloaded"); if the new version fails, the chat says -where and the last good version keeps drawing. The post passes run today; the sky and material stages are checked -but not drawn yet. +where and the last good version keeps drawing. The sky and post stages run today; the material stage is checked but +not drawn yet. ## A pack @@ -88,7 +89,7 @@ by Horizon: a pack changes how things look, not how they are drawn. | Stage | Your function | What it does | | --- | --- | --- | -| `[sky]` | `fn sky(input: SkyInput) -> vec4` | the sky's colour along each view ray; the sun, moon, stars and clouds are drawn over it | +| `[sky]` | `fn sky(input: SkyInput) -> vec4` | the sky's colour along each view ray, opaque (alpha is ignored), drawn where vanilla draws its sky dome (the Overworld's sky; not the Nether's or the End's); the sun, moon, stars and clouds are drawn over it | | `[material]` | `fn material(input: MaterialInput) -> Surface` | the lit colour of each point of a block's surface, before the alpha test and fog | | `[[post]]` | `fn post(input: PostInput) -> vec4` | a full-screen pass over the world's picture (up to 8, in order), under the hand and HUD | @@ -131,8 +132,9 @@ one keeps drawing), the launcher before it installs one, and the registry's CI b `[budget] gpu_ms` is the GPU time your pack aims to add to a frame. To compare, open F3 in the game: while it is open, each pass is timed on the GPU and the overlay shows the pack's total and its costliest passes, by their `name` -(the median of the last 15 timed frames). Timing waits for nothing, so it does not slow the game. +(the median of the last 15 timed frames). Timing waits for nothing, so it does not slow the game. In a timed frame the sky +stage draws in a pass of its own (it shares the world's pass otherwise), so its time includes clearing the picture. ## Next -The material and sky stages in the game, and the registry's `shader` kind with installs from the launcher. +The material stage in the game. diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock index ee0cb882a..dd9313df6 100644 --- a/launcher/Cargo.lock +++ b/launcher/Cargo.lock @@ -565,7 +565,16 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" dependencies = [ - "bit-vec", + "bit-vec 0.8.0", +] + +[[package]] +name = "bit-set" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d" +dependencies = [ + "bit-vec 0.9.1", ] [[package]] @@ -574,6 +583,12 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" +[[package]] +name = "bit-vec" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51" + [[package]] name = "bit_field" version = "0.10.3" @@ -611,7 +626,7 @@ dependencies = [ "ash-window", "bitflags 2.13.2", "bytemuck", - "codespan-reporting", + "codespan-reporting 0.12.0", "glow", "gpu-alloc", "gpu-alloc-ash", @@ -621,7 +636,7 @@ dependencies = [ "libloading", "log", "mint", - "naga", + "naga 25.0.1", "objc2", "objc2-app-kit", "objc2-core-foundation", @@ -1037,6 +1052,15 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "unicode-width", +] + [[package]] name = "color_quant" version = "1.1.0" @@ -2295,7 +2319,7 @@ dependencies = [ "log", "lyon", "metal", - "naga", + "naga 25.0.1", "num_cpus", "objc", "oo7", @@ -2560,6 +2584,11 @@ name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash 0.2.0", + "serde", + "serde_core", +] [[package]] name = "heck" @@ -2700,12 +2729,14 @@ dependencies = [ name = "horizon-mods" version = "0.1.0" dependencies = [ + "horizon-shader-api", "log", "minisign-verify", "serde", "serde_json", "sha2 0.10.9", "toml 1.1.8+spec-1.1.0", + "wasmparser", "zip", ] @@ -2742,6 +2773,19 @@ dependencies = [ "ring", ] +[[package]] +name = "horizon-shader-api" +version = "0.1.0" +dependencies = [ + "bytemuck", + "naga 30.0.1", + "serde", + "serde_json", + "sha2 0.10.9", + "toml 1.1.8+spec-1.1.0", + "zip", +] + [[package]] name = "horizon-telemetry" version = "0.1.0" @@ -3543,10 +3587,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b977c445f26e49757f9aca3631c3b8b836942cb278d69a92e7b80d3b24da632" dependencies = [ "arrayvec", - "bit-set", + "bit-set 0.8.0", "bitflags 2.13.2", "cfg_aliases", - "codespan-reporting", + "codespan-reporting 0.12.0", "half", "hashbrown 0.15.5", "hexf-parse", @@ -3555,12 +3599,50 @@ dependencies = [ "num-traits", "once_cell", "rustc-hash 1.1.0", - "spirv", + "spirv 0.3.0+sdk-1.3.268.0", "strum 0.26.3", "thiserror 2.0.21", "unicode-ident", ] +[[package]] +name = "naga" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130" +dependencies = [ + "arrayvec", + "bit-set 0.10.0", + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "codespan-reporting 0.13.1", + "half", + "hashbrown 0.17.1", + "indexmap", + "libm", + "log", + "naga-types", + "num-traits", + "once_cell", + "rustc-hash 1.1.0", + "spirv 0.4.0+sdk-1.4.341.0", + "thiserror 2.0.21", + "unicode-ident", +] + +[[package]] +name = "naga-types" +version = "30.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49" +dependencies = [ + "hashbrown 0.17.1", + "indexmap", + "rustc-hash 1.1.0", + "thiserror 2.0.21", +] + [[package]] name = "nanorand" version = "0.7.0" @@ -5405,6 +5487,15 @@ dependencies = [ "bitflags 2.13.2", ] +[[package]] +name = "spirv" +version = "0.4.0+sdk-1.4.341.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" +dependencies = [ + "bitflags 2.13.2", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -6516,6 +6607,19 @@ dependencies = [ "web-sys", ] +[[package]] +name = "wasmparser" +version = "0.254.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757" +dependencies = [ + "bitflags 2.13.2", + "hashbrown 0.17.1", + "indexmap", + "semver", + "serde", +] + [[package]] name = "wayland-backend" version = "0.3.17" diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index a2d870a84..dba6bcd25 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -422,6 +422,37 @@ pub fn version_dir(tag: &str) -> PathBuf { const COMPLETE: &str = ".installed"; +/// The mod API level of the game players run: the selected version's, else the newest installed +/// one's. None with no version installed: the launcher doesn't know yet which game will run mods. +pub fn game_mod_api_level() -> Option { + let installed = installed(); + let tag = Settings::load() + .selected + .filter(|s| installed.contains(s)) + .or_else(|| installed.into_iter().next())?; + Some(mod_api_level(&tag)) +} + +/// A game version's mod API level, read once from the mark its program carries +/// (`horizon_mods::api_level::MARK`). A program from before the mark serves level 0, the +/// contract of Horizon 0.2.67 and 0.2.68. +pub fn mod_api_level(tag: &str) -> u32 { + static LEVELS: Mutex> = Mutex::new(Vec::new()); + let mut levels = LEVELS.lock().unwrap_or_else(|e| e.into_inner()); + if let Some(&(_, level)) = levels.iter().find(|(t, _)| t == tag) { + return level; + } + let level = program_mod_api_level(&version_dir(tag).join(CLIENT)); + levels.push((tag.to_owned(), level)); + level +} + +/// The mod API level in the game program at `path`: its mark's, else 0. +fn program_mod_api_level(path: &Path) -> u32 { + let program = fs::read(path).unwrap_or_default(); + horizon_mods::api_level::read_mark(&program).unwrap_or(0) +} + /// Installed versions, newest tag first. pub fn installed() -> Vec { installed_in(&versions_dir()) @@ -2557,6 +2588,24 @@ mod tests { use super::*; use std::cmp::Ordering::*; + /// The game program's mod API level is its mark's; a program from before the mark (0.2.68 + /// and older) or none at all serves level 0. + #[test] + fn a_game_program_says_its_mod_api_level() { + let dir = std::env::temp_dir().join(format!("horizon-api-level-{}", std::process::id())); + fs::create_dir_all(&dir).unwrap(); + let marked = dir.join("marked"); + let mut program = b"\x7fELF code code".to_vec(); + program.extend_from_slice(b"horizon-mod-api-level:0007;"); + fs::write(&marked, &program).unwrap(); + let old = dir.join("old"); + fs::write(&old, b"\x7fELF code without a mark").unwrap(); + assert_eq!(program_mod_api_level(&marked), 7); + assert_eq!(program_mod_api_level(&old), 0); + assert_eq!(program_mod_api_level(&dir.join("missing")), 0); + fs::remove_dir_all(&dir).unwrap(); + } + /// A preparation that reuses the imported game files still reads the assets from the /// launcher that has them: a Prism Launcher instance's are in the launcher root, linked into /// the official layout (jan.sonki on Discord: silent, grey title screen since 0.2.48). diff --git a/launcher/src/browser.rs b/launcher/src/browser.rs index 7f81d5e37..295ba3c08 100644 --- a/launcher/src/browser.rs +++ b/launcher/src/browser.rs @@ -28,16 +28,20 @@ pub enum Kind { Modpack, /// A Java mod: its content is ported ([`java`]). Mod, + /// One of Horizon's own shader packs (`.hshader`, docs/shaders.md), from Horizon's registry + /// only. + Shader, } impl Kind { - pub const ALL: [Kind; 3] = [Kind::Mod, Kind::Modpack, Kind::ResourcePack]; + pub const ALL: [Kind; 4] = [Kind::Mod, Kind::Modpack, Kind::ResourcePack, Kind::Shader]; pub fn label(self) -> &'static str { match self { Kind::Mod => "Mods", Kind::ResourcePack => "Resource packs", Kind::Modpack => "Modpacks", + Kind::Shader => "Shader packs", } } @@ -46,6 +50,7 @@ impl Kind { pub fn folder(self) -> Option<&'static str> { match self { Kind::ResourcePack => Some("resourcepacks"), + Kind::Shader => Some("shaderpacks"), Kind::Modpack | Kind::Mod => None, } } @@ -237,6 +242,9 @@ pub trait Source: Send + Sync { /// What the launcher says wherever CurseForge would be. pub const CURSEFORGE_SOON: &str = "CurseForge support is coming soon."; +/// What another source answers for shader packs: Horizon's own are on its registry only. +pub const SHADERS_ON_HORIZON: &str = + "Horizon's shader packs are on Horizon's registry: pick Horizon."; /// The sources this launcher uses: Modrinth and Horizon's registry. CurseForge support is coming /// soon: its API needs a paid key, so no search or install goes to it; `curseforge` is kept for @@ -277,6 +285,7 @@ pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Supp Kind::Modpack => { Support::Partial("Horizon runs the mods it can port, from your own downloads.".into()) } + Kind::Shader => Support::No("Not one of Horizon's own shader packs.".into()), Kind::Mod => { if !loaders.iter().any(|l| java::LOADERS.contains(&l.as_str())) { Support::No("Not a Fabric, NeoForge or Forge mod.".into()) diff --git a/launcher/src/browser/curseforge.rs b/launcher/src/browser/curseforge.rs index e17a6b822..1db533a93 100644 --- a/launcher/src/browser/curseforge.rs +++ b/launcher/src/browser/curseforge.rs @@ -24,11 +24,16 @@ fn class(kind: Kind) -> u64 { Kind::ResourcePack => 12, Kind::Modpack => 4471, Kind::Mod => 6, + Kind::Shader => 6552, } } +/// The kind of a CurseForge class; its shader packs (the shaders/ format) are not offered. fn kind_of(class_id: u64) -> Option { - Kind::ALL.into_iter().find(|k| class(*k) == class_id) + Kind::ALL + .into_iter() + .filter(|k| *k != Kind::Shader) + .find(|k| class(*k) == class_id) } /// The key: the environment's, else the one built in. Empty counts as none. @@ -196,6 +201,9 @@ impl Source for CurseForge { } fn search(&self, query: &Query) -> Result, String> { + if query.kind == Kind::Shader { + return Err(super::SHADERS_ON_HORIZON.into()); + } let found = self.get(&search_url(query))?; Ok(found["data"] .as_array() diff --git a/launcher/src/browser/horizon.rs b/launcher/src/browser/horizon.rs index 66553ab50..3bf465faf 100644 --- a/launcher/src/browser/horizon.rs +++ b/launcher/src/browser/horizon.rs @@ -111,13 +111,14 @@ fn fetch_index() -> Result<(Index, String), String> { } /// The browser's kind for a registry kind; None for one the launcher doesn't install yet -/// (shader packs, kinds newer than this launcher). +/// (kinds newer than this launcher). fn kind_of(kind: &index::Kind) -> Option { match kind { index::Kind::Mod => Some(Kind::Mod), index::Kind::ResourcePack => Some(Kind::ResourcePack), index::Kind::Modpack => Some(Kind::Modpack), - index::Kind::Shader | index::Kind::Other(_) => None, + index::Kind::Shader => Some(Kind::Shader), + index::Kind::Other(_) => None, } } @@ -167,7 +168,14 @@ fn project_of(p: &index::Project) -> Option { }) } -fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version { +/// Version `v` of `p` as the browser shows it; blocked when taken down, or when it needs a newer +/// mod API level than `level`, the game's. +fn version_of( + index: &Index, + p: &index::Project, + v: &index::Version, + level: Option, +) -> Version { Version { id: v.version.clone(), number: v.version.clone(), @@ -186,7 +194,8 @@ fn version_of(index: &Index, p: &index::Project, v: &index::Version) -> Version required: v.requires.iter().map(|r| r.id.clone()).collect(), blocked: index .revoked(&p.id, &v.file.sha256) - .map(|r| format!("taken down: {}", r.reason)), + .map(|r| format!("taken down: {}", r.reason)) + .or_else(|| needs_newer(v, level).then(|| NEEDS_NEWER.to_string())), } } @@ -253,9 +262,10 @@ impl Source for Registry { let p = index .project(&project.id) .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; + let level = crate::backend::game_mod_api_level(); Ok(p.versions .iter() - .map(|v| version_of(&index, p, v)) + .map(|v| version_of(&index, p, v, level)) .collect()) } @@ -372,24 +382,29 @@ fn relative(kind: Kind, id: &str, file_name: &str) -> Result { match kind { Kind::Mod => Ok(format!("{}/{id}.hmod", java::MODS_DIR)), Kind::ResourcePack => Ok(format!("resourcepacks/{file_name}")), + Kind::Shader => Ok(format!("shaderpacks/{file_name}")), Kind::Modpack => Err("A modpack installs as its own profile (pack::install).".into()), } } -/// Installs a registry project into the game folder `home`: its newest version for this game, -/// downloaded into `mod-browser/downloads/`, checked against the index, then moved into place. -/// A mod is `horizon-mods/.hmod`, turned on in `horizon-mods.txt`. +/// Installs a registry project into the game folder `home`: its newest version for this game that +/// the game the player runs can load, downloaded into `mod-browser/downloads/`, checked against +/// the index, then moved into place. A mod is `horizon-mods/.hmod`, turned on in +/// `horizon-mods.txt`. pub fn install( project: &Project, home: &Path, progress: &dyn Fn(&str, f32), ) -> Result, String> { - install_from(&*index()?, local(), project, home, progress) + let level = crate::backend::game_mod_api_level(); + install_from(&*index()?, local(), level, project, home, progress) } +/// [`install`] from `index`, for a game serving mod API `level`. fn install_from( index: &Index, local: bool, + level: Option, project: &Project, home: &Path, progress: &dyn Fn(&str, f32), @@ -397,28 +412,43 @@ fn install_from( let p = index .project(&project.id) .ok_or_else(|| format!("{} isn't in Horizon's registry.", project.title))?; - let v = newest(index, p)?; + let v = newest(index, p, level)?; install_version(index, local, p, v, home, progress).map(|e| vec![e]) } -/// A project's newest version for this game that wasn't taken down. -fn newest<'a>(index: &Index, p: &'a index::Project) -> Result<&'a index::Version, String> { - let mut taken_down = None; +/// A project's newest version for this game that wasn't taken down and that a game serving mod +/// API `level` runs (any, when the level isn't known). +fn newest<'a>( + index: &Index, + p: &'a index::Project, + level: Option, +) -> Result<&'a index::Version, String> { + let (mut taken_down, mut too_new) = (None, false); for v in p.versions.iter().filter(|v| v.game == GAME) { - match index.revoked(&p.id, &v.file.sha256) { - None => return Ok(v), - Some(r) => { - taken_down.get_or_insert(r); - } + if let Some(r) = index.revoked(&p.id, &v.file.sha256) { + taken_down.get_or_insert(r); + } else if needs_newer(v, level) { + too_new = true; + } else { + return Ok(v); } } Err(match taken_down { + _ if too_new => format!("{} {NEEDS_NEWER}: update it first.", p.name), Some(r) => format!("{} was taken down: {}", p.name, r.reason), None => format!("{} has no version for {GAME} to install.", p.name), }) } -/// Installs version `v` of the registry's mod or resource pack `p` into the game folder `home`. +const NEEDS_NEWER: &str = "needs a newer Horizon than the game you play"; + +/// Whether version `v` calls mod API functions a game serving `level` doesn't have. +fn needs_newer(v: &index::Version, level: Option) -> bool { + matches!((v.api_level, level), (Some(needed), Some(level)) if needed > level) +} + +/// Installs version `v` of the registry's mod, resource pack or shader pack `p` into the game +/// folder `home`. fn install_version( index: &Index, local: bool, @@ -447,15 +477,19 @@ fn install_version( other.title )); } - if (target.exists() && old.as_ref().is_none_or(|o| o.file != relative)) || folder_mod.exists() { + let clash = target.exists() && old.as_ref().is_none_or(|o| o.file != relative); + if project.kind == Kind::Mod && (clash || folder_mod.exists()) { return Err(format!( "A mod with the id {} is already in {}: move it away first.", p.id, java::MODS_DIR )); } + if clash { + return Err(format!("{relative} is already there: move it away first.")); + } let line = format!("{} {}", p.name, v.version); - let file = &version_of(index, p, v).files[0]; + let file = &version_of(index, p, v, None).files[0]; let staging = home.join("mod-browser/downloads"); let path = fetch(file, &staging, local, &|f| progress(&line, f))?; let trust = index::check_file(index, p, v, &path).inspect_err(|_| { @@ -518,7 +552,7 @@ pub fn turn_off_revoked(index: &Index, home: &Path) -> Vec { e.title, r.reason )); } - } else if e.kind == Kind::ResourcePack { + } else if matches!(e.kind, Kind::ResourcePack | Kind::Shader) { out.push(format!( "{} was taken down: {} Remove it.", e.title, r.reason diff --git a/launcher/src/browser/horizon/pack.rs b/launcher/src/browser/horizon/pack.rs index 3cb6d7c9b..95235a505 100644 --- a/launcher/src/browser/horizon/pack.rs +++ b/launcher/src/browser/horizon/pack.rs @@ -84,7 +84,7 @@ fn install_in( if p.kind != idx::Kind::Modpack { return Err(format!("{} is a {}, not a modpack.", p.name, p.kind.name())); } - let v = newest(index, p)?; + let v = newest(index, p, None)?; let work = dir.join(&p.id); let fresh = !work.exists(); let result = install_version_in(index, local, p, v, &work, progress); diff --git a/launcher/src/browser/horizon/tests.rs b/launcher/src/browser/horizon/tests.rs index fb99462e1..7e1b8f585 100644 --- a/launcher/src/browser/horizon/tests.rs +++ b/launcher/src/browser/horizon/tests.rs @@ -48,6 +48,7 @@ fn searches_by_kind_and_words() { // Modpacks under Modpacks; a kind this launcher can't install yet (a world) never. assert_eq!(found("", Kind::Modpack), ["cozy"]); assert!(found("skyblock", Kind::ResourcePack).is_empty()); + assert_eq!(found("", Kind::Shader), ["glow"]); let p = hud(&index); assert_eq!(p.support(), super::super::Support::Works); assert_eq!(p.page, "https://playhorizon.dev/mods/coords_hud"); @@ -58,7 +59,7 @@ fn installs_checked_turns_on_and_removes() { let index = sample(); let home = scratch("install"); let p = hud(&index); - let done = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(done[0].file, "horizon-mods/coords_hud.hmod"); assert_eq!(done[0].verdict.as_deref(), Some("Verified")); assert!(done[0].checksum.starts_with("SHA-256:e1135345")); @@ -72,7 +73,7 @@ fn installs_checked_turns_on_and_removes() { 0 ); // Installed already: nothing to do. - let again = install_from(&index, true, &p, &home, &|_, _| {}).unwrap(); + let again = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); assert_eq!(again, done); let mut revoked = index.clone(); @@ -95,6 +96,41 @@ fn installs_checked_turns_on_and_removes() { fs::remove_dir_all(&home).unwrap(); } +#[test] +fn installs_a_shader_pack_into_shaderpacks() { + let index = sample(); + let home = scratch("shader"); + let p = project_of(index.project("glow").unwrap()).unwrap(); + assert_eq!(p.support(), super::super::Support::Works); + let done = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap(); + assert_eq!(done[0].file, "shaderpacks/glow-1.0.0.hshader"); + assert_eq!(done[0].kind, Kind::Shader); + assert!(home.join("shaderpacks/glow-1.0.0.hshader").is_file()); + // Not a mod: nothing turns on in horizon-mods.txt; the game's Shader Packs page picks it. + assert!(!home.join("horizon-mods.txt").exists()); + + let mut revoked = index.clone(); + revoked.revoked.push(index::Revoked { + id: "glow".into(), + sha256: None, + reason: "Test.".into(), + date: String::new(), + }); + let said = turn_off_revoked(&revoked, &home); + assert_eq!(said, ["Soft Glow was taken down: Test. Remove it."]); + + installed::remove(&home, "glow").unwrap(); + assert!(!home.join("shaderpacks/glow-1.0.0.hshader").exists()); + // A file of the same name the registry didn't put there is left alone. + fs::write(home.join("shaderpacks/glow-1.0.0.hshader"), b"mine").unwrap(); + let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err(); + assert_eq!( + e, + "shaderpacks/glow-1.0.0.hshader is already there: move it away first." + ); + fs::remove_dir_all(&home).unwrap(); +} + #[test] fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { let index = sample(); @@ -104,15 +140,15 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { let mut tampered = index.clone(); let cozy = tampered.projects[1].versions[0].file.url.clone(); tampered.projects[0].versions[0].file.url = cozy; - let e = install_from(&tampered, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&tampered, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("larger than its source says"), "{e}"); assert!(!home.join("horizon-mods").exists()); - let e = install_from(&index, false, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, false, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("file servers"), "{e}"); fs::create_dir_all(home.join("horizon-mods/coords_hud")).unwrap(); - let e = install_from(&index, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&index, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert!(e.contains("already in horizon-mods"), "{e}"); let mut taken_down = index.clone(); @@ -122,7 +158,7 @@ fn refuses_a_changed_file_a_taken_id_and_local_files_from_the_real_registry() { reason: "Test.".into(), date: String::new(), }); - let e = install_from(&taken_down, true, &p, &home, &|_, _| {}).unwrap_err(); + let e = install_from(&taken_down, true, None, &p, &home, &|_, _| {}).unwrap_err(); assert_eq!(e, "Coordinates HUD was taken down: Test."); fs::remove_dir_all(&home).unwrap(); } @@ -139,7 +175,7 @@ fn registry_versions_run_when_made_for_this_game() { let versions: Vec = p .versions .iter() - .map(|x| version_of(&index, p, x)) + .map(|x| version_of(&index, p, x, None)) .collect(); assert_eq!(pick(Kind::Mod, &versions, false).unwrap().number, "0.1.0"); } @@ -162,3 +198,21 @@ fn owner_links_only_take_github_logins() { assert!(!github_login(bad), "{bad}"); } } + +/// A version that calls mod API functions the game doesn't have is marked and skipped. +#[test] +fn versions_for_a_newer_horizon_are_not_installed() { + let mut index = sample(); + index.projects[0].versions[0].api_level = Some(1); + let p = index.project("coords_hud").unwrap(); + let e = newest(&index, p, Some(0)).unwrap_err(); + assert_eq!( + e, + "Coordinates HUD needs a newer Horizon than the game you play: update it first." + ); + assert!(newest(&index, p, Some(1)).is_ok()); + assert!(newest(&index, p, None).is_ok()); + let v = version_of(&index, p, &p.versions[0], Some(0)); + assert_eq!(v.blocked.as_deref(), Some(NEEDS_NEWER)); + assert_eq!(version_of(&index, p, &p.versions[0], Some(1)).blocked, None); +} diff --git a/launcher/src/browser/modrinth.rs b/launcher/src/browser/modrinth.rs index 52e0aa7f0..dabd9a604 100644 --- a/launcher/src/browser/modrinth.rs +++ b/launcher/src/browser/modrinth.rs @@ -13,12 +13,15 @@ fn project_type(kind: Kind) -> &'static str { Kind::ResourcePack => "resourcepack", Kind::Modpack => "modpack", Kind::Mod => "mod", + Kind::Shader => "shader", } } +/// The kind of a Modrinth project; its shader packs (the shaders/ format) are not offered. fn kind_of(project_type: &str) -> Option { Kind::ALL .into_iter() + .filter(|k| *k != Kind::Shader) .find(|k| self::project_type(*k) == project_type) } @@ -170,6 +173,9 @@ impl Source for Modrinth { } fn search(&self, query: &Query) -> Result, String> { + if query.kind == Kind::Shader { + return Err(super::SHADERS_ON_HORIZON.into()); + } let found = get(&search_url(query))?; Ok(found["hits"] .as_array() diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs index 25bbe0bee..64ddb1bd2 100644 --- a/launcher/src/cli.rs +++ b/launcher/src/cli.rs @@ -210,6 +210,8 @@ enum KindArg { Mod, Resource, Modpack, + /// Horizon's own shader packs (Horizon's registry only) + Shader, } #[derive(Clone, Copy, clap::ValueEnum)] @@ -1120,6 +1122,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> { KindArg::Resource => Kind::ResourcePack, KindArg::Modpack => Kind::Modpack, KindArg::Mod => Kind::Mod, + KindArg::Shader => Kind::Shader, }; let query = Query { everything, diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs index e420576b5..45763296a 100644 --- a/launcher/src/cli_tools.rs +++ b/launcher/src/cli_tools.rs @@ -394,7 +394,7 @@ mod tests { let kinds = &schema["inputSchema"]["properties"]["kind"]["enum"]; assert!( kinds.as_array().unwrap().contains(&json!("modpack")) - && !kinds.as_array().unwrap().contains(&json!("shader")), + && kinds.as_array().unwrap().contains(&json!("shader")), "{kinds}" ); assert_eq!( diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 9105f71a2..7d778b6b9 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -54,11 +54,11 @@ enum Page { } impl Page { - /// `HORIZON_LAUNCHER_PAGE=mods` (or `modpacks`, `servers`, `versions`, `notes`, `settings`) - /// opens on that page, for screenshots; Home otherwise. + /// `HORIZON_LAUNCHER_PAGE=mods` (or `modpacks`, `shaders`, `servers`, `versions`, `notes`, + /// `settings`) opens on that page, for screenshots; Home otherwise. fn from_env() -> Page { match std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() { - Ok("mods" | "modpacks") => Page::Mods, + Ok("mods" | "modpacks" | "shaders") => Page::Mods, Ok("servers") => Page::Servers, Ok("versions") => Page::Versions, Ok("notes") => Page::Notes, diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs index 50434756c..e6ebedc5b 100644 --- a/launcher/src/mods_page.rs +++ b/launcher/src/mods_page.rs @@ -14,10 +14,11 @@ use horizon_port_pack::check::Check; use std::collections::HashMap; /// The kinds, as the Mods page's tabs: name and icon. -const KINDS: [(PackKind, &str, &str); 3] = [ +const KINDS: [(PackKind, &str, &str); 4] = [ (PackKind::Mod, "Mods", "box"), (PackKind::Modpack, "Modpacks", "archive"), (PackKind::ResourcePack, "Resource packs", "image"), + (PackKind::Shader, "Shader packs", "zap"), ]; /// Java mods checked at once. const CHECKING: usize = 2; @@ -99,14 +100,18 @@ impl Mods { pub(super) fn new(cx: &mut App) -> Self { let (tx, rx) = channel(); + let page = std::env::var("HORIZON_LAUNCHER_PAGE"); + let kind = match page.as_deref() { + Ok("modpacks") => PackKind::Modpack, + Ok("shaders") => PackKind::Shader, + _ => PackKind::Mod, + }; Self { - kind: if std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() == Ok("modpacks") { - PackKind::Modpack - } else { - PackKind::Mod - }, - // `HORIZON_LAUNCHER_SOURCE=horizon` opens on Horizon's registry, for screenshots. + kind, + // `HORIZON_LAUNCHER_SOURCE=horizon` opens on Horizon's registry, for screenshots; + // shader packs are only there. source: match std::env::var("HORIZON_LAUNCHER_SOURCE").as_deref() { + _ if kind == PackKind::Shader => SourceId::Horizon, Ok("horizon") => SourceId::Horizon, _ => SourceId::Modrinth, }, @@ -602,9 +607,9 @@ impl Launcher { } let header = page_header( "Mods", - "Mods made for Horizon from its own reviewed registry, and Java mods, modpacks and \ - resource packs from Modrinth: Horizon ports what a Java mod carries (blocks, items, \ - recipes, worldgen) and says before you install what runs. Each file is checked \ + "Mods and shader packs made for Horizon from its own reviewed registry, and Java \ + mods, modpacks and resource packs from Modrinth: Horizon ports what a Java mod \ + carries (blocks, items, recipes, worldgen) and says before you install what runs. Each file is checked \ against its source's checksum before it reaches your game folder.", &t, ); @@ -615,6 +620,10 @@ impl Launcher { let _ = this.update(cx, |this, cx| { if this.mods.kind != kind { this.mods.kind = kind; + // Horizon's own shader packs are on its registry only. + if kind == PackKind::Shader { + this.mods.source = SourceId::Horizon; + } // Categories and loaders differ by kind. this.mods.browse.filters = Default::default(); this.mods.browse.open = None; diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java index d8c0483b6..0c02fa9aa 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/KnockbackClient.java @@ -5,9 +5,12 @@ import io.netty.buffer.Unpooled; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.DataInputStream; +import java.io.FileDescriptor; +import java.io.FileOutputStream; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.io.PrintStream; import java.io.PrintWriter; import java.net.InetSocketAddress; import java.net.Socket; @@ -76,7 +79,8 @@ import net.minecraft.world.phys.Vec3; * {@code step LABEL}, {@code join NAME}, {@code cmd NAME COMMAND...} (waits * for its feedback), {@code pos NAME X Y Z YAW PITCH GROUND} (one client tick * at that place, on the ground or not), {@code sprint NAME on|off}, {@code - * attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a + * sync NAME} (a round trip through the server thread; "synced NAME" on stdout when + * it is back), {@code attack NAME TARGET} (ServerboundAttackPacket then the swing; TARGET is a * player's name or an entity type's path, the last one added), {@code use * NAME} (ServerboundUseItemPacket, main hand) and {@code end}. Each player * records the ClientboundSetEntityMotionPacket it receives, its own sprint @@ -88,6 +92,8 @@ public final class KnockbackClient { private static final Map NAMES = new LinkedHashMap<>(); public static void main(String[] args) throws Exception { + // Bootstrap sends System.out to the logger: `synced` lines go to the real stdout. + PrintStream stdout = new PrintStream(new FileOutputStream(FileDescriptor.out), true, StandardCharsets.UTF_8); ParityData.init(); String host = args[0]; int port = Integer.parseInt(args[1]); @@ -116,6 +122,13 @@ public final class KnockbackClient { case "attack" -> players.get(w[1]).attack(w[2]); case "use" -> players.get(w[1]).send(new ServerboundUseItemPacket(InteractionHand.MAIN_HAND, 0, 0, 0)); case "punch" -> players.get(w[1]).send(net.minecraft.network.protocol.game.ServerboundPunchPacket.INSTANCE); + case "sync" -> { + try { + players.get(w[1]).sync(); + } finally { + stdout.println("synced " + w[1]); + } + } case "mark" -> players.get(w[1]).mark(); case "await" -> players.get(w[1]).await(); case "end" -> { @@ -157,6 +170,7 @@ public final class KnockbackClient { private final Map last = new java.util.concurrent.ConcurrentHashMap<>(); private final Object replyLock = new Object(); private int replies; + private int syncs; /** The motion packets about this player it was sent, and how many there were at the last `mark`. */ private int pushes; private int marked; @@ -181,6 +195,24 @@ public final class KnockbackClient { } } + /** A round trip through the server thread, its reply left out of the transcript: every packet this player + * was sent before the reply has been recorded when it returns. */ + void sync() throws Exception { + synchronized (replyLock) { + int before = syncs; + send(new ServerboundChatCommandPacket("time query gametime")); + long until = System.nanoTime() + 30_000_000_000L; + while (syncs == before) { + long left = (until - System.nanoTime()) / 1_000_000L; + if (left <= 0) { + record("error no reply to sync"); + return; + } + replyLock.wait(left); + } + } + } + void mark() { synchronized (replyLock) { marked = pushes; @@ -327,6 +359,13 @@ public final class KnockbackClient { for (var value : d.packedItems()) { if (value.id() == 0) record("sprinting " + ((((Byte) value.value()) & 8) != 0)); } + } else if (p instanceof ClientboundSystemChatPacket c + && c.content().getContents() instanceof net.minecraft.network.chat.contents.TranslatableContents t + && t.getKey().equals("commands.time.query.gametime")) { + synchronized (replyLock) { + syncs++; + replyLock.notifyAll(); + } } else if (p instanceof ClientboundSystemChatPacket c) { record("chat " + c.content().getString()); synchronized (replyLock) { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java b/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java index 09e9911d6..3390b37f6 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/ParityFont.java @@ -10,6 +10,8 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Path; import java.util.ArrayList; import java.util.List; +import java.util.HashSet; +import java.util.Set; import net.minecraft.client.gui.Font; import net.minecraft.client.gui.GlyphSource; import net.minecraft.client.gui.font.glyphs.BakedGlyph; @@ -31,9 +33,13 @@ import net.minecraft.util.RandomSource; */ public final class ParityFont { public static ResourceManager resources() throws Exception { + return resources(Path.of("/nonexistent-horizon-assets")); + } + + public static ResourceManager resources(Path assets) throws Exception { var method = net.minecraft.client.resources.ClientPackSource.class.getDeclaredMethod("createVanillaPackSource", Path.class); method.setAccessible(true); - var pack = (net.minecraft.server.packs.VanillaPackResources) method.invoke(null, Path.of("/nonexistent-horizon-assets")); + var pack = (net.minecraft.server.packs.VanillaPackResources) method.invoke(null, assets); return pack.asResourceManager(); } @@ -50,6 +56,38 @@ public final class ParityFont { } } } + return create(providers); + } + + /** The full default font, including references and the external Unihex fallback. */ + public static Font createDefault(ResourceManager resources) throws Exception { + List providers = new ArrayList<>(); + loadProviders(resources, Identifier.withDefaultNamespace("default"), providers, new HashSet<>()); + return create(providers); + } + + private static void loadProviders(ResourceManager resources, Identifier font, List providers, + Set visiting) throws Exception { + if (!visiting.add(font)) throw new IllegalArgumentException("Cyclic font reference: " + font); + var file = font.withPath("font/" + font.getPath() + ".json"); + try (var reader = new InputStreamReader(resources.open(file), StandardCharsets.UTF_8)) { + var json = JsonParser.parseReader(reader).getAsJsonObject(); + for (var element : json.getAsJsonArray("providers")) { + var conditional = GlyphProviderDefinition.Conditional.CODEC.parse(JsonOps.INSTANCE, element).getOrThrow(); + if (!conditional.filter().apply(Set.of())) continue; + var definition = conditional.definition().unpack(); + if (definition.left().isPresent()) { + providers.add(definition.left().orElseThrow().load(resources)); + } else { + loadProviders(resources, definition.right().orElseThrow().id(), providers, visiting); + } + } + } finally { + visiting.remove(font); + } + } + + private static Font create(List providers) { GlyphSource source = new GlyphSource() { @Override public BakedGlyph getGlyph(int codepoint) { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java index 9b3509e94..d3513d3ac 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java @@ -370,7 +370,7 @@ public final class VanillaPackScreenOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - font = ParityFont.create(ParityFont.resources()); + font = ParityFont.createDefault(ParityFont.resources(Path.of(args[2]))); Minecraft mc = alloc(Minecraft.class); put(mc, Minecraft.class, "font", font); put(mc, Minecraft.class, "lastInputType", InputType.MOUSE); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java index b48d45041..532c8823c 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTabListOracle.java @@ -230,7 +230,7 @@ public final class VanillaTabListOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - Font font = ParityFont.create(ParityFont.resources()); + Font font = ParityFont.createDefault(ParityFont.resources(Path.of(args[2]))); var gson = new Gson(); var out = new StringBuilder(); for (String line : Files.readAllLines(Path.of(args[0]))) { @@ -284,6 +284,8 @@ public final class VanillaTabListOracle { put(mc, Minecraft.class, "user", user); var skins = skinManager(c); put(mc, Minecraft.class, "skinManager", skins); + var profiles = new ArrayList(); + var lookups = new ArrayList>(); for (var p : c.getAsJsonArray("players")) { var o = p.getAsJsonObject(); var uuid = UUID.fromString(o.get("uuid").getAsString()); @@ -296,12 +298,22 @@ public final class VanillaTabListOracle { : new Property("textures", t.get("value").getAsString(), sig.getAsString())); } var profile = new GameProfile(uuid, o.get("name").getAsString(), new PropertyMap(properties)); - // Let the lookup's unpacking and downloads run before the first frame, - // as they would have by the time a player list shows. - try { - skins.get(profile).get(1, java.util.concurrent.TimeUnit.SECONDS); - } catch (java.util.concurrent.TimeoutException pending) { - } + profiles.add(profile); + lookups.add(skins.get(profile)); + } + // Start every lookup before waiting: intentionally pending fake + // downloads must not add a second for each player in the list. + // Keep the same observation window and leave those futures pending. + try { + CompletableFuture.allOf(lookups.toArray(CompletableFuture[]::new)) + .get(1, java.util.concurrent.TimeUnit.SECONDS); + } catch (java.util.concurrent.TimeoutException pending) { + } + int profileIndex = 0; + for (var p : c.getAsJsonArray("players")) { + var o = p.getAsJsonObject(); + var profile = profiles.get(profileIndex++); + var uuid = profile.id(); var info = new PlayerInfo(profile, false); put(info, PlayerInfo.class, "gameMode", GameType.byId(o.get("gameMode").getAsInt())); put(info, PlayerInfo.class, "latency", o.get("latency").getAsInt()); diff --git a/tests/test_game_home.py b/tests/test_game_home.py index b4d9e017f..b0561a9a2 100644 --- a/tests/test_game_home.py +++ b/tests/test_game_home.py @@ -29,6 +29,7 @@ EXEMPT = { "build_release.py": "builds and packs the release", "release_train.py": "release bookkeeping", "pr_ready.py": "runs cargo checks and parity.py", + "test_friends_integration_parity.py": "builds binaries; test_friends.Game isolates every game through integration_env", "port_harness.py": "ports Java code, starts no game", } diff --git a/tests/test_integration_env.py b/tests/test_integration_env.py new file mode 100644 index 000000000..018b02763 --- /dev/null +++ b/tests/test_integration_env.py @@ -0,0 +1,50 @@ +"""Automated game runs must never inherit a real player's data directories.""" +import json +import os +from pathlib import Path +import sys +import tempfile +import unittest + +from tools.integration_env import game_environment, run_game, require_server_reports + + +class IntegrationEnvironmentTests(unittest.TestCase): + def test_all_data_homes_and_network_settings_are_overridden(self): + keys = ('HORIZON_HOME', 'HORIZON_LAUNCHER_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME') + with tempfile.TemporaryDirectory() as root: + env = game_environment({**dict.fromkeys(keys, '/real/player'), 'DISPLAY': ':123'}, root) + homes = [Path(env[key]) for key in keys] + self.assertEqual(len(set(homes)), 4) + self.assertTrue(all(p.is_dir() and p.is_relative_to(root) for p in homes)) + self.assertEqual(env['DISPLAY'], ':123') + self.assertEqual(env['HORIZON_TELEMETRY_URL'], 'off') + self.assertEqual(env['HORIZON_LAUNCHER_NO_SELF_UPDATE'], '1') + self.assertEqual(env['HORIZON_NO_AUDIO'], '1') + + def test_each_fixture_process_gets_fresh_homes_and_cleanup(self): + script = ('import json, os; from pathlib import Path; ' + 'homes = [os.environ[k] for k in ' + '("HORIZON_HOME", "HORIZON_LAUNCHER_HOME", "XDG_DATA_HOME", "XDG_CONFIG_HOME")]; ' + 'assert all(Path(p).is_dir() for p in homes); print(json.dumps(homes))') + runs = [json.loads(run_game([sys.executable, '-c', script], env=os.environ, + capture_output=True, text=True, check=True).stdout) for _ in range(2)] + self.assertFalse(set(runs[0]) & set(runs[1])) + self.assertTrue(all(not Path(p).exists() for homes in runs for p in homes)) + + +class PreparedReportTests(unittest.TestCase): + def test_partial_report_install_shadows_complete_fallback(self): + with tempfile.TemporaryDirectory() as root: + resources = Path(root) / 'horizon-client' / '26.3' + fallback = Path(root) / 'datagen' / 'out' / 'reports' + resources.mkdir(parents=True) + fallback.mkdir(parents=True) + for name in ('registries.json', 'commands.json'): + (fallback / name).write_text('{}') + self.assertEqual(require_server_reports(resources).resolve(), fallback.resolve()) + (resources / 'registries.json').write_text('{}') + with self.assertRaisesRegex(ValueError, 'installed together'): + require_server_reports(resources) + (resources / 'commands.json').write_text('{}') + self.assertEqual(require_server_reports(resources), resources) diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py index 2d16e7179..a85f1e969 100644 --- a/tests/test_parity_runner.py +++ b/tests/test_parity_runner.py @@ -145,6 +145,11 @@ class ParityRunnerTests(unittest.TestCase): with mock.patch.object(parity.sys, "platform", "darwin"): self.assertEqual(parity.platform_skips(config), {"options": "libm"}) + def test_named_only_harnesses_are_listed_from_the_host_config(self): + self.assertEqual(parity.named_only({"named_only": {"lan_integration": "slow"}}), {"lan_integration": "slow"}) + self.assertEqual(parity.named_only({}), {}) + self.assertIn("lan_integration", parity.named_only(parity.host_config())) + def test_a_pass_from_another_worktree_counts_only_for_the_same_content(self): with tempfile.TemporaryDirectory() as temp: elsewhere, here, shared = Path(temp, "a"), Path(temp, "b"), Path(temp, "shared") diff --git a/tools/agent_control_e2e.py b/tools/agent_control_e2e.py index 7f0c52bce..116aed49b 100644 --- a/tools/agent_control_e2e.py +++ b/tools/agent_control_e2e.py @@ -75,6 +75,8 @@ def game_env(screen, home=None): extra['HORIZON_HOME'] = home if sys.platform == 'darwin': return lab.game_env(**extra) + if not shutil.which('vscreen') and os.environ.get('DISPLAY'): + return lab.game_env(**extra) env = lab.game_env(VSCREEN=screen, **extra) subprocess.run(['vscreen', 'up'], env=env, check=False, capture_output=True) text = subprocess.run(['vscreen', 'env'], env=env, capture_output=True, text=True, check=True).stdout diff --git a/tools/integration_env.py b/tools/integration_env.py new file mode 100644 index 000000000..ed7122c1e --- /dev/null +++ b/tools/integration_env.py @@ -0,0 +1,54 @@ +"""Per-process scratch data for game integration tests (never a player's home).""" +from pathlib import Path +from contextlib import contextmanager +import os +import subprocess +import tempfile + +try: + from . import lab +except ImportError: + import lab + + +def game_environment(base, root): + root = Path(root) + env = dict(base, HORIZON_TELEMETRY_URL='off') + for key, folder in [('HORIZON_HOME', 'home'), ('HORIZON_LAUNCHER_HOME', 'launcher'), + ('XDG_DATA_HOME', 'data'), ('XDG_CONFIG_HOME', 'config')]: + path = root / folder + path.mkdir(parents=True, exist_ok=True) + env[key] = str(path) + return lab.game_env(env) + + +def run_game(command, **kwargs): + """Run a headless game fixture with the same isolation as real-client tests.""" + with tempfile.TemporaryDirectory(prefix='hz-fixture-') as root: + kwargs['env'] = game_environment(kwargs.pop('env', os.environ), root) + if any(key in kwargs['env'] for key in + ('HORIZON_COMMAND_SCRIPT', 'HORIZON_DISPENSE_FIXTURE', 'HORIZON_SCULK_FIXTURE')): + # These compare seeded rule/callback traces, not the client/server boundary. + command = [*command, '--in-frame'] + return subprocess.run(command, **kwargs) + + +@contextmanager +def suite_lock(): + """Real-client CI suites share a GPU, even when parity.py runs harnesses in parallel.""" + import fcntl + with (Path(tempfile.gettempdir()) / 'horizon-integration-gpu.lock').open('a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + yield + + +def require_server_reports(resources): + """Match Builtin.find: a registry report shadows later fallback directories.""" + resources = Path(resources) + reports = next((p for p in (resources, resources / '../../datagen/out/reports', + resources / '../datagen/out/reports') + if (p / 'registries.json').is_file()), None) + if reports is None or not (reports / 'commands.json').is_file(): + raise ValueError(f'incomplete prepared resources in {resources}: registries.json and ' + 'commands.json must be installed together; prepare the pinned resources again') + return reports diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 804add98a..449d47c0b 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -1,7 +1,8 @@ #!/usr/bin/env python3 """LAN multiplayer end to end: a host opens its world to LAN and a guest joins, both real games. -Two Horizon clients run side by side under horizon-ctl, each in its own scratch folder. The host +The host uses its integrated server thread by default; --in-frame compares the fallback, and +--server-thread remains accepted. Two Horizon clients run under horizon-ctl in scratch folders. The host creates a survival world and opens it to LAN with commands allowed; the guest connects to it by address. The script then checks, from both sides, what a guest's game used to get wrong (#366): @@ -272,7 +273,6 @@ import math import os import re import shutil -import signal import subprocess import sys import tempfile @@ -284,11 +284,12 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) from agent_control_e2e import Cli, Failed, game_env # noqa: E402 import lab # noqa: E402 +from integration_env import game_environment, require_server_reports # noqa: E402 ROOT = Path(__file__).resolve().parents[1] GUEST_NAME = 'Guest' -# The host plays single player on its server thread (--server-thread). -SERVER_THREAD = False +# Match normal single player; --in-frame is the comparison path. +SERVER_THREAD = True CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater'] @@ -302,6 +303,7 @@ class Game: os.symlink(resources, self.work / '.local/horizon-client' / lab.VERSION) self.socket = self.work / 'c.sock' env = game_env(os.environ.get('VSCREEN', 'lan-e2e'), home=self.work / 'home') + env = game_environment(env, self.work) self.d = Cli(ctl, self.socket, self.work, env) self.d.name = name @@ -327,6 +329,28 @@ class Game: def wait(self, ticks): self.d('wait', ticks=ticks) + def script(self, lines): + """Keep tick-sensitive input in one ctl process, through the normal control commands.""" + result = subprocess.run(self.d.base + ['script'], input='\n'.join(lines) + '\n', + cwd=self.work, env=self.d.env, capture_output=True, text=True, + timeout=600) + replies = [json.loads(line) for line in result.stdout.splitlines() if line.strip()] + ticks = [r['ticks'] for r in replies if 'ticks' in r] + print(f'[{self.name}] script {lines} -> {replies[-1] if replies else result.stderr[:400]}; ticks={ticks}') + assert result.returncode == 0 and replies and not any('error' in r for r in replies), result.stdout + return replies[-1] + + def until(self, observe, predicate, ticks=100): + """Wait for an observable answer, within the existing tick budget.""" + last = observe() + for _ in range(ticks): + if predicate(last): + return last + self.wait(1) + last = observe() + assert predicate(last), f'{self.name}: state did not arrive within {ticks} ticks: {last}' + return last + def close(self): try: self.d('quit') @@ -534,6 +558,8 @@ def check_sign(host, guest, out): host.shot(out, 'sign') assert placed and 'sign' in placed, f'the guest placed {placed}' host_unaffected(host, "the guest's sign") + guest.raw('key', 'esc', 'tap') + guest.raw('wait-for', 'screen', 'playing') return placed @@ -678,7 +704,7 @@ def check_levels(host, guest, out): for name, step in LEVEL_STEPS: try: steps[name] = step(host, guest, out) - except (Failed, AssertionError, StopIteration, KeyError) as e: + except (Failed, AssertionError, StopIteration, KeyError, TypeError, IndexError) as e: steps[name], failed = repr(e), failed + [name] for g in (host, guest): back_to_game(g) @@ -751,10 +777,12 @@ def level_ticking(host, guest, out): has its own id across the levels.""" gx, gy, gz = pos_of(guest) hx, hy, hz = pos_of(host) - # A floor of its own beside the host (earlier checks may have broken the open one there). - bx, by, bz = int(hx // 1), int(hy // 1), int(hz // 1) - host('command', command=f'fill {bx - 4} {by - 1} {bz - 4} {bx + 4} {by - 1} {bz - 2} minecraft:stone') - host('command', command=f'fill {bx - 4} {by} {bz - 4} {bx + 4} {by + 4} {bz - 2} minecraft:air') + # Clear the whole walking area in each level: normal pig AI can leave a + # narrow landing strip during the fall/observation window. + for game, x, y, z in ((host, hx, hy, hz), (guest, gx, gy, gz)): + bx, by, bz = int(x // 1), int(y // 1), int(z // 1) + game('command', command=f'fill {bx - 12} {by - 1} {bz - 12} {bx + 12} {by - 1} {bz + 12} minecraft:stone') + game('command', command=f'fill {bx - 12} {by} {bz - 12} {bx + 12} {by + 6} {bz + 12} minecraft:air') guest('command', command=f'summon minecraft:pig {gx + 2.5:.2f} {gy + 3:.2f} {gz:.2f}') guest('command', command=f'summon minecraft:armor_stand {gx - 2.5:.2f} {gy + 3:.2f} {gz:.2f}') host('command', command=f'summon minecraft:pig {hx + 2.5:.2f} {hy + 3:.2f} {hz - 3:.2f}') @@ -766,6 +794,7 @@ def level_ticking(host, guest, out): mobs = [m for m in g.raw('mobs', 8)['near'] if m['kind'] == 'minecraft:pig'] stands = [o for o in g('status')['objects'] if o['kind'] == 'minecraft:armor_stand'] seen[name] = {'pigs': [(m['id'], round(m['pos'][1], 2)) for m in mobs], + 'pig_positions': [m['pos'] for m in mobs], 'stands': [(o['id'], round(o['position'][1], 2)) for o in stands], 'floor': floor} finally: guest('command', command='kill @e[type=!minecraft:player,distance=..8]') @@ -1993,12 +2022,11 @@ def chat_input(game): def complete(guest, text): """Opens the chat on `/`, types `text` and presses Tab: the input after it.""" guest.raw('key', 'slash', 'tap') - guest.wait(3) + guest.until(lambda: guest('screen').get('screen'), lambda s: s == 'chat', ticks=3) guest.raw('type', text) - guest.wait(2) + guest.until(lambda: guest('screen').get('chat_suggestions'), bool, ticks=2) guest.raw('key', 'tab', 'tap') - guest.wait(2) - return chat_input(guest) + return guest.until(lambda: chat_input(guest), lambda value: value != '/' + text, ticks=2) def check_commands(host, guest, out): @@ -2408,7 +2436,8 @@ def check_predict(host, guest, out): seen = {} creaks = lambda game: sum(n for s, n in game('status')['heard'].items() if 'door' in s) heard = {'guest': creaks(guest), 'host': creaks(host)} - os.kill(host.pid, signal.SIGSTOP) + host.raw('server-hold', 'on') + held_at = host.raw('simulation')['game_time'] try: guest.raw('interact', *wood) seen['guest_frozen'] = (state(guest, wood), state(guest, (wood[0], wood[1] + 1, wood[2]))) @@ -2416,8 +2445,9 @@ def check_predict(host, guest, out): seen['guest_heard_frozen'] = creaks(guest) - heard['guest'] guest.raw('interact', *iron) seen['guest_iron_frozen'] = state(guest, iron) + assert host.raw('simulation')['game_time'] == held_at, 'server barrier advanced the world' finally: - os.kill(host.pid, signal.SIGCONT) + host.raw('server-hold', 'off') guest.wait(20) seen['guest_after'] = state(guest, wood) seen['host_after'] = state(host, wood) @@ -2529,7 +2559,11 @@ def check_swings(host, guest, out): guest.wait(10) guest.raw('select', 'minecraft:wooden_hoe') before = guest('state')['swings'] - guest.raw('interact', *soil) + guest.raw('look-at', soil[0] + 0.5, soil[1] + 1, soil[2] + 0.5) + guest.wait(1) + target = guest('state')['looking_at']['block'] + assert target and target['pos'] == list(soil) and target['face'] == 'up', target + guest.raw('mouse', 'right', 'click') guest.wait(10) hoe = {'swings': guest('state')['swings'] - before, 'soil': host.raw('block', *soil)['block']} guest('command', command=f'setblock {soil[0]} {soil[1]} {soil[2]} minecraft:stone') @@ -2636,16 +2670,22 @@ def check_xp(host, guest, out): x, y, z = pos_of(guest) # Three orbs of 7 points 4 blocks east of the guest (out of reach, within the 8 blocks orbs # follow from): they fly to the guest. + # Freeze setup so command/IPC latency cannot let all three be collected + # before the two-tick in-flight observation. + host('command', command='tick freeze') for _ in range(3): guest('command', command=f'summon minecraft:experience_orb {x + 4:.2f} {y + 0.5:.2f} {z:.2f} {{Value:7s}}') + host('command', command='tick step 2') guest.wait(2) seen = remote(guest).get('entities', {}).get('minecraft:experience_orb', 0) guest.shot(out, 'xp-orbs') + host('command', command='tick unfreeze') guest.wait(60) xp = guest('state')['player']['xp'] host_xp = host('state')['player']['xp'] left = remote(guest).get('entities', {}).get('minecraft:experience_orb', 0) finally: + host('command', command='tick unfreeze') host('command', command='gamemode survival') # Back where it stood: a spectator sinks (Player.travel keeps 0.6 of its fall speed each tick, # about 0.2 blocks from standing), and a later check that makes it survival again would land @@ -2671,9 +2711,7 @@ def check_time(host, guest, out): guest.wait(20) # A stalled game runs at most 10 missed ticks when it wakes (DeltaTracker); the server's # game time, sent every second, moves the guest's clock on (ClientClockManager.tick). - os.kill(guest.pid, signal.SIGSTOP) - time.sleep(4) - os.kill(guest.pid, signal.SIGCONT) + guest.raw('stall', 4000) guest.wait(60) stalled = times() detail = {'paused': paused, 'after_stall': stalled} @@ -3126,12 +3164,10 @@ def same_light(host, guest, lo, hi, what, ticks=100): def check_flight(host, guest, out): def double_jump(game): # LocalPlayer.aiStep: a second jump press within 7 ticks of the first toggles flight. + lines = [] for hold in (1, 4): - game.raw('key', 'space', 'down') - game.wait(hold) - game.raw('key', 'space', 'up') - game.wait(2) - game.wait(10) + lines += ['key space down', f'wait {hold}', 'key space up', 'wait 2'] + game.script(lines + ['wait 10']) return game('state')['player'] def set_mode(game, mode): @@ -3146,6 +3182,9 @@ def check_flight(host, guest, out): players = [('guest', guest)] + ([('host', host)] if SERVER_THREAD else []) seen = {} + # The rule is seven simulation ticks, independent of wall time. A slow + # server clock leaves enough time to deliver the key events even on busy CI. + host('command', command='tick rate 4') try: for name, game in players: set_mode(game, 'creative') @@ -3159,6 +3198,7 @@ def check_flight(host, guest, out): 'stayed': round(later['position'][1] - up['position'][1], 2), 'survival_flying': fell['flying']} finally: + host('command', command='tick rate 20') for _, game in players: game('command', command='gamemode survival') for name, s in seen.items(): @@ -3673,15 +3713,16 @@ def leave_vehicle(player, kind): 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') + here = [o for o in player('status')['objects'] if o['id'] == vehicle_id] + if not here: + return + vp = here[0]['position'] + # Keep the original ten hits/two-tick spacing in one connection. Starting + # several ctl processes per hit lets the vehicle's damage decay between hits. + player.script([f'look-at {vp[0]:.2f} {vp[1] + 0.3:.2f} {vp[2]:.2f}', + *[line for _ in range(10) for line in ('mouse left click', 'wait 2')]]) + assert not any(o['id'] == vehicle_id for o in player('status')['objects']), \ + f'ten hits left the {kind} in place' def check_boats(host, guest, out): @@ -4338,10 +4379,8 @@ def check_deflect(host, guest, out): (Player.attack: AIM_DEFLECT on #redirectable_projectile; Ghast.isReflectedFireball). The ghast is caged (a window toward the host); the game runs at 4 ticks a second, and once the fireball is within 4.5 blocks the host looks at the ghast and clicks.""" - if SERVER_THREAD: - # The fireball's position and the host's hurts are read from the host's own level. - return 'skipped (in-frame only)' - x, y, z = (int(v // 1) for v in pos_of(host)) + back = pos_of(host) + x, y, z = (int(v // 1) for v in back) guest('command', command='gamemode creative') host('command', command='gamemode survival') host('command', command='difficulty normal') @@ -4362,23 +4401,36 @@ def check_deflect(host, guest, out): try: deadline = time.monotonic() + 120 while time.monotonic() < deadline: - balls = [q for q in host.raw('status')['projectiles'] if q['kind'] == 'LargeFireball'] + # Aim and click at the projectile the client actually sees. Holding + # non-player simulation keeps the reach window open while ordinary + # player input and its attack packet cross the connection. + balls = [q for q in host('status')['projectiles'] if q['kind'] == 'LargeFireball'] near = min((math.dist(q['position'], eye) for q in balls), default=None) if near is not None and near < 4.5: + ball = min(balls, key=lambda q: math.dist(q['position'], eye)) + host('command', command='tick freeze') + held_tick = host.raw('simulation')['game_time'] g = [m['pos'] for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast')][0] - host.raw('look-at', f'{g[0]:.2f}', f'{g[1] + 2:.2f}', f'{g[2]:.2f}') - host.raw('mouse', 'left', 'down') - host.raw('mouse', 'left', 'up') + host.script([f'look-at {g[0]:.2f} {g[1] + 2:.2f} {g[2]:.2f}', + 'wait 1', 'mouse left click', 'wait 1']) + host.until(lambda: host.raw('simulation')['projectiles'], + lambda qs: any(q.get('id') == ball['id'] and q.get('player_owned') for q in qs), + ticks=60) + assert host.raw('simulation')['game_time'] == held_tick, 'the deflection barrier advanced simulation' + host('command', command='tick unfreeze') turned = near break host('command', command='tick rate 20') host.wait(60) ghast = [m for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast') and m['health'] > 0] - hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == 'host' for h in pl['hurts'] + hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == (host.player if SERVER_THREAD else 'host') for h in pl['hurts'] if 'fireball' in h['source'] or 'explosion' in h['source']] finally: + host('command', command='tick unfreeze') host('command', command='tick rate 20') host('command', command='kill @e[type=minecraft:ghast]') + host('command', command=f'tp @s {back[0]} {back[1]} {back[2]}') + host.until(lambda: pos_of(host), lambda p: math.dist(p, back) < 0.1) host('command', command=f'fill {gx - 3} {gy - 1} {gz - 3} {gx + 24} {gy + 8} {gz + 3} minecraft:air') guest('command', command='gamemode survival') assert turned is not None, f'no fireball came within 4.5 blocks (nearest {near})' @@ -4564,8 +4616,22 @@ def run(ctl, out, resources, checks): guest.shot(out, 'joined') for name in checks: try: - results[name] = {'pass': True, 'detail': CHECK_FNS[name](host, guest, out)} - except (Failed, AssertionError, StopIteration, KeyError) as e: + # Cases assert their own deaths, menus and held actions before returning. + # Do not let those states turn later independent cases into false failures. + for game in (host, guest): + game.raw('release') + back_to_game(game) + state = game('state') + assert state.get('player') is not None, f'{game.name} lost its session before {name}: {state}' + if state.get('screen') == 'dead' or state['player']['health'] <= 0: + game.raw('respawn') + game.until(lambda: game('state'), + lambda s: s.get('screen') == 'playing' and s['player']['health'] > 0, + ticks=40) + detail = CHECK_FNS[name](host, guest, out) + skipped = isinstance(detail, str) and detail.startswith('skipped') + results[name] = {'pass': not skipped, 'skipped': skipped, 'detail': detail} + except (Failed, AssertionError, StopIteration, KeyError, TypeError, IndexError) as e: results[name] = {'pass': False, 'detail': repr(e)} for g in (host, guest): back_to_game(g) @@ -4584,14 +4650,19 @@ def main(): parser.add_argument('--bin-dir', help='prebuilt horizon-client and horizon-ctl (default: build with the fast profile)') parser.add_argument('--check', action='append', choices=CHECKS, help='run only these checks (repeatable)') parser.add_argument('--out', default=str(ROOT / '.local/lan-e2e'), help='screenshots and game logs go here') - parser.add_argument('--server-thread', action='store_true', help="the host's world runs on its server thread") + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--server-thread', dest='server_thread', action='store_true', default=True, + help='host on its server thread (default; retained for existing callers)') + mode.add_argument('--in-frame', dest='server_thread', action='store_false', + help='host the world in the window, for comparison') args = parser.parse_args() global SERVER_THREAD SERVER_THREAD = args.server_thread if args.bin_dir: bins = Path(args.bin_dir).resolve() else: - subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bins'], + subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', + '--bin', 'horizon-client', '--bin', 'horizon-ctl'], cwd=ROOT, check=True) meta = json.loads(subprocess.run(['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=ROOT, capture_output=True, text=True, check=True).stdout) @@ -4599,9 +4670,16 @@ def main(): resources = lab.RESOURCES.resolve() if not (resources / 'horizon-resources.json').exists(): sys.exit(f'no prepared resources in {resources}') - out = Path(args.out) + try: + require_server_reports(resources) + except ValueError as error: + sys.exit(str(error)) + out = Path(args.out).resolve() out.mkdir(parents=True, exist_ok=True) + print(f'LAN host mode: {"server-thread" if SERVER_THREAD else "in-frame"}') results = run(bins / 'horizon-ctl', out, resources, args.check or CHECKS) + (out / 'results.json').write_text(json.dumps({'mode': 'server-thread' if SERVER_THREAD else 'in-frame', + 'checks': results}, indent=2) + '\n') print(json.dumps(results, indent=1)) sys.exit(0 if results and all(r['pass'] for r in results.values()) else 1) @@ -4658,16 +4736,33 @@ def check_keep_inventory(host, guest, out): neither; with it on, nothing drops and it respawns with both (#1284).""" hx, hy, hz = (int(v // 1) for v in pos_of(host)) seen = {} + # Totem coverage leaves both players near one health. Protect the waiting + # player from residual fire/damage while the other player's death is tested. + for game in (host, guest): + game('command', command='gamemode creative') + game('command', command='effect clear @s') + game('command', command='effect give @s minecraft:instant_health 1 5 true') host('command', command=f'setworldspawn {hx} {hy} {hz}') host('command', command='gamerule respawn_radius 0') + # Keep the inactive player alive and away from the death drops. Earlier + # fixtures may leave a personal respawn point or an unsafe waiting position. + host('command', command=f'fill {hx - 6} {hy - 1} {hz - 6} {hx + 6} {hy - 1} {hz + 6} minecraft:stone') + host('command', command=f'fill {hx - 6} {hy} {hz - 6} {hx + 6} {hy + 3} {hz + 6} minecraft:air') + for game, dz in ((host, -3), (guest, 3)): + waiting = (hx - 3.5, hy, hz + dz + 0.5) + game('command', command=f'spawnpoint @s {hx} {hy} {hz}') + game('command', command=f'tp @s {waiting[0]} {waiting[1]} {waiting[2]}') + game.until(lambda: pos_of(game), lambda p: math.dist(p, waiting) < 0.1) try: for keep in ('false', 'true'): host('command', command=f'gamerule keep_inventory {keep}') for game, dz in ((host, -3), (guest, 3)): # 14 blocks from the world spawn: nothing dropped is picked up on respawning. x, z = hx + 14, hz + dz - host('command', command=f'fill {x - 2} {hy - 1} {z - 1} {x + 2} {hy - 1} {z + 1} minecraft:stone') - host('command', command=f'fill {x - 2} {hy} {z - 1} {x + 2} {hy + 2} {z + 1} minecraft:air') + # Death drops scatter several blocks before landing. Keep the + # entire observation area solid so they cannot fall off a ledge. + host('command', command=f'fill {x - 6} {hy - 1} {z - 6} {x + 6} {hy - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {x - 6} {hy} {z - 6} {x + 6} {hy + 3} {z + 6} minecraft:air') host('command', command='kill @e[type=minecraft:item]') game('command', command='gamemode survival') game('command', command='clear @s') @@ -4675,8 +4770,10 @@ def check_keep_inventory(host, guest, out): game('command', command='item replace entity @s armor.head with minecraft:iron_helmet') game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5}') game.wait(20) + assert game('state').get('screen') == 'playing', f'{game.name} died during setup' game('command', command='kill @s') game.wait(30) + assert game('state').get('screen') == 'dead', f'{game.name} did not die' dropped = sorted((e['item']['item'], e['item']['count']) for e in game.raw('entities', 8, 'minecraft:item')['entities']) game.shot(out, f'keepinv-{keep}') @@ -4686,12 +4783,14 @@ def check_keep_inventory(host, guest, out): seen[f'{game.name}-keep-{keep}'] = { 'dropped': dropped, 'kept': {item: server_count(game, item) for item in ('diamond', 'iron_helmet')}} + game('command', command='gamemode creative') finally: host('command', command='gamerule keep_inventory false') host('command', command='gamerule respawn_radius 10') host('command', command='kill @e[type=minecraft:item]') for game in (host, guest): game('command', command='clear @s') + game('command', command='gamemode survival') face_each_other(host, guest) for case, s in seen.items(): want = ({'dropped': [], 'kept': {'diamond': 7, 'iron_helmet': 1}} if case.endswith('true') else @@ -4709,6 +4808,16 @@ def check_signs(host, guest, out): seen = {} for game, other, dz in ((host, guest, -2), (guest, host, 2)): spot = (hx + 2, hy, hz + dz) + for viewer in (game, other): + back_to_game(viewer) + # Earlier death/travel checks leave the players at different spawn points. + # Give this placement case its own floor, line of sight and reachable target. + host('command', command=f'fill {spot[0] - 3} {hy - 1} {spot[2] - 1} {spot[0] + 3} {hy - 1} {spot[2] + 1} minecraft:stone') + host('command', command=f'fill {spot[0] - 3} {hy} {spot[2] - 1} {spot[0] + 3} {hy + 3} {spot[2] + 1} minecraft:air') + for viewer, dx in ((game, -2), (other, 2)): + at = (spot[0] + dx + 0.5, hy, spot[2] + 0.5) + viewer('command', command=f'tp @s {at[0]} {at[1]} {at[2]}') + viewer.until(lambda: pos_of(viewer), lambda p: math.dist(p, at) < 0.1) game('command', command=f'setblock {spot[0]} {spot[1] - 1} {spot[2]} minecraft:stone') game('command', command=f'setblock {spot[0]} {spot[1]} {spot[2]} minecraft:air') game('command', command='gamemode survival') @@ -4716,7 +4825,12 @@ def check_signs(host, guest, out): game('command', command='give @s minecraft:oak_sign 1') game.wait(10) game.raw('place', *spot, '--item', 'minecraft:oak_sign') - game.wait(10) + game.until(lambda: game('state').get('screen'), lambda s: s == 'sign', ticks=10) + # Drain the placement's initial block-entity data before typing. The + # reply travels on the same connection after that data, unlike a local + # screen check which may see the editor before the initial data arrives. + server_reply(game, f'data get block {spot[0]} {spot[1]} {spot[2]} front_text.messages', + 'following block data') opened = {g.name: g('state').get('screen') for g in (game, other)} game.shot(out, 'signs-editor') lines = [f'{game.name} wrote', 'line two'] @@ -4724,11 +4838,13 @@ def check_signs(host, guest, out): game.raw('key', 'enter', 'tap') game.raw('type', lines[1]) game.raw('key', 'esc', 'tap') - game.wait(20) + game.until(lambda: game('state').get('screen'), lambda s: s == 'playing', ticks=20) back_to_game(other) + shown = {g.name: g.until(lambda: (g.raw('block', *spot).get('sign') or {}).get('front'), + lambda front: front == lines + ['', ''], ticks=20) + for g in (game, other)} seen[game.name] = {'opened': opened, - 'shown': {g.name: (g.raw('block', *spot).get('sign') or {}).get('front') - for g in (game, other)}} + 'shown': shown} other.shot(out, 'signs-shown') for name, s in seen.items(): other = 'guest' if name == 'host' else 'host' @@ -5079,8 +5195,12 @@ def check_fishing(host, guest, out): tracked to the clients as a fishing bobber under its owner), lands on the ground and reels back in; cast into open water with Lure III, a fish bites and reeling in during the bite catches it for 1 (#1348).""" + # Both players need a safe floor for the entire other player's fishing wait. + apart(host, guest) hx, hy, hz = (int(v // 1) for v in pos_of(host)) host('command', command='weather clear') + for game in (host, guest): + game('command', command='effect give @s minecraft:instant_health 1 5 true') seen = {} try: for game, other, dz in ((host, guest, -5), (guest, host, 5)): @@ -5396,12 +5516,8 @@ def check_digging(host, guest, out): before = heard('minecraft:block.stone.break') guest.raw('look-at', *at(stone)) guest.raw('mouse', 'left', 'down') - time.sleep(0.4) - os.kill(guest.pid, signal.SIGSTOP) - try: - time.sleep(1.0) - finally: - os.kill(guest.pid, signal.SIGCONT) + guest.wait(8) + guest.raw('stall', 1000) resumed = {'guest': guest.raw('block', *stone).get('block'), 'server': host.raw('block', *stone).get('block'), 'mining': guest('state').get('mining')} # Let go once it breaks: past it the crosshair reaches the floor. @@ -5597,6 +5713,68 @@ CHECKS += ['knockback'] CHECK_FNS.update(knockback=check_knockback) + +def check_fixture_input(host, guest, out, kind, role): + """Complement seeded rules with real client input and authoritative observations.""" + player = host if role == 'host' else guest + hx, y, hz = (int(v // 1) for v in pos_of(host)) + x, z = hx + 6, hz + (-8 if role == 'host' else 8) + sensor, dispenser, button = (x + 3, y, z + 1), (x, y, z + 3), (x, y, z + 2) + player('command', command='gamemode survival') + player('command', command='item replace entity @s weapon.mainhand with minecraft:air') + host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 5} {y - 1} {z + 5} minecraft:stone') + host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air') + start = (x + 0.5, y, z + 0.5) + player('command', command=f'tp @s {start[0]} {start[1]} {start[2]} 0 0') + player.until(lambda: pos_of(player), lambda p: math.dist(p, start) < 0.1) + player.raw('look', 0, 0) + try: + if kind == 'sculk': + player.wait(2) # finish setup movement before installing the listener + host.raw('setblock', *sensor, 'minecraft:sculk_sensor') + phase = lambda: host.raw('getblock', *sensor)['block'] + host.until(phase, lambda state: 'sculk_sensor_phase=inactive' in state) + player.wait(10) + assert 'sculk_sensor_phase=inactive' in phase(), 'setup activated the sensor before player input' + player.raw('key', 'w', 'down') + try: + player.wait(15) # defined input duration; no wall-clock simulation sleep + finally: + player.raw('key', 'w', 'up') + moved = {'client': math.dist(pos_of(player), start), + 'server': math.dist(server_player(host, player)['position'], start)} + assert all(d > 1 for d in moved.values()), f'{role} did not walk on both sides: {moved}' + active = host.until(phase, lambda state: 'sculk_sensor_phase=active' in state, ticks=85) + for viewer in (host, guest): + viewer.until(lambda: state_of(viewer, sensor, 'sculk_sensor_phase'), lambda v: v == 'active') + return {'moved': moved, 'phase': active} + host.raw('setblock', *dispenser, 'minecraft:dispenser[facing=east]') + host.raw('container', *dispenser, 'minecraft:diamond', 1) + host.raw('setblock', *button, 'minecraft:stone_button[face=wall,facing=north]') + player.until(lambda: player.raw('block', *button)['block'], lambda v: v == 'minecraft:stone_button') + player.raw('interact', *button) + slots = host.until(lambda: host.raw('container', *dispenser)['slots'], lambda v: all(s is None for s in v)) + dropped = {} + for viewer in (host, guest): + dropped[viewer.name] = viewer.until( + lambda: [e for e in viewer.raw('entities', 24, 'minecraft:item')['entities'] + if e.get('item', {}).get('item') == 'minecraft:diamond' + and math.dist(e['pos'], (x + 1.5, y + 0.5, z + 3.5)) < 3], + lambda drops: len(drops) == 1 and drops[0]['item']['count'] == 1) + player.shot(out, f'{kind}-input') + return {'slots': slots, 'drops': dropped} + finally: + player.raw('key', 'w', 'up') + host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air') + + +for _kind in ('sculk', 'dispenser'): + for _role in ('host', 'guest'): + _name = f'{_kind}_input_{_role}' + CHECKS.append(_name) + CHECK_FNS[_name] = lambda h, g, o, kind=_kind, role=_role: check_fixture_input(h, g, o, kind, role) + + def check_hero_trading(host, guest, out): """Villager.updateSpecialPrices keeps the trading player's Hero effect: the offer sent to the client and the server's payment consumption agree, independently of the other player's effect.""" diff --git a/tools/oracle_harness.py b/tools/oracle_harness.py index 92e2a26a2..787c8a293 100644 --- a/tools/oracle_harness.py +++ b/tools/oracle_harness.py @@ -9,13 +9,16 @@ import subprocess try: from . import lab, test_rust_parity as base, test_model_baking_parity as baking + from .integration_env import run_game except ImportError: import lab, test_rust_parity as base, test_model_baking_parity as baking + from integration_env import run_game def run_logged(command, build, name, timeout=900, **kwargs): with (build / (name + '.log')).open('w') as log: - subprocess.run([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, + runner = run_game if Path(command[0]).name == 'horizon-client' else subprocess.run + runner([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, stdout=log, stderr=subprocess.STDOUT, **kwargs) diff --git a/tools/parity.py b/tools/parity.py index 285e7268b..dbff8c146 100644 --- a/tools/parity.py +++ b/tools/parity.py @@ -11,6 +11,9 @@ python3 tools/parity.py --list # what would run, without running it python3 tools/parity.py --status # last result of every harness +Harnesses in parity_hosts.json's "named_only" run only when named or with --all +(the nightly audit): no automatic selection picks them. + Each harness runs unmodified, in parallel, under a tracer that records what it read: its Python modules, Java oracle sources, other repository files, and the Rust sources of every probe it executed (from Cargo's dep-info). A harness @@ -1306,6 +1309,12 @@ def platform_skips(config): return dict(config.get("linux_only", {})) +def named_only(config): + """Harnesses tools/parity_hosts.json keeps out of every automatic selection (--changed, --failed, the default, + --flake-check): they run only when named or with --all, the nightly audit. {name: reason}""" + return dict(config.get("named_only", {})) + + def finished_run(failed): """Record that this run completed, for tools/gate.py: a crashed runner never writes it.""" STATE_DIR.mkdir(parents=True, exist_ok=True) @@ -1390,9 +1399,13 @@ def main(): for name in [name for name in chosen if base_name(name) in skips and not args.names]: print(f"skipped on {sys.platform}: {name}: {skips[base_name(name)]}", flush=True) chosen.remove(name) + manual = {} if args.names or args.all else named_only(host_config()) + for name in [name for name in chosen if base_name(name) in manual]: + print(f"not selected (runs when named, and nightly): {name}: {manual[base_name(name)]}", flush=True) + chosen.remove(name) rounds = {name: args.repeat for name in chosen} if args.repeat > 1 else {} if args.flake_check: - changed = changed_harnesses(found, records, args.flake_check) + changed = {name for name in changed_harnesses(found, records, args.flake_check) if base_name(name) not in manual} for name in sorted(changed): # A pass counts for a changed harness only if it held over enough runs. if name not in chosen and records.get(name, {}).get("rounds", 1) < args.flake_rounds: diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json index f2ba65c68..164a3ff42 100644 --- a/tools/parity_hosts.json +++ b/tools/parity_hosts.json @@ -36,5 +36,8 @@ "local_only": { "save_roundtrip": "runs the game on a virtual screen (vscreen) with a null ALSA device, or offscreen in the logged-in macOS session" }, - "linux_only": {} + "linux_only": {}, + "named_only": { + "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py" + } } diff --git a/tools/test_command_exec_parity.py b/tools/test_command_exec_parity.py index 75f38c351..7993a93a7 100644 --- a/tools/test_command_exec_parity.py +++ b/tools/test_command_exec_parity.py @@ -25,9 +25,11 @@ import sys try: from . import lab, test_rust_parity as base + from .integration_env import run_game from . import command_exec_corpus as corpus_module except ImportError: import lab + from integration_env import run_game import test_rust_parity as base import command_exec_corpus as corpus_module @@ -55,7 +57,8 @@ def main(): def run(command, name, **kw): with (build / (name + '.log')).open('w', encoding='utf-8') as log: - result = subprocess.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw) + runner = run_game if Path(command[0]).name == 'horizon-client' else subprocess.run + result = runner(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT, **kw) if result.returncode: tail = (build / (name + '.log')).read_text(errors='replace')[-3000:] sys.exit(f'{name} failed ({result.returncode}):\n{tail}') diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py index 49a934987..7572ee3e2 100644 --- a/tools/test_dedicated_server_parity.py +++ b/tools/test_dedicated_server_parity.py @@ -65,13 +65,16 @@ import struct import subprocess import sys import threading +import tempfile import time import zlib try: from . import lab, oracle_harness as oh, test_rust_parity as base + from .integration_env import game_environment, run_game from .lab import free_port # the other server harnesses import it from here except ImportError: + from integration_env import game_environment, run_game import lab import oracle_harness as oh import test_rust_parity as base @@ -124,9 +127,11 @@ class Server: self.log_path = directory.parent / f'{log_name}.log' self.log = self.log_path.open('w', encoding='utf-8') self.lines = [] - self.process = subprocess.Popen(list(map(str, command)), cwd=directory, stdin=subprocess.PIPE, + self.scratch = tempfile.TemporaryDirectory(prefix='hz-server-') + env = game_environment(os.environ, self.scratch.name) + self.process = subprocess.Popen(list(map(str, command)), cwd=directory, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, - encoding='utf-8', errors='replace', env=lab.game_env()) + encoding='utf-8', errors='replace') self.reader = threading.Thread(target=self._read, daemon=True) self.reader.start() @@ -163,6 +168,7 @@ class Server: self.process.wait() self.reader.join(timeout=10) self.log.close() + self.scratch.cleanup() def settle(server, ticks=600, timeout=600): @@ -200,6 +206,17 @@ def game_time(server, timeout=300): raise AssertionError(f'{server.log_path.name}: no game time in {timeout:.0f} s') +def wait_ticks(server, count, timeout=300): + """Waits until the server's game clock has advanced `count` ticks: a server that stalls under load still gets + as many ticks as an idle one, where a sleep gives it fewer. (Not while ticking is frozen.)""" + deadline = time.time() + timeout + until = game_time(server, timeout) + count + while game_time(server, max(1.0, deadline - time.time())) < until: + if time.time() > deadline: + raise AssertionError(f'{server.log_path.name}: the game clock did not advance {count} ticks in {timeout} s') + time.sleep(0.2) + + def legacy_ping(port): """The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler).""" host = 'localhost' @@ -327,7 +344,9 @@ def run_side(label, command, directory, client): joined.join() if failure: raise failure[0] - time.sleep(1) + # The client has gone; `list` must find no one, once the server has handled its leaving (a busy machine + # took longer than a second). + server.wait_for(rf'{PLAYER} left the game', timeout=60) server.console('list') server.console('say console says hi') server.wait_for(r'\[Server\] console says hi', timeout=30) @@ -359,7 +378,7 @@ def horizon_client_joins(vanilla_server, binary, world, build, reference): server.wait_for(r'Done \(') env = lab.game_env(HORIZON_NET_REPORT=report) with (build / 'horizon-client-run.log').open('w') as log: - subprocess.run([str(c) for c in [binary, '--resources', lab.RESOURCES, '--render-distance', 2, + run_game([str(c) for c in [binary, '--resources', lab.RESOURCES, '--render-distance', 2, '--server', f'127.0.0.1:{port}', '--name', PLAYER]], cwd=client_dir, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True) server.wait_for(r'left the game', timeout=30) diff --git a/tools/test_dispenser_parity.py b/tools/test_dispenser_parity.py index 7ca48cb7f..a2c6ba036 100644 --- a/tools/test_dispenser_parity.py +++ b/tools/test_dispenser_parity.py @@ -17,7 +17,9 @@ import random import subprocess try: from . import block_update_harness as h, lab, test_rust_parity as base + from .integration_env import run_game except ImportError: + from integration_env import run_game import block_update_harness as h import lab import test_rust_parity as base @@ -349,7 +351,8 @@ def voice(line): def run(command, **kwargs): - done = subprocess.run(command, capture_output=True, text=True, **kwargs) + runner = run_game if str(command[0]).endswith('/horizon-client') else subprocess.run + done = runner(command, capture_output=True, text=True, **kwargs) if done.returncode: print((done.stdout + done.stderr)[-4000:]) raise SystemExit(f'{command[0]} failed') diff --git a/tools/test_entity_fluid_parity.py b/tools/test_entity_fluid_parity.py index b37a3e11d..f8cbf918d 100644 --- a/tools/test_entity_fluid_parity.py +++ b/tools/test_entity_fluid_parity.py @@ -29,6 +29,15 @@ def corpus(): if v[k] is not None:v[k]=[bits(n) for n in v[k]] return v def row(ops,player=False,order=(0,1,2)):return dict(ops=ops,player=player,order=order) + # Dropped items: the 0.25-wide box is deflated by Entity before scanning. + # Cover surface grazing, buoyancy depth, cell boundaries and repeated pushes. + for x in [.5, 1.0, 15.99]: + for y in [0, .1, .7, 8/9-.1, 8/9-.001, 8/9, 1]: + for flow in [(0,0,0),(1,0,0),(-1,0,1),(0,-1,0)]: + update=op(bounds=[x-.124,y+.001,.376,x+.124,y+.249,.624], + base_y=y,eye=y+.2125,block=[int(x),int(y),0], + default=cell(flow=flow)) + yield row([update,op(mode='apply'),update,op(mode='apply')]) values=[-float('inf'),-1,-.0,0,.1,.39999998,.4,.40000004,8/9,1,2,float('inf'),float('nan')] for kind in range(5): for height in values: diff --git a/tools/test_friends.py b/tools/test_friends.py index cc5d15b92..fd3d626a9 100644 --- a/tools/test_friends.py +++ b/tools/test_friends.py @@ -15,8 +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). +The host runs on its integrated server thread by default (the window is a +client of it). `--in-frame` compares the fallback; `--server-thread` is accepted +for compatibility. `--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` @@ -36,8 +37,10 @@ import urllib.request try: from . import lab + from .integration_env import game_environment, require_server_reports except ImportError: import lab + from integration_env import game_environment, require_server_reports ROOT = Path(__file__).resolve().parents[1] @@ -84,7 +87,7 @@ class Game: prefix = [] extra = [] # The host's world on its server thread (`--server-thread`), else in the window. - server_thread = False + server_thread = True def __init__(self, client, resources, work, name, env): # Either way explicitly, whatever the game's default. @@ -96,7 +99,8 @@ class Game: self.process = subprocess.Popen(Game.prefix + [ str(client), '--resources', str(resources), '--render-distance', '2', '--test-terrain', '--control-socket', str(self.endpoint), '--timeout-seconds', '600', - ] + Game.extra, cwd=self.home, env=lab.game_env(HORIZON_HOME=self.home, **env), + ] + Game.extra, cwd=self.home, + env={**game_environment({**os.environ, **env}, self.home), 'HORIZON_HOME': str(self.home)}, stdout=self.log, stderr=subprocess.STDOUT) wait_for(self.endpoint, 'screen', lambda v: v['screen'] == 'title', 120, f'{name} title') @@ -149,10 +153,11 @@ def play_together(host, guest, name, round_index): before = guest_pos(host, name) guest('look 0 0') guest('key w down') - time.sleep(1.5) - guest('key w up') - host.wait('lan status', lambda v: math.dist(before, next(g['position'] for g in v['guests'] if g['name'] == name)) > 1.0, - 20, 'guest movement on the host') + try: + host.wait('lan status', lambda v: math.dist(before, next(g['position'] for g in v['guests'] if g['name'] == name)) > 1.0, + 20, 'guest movement on the host') + finally: + guest('key w up') # 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] @@ -179,10 +184,11 @@ def play_together(host, guest, name, round_index): guest.wait('status', lambda v: v['target']['pos'] == block, 10, 'the guest aiming at the block') # Held for a few ticks, as a player clicks (creative breaks at once). guest('mouse left down') - time.sleep(0.25) - guest('mouse left up') - host.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, - 'the guest breaking the block, on the host') + try: + host.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, + 'the guest breaking the block, on the host') + finally: + guest('mouse left up') guest.wait(f'getblock {block[0]} {block[1]} {block[2]}', lambda v: v['block'] == 'minecraft:air', 20, 'the broken block on the guest') @@ -250,7 +256,7 @@ def full(args, work): join(guest, code, 'Guest') play_together(host, guest, 'Guest', 1) assert host('friends status')['direct'] == 1, host('friends status') - print('code alone: chat, movement and blocks both ways, no server involved') + print('code alone: chat, movement and blocks both ways, no relay involved') leave(host, guest, 'Guest') host('friends stop') assert host('friends status')['code'] is None @@ -316,8 +322,8 @@ def one_side(args, work): if args.role == 'host': code = host_world(game) print(f'CODE {code}', flush=True) - game.wait('lan status', lambda v: v['guests'], args.wait, 'a guest') - game.wait('lan status', lambda v: not v['guests'], args.wait, 'the guest leaving') + game.wait('lan status', lambda v: any(g['name'] == 'Remote' for g in v['guests']), args.wait, 'a guest') + game.wait('lan status', lambda v: all(g['name'] != 'Remote' for g in v['guests']), args.wait, 'the guest leaving') print(f'host: {game("friends status")}') else: join(game, args.code, 'Remote') @@ -347,16 +353,25 @@ 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") + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--server-thread', dest='server_thread', action='store_true', default=True, + help='host on its server thread (default; retained for existing callers)') + mode.add_argument('--in-frame', dest='server_thread', action='store_false', + help='host the world in the window, for comparison') 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() + try: + require_server_reports(args.resources) + except ValueError as error: + parser.error(str(error)) # Short: Unix socket paths are limited to about 100 bytes. with tempfile.TemporaryDirectory(prefix='hzf-', dir='/tmp') as directory: work = Path(directory) + print(f'Friends host mode: {"server-thread" if Game.server_thread else "in-frame"}') if args.role: return one_side(args, work) assert args.relay, 'give --relay (the relay binary, run locally for the relay half)' diff --git a/tools/test_friends_integration_parity.py b/tools/test_friends_integration_parity.py new file mode 100644 index 000000000..c97787803 --- /dev/null +++ b/tools/test_friends_integration_parity.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +"""Real clients over LAN, direct invitations and a local relay, with a server-thread host. + +Registered with parity.py so changes to the drivers and the game binary select +this integration coverage in CI as well as the deterministic library probes. +""" +import json +from pathlib import Path +import subprocess +import sys + +import lab +import test_friends +from integration_env import suite_lock + + +if __name__ == '__main__': + subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', + '-p', 'horizon-relay', '--bin', 'horizon-client', '--bin', 'horizon-ctl', + '--bin', 'horizon-relay'], cwd=lab.ROOT, check=True) + metadata = json.loads(subprocess.check_output( + ['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=lab.ROOT, text=True)) + bins = Path(metadata['target_directory']) / 'fast' + sys.argv = [sys.argv[0], '--client', str(bins / 'horizon-client'), + '--relay', str(bins / 'horizon-relay'), '--baseline', + *(['--offscreen'] if sys.platform == 'darwin' else [])] + with suite_lock(): + # The wrapper only selects binaries; test_friends isolates each game + # through integration_env and lab.game_env. + test_friends.main() diff --git a/tools/test_lan_integration_parity.py b/tools/test_lan_integration_parity.py new file mode 100644 index 000000000..773a7cd82 --- /dev/null +++ b/tools/test_lan_integration_parity.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +"""Register the real-client LAN suite with parity.py's traced harness selection. + +The assertions live in lan_e2e; this is integration coverage, alongside the +fast vanilla differential probes. The host uses the normal server thread. +Linux runners need a display (for example xvfb-run -a). +""" +import lan_e2e +from integration_env import suite_lock + + +if __name__ == '__main__': + with suite_lock(): + lan_e2e.main() diff --git a/tools/test_locator_bar_parity.py b/tools/test_locator_bar_parity.py index 985b87a35..6574af76e 100644 --- a/tools/test_locator_bar_parity.py +++ b/tools/test_locator_bar_parity.py @@ -23,15 +23,14 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, wait_ticks except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, wait_ticks NAME = 'locator-bar-parity' PROPERTIES = { @@ -82,7 +81,7 @@ SCRIPT = [ ('creative', [], ['cmd Bob gamemode creative', 'cmd Bob tp @s 6.5 100 0.5']), ('bob-leaves', [], ['quit Bob']), ] -STEP_SECONDS = 2.0 +STEP_TICKS = 40 # Vanilla's server moves a player who just joined on their own first ticks (a tiny step and back), which tracks # them where they spawned; Horizon does not simulate its guests. These steps compare what the bar shows at # their end (Bob has moved by then) rather than every packet. @@ -147,6 +146,47 @@ def server_dir(directory, world=None): return port +class Client: + """A LocatorBarClient process driven by a script on its stdin. A step ends by the server's clock, not the wall's: + every script line has run (`sync`), the server has ticked `ticks` more times, and each client holds what the + server sent until then (a last `sync`). A server that stalls under load still gets all its ticks in the step, + where a fixed sleep filed a stalled server's packets under the next step.""" + + def __init__(self, command, port, out, log): + self.log = log + self.process = subprocess.Popen([*map(str, command), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True) + + def tell(self, line): + self.process.stdin.write(line + '\n') + self.process.stdin.flush() + + def sync(self, names): + """Every line told so far has run for these joined players, and they have received what the server sent + before.""" + for name in names: + self.tell(f'sync {name}') + for name in names: + while (line := self.process.stdout.readline()) != f'synced {name}\n': + if not line: + raise AssertionError(f'the client exited (see {self.log.name})') + self.log.write(line) + + def wait(self, server, names, ticks): + self.sync(names) + wait_ticks(server, ticks) + self.sync(names) + + def end(self): + self.tell('end') + self.log.write(self.process.communicate(timeout=60)[0]) + + def kill(self): + if self.process.poll() is None: + self.process.kill() + + def generate_world(server_command, build): """The flat world both servers load, made once by vanilla: players appear at its spawn itself (respawn_radius 0), on the ground at 0 -60 0, and the chunks around it are saved.""" @@ -176,28 +216,26 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + client = Client(client_command, port, out, log) + joined = [] try: for step, console, actions in SCRIPT: - client.stdin.write(f'step {step}\n') - client.stdin.flush() + client.tell(f'step {step}') for command in console: server.console(command) for action in actions: - client.stdin.write(action + '\n') - client.stdin.flush() - if action.startswith('join'): + client.tell(action) + verb, *rest = action.split() + if verb == 'join': # Joining takes the world's first chunks: wait for the server to place the player. - server.wait_for(rf'{action.split()[1]} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - client.stdin.write('end\n') - client.stdin.flush() - client.wait(timeout=60) + server.wait_for(rf'{rest[0]} joined the game', timeout=120) + joined.append(rest[0]) + elif verb == 'quit': + joined.remove(rest[0]) + client.wait(server, joined, STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): @@ -234,10 +272,11 @@ def sides(name): def one_player(name, script, shown, check, scope, step_seconds=4.0): """A harness of one player, Alice: on each server she joins, then runs `script`, a list of (step, client - actions) `step_seconds` apart. The lines `shown(transcript)` keeps must match vanilla's exactly, and + actions) that each last `step_seconds` of the server's time (20 ticks a second). The lines `shown(transcript)` keeps must match vanilla's exactly, and `check(vanilla's shown lines, vanilla's transcript)` returns why vanilla's run is no proof (the script did not run), or None.""" lock, build, vanilla_server, horizon_server, client = sides(name) + ticks = round(step_seconds * 20) def run(label, server_command, world): directory = build / label @@ -248,27 +287,20 @@ def one_player(name, script, shown, check, scope, step_seconds=4.0): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - process = subprocess.Popen([*map(str, client), '127.0.0.1', str(port), str(out)], cwd=lab.ROOT, - stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, text=True) - - def tell(line): - process.stdin.write(line + '\n') - process.stdin.flush() + session = Client(client, port, out, log) try: for line in ['players on', 'state on', 'step joins', 'join Alice']: - tell(line) + session.tell(line) server.wait_for(r'Alice joined the game', timeout=120) - time.sleep(step_seconds) + session.wait(server, ['Alice'], ticks) for step, actions in script: - tell(f'step {step}') + session.tell(f'step {step}') for action in actions: - tell(action) - time.sleep(step_seconds) - tell('end') - process.wait(timeout=60) + session.tell(action) + session.wait(server, ['Alice'], ticks) + session.end() finally: - if process.poll() is None: - process.kill() + session.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_online_mode_parity.py b/tools/test_online_mode_parity.py index d03838bf3..8096efd80 100644 --- a/tools/test_online_mode_parity.py +++ b/tools/test_online_mode_parity.py @@ -50,11 +50,13 @@ import urllib.parse try: from . import lab, oracle_harness as oh, test_rust_parity as base from .test_dedicated_server_parity import Server, free_port + from .integration_env import run_game except ImportError: import lab import oracle_harness as oh import test_rust_parity as base from test_dedicated_server_parity import Server, free_port + from integration_env import run_game NAME = 'online-mode-parity' PLAYER = 'Tester' @@ -185,7 +187,7 @@ def run_client(binary, build, port, label, token, discovery): if token: command += ['--session-file', session_file(directory, token)] with (build / f'client-{label}.log').open('w') as log: - subprocess.run([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT, + run_game([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True) got = json.loads(report.read_text()) got['session file left'] = (directory / 'session.json').exists() diff --git a/tools/test_pack_screen_parity.py b/tools/test_pack_screen_parity.py index 1f3f03ede..77249ec5e 100644 --- a/tools/test_pack_screen_parity.py +++ b/tools/test_pack_screen_parity.py @@ -147,7 +147,7 @@ def main(): run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaPackScreenOracle'))], 'compile-java') run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaPackScreenOracle', - inputs, build / 'vanilla.jsonl'], 'vanilla') + inputs, build / 'vanilla.jsonl', lab.RESOURCES / 'assets'], 'vanilla') lib.cargo_example('horizon-client', 'pack_screen_fixture', lib.RESOURCES, inputs, build / 'rust.jsonl') vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()] rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()] diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py index b1efc4378..ea026a509 100644 --- a/tools/test_server_dimension_players_parity.py +++ b/tools/test_server_dimension_players_parity.py @@ -16,17 +16,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-dimension-players-parity' NETHER, END, OVERWORLD = 'minecraft:the_nether', 'minecraft:the_end', 'minecraft:overworld' @@ -41,8 +40,14 @@ SCRIPT = [ # Through an End portal (Entity.handlePortal), and back by command. ('bob-portal', ['cmd Bob setblock 2 101 3 minecraft:end_portal', 'cmd Bob tp @s 2.5 101 3.5']), ('bob-portal-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), + # Sent far into the Nether, then teleported within it before the far chunks load: a portal there + # still takes him (the abandoned arrival does not hold him). + ('bob-retarget', [f'cmd Bob execute in {NETHER} run tp @s 8192.5 100 0.5', 'cmd Bob tp @s 0.5 100 0.5']), + ('bob-retarget-portal', ['cmd Bob setblock 0 101 3 minecraft:end_portal', 'cmd Bob tp @s 0.5 101 3.5']), + ('bob-retarget-back', [f'cmd Bob execute in {OVERWORLD} run tp @s 2.5 100 0.5']), ] -STEP_SECONDS = 5.0 +PLAYERS = ('Alice', 'Bob') +STEP_TICKS = 100 def run_side(label, server_command, client_command, build, world): @@ -54,38 +59,30 @@ def run_side(label, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: - tell('players on') - tell('step joins') - for name, x in (('Alice', 0.5), ('Bob', 2.5)): - tell(f'join {name}') + client.tell('players on') + client.tell('step joins') + for name, x in zip(PLAYERS, (0.5, 2.5)): + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - tell(f'fly {name} on') - tell(f'cmd {name} tp @s {x} 100 0.5') - time.sleep(STEP_SECONDS) + client.tell(f'fly {name} on') + client.tell(f'cmd {name} tp @s {x} 100 0.5') + client.wait(server, PLAYERS, STEP_TICKS) for step, actions in SCRIPT: - tell(f'step {step}') + client.tell(f'step {step}') for action in actions: - tell(action) + client.tell(action) # Standing still, a client still sends its position every 20 ticks # (LocalPlayer.sendPosition): the server then tracks to it what it has sent the # chunks of since (ChunkMap.move). - time.sleep(STEP_SECONDS / 2) - tell('still Alice') - tell('still Bob') - time.sleep(STEP_SECONDS / 2) - tell('end') - client.wait(timeout=60) + client.wait(server, PLAYERS, STEP_TICKS // 2) + for name in PLAYERS: + client.tell(f'still {name}') + client.wait(server, PLAYERS, STEP_TICKS // 2) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py index d7fbaeba1..66b75946e 100644 --- a/tools/test_server_knockback_parity.py +++ b/tools/test_server_knockback_parity.py @@ -18,6 +18,11 @@ players made of vanilla's protocol code, joins them both and runs one script on travelled a tick (the mob's hit, then ServerPlayer's travel, then ServerEntity.sendChanges). It is night, so that no zombie burns (a burning mob is in its hurt cooldown). +The script waits on the server, not on the wall: `ticks N` is N ticks of its game clock (with a `sync` round trip +before and after, so each client holds what the server sent), `tickstep` is one `/tick step` that has run, `frozen` +a frozen game that has stopped, and `hit` a hit that has landed (a frozen server still ticks its players, so a hit +lands in Alice's next tick). A server that stalls under load gets the same ticks as an idle one. + Each case is compared on its own. KNOWN lists the cases Horizon still gets wrong and why; one that matches again is reported, and should leave the list. """ @@ -32,15 +37,16 @@ import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server, free_port + from .test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from .test_locator_bar_parity import generate_world, ops_json except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server, free_port + from test_dedicated_server_parity import Server, free_port, game_time, wait_ticks from test_locator_bar_parity import generate_world, ops_json NAME = 'server-knockback-parity' +PLAYERS = ('Alice', 'Bob') PROPERTIES = { 'online-mode': 'false', 'white-list': 'false', @@ -82,18 +88,17 @@ def mob_case(kind, weapon=SWORD, sprint=False, crit=False, air=False): f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true'] lines = ['cmd Alice kill @e[type=!player]', 'cmd Alice gamemode creative', 'cmd Bob gamemode creative', f'cmd Alice item replace entity @s weapon.mainhand with {weapon}', 'cmd Alice tp Bob 2.5 -60 12.5', - *stand('Alice', A, -90), 'sleep 1.2'] + *stand('Alice', A, -90), 'ticks 24'] # In the air: frozen before its first tick, so it has not landed. - lines += ['cmd Alice tick freeze', *summon] if air else [*summon, 'sleep 1.5', 'cmd Alice tick freeze'] - lines += ['sleep 0.3', f'cmd Alice data get entity {mob} Pos'] + lines += ['cmd Alice tick freeze', 'frozen', *summon] if air else [*summon, 'ticks 30', 'cmd Alice tick freeze', 'frozen'] + lines += [f'cmd Alice data get entity {mob} Pos'] if sprint: lines.append('sprint Alice on') if crit: lines += falling(0.8) - lines += ['sleep 0.2', f'attack Alice {kind}', 'sleep 0.2', f'cmd Alice data get entity {mob} Motion'] + lines += [f'hit {kind}', f'cmd Alice data get entity {mob} Motion'] for _ in range(20): - lines += ['cmd Alice tick step 1', 'sleep 0.25', f'cmd Alice data get entity {mob} Pos', - f'cmd Alice data get entity {mob} Motion'] + lines += ['tickstep', f'cmd Alice data get entity {mob} Pos', f'cmd Alice data get entity {mob} Motion'] lines += ['cmd Alice tick unfreeze', 'cmd Alice kill @e[type=!player]'] if sprint: lines.append('sprint Alice off') @@ -114,7 +119,7 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if shield: # A shield blocks from five ticks after it is raised. lines += ['cmd Bob item replace entity @s weapon.mainhand with minecraft:shield', 'use Bob'] - lines += ['sleep 1.5', *stand('Bob', V, 90, ticks=1)] + lines += ['ticks 30', *stand('Bob', V, 90, ticks=1)] if sprint: lines.append('sprint Alice on') if crit: @@ -124,10 +129,12 @@ def pvp_case(weapon=SWORD, sprint=False, crit=False, shield=False, armour=False, if cooldown: # A swing at the air first: the hit is weak, and the stronger one four ticks later lands inside Bob's hurt # cooldown (LivingEntity.hurtServer: it hurts by the difference, with no knockback and no motion packet). - lines += ['sleep 0.2', 'punch Alice', 'attack Alice Bob'] - lines += ['sleep 0.2', 'attack Alice Bob', 'sleep 0.3'] + lines += ['ticks 4', 'punch Alice', 'attack Alice Bob'] + # The gap between those two hits is an upper bound on the server's ticks, so a stalled server (which gets + # fewer in a wall's 0.2 s) still lands the second inside the cooldown; the rest is to have the server's ticks. + lines += ['sleep 0.2' if cooldown else 'ticks 4', 'attack Alice Bob', 'ticks 6'] if twice: - lines += [*stand('Bob', V, 90, ticks=20), 'sleep 1.5', 'attack Alice Bob', 'sleep 0.3'] + lines += [*stand('Bob', V, 90, ticks=20), 'ticks 30', 'attack Alice Bob', 'ticks 6'] if sprint: lines.append('sprint Alice off') lines += stand('Alice', A, -90) @@ -144,7 +151,7 @@ def mob_hits_case(kind): hit = ['mark Bob', f'cmd Alice summon minecraft:{kind} {V[0] + 1} {V[1]} {V[2]} {{Rotation:[90f,0f]}}', f'cmd Alice effect give {mob} minecraft:slowness 100000 127 true', 'await Bob', f'cmd Alice kill {mob}'] return ['cmd Bob clear @s', 'cmd Bob effect give @s minecraft:resistance 1000 4 true', 'cmd Alice gamemode creative', - *stand('Bob', V, 90), *hit, 'sleep 2', *stand('Bob', V, 90), *hit, 'sleep 1', + *stand('Bob', V, 90), *hit, 'ticks 40', *stand('Bob', V, 90), *hit, 'ticks 20', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamemode survival'] @@ -173,7 +180,20 @@ CASES = { } SETUP = ['cmd Alice gamerule spawn_mobs false', 'cmd Alice gamerule spawn_monsters false', 'cmd Alice kill @e[type=!player]', 'cmd Alice gamerule advance_time false', 'cmd Alice time set midnight', - f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'sleep 2'] + f'cmd Alice tp Alice {A[0]} {A[1]} {A[2]} -90 0', f'cmd Alice tp Bob {V[0]} {V[1]} {V[2]} 90 0', 'ticks 40'] + + +def server_data(server, selector, path, timeout=120): + """An entity's data, asked from the console (its reply stays in the server's log, out of the clients').""" + deadline = time.time() + timeout + start = len(server.lines) + server.console(f'data get entity {selector} {path}') + while time.time() < deadline: + for line in server.lines[start:]: + if 'has the following entity data' in line: + return line.split('data: ', 1)[-1] + time.sleep(0.02) + raise AssertionError(f'{server.log_path.name}: no entity data in {timeout} s') def server_dir(directory, world): @@ -201,29 +221,72 @@ def run_side(label, server_command, client_command, build, world): server.wait_for(r'Done \(') with (build / f'{label}-client.log').open('w') as log: client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) + cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True) + + def sync(): + """Every script line sent so far has run, and each client holds what its server sent before.""" + for name in PLAYERS: + client.stdin.write(f'sync {name}\n') + client.stdin.flush() + for name in PLAYERS: + while (reply := client.stdout.readline()) != f'synced {name}\n': + if not reply: + raise AssertionError(f'{label}: the client exited (see {build}/{label}-client.log)') + log.write(reply) def send(line): - if line.startswith('sleep '): + """A script line for the client, or one of ours: the waits are on the server's game clock, not the + wall's, so a server that stalls under load still gets the ticks each case needs.""" + word = line.split()[0] + if word == 'sleep': time.sleep(float(line.split()[1])) + elif word == 'ticks': + sync() + wait_ticks(server, int(line.split()[1])) + sync() + elif word == 'frozen': + # The tick in flight when ticking was frozen has finished: the clock reads the same twice. + sync() + while game_time(server) != game_time(server): + pass + elif word == 'hit': + # Alice hits the mob. A frozen server still ticks its players, and the hit lands in Alice's + # next tick, not when the packet arrives: the mob's motion says when it has. + sync() + mob = f'@e[type=minecraft:{line.split()[1]},limit=1]' + before = server_data(server, mob, 'Motion') + client.stdin.write(f'attack Alice {line.split()[1]}\n') + client.stdin.flush() + while server_data(server, mob, 'Motion') == before: + time.sleep(0.05) + sync() + elif word == 'tickstep': + # `/tick step 1` answers at once and the tick runs after: the clock says when it has. + sync() + before = game_time(server) + client.stdin.write('cmd Alice tick step 1\n') + client.stdin.flush() + while game_time(server) == before: + time.sleep(0.05) + sync() else: client.stdin.write(line + '\n') client.stdin.flush() try: - for name in ('Alice', 'Bob'): + for name in PLAYERS: send(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(2) + wait_ticks(server, 40) for line in SETUP: send(line) for case, lines in CASES.items(): send(f'step {case}') for line in lines: send(line) - time.sleep(0.5) + send('ticks 10') send('end') - client.wait(timeout=60) + log.write(client.communicate(timeout=60)[0]) finally: if client.poll() is None: client.kill() diff --git a/tools/test_server_ops_feedback_parity.py b/tools/test_server_ops_feedback_parity.py index f7b7a0e73..91854fac6 100644 --- a/tools/test_server_ops_feedback_parity.py +++ b/tools/test_server_ops_feedback_parity.py @@ -19,17 +19,16 @@ import platform import shutil import subprocess import sys -import time try: from . import lab, test_rust_parity as base - from .test_dedicated_server_parity import Server - from .test_locator_bar_parity import generate_world, server_dir + from .test_dedicated_server_parity import Server, game_time + from .test_locator_bar_parity import Client, generate_world, server_dir except ImportError: import lab import test_rust_parity as base - from test_dedicated_server_parity import Server - from test_locator_bar_parity import generate_world, server_dir + from test_dedicated_server_parity import Server, game_time + from test_locator_bar_parity import Client, generate_world, server_dir NAME = 'server-ops-feedback-parity' # (label, what the console does, what the players do). @@ -53,7 +52,11 @@ QUIET = [ ('alice', [], ['cmd Alice time set 3000']), ] CASES = {'broadcast': ({}, BROADCAST), 'quiet': ({'broadcast-console-to-ops': 'false'}, QUIET)} -STEP_SECONDS = 2.0 +STEP_TICKS = 40 +# A step ends by the server's clock (Client.wait): after a round trip of Alice's (Bob is deopped for a while, so +# his is not used). While send_command_feedback is off a command has no reply for her, so those steps wait for +# the ticks alone. +NO_SYNC = {'feedback-off', 'console-feedback-off'} # Steps whose reply can take longer than a step: the next step waits for this console line first. A loaded machine # took 2 s to save vanilla's world, and the transcript ended before "Saved the game". WAIT_FOR = {'console-save': r'System chat: Saved the game'} @@ -72,33 +75,26 @@ def run_side(label, case, server_command, client_command, build, world): try: server.wait_for(r'Done \(') with (build / f'{label}-{case}-client.log').open('w') as log: - client = subprocess.Popen([*map(str, client_command), '127.0.0.1', str(port), str(out)], - cwd=lab.ROOT, stdin=subprocess.PIPE, stdout=log, stderr=subprocess.STDOUT, - text=True) - - def tell(line): - client.stdin.write(line + '\n') - client.stdin.flush() + client = Client(client_command, port, out, log) try: for name in ('Alice', 'Bob'): - tell(f'join {name}') + client.tell(f'join {name}') server.wait_for(rf'{name} joined the game', timeout=120) - time.sleep(STEP_SECONDS) - tell('chat on') + client.wait(server, ['Alice'], STEP_TICKS) + client.tell('chat on') for step, console, actions in script: - tell(f'step {step}') + client.tell(f'step {step}') for command in console: server.console(command) + game_time(server) # the console runs its queue in order: these commands have run for action in actions: - tell(action) + client.tell(action) if step in WAIT_FOR: server.wait_for(WAIT_FOR[step], timeout=120) - time.sleep(STEP_SECONDS) - tell('end') - client.wait(timeout=60) + client.wait(server, [] if step in NO_SYNC else ['Alice'], STEP_TICKS) + client.end() finally: - if client.poll() is None: - client.kill() + client.kill() finally: server.stop() if not out.exists(): diff --git a/tools/test_structure_blocks_parity.py b/tools/test_structure_blocks_parity.py index 39ccb4e49..fc4151f8d 100644 --- a/tools/test_structure_blocks_parity.py +++ b/tools/test_structure_blocks_parity.py @@ -55,6 +55,12 @@ KNOWN = { "Better Dungeons' own structure types (spec-betterdungeons §5, §6; OPEN-B14, B15) are not " 'implemented yet', }, + 'ctov': { + r'^ctov:': "Lithostitched's random is not known (spec-lithostitched OPEN-L6): per-block road and palette " + 'choices match by share, not by block; and decoration (grass, trees) differs where the village ' + 'changed the terrain', + r'^minecraft:village_plains$': 'decoration (grass, trees) differs where the village changed the terrain', + }, } diff --git a/tools/test_tab_list_parity.py b/tools/test_tab_list_parity.py index 4075859e7..3d7c84d62 100644 --- a/tools/test_tab_list_parity.py +++ b/tools/test_tab_list_parity.py @@ -240,7 +240,7 @@ def main(): run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaTabListOracle', 'VanillaSkinImageOracle'))], 'compile-java') run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTabListOracle', - inputs, build / 'vanilla.jsonl'], 'vanilla') + inputs, build / 'vanilla.jsonl', resources / 'assets'], 'vanilla') run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe', '--', 'tab_list_fixture', resources, inputs, build / 'rust.jsonl'], 'rust') images = build / 'skins.txt'; images.write_text(''.join(i + '\n' for i in skin_images(args.images))) diff --git a/website/docs/index.md b/website/docs/index.md index f22994f9c..5a64a4a8a 100644 --- a/website/docs/index.md +++ b/website/docs/index.md @@ -7,7 +7,7 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust. You install it with a - **A new game program, not a mod.** Horizon is written from scratch in Rust. It reads the same worlds, plays by the same rules and generates the same terrain as the Java game. - **Checked against vanilla.** {{HARNESSES}} automated tests ("harnesses") feed the same inputs to Horizon and to the real game, then compare the results. Today every subsystem matches in every harness that compares it. That is {{PERCENT}} of what the harnesses compare, which is not proof that nothing else differs. The [status table](/#parity) lists what is covered. - **Light and fast.** It starts quickly, uses little memory and draws efficiently. See [Performance](/docs/performance) for what is measured and what is not. -- **A few things vanilla doesn't have.** Its own settings, added to vanilla's menus the way mods add theirs, graphics presets, distant terrain, controller support, optional extras such as a minimap and dynamic lights, official mods such as zoom, an invite code to play your world with friends, and a server you can run without Java. +- **A few things vanilla doesn't have.** Its own settings, added to vanilla's menus the way mods add theirs, graphics presets, distant terrain, controller support, optional extras such as dynamic lights, official mods such as zoom and a minimap, an invite code to play your world with friends, and a server you can run without Java. ## What Horizon is not diff --git a/website/docs/settings.md b/website/docs/settings.md index e9b228b4c..1e36bee11 100644 --- a/website/docs/settings.md +++ b/website/docs/settings.md @@ -63,7 +63,7 @@ Horizon plays with PlayStation (DualShock 4 and DualSense), Xbox (360, One and S ## Extras -**Options, Horizon Settings, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, a minimap, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. The FPS counter, the keystroke display and zoom are official mods now, in **Options, Mods**: if you had one on, the game installed it for you on its first start after the update, with your settings. One more is **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. +**Options, Horizon Settings, Extras** holds small, optional conveniences. Every one is off by default, so a fresh install behaves like vanilla: fullbright, auto-reconnect, Mouse Tweaks-style inventory controls and inventory sorting. The FPS counter, the keystroke display, zoom and the minimap are official mods now, in **Options, Mods**: if you had one on, the game installed it for you on its first start after the update, with your settings. One more is **dynamic lights**: a torch, lantern or other light source that you hold, that lies dropped as an item, or a burning mob, lights the blocks around it. It is client-side only, so other players do not see it. ## Where your settings are stored