diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index 34a2f0398..ff500a08f 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -482,31 +482,12 @@ impl Game<'_> { * glam::Mat4::from_translation(glam::Vec3::new(0.0, height / 2.0 + offset_y, 0.0)) * glam::Mat4::from_rotation_z(std::f32::consts::PI) * glam::Mat4::from_rotation_x((y_angle * 20.0).to_radians()); - let mut quads: Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new(); - for q in verts.as_chunks::<4>().0 { - let p: [glam::Vec3; 4] = - std::array::from_fn(|i| gui.transform_point3(glam::Vec3::from_array(q[i].pos))); - let n = (p[1] - p[0]).cross(p[2] - p[0]); - // The winding gives inward normals: faces with n.z >= 0 point away. - if n.z >= 0.0 { - continue; - } - let n = n.normalize_or_zero(); - // Lighting.Entry.ENTITY_IN_UI, roughly: lit from the front and above. - let shade = (0.55 + 0.45 * -n.z - 0.15 * n.y).clamp(0.4, 1.0); - let c = q[0].color; - let ch = |s: u32| ((((c >> s) & 255) as f32 * shade) as u32) << s; - let color = (c & 0xFF00_0000) | ch(0) | ch(8) | ch(16); - let depth = p.iter().map(|v| v.z).sum::() / 4.0; - quads.push(( - depth, - p.map(|v| [v.x, v.y]), - std::array::from_fn(|i| q[i].uv), - color, - )); - } - // Far (low z) first: the viewer is on the +z side. - quads.sort_by(|a, b| a.0.total_cmp(&b.0)); + let fire = self + .player + .as_ref() + .filter(|p| p.fire_ticks > 0 && !p.spectator) + .map(|p| (p.dimensions.width, p.dimensions.height)); + let quads = player_preview_quads(verts, gui, fire, &atlas.sprites); let start = batch.vertices.len(); for (_, p, uv, color) in quads { batch.quad(p, uv, color); @@ -579,3 +560,89 @@ impl Game<'_> { ); } } + +fn player_preview_quads( + mut verts: Vec, + gui: glam::Mat4, + fire: Option<(f32, f32)>, + sprites: &std::collections::HashMap, +) -> Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> { + let flame_start = verts.len(); + if let Some((width, height)) = fire { + horizon_client::fire_render::flames( + [0.0; 3], + width, + height, + glam::DVec3::ZERO, + 0.0, + sprites, + 0xff, + &mut verts, + ); + } + let mut quads: Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new(); + for (index, q) in verts.as_chunks::<4>().0.iter().enumerate() { + let p: [glam::Vec3; 4] = + std::array::from_fn(|i| gui.transform_point3(glam::Vec3::from_array(q[i].pos))); + let n = (p[1] - p[0]).cross(p[2] - p[0]); + // The winding gives inward normals: faces with n.z >= 0 point away. + if n.z >= 0.0 { + continue; + } + let n = n.normalize_or_zero(); + // Lighting.Entry.ENTITY_IN_UI, roughly: lit from the front and above. + let shade = if index * 4 >= flame_start { + 1.0 + } else { + (0.55 + 0.45 * -n.z - 0.15 * n.y).clamp(0.4, 1.0) + }; + let c = q[0].color; + let ch = |s: u32| ((((c >> s) & 255) as f32 * shade) as u32) << s; + let color = (c & 0xFF00_0000) | ch(0) | ch(8) | ch(16); + let depth = p.iter().map(|v| v.z).sum::() / 4.0; + quads.push(( + depth, + p.map(|v| [v.x, v.y]), + std::array::from_fn(|i| q[i].uv), + color, + )); + } + // Far (low z) first: the viewer is on the +z side. + quads.sort_by(|a, b| a.0.total_cmp(&b.0)); + quads +} + +#[cfg(test)] +mod preview_tests { + use super::*; + #[test] + fn burning_inventory_preview_keeps_visible_fullbright_flames() { + let rect = |u0| horizon_client::hud::Rect { + u0, + v0: 0.0, + u1: u0 + 0.1, + v1: 0.1, + w: 16, + h: 16, + }; + let sprites = std::collections::HashMap::from([ + ("block/fire_0".into(), rect(0.0)), + ("block/fire_1".into(), rect(0.5)), + ]); + for pitch in [-30.0f32, 0.0, 30.0] { + let gui = glam::Mat4::from_scale(glam::Vec3::new(30.0, 30.0, -30.0)) + * glam::Mat4::from_rotation_z(std::f32::consts::PI) + * glam::Mat4::from_rotation_x(pitch.to_radians()); + assert!(player_preview_quads(Vec::new(), gui, None, &sprites).is_empty()); + let quads = player_preview_quads(Vec::new(), gui, Some((0.6, 1.8)), &sprites); + assert!( + !quads.is_empty(), + "inventory projection must not cull all flames" + ); + assert!(quads.iter().all(|q| q.3 == 0xffff_ffff)); + assert!(quads.iter().any(|q| q.2[0][0] <= 0.1)); + assert!(quads.iter().any(|q| q.2[0][0] >= 0.5)); + assert!(quads.windows(2).all(|q| q[0].0 <= q[1].0)); + } + } +} diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs index 38889cf98..2a1404ace 100644 --- a/crates/horizon-client/src/game/tnt.rs +++ b/crates/horizon-client/src/game/tnt.rs @@ -31,6 +31,78 @@ impl PrimedTnt { ), ) } + fn tick( + &mut self, + world: &horizon_client::world::World, + collision: &horizon_world::block_collision::BlockCollisionRegistry<'_>, + assets: &horizon_client::assets::Assets, + facts: &horizon_client::blocks::BlockFacts, + ) -> Result<()> { + self.previous = self.position; + self.velocity.y -= 0.04; + let mut scene = SceneCollisions { + world, + binding: collision, + subject: None, + }; + let wanted = self.velocity; + let moved = scene + .resolve(self.bounds(), wanted, 0.0, self.on_ground) + .unwrap_or(Vec3::ZERO); + self.position = Vec3::new( + self.position.x + moved.x, + self.position.y + moved.y, + self.position.z + moved.z, + ); + self.on_ground = wanted.y < 0.0 && moved.y != wanted.y; + if moved.x != wanted.x { + self.velocity.x = 0.0; + } + if moved.z != wanted.z { + self.velocity.z = 0.0; + } + if moved.y != wanted.y { + self.velocity.y = 0.0; + } + self.velocity = Vec3::new( + self.velocity.x * 0.98, + self.velocity.y * 0.98, + self.velocity.z * 0.98, + ); + if self.on_ground { + self.velocity = Vec3::new( + self.velocity.x * 0.7, + self.velocity.y * -0.5, + self.velocity.z * 0.7, + ); + } + self.fuse -= 1; + if self.fuse > 0 { + // PrimedTnt updates immersion after moving and decrementing its fuse. + let mut fluids = + horizon_world::entity_fluid::EntityFluidInteraction::new([WATER, LAVA]); + let mut fluid_world = TntFluidWorld { + tnt: self, + world, + assets, + facts, + }; + fluids + .update(&mut fluid_world, false, 4096) + .map_err(|e| std::io::Error::other(e.to_string()))?; + fluids.apply_current(&mut fluid_world, WATER, 0.014)?; + fluids.apply_current( + &mut fluid_world, + LAVA, + if world.fast_lava { + 0.007 + } else { + 0.0023333333333333335 + }, + )?; + } + Ok(()) + } } impl Game<'_> { @@ -83,41 +155,12 @@ impl Game<'_> { let mut i = 0; while i < count { let t = &mut self.tnts[i]; - t.previous = t.position; - t.velocity.y -= 0.04; - let mut scene = SceneCollisions { - world: &self.world, - binding: self.collision, - subject: None, - }; - let wanted = t.velocity; - let moved = scene - .resolve(t.bounds(), wanted, 0.0, t.on_ground) - .unwrap_or(Vec3::ZERO); - t.position = Vec3::new( - t.position.x + moved.x, - t.position.y + moved.y, - t.position.z + moved.z, - ); - t.on_ground = wanted.y < 0.0 && moved.y != wanted.y; - if moved.x != wanted.x { - t.velocity.x = 0.0; - } - if moved.z != wanted.z { - t.velocity.z = 0.0; - } - if moved.y != wanted.y { - t.velocity.y = 0.0; - } - t.velocity = Vec3::new( - t.velocity.x * 0.98, - t.velocity.y * 0.98, - t.velocity.z * 0.98, - ); - if t.on_ground { - t.velocity = Vec3::new(t.velocity.x * 0.7, t.velocity.y * -0.5, t.velocity.z * 0.7); - } - t.fuse -= 1; + t.tick( + &self.world, + self.collision, + &self.res.assets, + &self.res.facts, + )?; if t.fuse <= 0 { let center = [ t.position.x, @@ -269,3 +312,230 @@ impl Game<'_> { } } } + +use horizon_world::{ + entity_fluid::{ + CurrentTarget, FluidInteractionWorld, FluidMembership, FluidSections, FluidTagId, + }, + fluid::{FluidHeightWorld, FluidKind, FluidState}, + fluid_flow::{FluidFlowWorld, flow_at}, +}; +const WATER: FluidTagId = FluidTagId(0); +const LAVA: FluidTagId = FluidTagId(1); +struct TntFluidWorld<'a> { + tnt: &'a mut PrimedTnt, + world: &'a horizon_client::world::World, + assets: &'a horizon_client::assets::Assets, + facts: &'a horizon_client::blocks::BlockFacts, +} +impl TntFluidWorld<'_> { + fn state(&self, p: BlockPos) -> horizon_world::registry::BlockStateId { + self.world.block(p.x, p.y, p.z) + } + fn fluid_at(&self, p: BlockPos) -> std::io::Result { + FluidState::from_block( + self.assets + .registry + .state(self.state(p)) + .ok_or_else(|| std::io::Error::other("missing TNT fluid state"))?, + ) + } +} +impl FluidMembership for TntFluidWorld<'_> { + fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool { + match tag { + WATER => matches!(kind, FluidKind::Water | FluidKind::FlowingWater), + LAVA => matches!(kind, FluidKind::Lava | FluidKind::FlowingLava), + _ => false, + } + } +} +impl CurrentTarget for TntFluidWorld<'_> { + type Error = std::io::Error; + fn is_player_class(&self) -> bool { + false + } + fn velocity(&mut self) -> std::io::Result { + Ok(self.tnt.velocity) + } + fn add_delta_movement(&mut self, v: Vec3) -> std::io::Result<()> { + self.tnt.velocity = Vec3::new( + self.tnt.velocity.x + v.x, + self.tnt.velocity.y + v.y, + self.tnt.velocity.z + v.z, + ); + Ok(()) + } +} +impl FluidInteractionWorld for TntFluidWorld<'_> { + type Error = std::io::Error; + type Chunk = (i32, i32); + fn interaction_box(&mut self) -> std::io::Result> { + Ok(Some( + self.tnt.bounds().deflate(Vec3::new(0.001, 0.001, 0.001)), + )) + } + fn loaded_chunk(&mut self, x: i32, z: i32) -> std::io::Result> { + Ok(self.world.chunks.contains_key(&(x, z)).then_some((x, z))) + } + fn chunk_sections(&mut self, _: Self::Chunk) -> std::io::Result> { + static SECTIONS: [bool; horizon_client::chunk::SECTIONS] = + [true; horizon_client::chunk::SECTIONS]; + Ok(FluidSections { + minimum_section_y: horizon_client::chunk::MIN_Y / 16, + has_fluid: &SECTIONS, + }) + } + fn bounding_box_min_y(&self) -> f64 { + self.tnt.position.y + } + fn block_x(&self) -> i32 { + self.tnt.position.x.floor() as i32 + } + fn block_z(&self) -> i32 { + self.tnt.position.z.floor() as i32 + } + fn eye_y(&mut self) -> std::io::Result { + Ok(self.tnt.position.y + f64::from(0.98f32 * 0.85f32)) + } + fn fluid_state(&mut self, p: BlockPos) -> std::io::Result { + self.fluid_at(p) + } + fn fluid_height(&mut self, s: FluidState, p: BlockPos) -> std::io::Result { + s.height_at(self, [p.x, p.y, p.z]) + } + fn camera_height(&mut self, s: FluidState, p: BlockPos) -> std::io::Result { + s.camera_height_at(self, [p.x, p.y, p.z]) + } + fn flow(&mut self, s: FluidState, p: BlockPos) -> std::io::Result { + flow_at(self, s, p) + } +} +impl FluidHeightWorld for TntFluidWorld<'_> { + type Error = std::io::Error; + fn fluid(&mut self, p: [i32; 3]) -> std::io::Result { + self.fluid_at(BlockPos::new(p[0], p[1], p[2])) + } + fn sturdy_down(&mut self, p: [i32; 3]) -> std::io::Result { + Ok(self + .facts + .get(self.state(BlockPos::new(p[0], p[1], p[2]))) + .sturdy_full + & 1 + != 0) + } +} +impl FluidFlowWorld for TntFluidWorld<'_> { + type Error = std::io::Error; + type Block = horizon_world::registry::BlockStateId; + fn fluid(&mut self, p: BlockPos) -> std::io::Result { + self.fluid_at(p) + } + fn block(&mut self, p: BlockPos) -> std::io::Result { + Ok(self.state(p)) + } + fn blocks_fluid_flow(&self, s: Self::Block) -> bool { + self.assets + .blocks_fluid_flow + .contains(&self.assets.registry.state(s).unwrap().name) + } + fn is_ice_class(&self, s: Self::Block) -> bool { + self.facts + .get(s) + .classes + .iter() + .any(|c| c.as_ref() == "IceBlock") + } + fn is_face_sturdy( + &mut self, + s: Self::Block, + _: BlockPos, + d: horizon_core::geometry::Direction, + ) -> std::io::Result { + Ok(self.facts.get(s).sturdy_full & (1 << d as u8) != 0) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn primed_tnt_follows_water_currents_after_moving() { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client/26.3"); + if !root.join("movement-properties.nbt").exists() { + return; + } + let assets = horizon_client::assets::Assets::load(&root).unwrap(); + let facts = horizon_client::blocks::BlockFacts::load(&root, assets.registry).unwrap(); + let collision = horizon_client::collisions::load(&root, assets.registry).unwrap(); + let mut world = horizon_client::world::World::test_scene(&assets, 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..=22 { + for z in 19..=21 { + world.set(x, 3, z, stone).unwrap(); + } + } + world.set(20, 4, 20, water).unwrap(); + world.set(21, 4, 20, flowing).unwrap(); + let at = Vec3::new(20.5, 4.0, 20.5); + let mut tnt = PrimedTnt { + position: at, + previous: at, + velocity: Vec3::ZERO, + fuse: 80, + on_ground: false, + }; + tnt.tick(&world, &collision, &assets, &facts).unwrap(); + assert_eq!( + tnt.position.x, at.x, + "current is applied after motion, not before" + ); + assert!( + (tnt.velocity.x - 0.014).abs() < 1e-12, + "water must push primed TNT east: {:?}", + tnt.velocity + ); + assert_eq!(tnt.fuse, 79); + tnt.tick(&world, &collision, &assets, &facts).unwrap(); + assert!((tnt.position.x - at.x - 0.014).abs() < 1e-12); + assert!(tnt.on_ground); + tnt.position = at; + tnt.velocity = Vec3::ZERO; + tnt.fuse = 1; + tnt.tick(&world, &collision, &assets, &facts).unwrap(); + assert_eq!(tnt.fuse, 0); + assert_eq!( + tnt.velocity.x, 0.0, + "expired TNT must not receive a current" + ); + world.set(21, 4, 20, water).unwrap(); + tnt.position = at; + tnt.velocity = Vec3::ZERO; + tnt.fuse = 80; + tnt.tick(&world, &collision, &assets, &facts).unwrap(); + assert_eq!( + tnt.velocity.x, 0.0, + "still water must not add horizontal motion" + ); + world + .set( + 20, + 3, + 20, + assets.registry.default_state("minecraft:air").unwrap(), + ) + .unwrap(); + tnt.on_ground = false; + tnt.velocity = Vec3::ZERO; + tnt.tick(&world, &collision, &assets, &facts).unwrap(); + assert!( + tnt.position.y < at.y && tnt.velocity.y < 0.0, + "TNT sinks; water does not add buoyancy" + ); + } +}