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:
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user