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.
This commit is contained in:
Kacpherek
2026-10-27 22:07:24 +01:00
parent 93d77962ee
commit 16cda1637b
4 changed files with 149 additions and 18 deletions
+3 -1
View File
@@ -444,6 +444,8 @@ pub struct EntityView {
pub gamemode: Option<String>,
/// Lightning: entities it struck.
pub struck: Vec<EntityView>,
/// Lightning: blocks it set on fire (`LightningBolt.blocksSetOnFire`).
pub blocks_set_on_fire: i32,
pub fishing_open_water: Option<bool>,
pub variant: Option<String>,
/// 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()
@@ -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();
+72 -8
View File
@@ -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<u32>,
/// The mobs it has struck (`hitEntities`).
hit: Vec<u32>,
/// 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<Option<u32>>,
}
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<EntityView> = 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<EntityView> {
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<horizon_client::gfx::lightning::Bolt> {
+16 -9
View File
@@ -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<u32>) {
// 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<u32>) {
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;