Merge pull request #96 from ludovic111/fix/particles-63-missing-types

Particles: 29 missing vanilla particle types (part of #63)
This commit is contained in:
Ludovic Marie
2026-10-14 16:51:35 +02:00
committed by GitHub
8 changed files with 599 additions and 22 deletions
@@ -46,9 +46,10 @@ fn options(case: &Value) -> Option<ParticleOptions> {
[r, g, b, ((c >> 24) & 255) as f32 / 255.0]
};
Some(match ty {
ParticleType::Block | ParticleType::BlockCrumble | ParticleType::DustPillar => {
ParticleOptions::block(ty, "terrain".into(), 0xFF_FFFF)
}
ParticleType::Block
| ParticleType::BlockCrumble
| ParticleType::DustPillar
| ParticleType::BlockMarker => ParticleOptions::block(ty, "terrain".into(), 0xFF_FFFF),
// Stone's map colour: FallingDustParticle.Provider's tint without a tint source.
ParticleType::FallingDust => ParticleOptions::block(ty, "terrain".into(), 0x70_7070),
ParticleType::Dust => ParticleOptions::dust(rgb(c), scale),
@@ -59,7 +60,15 @@ fn options(case: &Value) -> Option<ParticleOptions> {
scale,
..ParticleOptions::colored(ty, argb)
},
ParticleType::EntityEffect | ParticleType::TintedLeaves => {
// The oracle's item models: one layer whose sprite is named after the item.
ParticleType::Item => {
let item = o["item"].as_str()?;
ParticleOptions::item(vec![format!(
"item_{}",
item.strip_prefix("minecraft:").unwrap_or(item)
)])
}
ParticleType::EntityEffect | ParticleType::TintedLeaves | ParticleType::Flash => {
ParticleOptions::colored(ty, argb)
}
ParticleType::DragonBreath => ParticleOptions {
@@ -137,6 +146,13 @@ fn main() -> Result<()> {
world(&assets, &facts, true)?,
];
let mut engine = ParticleEngine::new(root, &HashMap::new());
for (ty, item) in [
(ParticleType::ItemSlime, "item_slime_ball"),
(ParticleType::ItemSnowball, "item_snowball"),
(ParticleType::ItemCobweb, "item_cobweb"),
] {
engine.item_sprites.insert(ty, vec![item.to_owned()]);
}
// The oracle's output: the seed line of each case.
let mut seeds = Vec::new();
for line in BufReader::new(File::open(&args[2])?).lines() {
+1
View File
@@ -45,6 +45,7 @@ mod golems;
mod growth;
mod hand;
mod item_draw;
mod item_particles;
mod jukebox;
mod lan;
mod lan_actions;
@@ -418,7 +418,30 @@ impl Game<'_> {
.unwrap_or(1.0)
.clamp(0.01, 4.0),
),
ParticleType::Block | ParticleType::FallingDust | ParticleType::DustPillar => {
// ItemParticleOption: an item id, or a stack {id, ...}.
ParticleType::Item => {
let id = match field("item") {
Some(Tag::String(s)) => s.to_string_lossy(),
Some(Tag::Compound(c)) => {
c.get(&"id".into()).and_then(string).unwrap_or_default()
}
_ => String::new(),
};
let id = if id.contains(':') {
id
} else {
format!("minecraft:{id}")
};
self.item_particle(&horizon_client::items::ItemStack::new(&id, 1))
}
ParticleType::ItemSlime | ParticleType::ItemSnowball | ParticleType::ItemCobweb => {
self.ensure_item_particle_sprites();
ParticleOptions::simple(ty)
}
ParticleType::Block
| ParticleType::FallingDust
| ParticleType::DustPillar
| ParticleType::BlockMarker => {
// BlockParticleOption: a block id, or {Name, Properties}.
let text = match field("block_state") {
Some(Tag::String(s)) => s.to_string_lossy(),
@@ -0,0 +1,35 @@
//! The sprites of item particles: `BreakingItemParticle.ItemParticleProvider.getSprite`
//! resolves the stack's model for the ground and picks a layer's particle sprite.
use super::Game;
use horizon_assets::item_model::DisplayContext;
use horizon_client::{
items::ItemStack,
particles::{ParticleOptions, ParticleType},
};
impl Game<'_> {
/// `ItemParticleOption(ITEM, stack)`: the layer particle sprites of the
/// stack's model resolved for the ground, with seed 0.
pub(super) fn item_particle(&self, stack: &ItemStack) -> ParticleOptions {
let state = self.resolve_item(stack, DisplayContext::Ground, None, 0);
ParticleOptions::item(state.layers.iter().map(|l| l.particle.clone()).collect())
}
/// The slime ball, snowball and cobweb models behind `item_slime`,
/// `item_snowball` and `item_cobweb`, resolved on first use.
pub(super) fn ensure_item_particle_sprites(&mut self) {
if !self.particles.item_sprites.is_empty() {
return;
}
for (ty, item) in [
(ParticleType::ItemSlime, "minecraft:slime_ball"),
(ParticleType::ItemSnowball, "minecraft:snowball"),
(ParticleType::ItemCobweb, "minecraft:cobweb"),
] {
let sprites = self
.item_particle(&ItemStack::new(item, 1))
.item
.unwrap_or_default();
self.particles.item_sprites.insert(ty, sprites);
}
}
}
@@ -83,9 +83,21 @@ impl Game<'_> {
let count = num(8, 1.0)? as u32;
let options = match ty {
ParticleType::Dust => ParticleOptions::dust([1.0, 0.0, 0.0], 1.0),
ParticleType::Block | ParticleType::FallingDust | ParticleType::DustPillar => {
ParticleType::Block
| ParticleType::FallingDust
| ParticleType::DustPillar
| ParticleType::BlockMarker => {
ParticleOptions::block(ty, "block/stone".into(), 0x808080)
}
ParticleType::Item => self.item_particle(
&horizon_client::items::ItemStack::new("minecraft:apple", 1),
),
ParticleType::ItemSlime
| ParticleType::ItemSnowball
| ParticleType::ItemCobweb => {
self.ensure_item_particle_sprites();
ParticleOptions::simple(ty)
}
_ => ParticleOptions::simple(ty),
};
// ServerLevel.sendParticles: count 0 uses the delta as velocity.
+491 -12
View File
@@ -130,18 +130,69 @@ particle_types! {
Shriek = "shriek",
SonicBoom = "sonic_boom",
Vibration = "vibration",
SweepAttack = "sweep_attack",
Glow = "glow",
WaxOn = "wax_on",
WaxOff = "wax_off",
ElectricSpark = "electric_spark",
Scrape = "scrape",
SquidInk = "squid_ink",
GlowSquidInk = "glow_squid_ink",
Item = "item",
ItemSlime = "item_slime",
ItemSnowball = "item_snowball",
ItemCobweb = "item_cobweb",
SulfurCubeGoo = "sulfur_cube_goo",
Flash = "flash",
Firefly = "firefly",
TrialSpawnerDetection = "trial_spawner_detection",
TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
TrialOmen = "trial_omen",
RaidOmen = "raid_omen",
OminousSpawning = "ominous_spawning",
Spit = "spit",
Fishing = "fishing",
DustPlume = "dust_plume",
RedPoplarLeaves = "red_poplar_leaves",
OrangePoplarLeaves = "orange_poplar_leaves",
YellowPoplarLeaves = "yellow_poplar_leaves",
PauseMobGrowth = "pause_mob_growth",
ResetMobGrowth = "reset_mob_growth",
BlockMarker = "block_marker",
}
impl ParticleType {
/// `ParticleType.getOverrideLimiter`: spawned regardless of distance.
/// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
/// spawned regardless of distance.
pub fn override_limiter(self) -> bool {
matches!(
self,
Self::DamageIndicator
Self::BlockMarker
| Self::DamageIndicator
| Self::ExplosionEmitter
| Self::Explosion
| Self::Poof
| Self::Gust
| Self::GustEmitterLarge
| Self::GustEmitterSmall
| Self::SonicBoom
| Self::SculkCharge
| Self::SculkChargePop
| Self::Vibration
| Self::Poof
| Self::Spit
| Self::SquidInk
| Self::SweepAttack
| Self::CampfireCosySmoke
| Self::CampfireSignalSmoke
| Self::GlowSquidInk
| Self::Glow
| Self::WaxOn
| Self::WaxOff
| Self::ElectricSpark
| Self::Scrape
| Self::TrialSpawnerDetection
| Self::TrialSpawnerDetectionOminous
| Self::VaultConnection
| Self::OminousSpawning
)
}
}
@@ -161,6 +212,9 @@ pub struct ParticleOptions {
pub to_color: [f32; 3],
/// `TrailParticleOption`: the point it flies to and how many ticks it takes.
pub trail: Option<([f64; 3], i32)>,
/// `ItemParticleOption`: the particle sprite of each layer of the item's
/// model as resolved for the ground.
pub item: Option<Vec<String>>,
}
impl ParticleOptions {
pub fn simple(ty: ParticleType) -> Self {
@@ -171,6 +225,14 @@ impl ParticleOptions {
scale: 1.0,
to_color: [1.0, 0.0, 0.0],
trail: None,
item: None,
}
}
/// `ItemParticleOption`: the stack's layer particle sprites (`BreakingItemParticle`).
pub fn item(layers: Vec<String>) -> Self {
Self {
item: Some(layers),
..Self::simple(ParticleType::Item)
}
}
/// `DustColorTransitionOptions`.
@@ -260,6 +322,8 @@ enum Size {
ReversePortal,
/// `ShriekParticle.getQuadSize`.
Shriek,
/// `FireworkParticles.OverlayParticle.getQuadSize`: a sine pulse.
Flash,
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Light {
@@ -271,6 +335,8 @@ enum Light {
AgeEmission,
/// `addSmoothBlockEmission` with the age fraction to the fourth power.
AgeEmission4,
/// `FireflyParticle.getLightCoords`: block light fading in and out, no sky.
Firefly,
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Behaviour {
@@ -359,6 +425,20 @@ enum Behaviour {
Trail {
target: [f64; 3],
},
/// `SquidInkParticle`: `SimpleAnimatedParticle`, sinking through air.
SquidInk,
/// `FireflyParticle`: wanders, fading in and out, gone inside blocks.
Firefly,
/// `WakeParticle` (fishing): grows and cycles four sprites.
Wake,
/// `DustPlumeParticle`: gravity and friction decay every tick.
DustPlume,
/// `FlyStraightTowardsParticle`: from its start along its motion back to
/// the start, the colour moving from one to the other.
FlyStraight {
start: [f64; 3],
colors: [u32; 2],
},
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum DripStage {
@@ -801,6 +881,11 @@ impl Particle {
let b = (b * b) * (b * b);
(sky, (block + (b.clamp(0.0, 1.0) * 240.0) as u32).min(240))
}
Light::Firefly => (
0,
(255.0 * fade_amount(self.lifetime_progress(self.age as f32 + partial), 0.1, 0.3))
as u32,
),
}
}
fn quad_size(&self, a: f32) -> f32 {
@@ -818,8 +903,27 @@ impl Particle {
self.size * (1.0 - (self.age as f32 + a) / (self.lifetime as f32 * 1.5))
}
Size::Shriek => self.size * (t * 0.75).clamp(0.0, 1.0),
Size::Flash => {
7.1 * trig::sin(f64::from(
(self.age as f32 + a - 1.0) * 0.25 * std::f64::consts::PI as f32,
))
}
}
}
/// `FireflyParticle.getLifetimeProgress`.
fn lifetime_progress(&self, age: f32) -> f32 {
(age / self.lifetime as f32).clamp(0.0, 1.0)
}
}
/// `FireflyParticle.getFadeAmount`.
fn fade_amount(progress: f32, fade_in: f32, fade_out: f32) -> f32 {
if progress >= 1.0 - fade_in {
(1.0 - progress) / fade_in
} else if progress <= fade_out {
progress / fade_out
} else {
1.0
}
}
/// A particle's fields as the parity probe reports them.
@@ -936,6 +1040,9 @@ pub struct ParticleEngine {
starters: Vec<Starter>,
/// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
pub sounds: Vec<(&'static str, [f64; 3], f32, f32)>,
/// The item particles' sprites (`BreakingItemParticle`'s slime ball, snowball
/// and cobweb models, resolved for the ground), one per model layer.
pub item_sprites: HashMap<ParticleType, Vec<String>>,
}
/// `ParticleGroup.MAX_PARTICLES` (per render group; one group here).
const MAX_PARTICLES: usize = 16384;
@@ -958,6 +1065,7 @@ impl ParticleEngine {
starters: Vec::new(),
camera: [0.0; 3],
sounds: Vec::new(),
item_sprites: HashMap::new(),
};
let dir = root.join("assets/minecraft/particles");
for &ty in ParticleType::ALL {
@@ -1336,12 +1444,22 @@ impl ParticleEngine {
q.set = set;
q
}
T::Smoke | T::LargeSmoke | T::WhiteSmoke | T::Ash | T::WhiteAsh => {
T::Smoke | T::LargeSmoke | T::WhiteSmoke | T::Ash | T::WhiteAsh | T::DustPlume => {
// BaseAshSmokeParticle(dir, xa, scale, colorRandom, maxLifetime, gravity, hasPhysics).
let (dir, scale, color_random, max_lifetime, gravity, physics, vel) = match ty {
T::Smoke | T::WhiteSmoke => ([0.1, 0.1, 0.1], 1.0, 0.3, 8, -0.1, true, v),
T::LargeSmoke => ([0.1, 0.1, 0.1], 2.5, 0.3, 8, -0.1, true, v),
T::Ash => ([0.1, -0.1, 0.1], 1.0, 0.5, 20, 0.1, false, [0.0; 3]),
// DustPlumeParticle: ya + 0.15F.
T::DustPlume => (
[0.7, 0.6, 0.7],
1.0,
0.5,
7,
0.5,
false,
[v[0], v[1] + f64::from(0.15f32), v[2]],
),
_ => {
// WhiteAshParticle.Provider draws the motion.
let pr = &mut self.random;
@@ -1376,6 +1494,15 @@ impl ParticleEngine {
}
q.size_curve = Size::GrowIn;
q.behaviour = Behaviour::Animated;
if ty == T::DustPlume {
let shift = r.next_float() * 0.2;
q.set_color(
186.0 / 255.0 - shift,
177.0 / 255.0 - shift,
194.0 / 255.0 - shift,
);
q.behaviour = Behaviour::DustPlume;
}
q.set = set;
q
}
@@ -1849,9 +1976,9 @@ impl ParticleEngine {
}
q
}
T::Poof | T::Snowflake => {
T::Poof | T::Snowflake | T::Spit => {
let mut q = Particle::at(r, ty, p);
if ty == T::Poof {
if ty != T::Snowflake {
q.gravity = -0.1;
q.friction = 0.9;
} else {
@@ -1861,7 +1988,7 @@ impl ParticleEngine {
for i in 0..3 {
q.velocity[i] = v[i] + f64::from((r.next_float() * 2.0 - 1.0) * 0.05);
}
if ty == T::Poof {
if ty != T::Snowflake {
let col = r.next_float() * 0.3 + 0.7;
q.set_color(col, col, col);
q.size = 0.1 * (r.next_float() * r.next_float() * 6.0 + 1.0);
@@ -1869,11 +1996,15 @@ impl ParticleEngine {
q.size = 0.1 * (r.next_float() * r.next_float() + 1.0);
}
q.lifetime = (16.0 / (f64::from(r.next_float()) * 0.8 + 0.2)) as i32 + 2;
q.behaviour = if ty == T::Poof {
Behaviour::Animated
} else {
q.behaviour = if ty == T::Snowflake {
Behaviour::Snowflake
} else {
Behaviour::Animated
};
// SpitParticle: ExplodeParticle falling at gravity 0.5.
if ty == T::Spit {
q.gravity = 0.5;
}
if ty == T::Snowflake {
q.set_color(0.923, 0.964, 0.999);
}
@@ -2114,7 +2245,12 @@ impl ParticleEngine {
q.set = set;
q
}
T::CherryLeaves | T::PaleOakLeaves | T::TintedLeaves => {
T::CherryLeaves
| T::PaleOakLeaves
| T::TintedLeaves
| T::RedPoplarLeaves
| T::OrangePoplarLeaves
| T::YellowPoplarLeaves => {
let (fall, side, swirl, flow, scale, start) = if ty == T::CherryLeaves {
(0.25f32, 2.0f32, false, true, 1.0f32, 0.0f32)
} else {
@@ -2150,7 +2286,13 @@ impl ParticleEngine {
};
q
}
T::Effect | T::InstantEffect | T::EntityEffect | T::Witch | T::Infested => {
T::Effect
| T::InstantEffect
| T::EntityEffect
| T::Witch
| T::Infested
| T::TrialOmen
| T::RaidOmen => {
// SpellParticle: x/z velocity from `SpellParticle.RANDOM`, y from the option.
let xa = 0.5 - self.spell_random.next_double();
let za = 0.5 - self.spell_random.next_double();
@@ -2226,6 +2368,239 @@ impl ParticleEngine {
q.set_power(o.scale);
q
}
// AttackSweepParticle: `xAux` shrinks it; still, bright, animated over 4 ticks.
T::SweepAttack => {
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.lifetime = 4;
let col = r.next_float() * 0.6 + 0.4;
q.set_color(col, col, col);
q.size = 1.0 - v[0] as f32 * 0.5;
q.light = Light::FullBright;
q.behaviour = Behaviour::HugeExplosion;
q.set = set;
q
}
// GlowParticle and its providers.
T::Glow | T::WaxOn | T::WaxOff | T::ElectricSpark | T::Scrape => {
let pr = &mut self.random;
let start = if ty == T::Glow {
let xa = 0.5 - pr.next_double();
[xa, v[1], 0.5 - pr.next_double()]
} else {
[0.0; 3]
};
let mut q = Particle::moving(r, ty, p, start);
q.friction = 0.96;
q.speed_up_when_y_blocked = true;
q.size *= 0.75;
q.has_physics = false;
q.light = Light::AgeEmission;
q.behaviour = Behaviour::Animated;
q.set = set;
match ty {
T::ElectricSpark => {
q.set_color(1.0, 0.9, 1.0);
q.velocity = [v[0] * 0.25, v[1] * 0.25, v[2] * 0.25];
q.lifetime = pr.next_int_bound(2).unwrap_or(0) + 2;
}
T::Glow => {
if pr.next_boolean() {
q.set_color(0.6, 1.0, 0.8);
} else {
q.set_color(0.08, 0.4, 0.4);
}
q.velocity[1] *= f64::from(0.2f32);
if v[0] == 0.0 && v[2] == 0.0 {
q.velocity[0] *= f64::from(0.1f32);
q.velocity[2] *= f64::from(0.1f32);
}
q.lifetime = (8.0 / (pr.next_double() * 0.8 + 0.2)) as i32;
}
T::Scrape => {
if pr.next_boolean() {
q.set_color(0.29, 0.58, 0.51);
} else {
q.set_color(0.43, 0.77, 0.62);
}
q.velocity = [v[0] * 0.01, v[1] * 0.01, v[2] * 0.01];
q.lifetime = pr.next_int_bound(30).unwrap_or(0) + 10;
}
_ => {
if ty == T::WaxOn {
q.set_color(0.91, 0.55, 0.08);
} else {
q.set_color(1.0, 0.9, 1.0);
}
q.velocity = [v[0] * 0.01 / 2.0, v[1] * 0.01, v[2] * 0.01 / 2.0];
q.lifetime = pr.next_int_bound(30).unwrap_or(0) + 10;
}
}
q
}
// SquidInkParticle (SimpleAnimatedParticle, gravity 0).
T::SquidInk | T::GlowSquidInk => {
let mut q = Particle::at(r, ty, p);
q.friction = 0.92;
q.size = 0.5;
if ty == T::GlowSquidInk {
// ARGB.colorFromFloat(1, 0.2, 0.8, 0.6), back to floats.
q.set_color(51.0 / 255.0, 204.0 / 255.0, 153.0 / 255.0);
} else {
q.set_color(0.0, 0.0, 0.0);
}
q.lifetime = (q.size * 12.0 / (r.next_float() * 0.8 + 0.2)) as i32;
q.has_physics = false;
q.velocity = v;
q.light = Light::FullBright;
q.behaviour = Behaviour::SquidInk;
q.set = set;
q
}
// BreakingItemParticle: a crumb of the item's sprite.
T::Item | T::ItemSlime | T::ItemSnowball | T::ItemCobweb | T::SulfurCubeGoo => {
let sprite = if ty == T::SulfurCubeGoo {
self.first(ty)
} else {
// ItemStackRenderState.pickParticleMaterial.
let layers = match ty {
T::Item => o.item.clone().unwrap_or_default(),
_ => self.item_sprites.get(&ty).cloned().unwrap_or_default(),
};
if layers.is_empty() {
Sprite::Index(u32::MAX)
} else {
let i = self.random.next_int_bound(layers.len() as i32).unwrap_or(0);
Sprite::Named(layers[i as usize].clone())
}
};
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.sprite = sprite;
q.gravity = 1.0;
q.size /= 2.0;
let uo = r.next_float() * 3.0;
let vo = r.next_float() * 3.0;
q.uv = [(uo + 1.0) / 4.0, vo / 4.0, uo / 4.0, (vo + 1.0) / 4.0];
if ty == T::Item {
for i in 0..3 {
q.velocity[i] = q.velocity[i] * f64::from(0.1f32) + v[i];
}
}
q
}
// FireworkParticles.OverlayParticle: the flash of an explosion.
T::Flash => {
let mut q = Particle::at(r, ty, p);
q.lifetime = 4;
q.set_color(o.color[0], o.color[1], o.color[2]);
q.rgba[3] = o.color[3];
q.size_curve = Size::Flash;
q
}
// FireflyParticle; the provider draws its motion, sprite and lifetime.
T::Firefly => {
let pr = &mut self.random;
let xa = 0.5 - pr.next_double();
let ya = if pr.next_boolean() { v[1] } else { -v[1] };
let za = 0.5 - pr.next_double();
let sprite = self.sprite_from_set(ty);
let mut q = Particle::moving(r, ty, p, [xa, ya, za]);
q.sprite = sprite;
q.speed_up_when_y_blocked = true;
q.friction = 0.96;
q.size *= 0.75;
q.velocity[1] *= f64::from(0.8f32);
q.velocity[0] *= f64::from(0.8f32);
q.velocity[2] *= f64::from(0.8f32);
q.lifetime = self
.random
.next_int_between_inclusive(200, 300)
.unwrap_or(200);
q.scale(1.5);
q.rgba[3] = 0.0;
q.light = Light::Firefly;
q.behaviour = Behaviour::Firefly;
q
}
// TrialSpawnerDetectionParticle (scale 1.5 from the provider).
T::TrialSpawnerDetection | T::TrialSpawnerDetectionOminous => {
let scale = 1.5f32;
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.friction = 0.96;
q.gravity = -0.1;
q.speed_up_when_y_blocked = true;
q.velocity[0] *= 0.0;
q.velocity[1] *= 0.9;
q.velocity[2] *= 0.0;
for i in 0..3 {
q.velocity[i] += v[i];
}
q.size *= 0.75 * scale;
// Mth.randomBetween(random, 0.5, 1.0).
q.lifetime = ((8.0 / (r.next_float() * (1.0 - 0.5) + 0.5) * scale) as i32).max(1);
q.light = Light::Block15;
q.size_curve = Size::GrowIn;
q.behaviour = Behaviour::Animated;
q.set = set;
q
}
// FlyStraightTowardsParticle.OminousSpawnProvider.
T::OminousSpawning => {
let sprite = self.sprite_from_set(ty);
let mut q = Particle::at(r, ty, p);
q.sprite = sprite;
q.velocity = v;
let start = [p[0] + v[0], p[1] + v[1], p[2] + v[2]];
q.previous = start;
q.position = start;
q.size = 0.1 * (r.next_float() * 0.5 + 0.2);
q.has_physics = false;
q.free_move = true;
q.lifetime = (r.next_float() * 5.0) as i32 + 25;
q.light = Light::Block15;
q.behaviour = Behaviour::FlyStraight {
start: p,
colors: [0xFF45_AEFE, 0xFFFF_FFFF],
};
// Mth.randomBetween(level.getRandom(), 3, 5).
let s = self.level_random.next_float() * (5.0 - 3.0) + 3.0;
q.scale(s);
q
}
// WakeParticle.
T::Fishing => {
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.velocity[0] *= f64::from(0.3f32);
q.velocity[1] = f64::from(r.next_float() * 0.2 + 0.1);
q.velocity[2] *= f64::from(0.3f32);
q.set_size(0.01, 0.01);
q.lifetime = (8.0 / (f64::from(r.next_float()) * 0.8 + 0.2)) as i32;
q.gravity = 0.0;
q.velocity = v;
q.behaviour = Behaviour::Wake;
q.set = set;
q
}
// SimpleVerticalParticle.
T::PauseMobGrowth | T::ResetMobGrowth => {
let mut q = Particle::moving(r, ty, p, v);
q.velocity = v;
q.gravity = 0.0;
q.velocity[1] += if ty == T::ResetMobGrowth { 0.03 } else { -0.03 };
q.size *= r.next_float() * 0.6 + 0.5;
q.lifetime = 8;
q
}
// BlockMarker: the block's particle sprite, half a block wide, 80 ticks.
T::BlockMarker => {
let (sprite, _) = o.block.clone()?;
let mut q = Particle::at(r, ty, p);
q.sprite = Sprite::Named(sprite);
q.gravity = 0.0;
q.lifetime = 80;
q.has_physics = false;
q.size = 0.5;
q
}
T::Trail => {
let (target, duration) = o.trail?;
let mut q = Particle::moving(r, ty, p, v);
@@ -2365,6 +2740,19 @@ impl ParticleEngine {
}
}
}
// The flash: ColorParticleOption.create(FLASH, first colour), alpha 0.
let c = colors[0];
let rgba = [
((c >> 16) & 255) as f32 / 255.0,
((c >> 8) & 255) as f32 / 255.0,
(c & 255) as f32 / 255.0,
((c >> 24) & 255) as f32 / 255.0,
];
self.create(
&ParticleOptions::colored(ParticleType::Flash, rgba),
s.at,
[0.0; 3],
);
}
s.life += 1;
if s.life > s.lifetime {
@@ -2995,6 +3383,93 @@ impl ParticleEngine {
p.velocity[1] -= f64::from(0.003f32);
p.velocity[1] = p.velocity[1].max(f64::from(-0.14f32));
}
Behaviour::SquidInk => {
// SimpleAnimatedParticle.tick, then SquidInkParticle's.
p.base_tick(level);
self.sprite_from_age(p);
let half = |p: &mut Particle| {
if p.age > p.lifetime / 2 {
p.rgba[3] =
1.0 - (p.age as f32 - (p.lifetime / 2) as f32) / p.lifetime as f32;
}
};
half(p);
if !p.removed {
self.sprite_from_age(p);
half(p);
let b = ParticleLevel::block_at(p.position);
if level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
p.velocity[1] -= f64::from(0.0074f32);
}
}
}
Behaviour::Firefly => {
p.base_tick(level);
let b = ParticleLevel::block_at(p.position);
if !level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
p.removed = true;
} else {
p.rgba[3] = fade_amount(p.lifetime_progress(p.age as f32), 0.3, 0.5);
if p.random.next_float() > 0.95 || p.age == 1 {
let r = &mut p.random;
let mut speed = || f64::from(-0.05f32 + 0.1 * r.next_float());
p.velocity = [speed(), speed(), speed()];
}
}
}
Behaviour::Wake => {
p.previous = p.position;
let life = 60 - p.lifetime;
let lifetime = p.lifetime;
p.lifetime -= 1;
if lifetime <= 0 {
p.removed = true;
return;
}
p.velocity[1] -= f64::from(p.gravity);
p.move_by(level, p.velocity);
for c in &mut p.velocity {
*c *= f64::from(0.98f32);
}
let size = life as f32 * 0.001;
p.set_size(size, size);
// SpriteSet.get(life % 4, 4).
if let Some(set) = p.set {
let sprites = &self.set_sprites[set as usize];
let index = (life % 4) as usize * (sprites.len() - 1) / 4;
p.sprite = Sprite::Index(sprites[index]);
}
}
Behaviour::DustPlume => {
p.gravity *= 0.88;
p.friction *= 0.92;
p.base_tick(level);
self.sprite_from_age(p);
}
Behaviour::FlyStraight { start, colors } => {
p.previous = p.position;
let age = p.age;
p.age += 1;
if age >= p.lifetime {
p.removed = true;
return;
}
let normalized = p.age as f32 / p.lifetime as f32;
let along = 1.0 - normalized;
for i in 0..3 {
p.position[i] = start[i] + p.velocity[i] * f64::from(along);
}
// ARGB.srgbLerp: Mth.lerpInt on each 8-bit channel.
let lerp = |shift: u32| {
let (a, b) = (
(colors[0] >> shift & 255) as i32,
(colors[1] >> shift & 255) as i32,
);
(a + (normalized * (b - a) as f32).floor() as i32) as f32 / 255.0
};
p.set_color(lerp(16), lerp(8), lerp(0));
p.rgba[3] = lerp(24);
}
Behaviour::DragonBreath { mut hit_ground } => {
p.previous = p.position;
let age = p.age;
@@ -3070,6 +3545,10 @@ impl ParticleEngine {
};
let size = p.quad_size(partial);
let mut alpha = p.rgba[3];
// OverlayParticle.extract: the flash fades as it pulses.
if p.ty == ParticleType::Flash {
alpha = 0.6 - (p.age as f32 + partial - 1.0) * 0.25 * 0.5;
}
if let Behaviour::FlyTowards { alpha: la, .. } = p.behaviour {
alpha = lifetime_alpha(la, p.age, p.lifetime, partial);
}
@@ -198,6 +198,7 @@ public final class VanillaParticleProvidersOracle {
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion(); Bootstrap.bootStrap();
ParityData.init(); // item components, for the item particle providers' stacks
var u = Class.forName("sun.misc.Unsafe"); unsafe = field(u, "theUnsafe").get(null); allocate = u.getMethod("allocateInstance", Class.class);
var mc = make(Minecraft.class); field(Minecraft.class, "instance").set(null, mc);
var manager = make(ModelManager.class); field(ModelManager.class, "blockStateModelSet").set(manager, new Models());
+14 -4
View File
@@ -31,11 +31,15 @@ falling_lava falling_nectar falling_obsidian_tear falling_spore_blossom falling_
gust gust_emitter_large gust_emitter_small happy_villager heart infested landing_honey landing_lava
landing_obsidian_tear large_smoke lava mycelium nautilus note pale_oak_leaves poof portal rain reverse_portal
sculk_charge_pop sculk_soul smoke small_flame small_gust sneeze snowflake sonic_boom soul soul_fire_flame splash
spore_blossom_air totem_of_undying underwater vault_connection warped_spore white_ash white_smoke witch""".split()
spore_blossom_air totem_of_undying underwater vault_connection warped_spore white_ash white_smoke witch
sweep_attack glow wax_on wax_off electric_spark scrape squid_ink glow_squid_ink item_slime item_snowball item_cobweb
sulfur_cube_goo firefly trial_spawner_detection trial_spawner_detection_ominous trial_omen raid_omen ominous_spawning
spit fishing dust_plume red_poplar_leaves orange_poplar_leaves yellow_poplar_leaves pause_mob_growth
reset_mob_growth""".split()
def options(kind, rng):
if kind in ('block', 'block_crumble', 'dust_pillar', 'falling_dust'):
if kind in ('block', 'block_crumble', 'dust_pillar', 'falling_dust', 'block_marker'):
return dict(state=STONE)
if kind == 'dust':
return dict(color=rng.choice([0xFF0000, 0x3A9E2C, 0xFFFFFF]), scale=rng.choice([1.0, 0.5, 2.0]))
@@ -47,6 +51,10 @@ def options(kind, rng):
return dict(color=rng.choice([0xFF3366CC, 0x26AA00FF]))
if kind == 'tinted_leaves':
return dict(color=0xFF48B518)
if kind == 'flash':
return dict(color=rng.choice([0xFF3366CC, 0x00FFAA00]))
if kind == 'item':
return dict(item=rng.choice(['minecraft:apple', 'minecraft:cooked_beef', 'minecraft:egg']))
if kind == 'dragon_breath':
return dict(scale=rng.choice([1.0, 0.25]))
if kind == 'sculk_charge':
@@ -60,7 +68,8 @@ def options(kind, rng):
def cases(rng):
kinds = SIMPLE + ['block', 'block_crumble', 'dust_pillar', 'falling_dust', 'dust', 'dust_color_transition', 'effect',
'instant_effect', 'entity_effect', 'tinted_leaves', 'dragon_breath', 'sculk_charge', 'shriek', 'trail']
'instant_effect', 'entity_effect', 'tinted_leaves', 'dragon_breath', 'sculk_charge', 'shriek', 'trail',
'block_marker', 'flash', 'item']
# Dyadic values: serde_json's decimal parsing may round others a unit off.
starts = [([0.3125, 66.6875, -0.40625], False), ([0.3125, 64.046875, -0.40625], True), ([-5.75, 64.59375, 3.125], True)]
velocities = [[0.0, 0.0, 0.0], [0.078125, 0.125, -0.046875], [0.0, -0.296875, 0.0], [0.5, 0.0, 0.25]]
@@ -99,7 +108,8 @@ def decode(token):
# (Intel's libm) round a fraction of a percent of arguments a unit apart from
# the platform libm horizon_core::jmath uses, so their motion is compared to
# 1e-12 relative error; everything else about them, and every other type, exactly.
LIBM = {'cherry_leaves', 'pale_oak_leaves', 'tinted_leaves'}
LIBM = {'cherry_leaves', 'pale_oak_leaves', 'tinted_leaves', 'red_poplar_leaves', 'orange_poplar_leaves',
'yellow_poplar_leaves'}
def sections(path):