Files
horizon-airdef/crates/horizon-client/src/animate_tick.rs
T
Ludovic Marie c5a640dd56 Endermen, endermites, blazes, eyes of ender, dried ghasts and end portals make their ambient effects
The client-side branches vanilla runs on its own level: Enderman and
Endermite aiStep (two portal particles a tick), Blaze aiStep (two large
smoke particles, the burn sound one tick in 24), EyeOfEnder.tick (a
portal particle behind it, four bubbles in water), and the
DriedGhastBlock and EndPortalBlock animateTick. They run on the window's
game in-frame and as a server's client, never on a server.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 15:59:56 +01:00

1222 lines
45 KiB
Rust

//! Client-side ambient block effects: `ClientLevel.animateTick` (667 random
//! blocks within 16 and 32 blocks per tick calling `Block.animateTick` and
//! `FluidState.animateTick`, fluid drips and biome ambient particles) and the
//! campfire block-entity particle tick. Particle positions, odds and sounds
//! follow the vanilla block classes.
use crate::{
biome::Biomes,
blocks::{BlockFacts, Fluid},
command::args::GameMode,
items::ItemStack,
particles::{ParticleEngine, ParticleOptions, ParticleType as T},
world::World,
};
use horizon_core::{
geometry::Axis,
random::{LegacyRandom, RandomSource},
};
use horizon_world::{
block_collision::BlockCollisionRegistry,
registry::{BlockRegistry, BlockStateId},
worldgen::tags::TagDefinitions,
};
use std::{collections::BTreeMap, path::Path};
#[derive(Clone, Copy, Debug, PartialEq)]
enum Animate {
None,
Torch(T),
WallTorch(T, [i32; 3]),
RedstoneTorch,
RedstoneWallTorch([i32; 3]),
Furnace([i32; 3]),
BlastFurnace([i32; 3]),
Smoker,
Campfire {
spawn_particles: bool,
},
/// Leaves: optional falling-leaf particle and chance, tinted by foliage.
Leaves(Option<(T, f32)>),
NetherPortal,
EnchantingTable,
EndRod([i32; 3]),
SporeBlossom,
CryingObsidian,
Mycelium,
Candles(u8),
CandleCake,
BrewingStand,
EnderChest,
/// FallingBlock with its dust colour.
Falling(u32),
RedstoneOre,
RedstoneWire {
power: u8,
sides: [u8; 4],
},
RespawnAnchor,
BubbleColumn {
drag: bool,
},
Fire,
/// An active sculk sensor.
SculkSensor,
/// Potent sulfur that is not dry.
PotentSulfur,
DriedGhast {
waterlogged: bool,
},
EndPortal,
}
fn step(facing: &str) -> [i32; 3] {
match facing {
"north" => [0, 0, -1],
"south" => [0, 0, 1],
"west" => [-1, 0, 0],
"east" => [1, 0, 0],
"up" => [0, 1, 0],
_ => [0, -1, 0],
}
}
fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
let name = name.strip_prefix("minecraft:").unwrap_or(name);
let lit = prop("lit").as_deref() == Some("true");
let facing = || step(&prop("facing").unwrap_or_default());
match name {
"torch" => Animate::Torch(T::Flame),
"soul_torch" => Animate::Torch(T::SoulFireFlame),
"copper_torch" => Animate::Torch(T::CopperFireFlame),
"wall_torch" => Animate::WallTorch(T::Flame, facing()),
"soul_wall_torch" => Animate::WallTorch(T::SoulFireFlame, facing()),
"copper_wall_torch" => Animate::WallTorch(T::CopperFireFlame, facing()),
"redstone_torch" if lit => Animate::RedstoneTorch,
"redstone_wall_torch" if lit => Animate::RedstoneWallTorch(facing()),
"furnace" if lit => Animate::Furnace(facing()),
"blast_furnace" if lit => Animate::BlastFurnace(facing()),
"smoker" if lit => Animate::Smoker,
"campfire" if lit => Animate::Campfire {
spawn_particles: true,
},
"soul_campfire" if lit => Animate::Campfire {
spawn_particles: false,
},
"oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves"
| "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01))),
"cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1))),
"pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02))),
"spruce_leaves" | "azalea_leaves" | "flowering_azalea_leaves" => Animate::Leaves(None),
"nether_portal" => Animate::NetherPortal,
"enchanting_table" => Animate::EnchantingTable,
"end_rod" => Animate::EndRod(facing()),
"spore_blossom" => Animate::SporeBlossom,
"crying_obsidian" => Animate::CryingObsidian,
"mycelium" => Animate::Mycelium,
"brewing_stand" => Animate::BrewingStand,
"ender_chest" => Animate::EnderChest,
"sand" => Animate::Falling(0xDBD3A0),
"red_sand" => Animate::Falling(0xA95821),
"gravel" => Animate::Falling(0x807C7B),
"redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre,
"redstone_wire" => {
let power = prop("power").and_then(|p| p.parse().ok()).unwrap_or(0);
let side = |d: &str| match prop(d).as_deref() {
Some("up") => 2,
Some("side") => 1,
_ => 0,
};
if power == 0 {
Animate::None
} else {
Animate::RedstoneWire {
power,
sides: [side("north"), side("east"), side("south"), side("west")],
}
}
}
"respawn_anchor" if prop("charges").is_some_and(|c| c != "0") => Animate::RespawnAnchor,
"potent_sulfur" if prop("potent_sulfur_state").is_some_and(|s| s != "dry") => {
Animate::PotentSulfur
}
"bubble_column" => Animate::BubbleColumn {
drag: prop("drag").as_deref() == Some("true"),
},
"fire" | "soul_fire" => Animate::Fire,
"dried_ghast" => Animate::DriedGhast {
waterlogged: prop("waterlogged").as_deref() == Some("true"),
},
"end_portal" => Animate::EndPortal,
"sculk_sensor" | "calibrated_sculk_sensor"
if prop("sculk_sensor_phase").as_deref() == Some("active") =>
{
Animate::SculkSensor
}
_ if name.ends_with("candle_cake") && lit => Animate::CandleCake,
_ if (name == "candle" || name.ends_with("_candle")) && lit => {
Animate::Candles(prop("candles").and_then(|c| c.parse().ok()).unwrap_or(1))
}
_ => Animate::None,
}
}
/// `RedstoneWireBlock.COLORS`.
fn redstone_color(power: u8) -> [f32; 3] {
let f = f32::from(power) / 15.0;
let r = f * 0.6 + if f > 0.0 { 0.4 } else { 0.3 };
let g = (f * f * 0.7 - 0.5).clamp(0.0, 1.0);
let b = (f * f * 0.6 - 0.7).clamp(0.0, 1.0);
// DustParticleOptions stores the packed int colour.
let q = |c: f32| ((c * 255.0) as u8) as f32 / 255.0;
[q(r), q(g), q(b)]
}
/// `CandleBlock.PARTICLE_OFFSETS` by candle count (pixels).
fn candle_offsets(count: u8) -> &'static [[f64; 3]] {
match count {
1 => &[[8.0, 8.0, 8.0]],
2 => &[[6.0, 7.0, 8.0], [10.0, 8.0, 7.0]],
3 => &[[8.0, 5.0, 10.0], [6.0, 7.0, 8.0], [9.0, 8.0, 7.0]],
_ => &[
[7.0, 5.0, 9.0],
[10.0, 7.0, 9.0],
[6.0, 7.0, 6.0],
[9.0, 8.0, 6.0],
],
}
}
/// Per-state animate behaviour and the block tags it needs.
pub struct AnimateTables {
kinds: Vec<Animate>,
impermeable: Vec<bool>,
power_provider: Vec<bool>,
power_transmitter: Vec<bool>,
/// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil).
dried_ghast_sounds: Vec<bool>,
/// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`).
ambient: Vec<Vec<(T, f32)>>,
}
impl AnimateTables {
pub fn load(root: &Path, registry: &BlockRegistry, biomes: &Biomes) -> crate::Result<Self> {
let kinds = (0..registry.len() as u32)
.map(|id| {
registry.state(BlockStateId(id)).map_or(Animate::None, |s| {
classify(&s.name, &|k| s.properties.get(k).cloned())
})
})
.collect();
let bundle: BTreeMap<String, String> =
serde_json::from_slice(&std::fs::read(root.join("block-tags.json"))?)?;
let mut definitions = TagDefinitions::default();
for (name, text) in bundle {
definitions.apply_json(&name, "vanilla", &text)?;
}
let built =
definitions.build(|name, _| registry.default_state(name).map(|_| name.to_owned()))?;
let by_state = |tag: &str| -> Vec<bool> {
let names = built.tags.get(tag);
(0..registry.len() as u32)
.map(|id| {
registry
.state(BlockStateId(id))
.is_some_and(|s| names.is_some_and(|n| n.contains(&s.name)))
})
.collect()
};
let mut ambient = vec![Vec::new(); biomes.list.len()];
for (name, &id) in &biomes.index {
let path = root.join(format!(
"data/minecraft/worldgen/biome/{}.json",
name.trim_start_matches("minecraft:")
));
let Ok(bytes) = std::fs::read(path) else {
continue;
};
let Ok(json) = serde_json::from_slice::<serde_json::Value>(&bytes) else {
continue;
};
let list = &json["attributes"]["minecraft:visual/ambient_particles"];
let entries = list["argument"].as_array().or_else(|| list.as_array());
for entry in entries.into_iter().flatten() {
let ty = entry["particle"]["type"].as_str().and_then(T::from_name);
let probability = entry["probability"].as_f64().unwrap_or(0.0) as f32;
if let (Some(ty), Some(slot)) = (ty, ambient.get_mut(id as usize)) {
slot.push((ty, probability));
}
}
}
Ok(Self {
kinds,
impermeable: by_state("minecraft:impermeable"),
power_provider: by_state("minecraft:enchantment_power_provider"),
power_transmitter: by_state("minecraft:enchantment_power_transmitter"),
dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"),
ambient,
})
}
fn kind(&self, state: BlockStateId) -> Animate {
self.kinds
.get(state.0 as usize)
.copied()
.unwrap_or(Animate::None)
}
/// Whether a state ticks campfire particles (`CampfireBlockEntity.particleTick`).
pub fn is_lit_campfire(&self, state: u32) -> bool {
matches!(self.kind(BlockStateId(state)), Animate::Campfire { .. })
}
}
/// World access for ambient effects.
pub struct AnimateContext<'a> {
pub world: &'a World,
pub facts: &'a BlockFacts,
pub collision: &'a BlockCollisionRegistry<'a>,
pub biomes: &'a Biomes,
pub registry: &'a BlockRegistry,
/// `Level.isRainingAt`.
pub raining_at: &'a dyn Fn([i32; 3]) -> bool,
/// Creative main-hand marker block and a resolver for each placed state's sprite.
pub marker: Option<(&'a str, &'a dyn Fn(BlockStateId) -> Option<ParticleOptions>)>,
}
/// `ClientLevel.getMarkerParticleTarget`: only the selected main-hand item counts.
pub fn marker_particle_target(
mode: GameMode,
main_hand: Option<&ItemStack>,
) -> Option<&'static str> {
if mode != GameMode::Creative {
return None;
}
let stack = main_hand.filter(|stack| stack.count > 0)?;
match stack.item.as_ref() {
"minecraft:barrier" => Some("minecraft:barrier"),
"minecraft:light" => Some("minecraft:light"),
_ => None,
}
}
impl AnimateContext<'_> {
fn state(&self, p: [i32; 3]) -> BlockStateId {
self.world.block(p[0], p[1], p[2])
}
fn is_air(&self, p: [i32; 3]) -> bool {
self.facts.is_air(self.state(p))
}
/// `isFaceSturdy` approximated by a full collision cube.
fn sturdy(&self, p: [i32; 3]) -> bool {
self.facts.get(self.state(p)).full_collision
}
fn shape_y(&self, p: [i32; 3]) -> Option<(f64, f64, [f64; 4])> {
let shape = self
.collision
.cached_shapes()
.cached_shape(self.state(p))
.ok()??;
if shape.is_empty() {
return Some((0.0, 0.0, [0.0; 4]));
}
Some((
shape.min(Axis::Y),
shape.max(Axis::Y),
[
shape.min(Axis::X),
shape.max(Axis::X),
shape.min(Axis::Z),
shape.max(Axis::Z),
],
))
}
fn foliage(&self, p: [i32; 3]) -> u32 {
let biome = self
.world
.chunks
.get(&(p[0] >> 4, p[2] >> 4))
.map_or(0, |c| c.biome(p[0], p[1], p[2]));
self.biomes.get(biome).foliage
}
}
fn add(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
engine.add(&ParticleOptions::simple(ty), p, v);
}
fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) {
engine.sounds.push((name, p, volume, pitch));
}
fn redstone(engine: &mut ParticleEngine, p: [f64; 3]) {
engine.add(&ParticleOptions::dust([1.0, 0.0, 0.0], 1.0), p, [0.0; 3]);
}
/// `ClientLevel.animateTick` around the player's block position.
pub fn animate_tick(
tables: &AnimateTables,
engine: &mut ParticleEngine,
ctx: &AnimateContext,
player: [i32; 3],
) {
for _ in 0..667 {
do_animate_tick(tables, engine, ctx, player, 16);
do_animate_tick(tables, engine, ctx, player, 32);
}
}
fn next_int(r: &mut LegacyRandom, bound: i32) -> i32 {
r.next_int_bound(bound).unwrap_or(0)
}
fn do_animate_tick(
tables: &AnimateTables,
engine: &mut ParticleEngine,
ctx: &AnimateContext,
center: [i32; 3],
r: i32,
) {
let random = engine.random();
let x = center[0] + next_int(random, r) - next_int(random, r);
let y = center[1] + next_int(random, r) - next_int(random, r);
let z = center[2] + next_int(random, r) - next_int(random, r);
let pos = [x, y, z];
if !ctx.world.loaded(x, z) {
return;
}
let state = ctx.state(pos);
block_animate_tick(tables, engine, ctx, state, pos);
let facts = ctx.facts.get(state);
if facts.fluid != Fluid::None {
fluid_animate_tick(
engine,
ctx,
pos,
facts.fluid,
facts.fluid_level,
facts.fluid_falling,
);
if next_int(engine.random(), 10) == 0 {
let drip = if facts.fluid == Fluid::Water {
T::DrippingWater
} else {
T::DrippingLava
};
let top_solid = ctx.sturdy(pos);
try_spawn_drip(tables, engine, ctx, [x, y - 1, z], drip, top_solid);
}
}
if let Some((block, options)) = ctx.marker
&& ctx.registry.state(state).is_some_and(|s| s.name == block)
&& let Some(options) = options(state)
{
engine.add(&options, pos.map(|v| f64::from(v) + 0.5), [0.0; 3]);
}
if !facts.full_collision {
let biome = ctx
.world
.chunks
.get(&(x >> 4, z >> 4))
.map_or(0, |c| c.biome(x, y, z));
for &(ty, probability) in tables.ambient.get(biome as usize).into_iter().flatten() {
// AmbientParticle.canSpawn: random.nextFloat() <= probability.
let random = engine.random();
if random.next_float() <= probability {
let p = [
f64::from(x) + random.next_double(),
f64::from(y) + random.next_double(),
f64::from(z) + random.next_double(),
];
add(engine, ty, p, [0.0; 3]);
}
}
}
}
/// `ClientLevel.trySpawnDripParticles`.
fn try_spawn_drip(
tables: &AnimateTables,
engine: &mut ParticleEngine,
ctx: &AnimateContext,
pos: [i32; 3],
drip: T,
top_solid: bool,
) {
let state = ctx.state(pos);
if ctx.facts.get(state).fluid != Fluid::None {
return;
}
let Some((bottom, top, bounds)) = ctx.shape_y(pos) else {
return;
};
let spawn = |engine: &mut ParticleEngine, x1: f64, x2: f64, z1: f64, z2: f64, y: f64| {
let r = engine.random();
let (a, b) = (r.next_double(), r.next_double());
add(
engine,
drip,
[x1 + (x2 - x1) * a, y, z1 + (z2 - z1) * b],
[0.0; 3],
);
};
let (fx, fy, fz) = (f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]));
if top < 1.0 {
if top_solid {
spawn(engine, fx, fx + 1.0, fz, fz + 1.0, fy + 1.0 - 0.05);
}
} else if !tables
.impermeable
.get(state.0 as usize)
.copied()
.unwrap_or(false)
{
if bottom > 0.0 {
spawn(
engine,
fx + bounds[0],
fx + bounds[1],
fz + bounds[2],
fz + bounds[3],
fy + bottom - 0.05,
);
} else {
let below = [pos[0], pos[1] - 1, pos[2]];
let below_top = ctx.shape_y(below).map_or(1.0, |s| s.1);
if below_top < 1.0 && ctx.facts.get(ctx.state(below)).fluid == Fluid::None {
spawn(
engine,
fx + bounds[0],
fx + bounds[1],
fz + bounds[2],
fz + bounds[3],
fy - 0.05,
);
}
}
}
}
/// `WaterFluid.animateTick` / `LavaFluid.animateTick`.
fn fluid_animate_tick(
engine: &mut ParticleEngine,
ctx: &AnimateContext,
pos: [i32; 3],
fluid: Fluid,
level: u8,
falling: bool,
) {
let (fx, fy, fz) = (f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]));
if fluid == Fluid::Water {
let source = level >= 8 && !falling;
let random = engine.random();
if !source && !falling {
if next_int(random, 64) == 0 {
let volume = random.next_float() * 0.25 + 0.75;
let pitch = random.next_float() + 0.5;
sound(
engine,
"minecraft:block.water.ambient",
[fx + 0.5, fy + 0.5, fz + 0.5],
volume,
pitch,
);
}
} else if next_int(random, 10) == 0 {
let p = [
fx + random.next_double(),
fy + random.next_double(),
fz + random.next_double(),
];
add(engine, T::Underwater, p, [0.0; 3]);
}
return;
}
let above = [pos[0], pos[1] + 1, pos[2]];
if ctx.is_air(above) {
let random = engine.random();
if next_int(random, 100) == 0 {
let p = [
fx + random.next_double(),
fy + 1.0,
fz + random.next_double(),
];
add(engine, T::Lava, p, [0.0; 3]);
let random = engine.random();
let (volume, pitch) = (
0.2 + random.next_float() * 0.2,
0.9 + random.next_float() * 0.15,
);
sound(engine, "minecraft:block.lava.pop", p, volume, pitch);
}
let random = engine.random();
if next_int(random, 200) == 0 {
let (volume, pitch) = (
0.2 + random.next_float() * 0.2,
0.9 + random.next_float() * 0.15,
);
sound(
engine,
"minecraft:block.lava.ambient",
[fx, fy, fz],
volume,
pitch,
);
}
}
}
#[allow(clippy::too_many_lines)]
fn block_animate_tick(
tables: &AnimateTables,
engine: &mut ParticleEngine,
ctx: &AnimateContext,
state: BlockStateId,
pos: [i32; 3],
) {
let (fx, fy, fz) = (f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]));
match tables.kind(state) {
Animate::None => {}
Animate::Torch(flame) => {
let p = [fx + 0.5, fy + 0.7, fz + 0.5];
add(engine, T::Smoke, p, [0.0; 3]);
add(engine, flame, p, [0.0; 3]);
}
Animate::WallTorch(flame, facing) => {
let p = [
fx + 0.5 - 0.27 * f64::from(facing[0]),
fy + 0.7 + 0.22,
fz + 0.5 - 0.27 * f64::from(facing[2]),
];
add(engine, T::Smoke, p, [0.0; 3]);
add(engine, flame, p, [0.0; 3]);
}
Animate::RedstoneTorch => {
let r = engine.random();
let p = [
fx + 0.5 + (r.next_double() - 0.5) * 0.2,
fy + 0.7 + (r.next_double() - 0.5) * 0.2,
fz + 0.5 + (r.next_double() - 0.5) * 0.2,
];
redstone(engine, p);
}
Animate::RedstoneWallTorch(facing) => {
let r = engine.random();
let p = [
fx + 0.5 + (r.next_double() - 0.5) * 0.2 - 0.27 * f64::from(facing[0]),
fy + 0.7 + (r.next_double() - 0.5) * 0.2 + 0.22,
fz + 0.5 + (r.next_double() - 0.5) * 0.2 - 0.27 * f64::from(facing[2]),
];
redstone(engine, p);
}
Animate::Furnace(facing) | Animate::BlastFurnace(facing) => {
let blast = matches!(tables.kind(state), Animate::BlastFurnace(_));
let (x, y, z) = (fx + 0.5, fy, fz + 0.5);
let r = engine.random();
if r.next_double() < 0.1 {
let name = if blast {
"minecraft:block.blastfurnace.fire_crackle"
} else {
"minecraft:block.furnace.fire_crackle"
};
sound(engine, name, [x, y, z], 1.0, 1.0);
}
let r = engine.random();
let ss = r.next_double() * 0.6 - 0.3;
let dx = if facing[0] != 0 {
f64::from(facing[0]) * 0.52
} else {
ss
};
let dy = r.next_double() * if blast { 9.0 } else { 6.0 } / 16.0;
let dz = if facing[2] != 0 {
f64::from(facing[2]) * 0.52
} else {
ss
};
let p = [x + dx, y + dy, z + dz];
add(engine, T::Smoke, p, [0.0; 3]);
if !blast {
add(engine, T::Flame, p, [0.0; 3]);
}
}
Animate::Smoker => {
let r = engine.random();
if r.next_double() < 0.1 {
sound(
engine,
"minecraft:block.smoker.smoke",
[fx + 0.5, fy, fz + 0.5],
1.0,
1.0,
);
}
add(engine, T::Smoke, [fx + 0.5, fy + 1.1, fz + 0.5], [0.0; 3]);
}
Animate::Campfire { spawn_particles } => {
let r = engine.random();
if next_int(r, 10) == 0 {
let (volume, pitch) = (0.5 + r.next_float(), r.next_float() * 0.7 + 0.6);
sound(
engine,
"minecraft:block.campfire.crackle",
[fx + 0.5, fy + 0.5, fz + 0.5],
volume,
pitch,
);
}
let r = engine.random();
if spawn_particles && next_int(r, 5) == 0 {
let count = next_int(r, 1) + 1;
for _ in 0..count {
let r = engine.random();
let v = [
f64::from(r.next_float() / 2.0),
5.0e-5,
f64::from(r.next_float() / 2.0),
];
add(engine, T::Lava, [fx + 0.5, fy + 0.5, fz + 0.5], v);
}
}
}
Animate::Leaves(falling) => {
let below = [pos[0], pos[1] - 1, pos[2]];
// LeavesBlock.makeDrippingWaterParticles.
if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1
{
let below_facts = ctx.facts.get(ctx.state(below));
if !below_facts.can_occlude || !ctx.sturdy(below) {
let r = engine.random();
let p = [fx + r.next_double(), fy - 0.05, fz + r.next_double()];
add(engine, T::DrippingWater, p, [0.0; 3]);
}
}
// FallingParticlesLeavesBlock.makeFallingLeavesParticles.
if let Some((ty, chance)) = falling
&& engine.random().next_float() < chance
&& !ctx.sturdy(below)
{
let r = engine.random();
let p = [fx + r.next_double(), fy - 0.05, fz + r.next_double()];
let options = if ty == T::TintedLeaves {
let c = ctx.foliage(pos);
let f = |s: u32| ((c >> s) & 255) as f32 / 255.0;
ParticleOptions::colored(ty, [f(16), f(8), f(0), 1.0])
} else {
ParticleOptions::simple(ty)
};
engine.add(&options, p, [0.0; 3]);
}
}
Animate::NetherPortal => {
let r = engine.random();
if next_int(r, 100) == 0 {
let pitch = r.next_float() * 0.4 + 0.8;
sound(
engine,
"minecraft:block.portal.ambient",
[fx + 0.5, fy + 0.5, fz + 0.5],
0.5,
pitch,
);
}
let along_z = ctx.state([pos[0] - 1, pos[1], pos[2]]) == state
|| ctx.state([pos[0] + 1, pos[1], pos[2]]) == state;
for _ in 0..4 {
let r = engine.random();
let mut p = [
fx + r.next_double(),
fy + r.next_double(),
fz + r.next_double(),
];
let mut v = [
f64::from(r.next_float() - 0.5) * 0.5,
f64::from(r.next_float() - 0.5) * 0.5,
f64::from(r.next_float() - 0.5) * 0.5,
];
let flip = f64::from(next_int(r, 2) * 2 - 1);
if along_z {
p[2] = fz + 0.5 + 0.25 * flip;
v[2] = f64::from(r.next_float() * 2.0) * flip;
} else {
p[0] = fx + 0.5 + 0.25 * flip;
v[0] = f64::from(r.next_float() * 2.0) * flip;
}
add(engine, T::Portal, p, v);
}
}
Animate::EnchantingTable => {
for ox in -2i32..=2 {
for oy in 0..=1 {
for oz in -2i32..=2 {
if ox.abs() != 2 && oz.abs() != 2 {
continue;
}
if next_int(engine.random(), 16) != 0 {
continue;
}
let provider = ctx.state([pos[0] + ox, pos[1] + oy, pos[2] + oz]);
let between = ctx.state([pos[0] + ox / 2, pos[1] + oy, pos[2] + oz / 2]);
if tables
.power_provider
.get(provider.0 as usize)
.copied()
.unwrap_or(false)
&& tables
.power_transmitter
.get(between.0 as usize)
.copied()
.unwrap_or(false)
{
let r = engine.random();
let v = [
f64::from(ox as f32 + r.next_float() - 0.5),
f64::from(oy as f32 - r.next_float() - 1.0),
f64::from(oz as f32 + r.next_float() - 0.5),
];
add(engine, T::Enchant, [fx + 0.5, fy + 2.0, fz + 0.5], v);
}
}
}
}
}
Animate::EndRod(facing) => {
let r = engine.random();
let x = fx + 0.55 - f64::from(r.next_float() * 0.1);
let y = fy + 0.55 - f64::from(r.next_float() * 0.1);
let z = fz + 0.55 - f64::from(r.next_float() * 0.1);
let d = f64::from(0.4 - (r.next_float() + r.next_float()) * 0.4);
if next_int(r, 5) == 0 {
let v = [
r.next_gaussian() * 0.005,
r.next_gaussian() * 0.005,
r.next_gaussian() * 0.005,
];
let p = [
x + f64::from(facing[0]) * d,
y + f64::from(facing[1]) * d,
z + f64::from(facing[2]) * d,
];
add(engine, T::EndRod, p, v);
}
}
Animate::SporeBlossom => {
let r = engine.random();
let p = [fx + r.next_double(), fy + 0.7, fz + r.next_double()];
add(engine, T::FallingSporeBlossom, p, [0.0; 3]);
for _ in 0..14 {
let r = engine.random();
let a = [
pos[0] + next_int(r, 21) - 10,
pos[1] - next_int(r, 10),
pos[2] + next_int(r, 21) - 10,
];
if !ctx.facts.get(ctx.state(a)).full_collision {
let r = engine.random();
let p = [
f64::from(a[0]) + r.next_double(),
f64::from(a[1]) + r.next_double(),
f64::from(a[2]) + r.next_double(),
];
add(engine, T::SporeBlossomAir, p, [0.0; 3]);
}
}
}
Animate::CryingObsidian => {
let r = engine.random();
if next_int(r, 5) == 0 {
// Direction.getRandom: down, up, north, south, west, east.
let d = [
[0, -1, 0],
[0, 1, 0],
[0, 0, -1],
[0, 0, 1],
[-1, 0, 0],
[1, 0, 0],
][next_int(r, 6) as usize];
if d != [0, 1, 0] {
let relative = [pos[0] + d[0], pos[1] + d[1], pos[2] + d[2]];
if !ctx.sturdy(relative) {
let r = engine.random();
let off = |s: i32, r: &mut LegacyRandom| {
if s == 0 {
r.next_double()
} else {
0.5 + f64::from(s) * 0.6
}
};
let p = [fx + off(d[0], r), fy + off(d[1], r), fz + off(d[2], r)];
add(engine, T::DrippingObsidianTear, p, [0.0; 3]);
}
}
}
}
Animate::PotentSulfur => {
// PotentSulfurBlock.animateTick: under a water source, two
// bubbles and, one time in ten, the noxious gas.
let above = ctx.facts.get(ctx.state([pos[0], pos[1] + 1, pos[2]]));
if above.fluid == Fluid::Water && above.fluid_level == 8 && !above.fluid_falling {
for _ in 0..2 {
let r = engine.random();
let p = [
fx + f64::from(r.next_float()),
fy + 1.0 + f64::from(r.next_float()),
fz + f64::from(r.next_float()),
];
add(engine, T::SulfurBubbles, p, [0.0; 3]);
}
if next_int(engine.random(), 10) == 0 {
let name = "minecraft:block.potent_sulfur.noxious_gas";
sound(engine, name, [fx, fy, fz], 1.0, 1.0);
}
}
}
Animate::Mycelium => {
let r = engine.random();
if next_int(r, 10) == 0 {
let p = [fx + r.next_double(), fy + 1.1, fz + r.next_double()];
add(engine, T::Mycelium, p, [0.0; 3]);
}
}
Animate::Candles(count) => {
for o in candle_offsets(count) {
candle(
engine,
[fx + o[0] / 16.0, fy + o[1] / 16.0, fz + o[2] / 16.0],
);
}
}
Animate::CandleCake => candle(engine, [fx + 0.5, fy + 1.0, fz + 0.5]),
Animate::BrewingStand => {
let r = engine.random();
let p = [
fx + 0.4 + f64::from(r.next_float() * 0.2),
fy + 0.7 + f64::from(r.next_float() * 0.3),
fz + 0.4 + f64::from(r.next_float() * 0.2),
];
add(engine, T::Smoke, p, [0.0; 3]);
}
Animate::DriedGhast { waterlogged } => {
// DriedGhastBlock.animateTick.
let c = [fx + 0.5, fy + 0.5, fz + 0.5];
if waterlogged {
if next_int(engine.random(), 40) == 0 {
let name = "minecraft:block.dried_ghast.ambient_water";
sound(engine, name, c, 1.0, 1.0);
}
let r = engine.random();
if next_int(r, 6) == 0 {
let x = c[0] + f64::from((r.next_float() * 2.0 - 1.0) / 3.0);
let y = c[1] + 0.4;
let z = c[2] + f64::from((r.next_float() * 2.0 - 1.0) / 3.0);
let v = [0.0, f64::from(r.next_float()), 0.0];
add(engine, T::HappyVillager, [x, y, z], v);
}
} else {
let below = ctx.state([pos[0], pos[1] - 1, pos[2]]);
let triggers = || {
tables
.dried_ghast_sounds
.get(below.0 as usize)
.copied()
.unwrap_or(false)
};
if next_int(engine.random(), 40) == 0 && triggers() {
sound(engine, "minecraft:block.dried_ghast.ambient", c, 1.0, 1.0);
}
if next_int(engine.random(), 6) == 0 {
add(engine, T::WhiteSmoke, c, [0.0, 0.02, 0.0]);
}
}
}
Animate::EndPortal => {
// EndPortalBlock.animateTick: one smoke particle above the surface.
let r = engine.random();
let p = [fx + r.next_double(), fy + 0.8, fz + r.next_double()];
add(engine, T::Smoke, p, [0.0; 3]);
}
Animate::EnderChest => {
for _ in 0..3 {
let r = engine.random();
let flip_x = f64::from(next_int(r, 2) * 2 - 1);
let flip_z = f64::from(next_int(r, 2) * 2 - 1);
let p = [
fx + 0.5 + 0.25 * flip_x,
fy + f64::from(r.next_float()),
fz + 0.5 + 0.25 * flip_z,
];
let v = [
f64::from(r.next_float()) * flip_x,
f64::from(r.next_float() - 0.5) * 0.125,
f64::from(r.next_float()) * flip_z,
];
add(engine, T::Portal, p, v);
}
}
Animate::Falling(color) => {
if next_int(engine.random(), 16) == 0 {
let below = ctx.facts.get(ctx.state([pos[0], pos[1] - 1, pos[2]]));
// FallingBlock.isFree: air, fire, liquids or replaceable.
if below.replaceable
|| below.fluid != Fluid::None
|| ctx.is_air([pos[0], pos[1] - 1, pos[2]])
{
let r = engine.random();
let p = [fx + r.next_double(), fy - 0.05, fz + r.next_double()];
engine.add(
&ParticleOptions::block(T::FallingDust, String::new(), color),
p,
[0.0; 3],
);
}
}
}
Animate::RedstoneOre => {
for d in [
[0, -1, 0],
[0, 1, 0],
[0, 0, -1],
[0, 0, 1],
[-1, 0, 0],
[1, 0, 0],
] {
let relative = [pos[0] + d[0], pos[1] + d[1], pos[2] + d[2]];
if ctx.facts.get(ctx.state(relative)).solid_render {
continue;
}
let r = engine.random();
let mut c = |s: i32| {
if s != 0 {
0.5 + 0.5625 * f64::from(s)
} else {
f64::from(r.next_float())
}
};
let p = [fx + c(d[0]), fy + c(d[1]), fz + c(d[2])];
redstone(engine, p);
}
}
Animate::RedstoneWire { power, sides } => {
let color = redstone_color(power);
let horizontals = [[0, 0, -1], [1, 0, 0], [0, 0, 1], [-1, 0, 0]];
let line = |engine: &mut ParticleEngine,
side: [i32; 3],
along: [i32; 3],
from: f32,
to: f32| {
let span = to - from;
let r = engine.random();
if r.next_float() < 0.2 * span {
let on = from + span * r.next_float();
let c = |i: usize| {
0.5 + 0.4375 * f64::from(side[i]) + f64::from(on) * f64::from(along[i])
};
engine.add(
&ParticleOptions::dust(color, 1.0),
[fx + c(0), fy + c(1), fz + c(2)],
[0.0; 3],
);
}
};
for (i, h) in horizontals.into_iter().enumerate() {
match sides[i] {
2 => {
line(engine, h, [0, 1, 0], -0.5, 0.5);
line(engine, [0, -1, 0], h, 0.0, 0.5);
}
1 => line(engine, [0, -1, 0], h, 0.0, 0.5),
_ => line(engine, [0, -1, 0], h, 0.0, 0.3),
}
}
}
Animate::SculkSensor => {
// SculkSensorBlock.animateTick.
let r = engine.random();
let direction = r.next_int_bound(6).unwrap_or(0);
// Direction.values(): down, up, north, south, west, east.
if direction >= 2 {
let step = [[0, 0, -1], [0, 0, 1], [-1, 0, 0], [1, 0, 0]][direction as usize - 2];
let x = fx
+ 0.5
+ if step[0] == 0 {
0.5 - r.next_double()
} else {
f64::from(step[0]) * 0.6
};
let z = fz
+ 0.5
+ if step[2] == 0 {
0.5 - r.next_double()
} else {
f64::from(step[2]) * 0.6
};
let ya = f64::from(r.next_float() * 0.04);
engine.add(
&crate::particles::ParticleOptions::sculk_to_redstone(),
[x, fy + 0.25, z],
[0.0, ya, 0.0],
);
}
}
Animate::RespawnAnchor => {
let r = engine.random();
if next_int(r, 100) == 0 {
sound(
engine,
"minecraft:block.respawn_anchor.ambient",
[fx + 0.5, fy + 0.5, fz + 0.5],
1.0,
1.0,
);
}
let r = engine.random();
let p = [
fx + 0.5 + (0.5 - r.next_double()),
fy + 1.0,
fz + 0.5 + (0.5 - r.next_double()),
];
let ya = f64::from(r.next_float() * 0.04);
add(engine, T::ReversePortal, p, [0.0, ya, 0.0]);
}
Animate::BubbleColumn { drag } => {
if drag {
add(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);
sound(
engine,
"minecraft:block.bubble_column.whirlpool_ambient",
[fx, fy, fz],
volume,
pitch,
);
}
} else {
add(
engine,
T::BubbleColumnUp,
[fx + 0.5, fy, fz + 0.5],
[0.0, 0.04, 0.0],
);
let r = engine.random();
let p = [
fx + f64::from(r.next_float()),
fy + f64::from(r.next_float()),
fz + f64::from(r.next_float()),
];
add(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);
sound(
engine,
"minecraft:block.bubble_column.upwards_ambient",
[fx, fy, fz],
volume,
pitch,
);
}
}
}
Animate::Fire => {
let r = engine.random();
if next_int(r, 24) == 0 {
let (volume, pitch) = (1.0 + r.next_float(), r.next_float() * 0.7 + 0.3);
sound(
engine,
"minecraft:block.fire.ambient",
[fx + 0.5, fy + 0.5, fz + 0.5],
volume,
pitch,
);
}
}
}
}
/// `AbstractCandleBlock.addParticlesAndSound`.
fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
let r = engine.random();
let chance = r.next_float();
if chance < 0.3 {
add(engine, T::Smoke, p, [0.0; 3]);
if chance < 0.17 {
let r = engine.random();
let (volume, pitch) = (1.0 + r.next_float(), r.next_float() * 0.7 + 0.3);
sound(
engine,
"minecraft:block.candle.ambient",
[p[0] + 0.5, p[1] + 0.5, p[2] + 0.5],
volume,
pitch,
);
}
}
add(engine, T::SmallFlame, p, [0.0; 3]);
}
/// `CampfireBlockEntity.particleTick` for every lit campfire (no cooking items).
pub fn campfire_particles<'a>(
tables: &AnimateTables,
engine: &mut ParticleEngine,
ctx: &AnimateContext,
blocks: impl Iterator<Item = &'a ([i32; 3], u32)>,
) {
for &(pos, state) in blocks {
if !tables.is_lit_campfire(state) {
continue;
}
let signal = ctx
.registry
.state(BlockStateId(state))
.is_some_and(|s| s.properties.get("signal_fire").map(String::as_str) == Some("true"));
let r = engine.random();
if r.next_float() < 0.11 {
let count = next_int(r, 2) + 2;
for _ in 0..count {
make_campfire_smoke(engine, pos, signal);
}
}
}
}
/// `CampfireBlock.makeParticles` (always visible, overriding the limiter).
pub fn make_campfire_smoke(engine: &mut ParticleEngine, pos: [i32; 3], signal: bool) {
let r = engine.random();
let sign = |r: &mut LegacyRandom| if r.next_boolean() { 1.0 } else { -1.0 };
let dx = r.next_double() / 3.0;
let x = f64::from(pos[0]) + 0.5 + dx * sign(r);
let y = f64::from(pos[1]) + r.next_double() + r.next_double();
let dz = r.next_double() / 3.0;
let z = f64::from(pos[2]) + 0.5 + dz * sign(r);
let ty = if signal {
T::CampfireSignalSmoke
} else {
T::CampfireCosySmoke
};
engine.create(&ParticleOptions::simple(ty), [x, y, z], [0.0, 0.07, 0.0]);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classifies_animated_blocks() {
let none = |_: &str| None;
assert_eq!(classify("minecraft:torch", &none), Animate::Torch(T::Flame));
let lit = |k: &str| (k == "lit").then(|| "true".to_owned());
assert_eq!(
classify("minecraft:furnace", &lit),
Animate::Furnace([0, -1, 0])
);
assert_eq!(classify("minecraft:furnace", &none), Animate::None);
let wall = |k: &str| (k == "facing").then(|| "north".to_owned());
assert_eq!(
classify("minecraft:soul_wall_torch", &wall),
Animate::WallTorch(T::SoulFireFlame, [0, 0, -1])
);
let candles = |k: &str| match k {
"lit" => Some("true".to_owned()),
"candles" => Some("3".to_owned()),
_ => None,
};
assert_eq!(
classify("minecraft:red_candle", &candles),
Animate::Candles(3)
);
assert_eq!(
classify("minecraft:red_candle_cake", &lit),
Animate::CandleCake
);
}
#[test]
fn redstone_colours_match_wire_table() {
// RedstoneWireBlock.COLORS[15] = (1.0, 0.2, 0.1) before int packing.
let c = redstone_color(15);
assert!((c[0] - 1.0).abs() < 1e-6);
assert!((c[1] - (51.0 / 255.0)).abs() < 0.01);
}
}