From 16cda1637bdae385d9e1dfbce2ed41cf9f377053 Mon Sep 17 00:00:00 2001 From: Kacpherek Date: Tue, 27 Oct 2026 22:07:24 +0100 Subject: [PATCH] Fire lightning_strike and channeled_lightning for the right players Vanilla's LightningBolt fires LIGHTNING_STRIKE when it is discarded, for players within 256 blocks, counting the fires it set and the mobs it missed as bystanders, and CHANNELED_LIGHTNING for the player who channelled it. The lightning rod advancement no longer passes for every bolt. --- crates/horizon-client/src/advancements.rs | 4 +- .../horizon-client/src/game/advancements.rs | 58 ++++++++++++++ crates/horizon-client/src/game/lightning.rs | 80 +++++++++++++++++-- crates/horizon-client/src/game/trident.rs | 25 +++--- 4 files changed, 149 insertions(+), 18 deletions(-) diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs index 229510dd7..0846132df 100644 --- a/crates/horizon-client/src/advancements.rs +++ b/crates/horizon-client/src/advancements.rs @@ -444,6 +444,8 @@ pub struct EntityView { pub gamemode: Option, /// Lightning: entities it struck. pub struck: Vec, + /// Lightning: blocks it set on fire (`LightningBolt.blocksSetOnFire`). + pub blocks_set_on_fire: i32, pub fishing_open_water: Option, pub variant: Option, /// The data components the entity reports (`Entity.get`): id and value. @@ -734,7 +736,7 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo .is_some_and(|t| entity(&p["looking_at"], t, w, origin))) } "minecraft:type_specific/lightning" => { - range_i(&p["blocks_set_on_fire"], 0) + range_i(&p["blocks_set_on_fire"], i64::from(e.blocks_set_on_fire)) && (p["entity_struck"].is_null() || e.struck .iter() diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 79e836322..39d4718ca 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -1007,6 +1007,64 @@ impl Game<'_> { adv::conditions(&c["location"], &ctx, w) }); } + /// `LightningStrikeTrigger`: the bolt, and the mobs around it that it did + /// not hit (`bystander`), each tested from this player's position. + pub(super) fn trigger_lightning_strike(&mut self, bolt: &EntityView, viewers: &[EntityView]) { + let me = self.player_entity(); + let (bolt, viewers) = (bolt.clone(), viewers.to_vec()); + self.trigger("minecraft:lightning_strike", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + let bctx = adv::Entities { + this: Some(&bolt), + ..pctx + }; + adv::conditions(&c["player"], &pctx, w) + && adv::conditions(&c["lightning"], &bctx, w) + && (c["bystander"].is_null() + || viewers.iter().any(|v| { + adv::conditions( + &c["bystander"], + &adv::Entities { + this: Some(v), + ..pctx + }, + w, + ) + })) + }); + } + /// `ChanneledLightningTrigger`: each victim condition matched by some + /// mob the bolt hit, from the player who channelled it. + pub(super) fn trigger_channeled_lightning(&mut self, victims: &[EntityView]) { + let me = self.player_entity(); + let victims = victims.to_vec(); + self.trigger("minecraft:channeled_lightning", move |c, w| { + let pctx = adv::Entities { + this: Some(&me), + origin: me.position, + tool: None, + block_pos: None, + }; + adv::conditions(&c["player"], &pctx, w) + && c["victims"].as_array().into_iter().flatten().all(|want| { + victims.iter().any(|v| { + adv::conditions( + want, + &adv::Entities { + this: Some(v), + ..pctx + }, + w, + ) + }) + }) + }); + } /// A trigger with only the player condition (slept_in_bed, started_riding). pub(super) fn trigger_player(&mut self, name: &str) { let me = self.player_entity(); diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs index 6caf4458a..3bfb89e83 100644 --- a/crates/horizon-client/src/game/lightning.rs +++ b/crates/horizon-client/src/game/lightning.rs @@ -4,7 +4,8 @@ //! `thunderHit` (damage and burning, charged creepers, zombified piglins, //! witches, mooshroom colours, turtles, burnt items), lightning rods, the sky //! flash, the sounds and the branching additive bolt. -use super::Game; +use super::{Game, commands::Target}; +use horizon_client::advancements::EntityView; use horizon_client::mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species}; use horizon_core::{position::BlockPos, random::RandomSource}; @@ -18,6 +19,13 @@ pub(super) struct Bolt { visual_only: bool, /// Mooshrooms and copper golems change once per bolt. converted: Vec, + /// The mobs it has struck (`hitEntities`). + hit: Vec, + /// Blocks it set on fire (`blocksSetOnFire`). + fires: i32, + /// The player who channelled it (`LightningBolt.cause`): `Some(None)` for + /// the host, `Some(Some(conn))` for a guest. + pub cause: Option>, } impl Game<'_> { /// `ServerChunkCache.tickSpawningChunk`: one `tickThunder` roll per @@ -206,6 +214,9 @@ impl Game<'_> { seed, visual_only, converted: Vec::new(), + hit: Vec::new(), + fires: 0, + cause: None, }); } /// `ClientLevel.addEntity` for a server's lightning bolt: on a client it @@ -224,11 +235,16 @@ impl Game<'_> { seed, visual_only: true, converted: Vec::new(), + hit: Vec::new(), + fires: 0, + cause: None, }); } /// `spawnFire`: fire at the strike point and `extra` random neighbours, - /// wherever `BaseFireBlock.getState` fire can survive. - fn bolt_fire(&mut self, at: [f64; 3], extra: i32) { + /// wherever `BaseFireBlock.getState` fire can survive. Returns how many + /// blocks it set on fire. + fn bolt_fire(&mut self, at: [f64; 3], extra: i32) -> i32 { + let mut set = 0; let base = [ at[0].floor() as i32, at[1].floor() as i32, @@ -253,8 +269,10 @@ impl Game<'_> { }); if let Some(fire) = fire { let _ = self.level_set(p, fire); + set += 1; } } + set } /// `LightningBolt.tick` for every bolt. pub(super) fn tick_bolts(&mut self) { @@ -278,7 +296,7 @@ impl Game<'_> { if !b.visual_only { // Only Normal and Hard start fires with the strike itself. if self.ui.difficulty >= 2 { - self.bolt_fire(b.at, 4); + b.fires += self.bolt_fire(b.at, 4); } self.strike_rod(b.at); } @@ -293,6 +311,7 @@ impl Game<'_> { b.life -= 1; if b.life < 0 { if b.flashes == 0 { + self.lightning_strike_triggers(b); return false; } if b.life < -self.world.random.next_int_bound(10).unwrap_or(0) { @@ -300,7 +319,7 @@ impl Game<'_> { b.life = 1; b.seed = self.world.random.next_long(); if !b.visual_only { - self.bolt_fire(b.at, 0); + b.fires += self.bolt_fire(b.at, 0); } } } @@ -310,7 +329,11 @@ impl Game<'_> { } self.flash = 2; if !b.visual_only { - self.thunder_hit(b); + let struck = self.thunder_hit(b); + if let Some(cause) = b.cause { + let who = cause.map_or(Target::Player, Target::Guest); + self.for_player(who, |g| g.trigger_channeled_lightning(&struck)); + } } } true @@ -355,8 +378,41 @@ impl Game<'_> { self.with_level(|b, level, ticks| b.lightning_clear_copper(level, ticks, p)); let _ = self.process_level_events(); } - /// `thunderHit` for entities within 3 blocks (up to 9 above). - fn thunder_hit(&mut self, b: &mut Bolt) { + /// `LightningStrikeTrigger` at the bolt's discard: every player within 256 + /// blocks, with the mobs in its 30-block box that it did not hit. + fn lightning_strike_triggers(&mut self, b: &Bolt) { + let at = b.at; + let bolt = EntityView { + kind: "minecraft:lightning_bolt".into(), + position: at, + blocks_set_on_fire: b.fires, + ..Default::default() + }; + let viewers: Vec = self + .mobs + .iter() + .filter(|m| m.alive() && !b.hit.contains(&m.id)) + .filter(|m| { + (m.position.x - at[0]).abs() <= 15.0 + && (m.position.z - at[2]).abs() <= 15.0 + && m.position.y >= at[1] - 15.0 + && m.position.y <= at[1] + 21.0 + }) + .map(|m| self.mob_entity(m)) + .collect(); + self.for_each_player(|g| { + let Some(p) = g.player.as_ref().map(|p| p.position) else { + return; + }; + let d2 = (p.x - at[0]).powi(2) + (p.y - at[1]).powi(2) + (p.z - at[2]).powi(2); + if d2 < 256.0 * 256.0 { + g.trigger_lightning_strike(&bolt, &viewers); + } + }); + } + /// `thunderHit` for entities within 3 blocks (up to 9 above). Returns the + /// mobs in that box before the hit, as `CHANNELED_LIGHTNING` counts them. + fn thunder_hit(&mut self, b: &mut Bolt) -> Vec { let at = b.at; let inside = move |p: [f64; 3]| { (p[0] - at[0]).abs() <= 3.0 @@ -364,6 +420,13 @@ impl Game<'_> { && p[1] >= at[1] - 3.0 && p[1] <= at[1] + 9.0 }; + let struck: Vec<(u32, EntityView)> = self + .mobs + .iter() + .filter(|m| m.alive() && inside([m.position.x, m.position.y, m.position.z])) + .map(|m| (m.id, self.mob_entity(m))) + .collect(); + b.hit.extend(struck.iter().map(|(id, _)| *id)); let damage = Damage { kind: DamageKind::Generic, attacker: None, @@ -461,6 +524,7 @@ impl Game<'_> { !inside([e.position.x, e.position.y, e.position.z]) || e.stack.item.contains("netherite") }); + struck.into_iter().map(|(_, view)| view).collect() } /// Simulation-order render inputs; seeded geometry lives in the renderer. pub(super) fn bolt_instances(&self) -> Vec { diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs index b333156e1..2d6ddb878 100644 --- a/crates/horizon-client/src/game/trident.rs +++ b/crates/horizon-client/src/game/trident.rs @@ -225,7 +225,7 @@ impl Game<'_> { /// The `summon_entity` and `play_sound` effects of `channeling.json`: in a /// thunderstorm (`weather_check`) a spot that sees the sky (`can_see_sky`) /// gets a lightning bolt and the thunder sound. - fn channel_lightning(&mut self, at: [f64; 3]) { + fn channel_lightning(&mut self, at: [f64; 3], guest: Option) { // Level.isThundering: the thunder level, in dimensions with weather. if self.dim != super::Dim::Overworld || self.world.weather.levels(1.0).1 <= 0.9 { return; @@ -240,13 +240,17 @@ impl Game<'_> { return; } self.spawn_bolt(at, false); + // The summon effect's owner is the thrower: LightningBolt.setCause. + if let Some(bolt) = self.bolts.last_mut() { + bolt.cause = Some(guest); + } self.audio .play("minecraft:item.trident.thunder", Some(at), 5.0, 1.0); } /// `minecraft:hit_block` of Channeling (`AbstractArrow.hitBlockEnchantmentEffects`): /// the block the trident's path first hits, if it is a lightning rod, with /// the hit location clamped into the block (`BlockPos.clampLocationWithin`). - fn channel_rod_hit(&mut self, from: Vec3, velocity: Vec3) { + fn channel_rod_hit(&mut self, from: Vec3, velocity: Vec3, guest: Option) { let to = Vec3::new( from.x + velocity.x, from.y + velocity.y, @@ -279,11 +283,14 @@ impl Game<'_> { let edge = f64::from(1.0e-5f32); let clamp = |v: f64, origin: i32| v.clamp(f64::from(origin) + edge, f64::from(origin) + 1.0 - edge); - self.channel_lightning([ - clamp(hit.location.x, hit.block.x), - clamp(hit.location.y, hit.block.y), - clamp(hit.location.z, hit.block.z), - ]); + self.channel_lightning( + [ + clamp(hit.location.x, hit.block.x), + clamp(hit.location.y, hit.block.y), + clamp(hit.location.z, hit.block.z), + ], + guest, + ); } /// `TridentItem.releaseUsing`. pub(super) fn release_trident(&mut self, ticks: u32) { @@ -514,7 +521,7 @@ impl Game<'_> { if let Some(at) = hurt_at && t.stack.enchantment_level("minecraft:channeling") > 0 { - self.channel_lightning(at); + self.channel_lightning(at, t.guest); } if hurt_at.is_some() && let Some(m) = self.mobs.iter().find(|m| m.id == id) @@ -558,7 +565,7 @@ impl Game<'_> { ); if blocked { if t.stack.enchantment_level("minecraft:channeling") > 0 { - self.channel_rod_hit(from, flight); + self.channel_rod_hit(from, flight, t.guest); } t.in_ground = true; t.velocity = Vec3::ZERO;