diff --git a/crates/horizon-client/examples/probe/emitter_particles_probe.rs b/crates/horizon-client/examples/probe/emitter_particles_probe.rs index 6349eb8dc..949b306ff 100644 --- a/crates/horizon-client/examples/probe/emitter_particles_probe.rs +++ b/crates/horizon-client/examples/probe/emitter_particles_probe.rs @@ -54,7 +54,7 @@ pub fn main() -> Result<()> { match c["axis"].as_i64() { Some(axis @ 0..=2) => { let line = record("electric_spark"); - particles::along_axis(&mut random, axis as usize, p, |p, v| { + particles::along_axis(&mut random, axis as usize, p, (10, 19), |p, v| { lines.push(line(p, v)) }); } diff --git a/crates/horizon-client/examples/probe/marker_particles_probe.rs b/crates/horizon-client/examples/probe/marker_particles_probe.rs index 72ebaff22..3041a84d7 100644 --- a/crates/horizon-client/examples/probe/marker_particles_probe.rs +++ b/crates/horizon-client/examples/probe/marker_particles_probe.rs @@ -75,6 +75,10 @@ pub fn main() -> Result<()> { registry: assets.registry, raining_at: &|_| false, marker: target.map(|name| (name, &options as &dyn Fn(_) -> _)), + model_offset: &|_, _, _| None, + gateway_particles: &|_, _| 0, + thundering: false, + ultrawarm: false, }; engine.seed_randoms(1057, 0, 0); engine.requested = Some(Vec::new()); diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs index 48e8f16f4..ad160d787 100644 --- a/crates/horizon-client/src/animate_tick.rs +++ b/crates/horizon-client/src/animate_tick.rs @@ -8,7 +8,7 @@ use crate::{ blocks::{BlockFacts, Fluid}, command::args::GameMode, items::ItemStack, - particles::{ParticleEngine, ParticleOptions, ParticleType as T}, + particles::{ParticleEngine, ParticleOptions, ParticleType as T, along_axis}, world::World, }; use horizon_core::{ @@ -67,6 +67,22 @@ enum Animate { waterlogged: bool, }, EndPortal, + /// A powered lever: its facing and the direction it is attached toward. + Lever { + facing: [i32; 3], + connected: [i32; 3], + }, + /// A powered repeater. + Repeater { + facing: [i32; 3], + delay: i32, + }, + /// A free-hanging stalactite tip that is not waterlogged. + PointedDripstone, + WitherRose, + EndGateway, + /// A lightning rod, by the axis it points along (0, 1, 2 for X, Y, Z). + LightningRod(usize), } fn step(facing: &str) -> [i32; 3] { match facing { @@ -81,6 +97,7 @@ fn step(facing: &str) -> [i32; 3] { fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { let name = name.strip_prefix("minecraft:").unwrap_or(name); let lit = prop("lit").as_deref() == Some("true"); + let powered = prop("powered").as_deref() == Some("true"); let facing = || step(&prop("facing").unwrap_or_default()); match name { "torch" => Animate::Torch(T::Flame), @@ -145,6 +162,38 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option) -> Animate { waterlogged: prop("waterlogged").as_deref() == Some("true"), }, "end_portal" => Animate::EndPortal, + "lever" if powered => Animate::Lever { + facing: facing(), + // FaceAttachedHorizontalDirectionalBlock.getConnectedDirection. + connected: match prop("face").as_deref() { + Some("ceiling") => [0, -1, 0], + Some("floor") => [0, 1, 0], + _ => facing(), + }, + }, + "repeater" if powered => Animate::Repeater { + facing: facing(), + delay: prop("delay").and_then(|d| d.parse().ok()).unwrap_or(1), + }, + "pointed_dripstone" + if prop("vertical_direction").as_deref() == Some("down") + && prop("thickness").as_deref() == Some("tip") + && prop("waterlogged").as_deref() != Some("true") => + { + Animate::PointedDripstone + } + "wither_rose" => Animate::WitherRose, + "end_gateway" => Animate::EndGateway, + _ if name == "lightning_rod" || name.ends_with("_lightning_rod") => { + let [dx, dy, _] = facing(); + Animate::LightningRod(if dx != 0 { + 0 + } else if dy != 0 { + 1 + } else { + 2 + }) + } "sculk_sensor" | "calibrated_sculk_sensor" if prop("sculk_sensor_phase").as_deref() == Some("active") => { @@ -192,6 +241,8 @@ pub struct AnimateTables { dried_ghast_sounds: Vec, /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`). ambient: Vec>, + /// Per state: 1 for a pointed dripstone, 2 for one whose tip points down. + dripstone: Vec, } impl AnimateTables { pub fn load(root: &Path, registry: &BlockRegistry, biomes: &Biomes) -> crate::Result { @@ -242,8 +293,25 @@ impl AnimateTables { } } } + let dripstone = (0..registry.len() as u32) + .map(|id| { + registry.state(BlockStateId(id)).map_or(0, |s| { + let name = s.name.strip_prefix("minecraft:").unwrap_or(&s.name); + if name != "pointed_dripstone" { + 0 + } else if s.properties.get("vertical_direction").map(String::as_str) + == Some("down") + { + 2 + } else { + 1 + } + }) + }) + .collect(); Ok(Self { kinds, + dripstone, impermeable: by_state("minecraft:impermeable"), power_provider: by_state("minecraft:enchantment_power_provider"), power_transmitter: by_state("minecraft:enchantment_power_transmitter"), @@ -274,6 +342,14 @@ pub struct AnimateContext<'a> { pub raining_at: &'a dyn Fn([i32; 3]) -> bool, /// Creative main-hand marker block and a resolver for each placed state's sprite. pub marker: Option<(&'a str, &'a dyn Fn(BlockStateId) -> Option)>, + /// `BlockState.getOffset` of a state at (x, z), for blocks with a random model offset. + pub model_offset: &'a dyn Fn(BlockStateId, i32, i32) -> Option<[f64; 3]>, + /// `TheEndGatewayBlockEntity.getParticleAmount` of the gateway state at a position. + pub gateway_particles: &'a dyn Fn(BlockStateId, [i32; 3]) -> usize, + /// `Level.isThundering`. + pub thundering: bool, + /// The dimension has `water_evaporates` and drips lava from dripstone (the Nether). + pub ultrawarm: bool, } /// `ClientLevel.getMarkerParticleTarget`: only the selected main-hand item counts. @@ -322,6 +398,9 @@ impl AnimateContext<'_> { ], )) } + fn offset_of(&self, state: BlockStateId, p: [i32; 3]) -> [f64; 3] { + (self.model_offset)(state, p[0], p[2]).unwrap_or([0.0; 3]) + } fn foliage(&self, p: [i32; 3]) -> u32 { let biome = self .world @@ -919,6 +998,99 @@ fn block_animate_tick( let p = [fx + r.next_double(), fy + 0.8, fz + r.next_double()]; add(engine, T::Smoke, p, [0.0; 3]); } + Animate::Lever { facing, connected } => { + // LeverBlock.animateTick: a powered lever puffs red dust a quarter of the time. + if engine.random().next_float() < 0.25 { + // LeverBlock.makeParticle with scale 0.5. + let at = |base: f64, i: usize| { + base + 0.5 + 0.1 * f64::from(-facing[i]) + 0.2 * f64::from(-connected[i]) + }; + let p = [at(fx, 0), at(fy, 1), at(fz, 2)]; + engine.add(&ParticleOptions::dust([1.0, 0.0, 0.0], 0.5), p, [0.0; 3]); + } + } + Animate::Repeater { facing, delay } => { + // RepeaterBlock.animateTick: dust at one of the torches. + let r = engine.random(); + let x = fx + 0.5 + (r.next_double() - 0.5) * 0.2; + let y = fy + 0.4 + (r.next_double() - 0.5) * 0.2; + let z = fz + 0.5 + (r.next_double() - 0.5) * 0.2; + let mut offset = -5.0f32; + if r.next_boolean() { + offset = (delay * 2 - 1) as f32; + } + offset /= 16.0; + let xo = f64::from(offset * facing[0] as f32); + let zo = f64::from(offset * facing[2] as f32); + redstone(engine, [x + xo, y, z + zo]); + } + Animate::PointedDripstone => dripstone_drip(tables, engine, ctx, state, pos), + Animate::WitherRose => { + // WitherRoseBlock.animateTick: smoke puffs at the centre of the shape. + let center = ctx.shape_y(pos).map_or([0.5; 2], |s| { + [(s.2[0] + s.2[1]) / 2.0, (s.2[2] + s.2[3]) / 2.0] + }); + let offset = ctx.offset_of(state, pos); + let x = fx + center[0] + offset[0]; + let z = fz + center[1] + offset[2]; + for _ in 0..3 { + let r = engine.random(); + if r.next_boolean() { + let p = [ + x + r.next_double() / 5.0, + fy + (0.5 - r.next_double()), + z + r.next_double() / 5.0, + ]; + add(engine, T::Smoke, p, [0.0; 3]); + } + } + } + Animate::EndGateway => { + // EndGatewayBlock.animateTick: portal particles, one for each visible face. + for _ in 0..(ctx.gateway_particles)(state, pos) { + let r = engine.random(); + let mut p = [ + fx + r.next_double(), + fy + r.next_double(), + fz + r.next_double(), + ]; + let mut v = [ + (r.next_double() - 0.5) * 0.5, + (r.next_double() - 0.5) * 0.5, + (r.next_double() - 0.5) * 0.5, + ]; + let flip = next_int(r, 2) * 2 - 1; + if r.next_boolean() { + p[2] = fz + 0.5 + 0.25 * f64::from(flip); + v[2] = f64::from(r.next_float() * 2.0 * flip as f32); + } else { + p[0] = fx + 0.5 + 0.25 * f64::from(flip); + v[0] = f64::from(r.next_float() * 2.0 * flip as f32); + } + add(engine, T::Portal, p, v); + } + } + Animate::LightningRod(axis) => { + // LightningRodBlock.animateTick: in a thunderstorm, sparks along the + // topmost rod, more often as the game time within 200 ticks grows. + if ctx.thundering + && i64::from(next_int(engine.level_random(), 200)) <= ctx.world.game_time % 200 + && pos[1] + == ctx + .world + .world_surface(pos[0], pos[2], |id| ctx.facts.is_air(id)) + - 1 + { + let mut sparks = Vec::new(); + along_axis(engine.level_random(), axis, pos, (1, 2), |p, v| { + sparks.push((p, v)); + }); + let options = ParticleOptions::simple(T::ElectricSpark); + for (p, v) in sparks { + engine.add(&options, p, v); + } + } + } Animate::EnderChest => { for _ in 0..3 { let r = engine.random(); @@ -1118,6 +1290,68 @@ fn block_animate_tick( } } } +/// `PointedDripstoneBlock.animateTick`: a free-hanging stalactite tip drips the +/// fluid above the root of its stalactite. +fn dripstone_drip( + tables: &AnimateTables, + engine: &mut ParticleEngine, + ctx: &AnimateContext, + state: BlockStateId, + pos: [i32; 3], +) { + let roll = engine.random().next_float(); + if roll > 0.12 { + return; + } + // getFluidAboveStalactite: findRootBlock climbs at most ten blocks of + // stalactite and stops at the first block that is not pointed dripstone. + let mut root = None; + for step in 1..11 { + let p = [pos[0], pos[1] + step, pos[2]]; + match tables + .dripstone + .get(ctx.state(p).0 as usize) + .copied() + .unwrap_or(0) + { + 0 => { + root = Some(p); + break; + } + 2 => {} + _ => return, + } + } + let Some(root) = root else { + return; + }; + let above = ctx.facts.get(ctx.state([root[0], root[1] + 1, root[2]])); + // Mud above the root counts as a water source unless water evaporates here. + let (fluid, source) = if &*above.name == "minecraft:mud" && !ctx.ultrawarm { + (Fluid::Water, true) + } else { + (above.fluid, above.fluid_level >= 8 && !above.fluid_falling) + }; + // canFillCauldron: only a water or lava source passes below a 2% roll. + if roll >= 0.02 && !(fluid != Fluid::None && source) { + return; + } + // getDripParticle: no fluid drips what the dimension's default says. + let lava = fluid == Fluid::Lava || (fluid == Fluid::None && ctx.ultrawarm); + let ty = if lava { + T::DrippingDripstoneLava + } else { + T::DrippingDripstoneWater + }; + let offset = ctx.offset_of(state, pos); + // STALACTITE_DRIP_START_PIXEL is the tip's lowest point, 5/16. + let p = [ + f64::from(pos[0]) + 0.5 + offset[0], + f64::from(pos[1]) + 0.3125 - 0.0625, + f64::from(pos[2]) + 0.5 + offset[2], + ]; + add(engine, ty, p, [0.0; 3]); +} /// `AbstractCandleBlock.addParticlesAndSound`. fn candle(engine: &mut ParticleEngine, p: [f64; 3]) { let r = engine.random(); diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs index 10c5e2509..b8146a63f 100644 --- a/crates/horizon-client/src/block_entity_render.rs +++ b/crates/horizon-client/src/block_entity_render.rs @@ -931,6 +931,30 @@ impl BlockEntityRenderer { let lights = diffuse_lights(scene.nether); self.render_one(scene, pos, kind, base, packed, lights, false, false, out); } + /// `TheEndGatewayBlockEntity.shouldRenderFace` for each face of the gateway + /// at `pos`: the faces its portal is drawn on. + pub fn gateway_faces( + &self, + world: &World, + state: BlockStateId, + pos: [i32; 3], + ) -> Vec { + Direction::ALL + .into_iter() + .filter(|&d| { + let [dx, dy, dz] = d.normal(); + let neighbor = world.block(pos[0] + dx, pos[1] + dy, pos[2] + dz); + self.visibility.as_ref().is_none_or(|v| { + v.lock() + .map(|mut v| { + v.should_render_face(state, neighbor, d, true) + .unwrap_or(true) + }) + .unwrap_or(true) + }) + }) + .collect() + } /// Whether this block state has a block-entity renderer here. pub fn renders(&self, state: u32) -> bool { !matches!(self.kind(state), Kind::None) @@ -1431,22 +1455,8 @@ impl BlockEntityRenderer { out, ); } - // AbstractEndPortalRenderer.extractRenderState: TheEndGatewayBlockEntity.shouldRenderFace. - let faces: Vec = Direction::ALL - .into_iter() - .filter(|&d| { - let [dx, dy, dz] = d.normal(); - let neighbor = scene.world.block(pos[0] + dx, pos[1] + dy, pos[2] + dz); - self.visibility.as_ref().is_none_or(|v| { - v.lock() - .map(|mut v| { - v.should_render_face(BlockStateId(*state), neighbor, d, true) - .unwrap_or(true) - }) - .unwrap_or(true) - }) - }) - .collect(); + // AbstractEndPortalRenderer.extractRenderState. + let faces = self.gateway_faces(scene.world, BlockStateId(*state), pos); portal_cube(base, &faces, END_GATEWAY_LAYER, out); } Kind::Conduit => { diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs index f12aedc5b..deb739f96 100644 --- a/crates/horizon-client/src/game/level_particles.rs +++ b/crates/horizon-client/src/game/level_particles.rs @@ -33,7 +33,7 @@ impl Game<'_> { // 3002 with an axis: a lightning rod; otherwise copper cleaned by lightning. match usize::try_from(data) { Ok(axis) if id == 3002 && axis < 3 => { - particles::along_axis(random, axis, p, |p, v| spawned.push((p, v))); + particles::along_axis(random, axis, p, (10, 19), |p, v| spawned.push((p, v))); } _ => particles::on_block_faces(random, p, |p, v| spawned.push((p, v))), } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index e013c8d29..45d777986 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -271,6 +271,16 @@ impl Game<'_> { && motion_blocking(world, facts, p[0], p[2], p[1] + 64) <= p[1] && rains_at(world, biomes, p[0], p[1], p[2]) }; + let tables = &self.pack.context.tables; + let model_offset = |state, x, z| tables.offset(state, x, z); + let gateway_particles = |state, p| { + self.res + .block_entity_render() + .gateway_faces(world, state, p) + .len() + }; + // Level.isThundering: a thunder level above 0.9 where the sky is open. + let thundering = self.dim == Dim::Overworld && world.weather.levels(1.0).1 > 0.9; let ctx = AnimateContext { world, facts, @@ -279,6 +289,10 @@ impl Game<'_> { registry: self.pack.assets.registry, raining_at: &raining_at, marker: marker.map(|name| (name, &marker_options as &dyn Fn(_) -> _)), + model_offset: &model_offset, + gateway_particles: &gateway_particles, + thundering, + ultrawarm: self.dim == Dim::Nether, }; if let Some(e) = eye { let block = [ diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs index fa9dc9c6e..0c43204e8 100644 --- a/crates/horizon-client/src/particles.rs +++ b/crates/horizon-client/src/particles.rs @@ -782,15 +782,17 @@ pub fn on_block_faces( } } /// `ParticleUtils.spawnParticlesAlongAxis(axis, level, pos, 0.125, particle, -/// UniformInt.of(10, 19))` (level event 3002 on a lightning rod): sparks along -/// the rod, moving along it. `axis` is 0, 1, 2 for X, Y, Z. +/// UniformInt.of(min, max))` (`count` is the range; level event 3002 on a +/// lightning rod uses 10 to 19): sparks along the rod, moving along it. +/// `axis` is 0, 1, 2 for X, Y, Z. pub fn along_axis( random: &mut impl RandomSource, axis: usize, pos: [i32; 3], + (min, max): (i32, i32), mut emit: impl FnMut([f64; 3], [f64; 3]), ) { - let count = random.next_int_bound(19 - 10 + 1).unwrap_or(0) + 10; + let count = random.next_int_bound(max - min + 1).unwrap_or(0) + min; for _ in 0..count { let p: [f64; 3] = std::array::from_fn(|i| { f64::from(pos[i])