Make the Particles option thin every particle, explosion debris and rain splash

The Particles option only changed two effects. Follow ClientLevel.doAddParticle
and calculateParticleLevel in the one add path: Decreased drops a third, Minimal
drops all but the always-visible and limiter-overriding particles. Explosion
block debris is thrown only on All, and rain splashes halve on Decreased and
stop on Minimal.
This commit is contained in:
Kacpherek
2026-10-26 22:28:10 +01:00
parent 7e82902d15
commit a146754b0b
7 changed files with 65 additions and 40 deletions
+8 -4
View File
@@ -357,6 +357,10 @@ impl AnimateContext<'_> {
fn add(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
engine.add(&ParticleOptions::simple(ty), p, v);
}
/// `Level.addAlwaysVisibleParticle`: still shown under the Minimal option now and then.
fn add_visible(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
engine.add_with(&ParticleOptions::simple(ty), p, v, false, true);
}
fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) {
engine.sounds.push((name, p, volume, pitch));
}
@@ -869,7 +873,7 @@ fn block_animate_tick(
fy + 1.0 + f64::from(r.next_float()),
fz + f64::from(r.next_float()),
];
add(engine, T::SulfurBubbles, p, [0.0; 3]);
add_visible(engine, T::SulfurBubbles, p, [0.0; 3]);
}
if next_int(engine.random(), 10) == 0 {
let name = "minecraft:block.potent_sulfur.noxious_gas";
@@ -1086,7 +1090,7 @@ fn block_animate_tick(
}
Animate::BubbleColumn { drag } => {
if drag {
add(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
add_visible(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
let r = engine.random();
if next_int(r, 200) == 0 {
let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
@@ -1099,7 +1103,7 @@ fn block_animate_tick(
);
}
} else {
add(
add_visible(
engine,
T::BubbleColumnUp,
[fx + 0.5, fy, fz + 0.5],
@@ -1111,7 +1115,7 @@ fn block_animate_tick(
fy + f64::from(r.next_float()),
fz + f64::from(r.next_float()),
];
add(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
add_visible(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
let r = engine.random();
if next_int(r, 200) == 0 {
let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
+3 -1
View File
@@ -2127,10 +2127,12 @@ impl Game<'_> {
c.at[1],
c.at[2] + f64::from(a.sin() * d),
];
self.particles.add(
self.particles.add_with(
&ParticleOptions::simple(ParticleType::DragonBreath),
at,
[0.0, 0.0, 0.0],
false,
true,
);
}
// AreaEffectCloud: after its 20-tick wait, every 20 ticks per entity.
@@ -151,14 +151,10 @@ impl Game<'_> {
return;
};
let (d, s) = (p.dist.map(f64::from), p.max_speed.map(f64::from));
// ClientLevel.addParticle: the camera's 32 blocks unless the packet
// (`force`) or the type overrides the limiter.
// ClientLevel.addParticle: the camera's 32 blocks and the Particles
// option, unless the packet or the type overrides the limiter.
let add = |particles: &mut horizon_client::particles::ParticleEngine, at, v| {
if p.override_limiter {
particles.create(&options, at, v);
} else {
particles.add(&options, at, v);
}
particles.add_with(&options, at, v, p.override_limiter, p.always_show);
};
if p.count == 0 {
add(
@@ -9,13 +9,12 @@ use horizon_world::level::LevelEvent;
impl Game<'_> {
pub(super) fn dragon_egg_particles(&mut self, pos: [i32; 3], data: i32) {
self.particles
.block_teleportation(pos, data, [16, 8, 16], self.settings.particles);
self.particles.block_teleportation(pos, data, [16, 8, 16]);
}
/// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
self.particles
.block_teleportation(pos, data, [127, 127, 127], self.settings.particles);
.block_teleportation(pos, data, [127, 127, 127]);
}
/// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client
/// level's random.
@@ -452,7 +452,7 @@ impl Game<'_> {
];
(c.particle.clone(), v)
};
self.particles.add(&options, at, velocity);
self.particles.add_with(&options, at, velocity, false, true);
}
}
}
@@ -244,6 +244,7 @@ impl Game<'_> {
1.0,
);
}
self.particles.particle_level = self.settings.particles;
if let Some(e) = eye {
self.particles.camera = e;
}
@@ -292,7 +293,8 @@ impl Game<'_> {
let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231));
let radius = 10;
let diameter = 2 * radius + 1;
let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32;
let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32
/ if self.settings.particles == 1 { 2 } else { 1 };
for _ in 0..count {
let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius;
let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius;
@@ -304,6 +306,10 @@ impl Game<'_> {
{
continue;
}
// The Minimal option stops at the first spot that rains.
if self.settings.particles >= 2 {
break;
}
let below = top - 1;
let (bx, bz) = (random.next_double(), random.next_double());
let state = world.block(x, below, z);
+41 -23
View File
@@ -1188,6 +1188,8 @@ pub struct ParticleEngine {
emitters: Vec<(ParticleOptions, [f64; 3], f64, f64, u32)>,
/// Camera position for the 32-block spawn limiter.
pub camera: [f64; 3],
/// The Particles option (`ParticleStatus`): 0 all, 1 decreased, 2 minimal.
pub particle_level: u8,
/// FireworkParticles.Starter instances.
starters: Vec<Starter>,
/// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
@@ -1218,6 +1220,7 @@ impl ParticleEngine {
emitters: Vec::new(),
starters: Vec::new(),
camera: [0.0; 3],
particle_level: 0,
sounds: Vec::new(),
made: Default::default(),
item_sprites: HashMap::new(),
@@ -1328,30 +1331,48 @@ impl ParticleEngine {
&mut self.level_random
}
/// `ClientLevel.addParticle`: dropped beyond 32 blocks of the camera unless
/// the type overrides the limiter.
/// the type overrides the limiter, and thinned by the Particles option.
pub fn add(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
self.add_with(options, p, v, false, false);
}
/// `ClientLevel.addParticle(particle, overrideLimiter, alwaysShow, ...)`
/// (`doAddParticle`). `always_show` is `addAlwaysVisibleParticle`'s flag.
pub fn add_with(
&mut self,
options: &ParticleOptions,
p: [f64; 3],
v: [f64; 3],
override_limiter: bool,
always_show: bool,
) {
let c = self.camera;
let d2 = (p[0] - c[0]).powi(2) + (p[1] - c[1]).powi(2) + (p[2] - c[2]).powi(2);
if let Some(requested) = &mut self.requested {
requested.push((options.clone(), p, v));
return;
}
if !options.ty.override_limiter() && d2 > 1024.0 {
return;
let minimal = self.calculate_particle_level(always_show) == 2;
if override_limiter || options.ty.override_limiter() || (d2 <= 1024.0 && !minimal) {
self.create(options, p, v);
}
self.create(options, p, v);
}
/// `ClientLevel.calculateParticleLevel`: minimal still shows one in ten
/// always-visible particles as decreased, and decreased drops a third.
fn calculate_particle_level(&mut self, always_show: bool) -> u8 {
let mut level = self.particle_level.min(2);
if always_show && level == 2 && self.level_random.next_int_bound(10).unwrap_or(0) == 0 {
level = 1;
}
if level == 1 && self.level_random.next_int_bound(3).unwrap_or(0) == 0 {
level = 2;
}
level
}
/// `LevelEventHandler.singleBlockTeleportationParticles` towards
/// `BlockUtil.unpackDifferenceInPosition(from, data, radius)`: the dragon
/// egg's event 2015 packs offsets within (16, 8, 16), a consumable's
/// teleport (2017) within (127, 127, 127).
pub fn block_teleportation(
&mut self,
from: [i32; 3],
data: i32,
radius: [i32; 3],
particle_level: u8,
) {
pub fn block_teleportation(&mut self, from: [i32; 3], data: i32, radius: [i32; 3]) {
let to = [
from[0].wrapping_add(((data >> 16) & 255) - radius[0]),
from[1].wrapping_add(((data >> 8) & 255) - radius[1]),
@@ -1369,15 +1390,7 @@ impl ParticleEngine {
to[1] + t * (from[1] - to[1]) + r.next_double() - 0.5,
to[2] + t * (from[2] - to[2]) + (r.next_double() - 0.5) + 0.5,
];
// The option roll shares the level random and precedes the distance check.
let limited = match particle_level {
1 => r.next_int_bound(3).unwrap_or(0) == 0,
2 => true,
_ => false,
};
if !limited {
self.add(&options, position, velocity);
}
self.add(&options, position, velocity);
}
}
/// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the
@@ -1406,6 +1419,10 @@ impl ParticleEngine {
block_count: usize,
is_air: &dyn Fn([i32; 3]) -> bool,
) {
// ClientExplosionTracker.tick: only the All option throws the debris.
if self.particle_level != 0 {
return;
}
for _ in 0..block_count.min(512) {
let r = &mut self.random;
let d = Vec3::new(
@@ -3970,7 +3987,7 @@ mod tests {
let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
engine.seed_randoms(0, 0, 0);
// Destination offset (-15, 7, 15); the unused top byte is ignored.
engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16], 0);
engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16]);
assert_eq!(engine.pending.len(), 128);
assert!(engine.pending.iter().all(|p| p.ty == ParticleType::Portal));
let first = &engine.pending[0];
@@ -3997,7 +4014,7 @@ mod tests {
// TeleportRandomlyConsumeEffect: BlockUtil.clampedPackDifferenceInPosition
// of the move (-7, -3, 9) with radii 127, from (4, 12, -5) to (-3, 9, 4).
let data = (-7 + 127) << 16 | (-3 + 127) << 8 | (9 + 127);
engine.block_teleportation([4, 12, -5], data, [127, 127, 127], 0);
engine.block_teleportation([4, 12, -5], data, [127, 127, 127]);
assert_eq!(engine.pending.len(), 128);
for p in &engine.pending {
let [x, y, z] = p.position;
@@ -4023,7 +4040,8 @@ mod tests {
if distant {
engine.camera = [1000.0; 3];
}
engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16], option);
engine.particle_level = option;
engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16]);
assert_eq!(engine.pending.len(), if distant { 0 } else { count });
assert_eq!(engine.level_random.state(), state);
}