Merge pull request #422 from ludovic111/feat/trial-visuals

Show trial spawner and vault visuals
This commit is contained in:
Ludovic Marie
2026-10-16 06:42:27 +02:00
committed by GitHub
6 changed files with 411 additions and 37 deletions
+6
View File
@@ -122,6 +122,7 @@ mod tnt;
mod totem;
mod trading;
mod trial_spawner;
mod trial_visuals;
mod trident;
mod tweaks;
mod ui_control;
@@ -1818,6 +1819,11 @@ impl Game<'_> {
pos,
data,
} => self.composter_fill_event(pos, data == 1),
LevelEvent::LevelEvent {
id: id @ 3011..=3021,
pos,
data,
} => self.trial_level_event(id, [pos.x, pos.y, pos.z], data),
LevelEvent::LevelEvent { id, pos, .. } => {
let c = Some([
f64::from(pos.x) + 0.5,
+29 -12
View File
@@ -92,9 +92,12 @@ impl Game<'_> {
self.client_tick_spawner(key);
}
let entities = &self.world.block_entities;
self.spawners
.displays
.retain(|k, _| matches!(entities.get(k), Some(BlockEntity::Spawner(_))));
self.spawners.displays.retain(|k, _| {
matches!(
entities.get(k),
Some(BlockEntity::Spawner(_) | BlockEntity::TrialSpawner(_))
)
});
Ok(())
}
fn server_tick_spawner(&mut self, key: Pos, spawner: &mut Spawner) -> Result<()> {
@@ -323,7 +326,7 @@ impl Game<'_> {
}
/// `getOrCreateDisplayEntity`: the mob shown in the spawner, made again
/// when its type changes. False when there is none.
fn update_spawner_display(&mut self, key: Pos) -> bool {
pub(super) fn update_spawner_display(&mut self, key: Pos) -> bool {
let Some(kind) = self.spawner_display_kind(key) else {
self.spawners.displays.remove(&key);
return false;
@@ -344,11 +347,16 @@ impl Game<'_> {
}
/// The type of the mob a spawner shows: its next data's id, when the game
/// knows the mob.
/// A trial spawner shows one only in the states with a spinning mob.
fn spawner_display_kind(&self, key: Pos) -> Option<String> {
let Some(BlockEntity::Spawner(s)) = self.world.block_entities.get(&key) else {
return None;
let id = match self.world.block_entities.get(&key)? {
BlockEntity::Spawner(s) => s.next_data()?.id()?,
BlockEntity::TrialSpawner(s) => {
self.trial_spawner_block(key)?.0.spinning_mob_speed()?;
s.next_spawn_data.as_ref()?.id()?
}
_ => return None,
};
let id = s.next_data()?.id()?;
self.res.mob_types.contains_key(&id).then_some(id)
}
/// `SpawnEggItem.useOn` on a spawner: the egg sets its mob. None when the
@@ -383,8 +391,8 @@ impl Game<'_> {
self.post_block_game_event("minecraft:block_change", pos, Some(Who::Player), None);
Some(true)
}
/// `SpawnerRenderer`: the next mob of every spawner near the camera,
/// small and turning.
/// `SpawnerRenderer` and `TrialSpawnerRenderer`: the next mob of every
/// spawner near the camera, small and turning.
pub(super) fn spawner_geometry(
&self,
camera: glam::DVec3,
@@ -398,10 +406,19 @@ impl Game<'_> {
if at.distance_squared(camera) >= 64.0 * 64.0 {
continue;
}
let Some(BlockEntity::Spawner(s)) = self.world.block_entities.get(key) else {
continue;
let (spin, scale) = match self.world.block_entities.get(key) {
Some(BlockEntity::Spawner(s)) => {
s.display_pose(alpha as f32, mob.width(), mob.height())
}
Some(BlockEntity::TrialSpawner(s)) => horizon_client::mobs::spawner::display_pose(
s.o_spin,
s.spin,
alpha as f32,
mob.width(),
mob.height(),
),
_ => continue,
};
let (spin, scale) = s.display_pose(alpha as f32, mob.width(), mob.height());
let origin = glam::Mat4::from_translation(
(at - camera).as_vec3() + glam::Vec3::new(0.5, 0.4, 0.5),
) * glam::Mat4::from_rotation_y(spin.to_radians())
+25 -12
View File
@@ -64,33 +64,46 @@ impl Game<'_> {
.filter(|(_, e)| matches!(e, BlockEntity::TrialSpawner(_)))
.map(|(k, _)| *k)
.collect();
for key in keys {
let state = self.world.block(key.0, key.1, key.2);
let Some(block) = self.res.assets.registry.state(state).cloned() else {
for &key in &keys {
let Some((current, ominous)) = self.trial_spawner_block(key) else {
continue;
};
if block.name != "minecraft:trial_spawner" {
continue;
}
let Some(BlockEntity::TrialSpawner(mut spawner)) =
self.world.block_entities.remove(&key)
else {
continue;
};
let current = block
.properties
.get("trial_spawner_state")
.and_then(|s| TrialState::from_name(s))
.unwrap_or_default();
let ominous = block.properties.get("ominous").is_some_and(|v| v == "true");
let result = self.server_tick_trial_spawner(key, &mut spawner, current, ominous);
self.world
.block_entities
.insert(key, BlockEntity::TrialSpawner(spawner));
result?;
}
for key in keys {
self.client_tick_trial_spawner(key);
}
Ok(())
}
/// The trial spawner block at `key`: its state and ominous flag.
pub(super) fn trial_spawner_block(&self, key: Pos) -> Option<(TrialState, bool)> {
let block = self
.res
.assets
.registry
.state(self.world.block(key.0, key.1, key.2))?;
if block.name != "minecraft:trial_spawner" {
return None;
}
let state = block
.properties
.get("trial_spawner_state")
.and_then(|s| TrialState::from_name(s))
.unwrap_or_default();
Some((
state,
block.properties.get("ominous").is_some_and(|v| v == "true"),
))
}
fn server_tick_trial_spawner(
&mut self,
key: Pos,
@@ -0,0 +1,333 @@
//! The client side of trial spawners and vaults: `LevelEventHandler` 3011 to
//! 3021, `TrialSpawner.tickClient` (the state's particles, the spinning mob,
//! the ambient sound) and `VaultBlockEntity.Client.tick` (idle smoke and
//! flames, the connection particles towards the player, the ambient sound).
//! Every draw comes from the client level's random.
use super::Game;
use horizon_client::{
containers::BlockEntity,
mobs::trial_spawner::TrialState,
particles::{ParticleOptions, ParticleType as T},
};
use horizon_core::random::{LegacyRandom, RandomSource};
type Pos = (i32, i32, i32);
/// `Mth.nextDouble`.
fn next_double(random: &mut LegacyRandom, min: f64, max: f64) -> f64 {
if min >= max {
min
} else {
random.next_double() * (max - min) + min
}
}
/// `Vec3.offsetRandom`.
fn offset_random(v: [f64; 3], random: &mut LegacyRandom, amount: f32) -> [f64; 3] {
v.map(|c| c + f64::from((random.next_float() - 0.5) * amount))
}
/// The pitch of `playLocalSound`'s block event sounds.
fn event_pitch(random: &mut LegacyRandom) -> f32 {
(random.next_float() - random.next_float()) * 0.2 + 1.0
}
fn center(pos: [i32; 3]) -> [f64; 3] {
pos.map(|v| f64::from(v) + 0.5)
}
fn flame(ominous: bool) -> T {
if ominous {
T::SoulFireFlame
} else {
T::SmallFlame
}
}
impl Game<'_> {
fn particle(&mut self, ty: T, p: [f64; 3], v: [f64; 3]) {
self.particles.add(&ParticleOptions::simple(ty), p, v);
}
fn local_sound(&mut self, name: &str, pos: [i32; 3], volume: f32, pitch: f32) {
self.audio.play(
&format!("minecraft:{name}"),
Some(center(pos)),
volume,
pitch,
);
}
/// `LevelEventHandler.levelEvent` 3011 to 3021.
pub(super) fn trial_level_event(&mut self, id: i32, pos: [i32; 3], data: i32) {
// TrialSpawner.FlameParticle.decode.
let spawn_flame = if data == 1 {
T::SoulFireFlame
} else {
T::Flame
};
let sound = |s: &mut Self, name: &str, volume: f32| {
let pitch = event_pitch(s.particles.level_random());
s.local_sound(name, pos, volume, pitch);
};
match id {
3011 => self.trial_spawn_particles(pos, spawn_flame),
3012 => {
sound(self, "block.trial_spawner.spawn_mob", 1.0);
self.trial_spawn_particles(pos, spawn_flame);
}
3013 | 3019 => {
sound(self, "block.trial_spawner.detect_player", 1.0);
let ty = if id == 3013 {
T::TrialSpawnerDetection
} else {
T::TrialSpawnerDetectionOminous
};
self.detect_player_particles(pos, data, ty);
}
3014 => {
sound(self, "block.trial_spawner.eject_item", 1.0);
self.eject_item_particles(pos);
}
3015 => {
if matches!(
self.world.block_entities.get(&(pos[0], pos[1], pos[2])),
Some(BlockEntity::Vault(_))
) {
self.vault_activation_particles(pos, data != 0);
sound(self, "block.vault.activate", 1.0);
}
}
3016 => {
// emitDeactivationParticles.
let ty = flame(data != 0);
for _ in 0..20 {
let random = self.particles.level_random();
let p = [0.4, 0.4, 0.4].map(|lo| next_double(random, lo, 0.6));
let v = [0; 3].map(|_| random.next_gaussian() * 0.02);
let at = std::array::from_fn(|i| f64::from(pos[i]) + p[i]);
self.particle(ty, at, v);
}
sound(self, "block.vault.deactivate", 1.0);
}
3017 => self.eject_item_particles(pos),
3018 => {
for _ in 0..10 {
let random = self.particles.level_random();
let v = [0; 3].map(|_| random.next_gaussian() * 0.02);
let at = pos.map(|c| f64::from(c) + random.next_double());
self.particle(T::Poof, at, v);
}
sound(self, "block.cobweb.place", 1.0);
}
3020 => {
sound(
self,
"block.trial_spawner.ominous_activate",
if data == 0 { 0.3 } else { 1.0 },
);
self.detect_player_particles(pos, 0, T::TrialSpawnerDetectionOminous);
// addBecomeOminousParticles.
for _ in 0..20 {
let random = self.particles.level_random();
let at = pos.map(|c| f64::from(c) + 0.5 + (random.next_double() - 0.5) * 2.0);
let v = [0; 3].map(|_| random.next_gaussian() * 0.02);
self.particle(T::TrialOmen, at, v);
self.particle(T::SoulFireFlame, at, v);
}
}
3021 => {
sound(self, "block.trial_spawner.spawn_item", 1.0);
self.trial_spawn_particles(pos, spawn_flame);
}
_ => {}
}
}
/// `TrialSpawner.addSpawnParticles`.
fn trial_spawn_particles(&mut self, pos: [i32; 3], ty: T) {
for _ in 0..20 {
let random = self.particles.level_random();
let at = pos.map(|c| f64::from(c) + 0.5 + (random.next_double() - 0.5) * 2.0);
self.particle(T::Smoke, at, [0.0; 3]);
self.particle(ty, at, [0.0; 3]);
}
}
/// `TrialSpawner.addDetectPlayerParticles`.
fn detect_player_particles(&mut self, pos: [i32; 3], data: i32, ty: T) {
for _ in 0..30 + data.min(10) * 5 {
let random = self.particles.level_random();
let x = f64::from(2.0 * random.next_float() - 1.0) * 0.65;
let z = f64::from(2.0 * random.next_float() - 1.0) * 0.65;
let y = f64::from(pos[1]) + 0.1 + f64::from(random.next_float()) * 0.8;
let at = [f64::from(pos[0]) + 0.5 + x, y, f64::from(pos[2]) + 0.5 + z];
self.particle(ty, at, [0.0; 3]);
}
}
/// `TrialSpawner.addEjectItemParticles`.
fn eject_item_particles(&mut self, pos: [i32; 3]) {
for _ in 0..20 {
let random = self.particles.level_random();
let at = pos.map(|c| f64::from(c) + 0.4 + random.next_double() * 0.2);
let v = [0; 3].map(|_| random.next_gaussian() * 0.02);
self.particle(T::SmallFlame, at, [v[0], v[1], v[2] * 0.25]);
self.particle(T::Smoke, at, v);
}
}
/// `TrialSpawner.tickClient`: the state's particles, the spin of the
/// mob shown inside and the ambient sound.
pub(super) fn client_tick_trial_spawner(&mut self, key: Pos) {
let Some((state, ominous)) = self.trial_spawner_block(key) else {
return;
};
let pos = [key.0, key.1, key.2];
let time = self.world.game_time;
let c = center(pos);
let random = self.particles.level_random();
// TrialSpawnerState.ParticleEmission.
let mut emitted: Vec<(T, [f64; 3])> = Vec::new();
match state {
TrialState::WaitingForPlayers
| TrialState::WaitingForRewardEjection
| TrialState::EjectingReward => {
if random.next_int_bound(2) == Ok(0) {
emitted.push((flame(ominous), offset_random(c, random, 0.9)));
}
}
TrialState::Active => {
let at = offset_random(c, random, 1.0);
let ty = if ominous { T::SoulFireFlame } else { T::Flame };
emitted.extend([(T::Smoke, at), (ty, at)]);
}
TrialState::Cooldown => {
let at = offset_random(c, random, 0.9);
if random.next_int_bound(3) == Ok(0) {
emitted.push((T::Smoke, at));
}
if time % 20 == 0 {
let top = [c[0], c[1] + 0.5, c[2]];
let count = random.next_int_bound(4).unwrap_or(0) + 20;
emitted.extend((0..count).map(|_| (T::Smoke, top)));
}
}
TrialState::Inactive => {}
}
let ambient = state.capable_of_spawning() && random.next_float() <= 0.02;
let ambient =
ambient.then(|| (random.next_float() * 0.25 + 0.75, random.next_float() + 0.5));
for (ty, at) in emitted {
self.particle(ty, at, [0.0; 3]);
}
if let Some(BlockEntity::TrialSpawner(s)) = self.world.block_entities.get_mut(&key)
&& let Some(speed) = state.spinning_mob_speed()
{
let delay = (s.next_mob_spawns_at - time).max(0) as f64;
s.o_spin = s.spin;
s.spin = (s.spin + speed / (delay + 200.0)) % 360.0;
}
if let Some((volume, pitch)) = ambient {
let name = if ominous {
"block.trial_spawner.ambient_ominous"
} else {
"block.trial_spawner.ambient"
};
self.local_sound(name, pos, volume, pitch);
}
self.update_spawner_display(key);
}
/// `VaultBlockEntity.Client.tick`.
pub(super) fn client_tick_vault(&mut self, key: Pos) {
let Some((mut vault, _, ominous)) = self.take_vault(key) else {
return;
};
vault.update_display_item_spin();
let shows = vault.display_item.is_some();
self.world
.block_entities
.insert(key, BlockEntity::Vault(vault));
let pos = [key.0, key.1, key.2];
if self.world.game_time % 20 == 0 {
self.vault_connection_particles(pos);
}
// emitIdleParticles.
let random = self.particles.level_random();
if random.next_float() <= 0.5 {
let at = cage_point(pos, random);
self.particle(T::Smoke, at, [0.0; 3]);
if shows {
self.particle(flame(ominous), at, [0.0; 3]);
}
}
// playIdleSounds.
if shows {
let random = self.particles.level_random();
if random.next_float() <= 0.02 {
let volume = random.next_float() * 0.25 + 0.75;
let pitch = random.next_float() + 0.5;
self.local_sound("block.vault.ambient", pos, volume, pitch);
}
}
}
/// `VaultBlockEntity.Client.emitActivationParticles`.
fn vault_activation_particles(&mut self, pos: [i32; 3], ominous: bool) {
self.vault_connection_particles(pos);
for _ in 0..20 {
let at = cage_point(pos, self.particles.level_random());
self.particle(T::Smoke, at, [0.0; 3]);
self.particle(flame(ominous), at, [0.0; 3]);
}
}
/// `emitConnectionParticlesForNearbyPlayers`: from the keyhole towards
/// each connected player within the particles' range.
fn vault_connection_particles(&mut self, pos: [i32; 3]) {
let key = (pos[0], pos[1], pos[2]);
let Some(BlockEntity::Vault(vault)) = self.world.block_entities.get(&key) else {
return;
};
let me = self.level.player_uuid.unwrap_or_default();
let range = vault.connected_particles_range;
let (Some(p), true) = (self.player.as_ref(), vault.connected_players.contains(&me)) else {
return;
};
let block = [p.position.x, p.position.y, p.position.z].map(|v| v.floor() as i32);
let d = [0, 1, 2].map(|i| f64::from(block[i] - pos[i]));
if d[0] * d[0] + d[1] * d[1] + d[2] * d[2] > range * range {
return;
}
let target = [
p.position.x,
p.position.y + f64::from(p.dimensions.height / 2.0),
p.position.z,
];
let facing = self
.res
.assets
.registry
.state(self.world.block(pos[0], pos[1], pos[2]))
.and_then(|b| b.properties.get("facing").cloned());
let step = match facing.as_deref() {
Some("south") => [0.0, 1.0],
Some("west") => [-1.0, 0.0],
Some("east") => [1.0, 0.0],
_ => [0.0, -1.0],
};
// keyholePos: the bottom centre, 1.75 up and half a block out the front.
let keyhole = [
f64::from(pos[0]) + 0.5 + step[0] * 0.5,
f64::from(pos[1]) + 1.75,
f64::from(pos[2]) + 0.5 + step[1] * 0.5,
];
let direction: [f64; 3] = std::array::from_fn(|i| target[i] - keyhole[i]);
let random = self.particles.level_random();
let count = random.next_int_bound(4).unwrap_or(0) + 2;
for _ in 0..count {
let v = offset_random(direction, self.particles.level_random(), 1.0);
self.particle(T::VaultConnection, keyhole, v);
}
}
}
/// `randomPosInsideCage`.
fn cage_point(pos: [i32; 3], random: &mut LegacyRandom) -> [f64; 3] {
let x = next_double(random, 0.1, 0.9);
let y = next_double(random, 0.25, 0.75);
let z = next_double(random, 0.1, 0.9);
[
f64::from(pos[0]) + x,
f64::from(pos[1]) + y,
f64::from(pos[2]) + z,
]
}
+3 -3
View File
@@ -44,7 +44,7 @@ impl Game<'_> {
}
}
/// The vault at `key` with its block's state and ominous flag.
fn take_vault(&mut self, key: Pos) -> Option<(Box<Vault>, VaultState, bool)> {
pub(super) fn take_vault(&mut self, key: Pos) -> Option<(Box<Vault>, VaultState, bool)> {
let state = self.world.block(key.0, key.1, key.2);
let block = self.res.assets.registry.state(state)?;
if block.name != "minecraft:vault" {
@@ -116,7 +116,7 @@ impl Game<'_> {
.insert(key, BlockEntity::Vault(vault));
Some(self.vault_events(key, events).map(|()| out))
}
/// Every vault's server tick, then its client tick's spin.
/// Every vault's server tick, then its client tick.
pub(super) fn tick_vaults(&mut self) -> Result<()> {
let keys: Vec<Pos> = self
.world
@@ -129,11 +129,11 @@ impl Game<'_> {
let pos = [key.0, key.1, key.2];
let ticked = self.with_vault(key, |v, l, random, state, ominous, roll, events| {
v.server_tick(l, random, pos, state, ominous, roll, events);
v.update_display_item_spin();
});
if let Some(result) = ticked {
result?;
}
self.client_tick_vault(key);
}
Ok(())
}
+15 -10
View File
@@ -640,20 +640,25 @@ impl Spawner {
pub fn client_loaded(&mut self) {
self.client_delay = self.spawn_delay;
}
/// `TrialSpawnerRenderer.extractSpawnerData`: the spin in degrees and
/// the scale of a display mob of the given size.
/// The display mob's spin in degrees and scale ([`display_pose`]).
pub fn display_pose(&self, alpha: f32, width: f32, height: f32) -> (f32, f32) {
let spin = (self.o_spin + f64::from(alpha) * (self.spin - self.o_spin)) as f32 * 10.0;
let longest = width.max(height);
let scale = if longest > 1.0 {
0.53125 / longest
} else {
0.53125
};
(spin, scale)
display_pose(self.o_spin, self.spin, alpha, width, height)
}
}
/// `TrialSpawnerRenderer.extractSpawnerData`: the spin in degrees and the
/// scale of a display mob of the given size, between the last two spins.
pub fn display_pose(o_spin: f64, spin: f64, alpha: f32, width: f32, height: f32) -> (f32, f32) {
let spin = (o_spin + f64::from(alpha) * (spin - o_spin)) as f32 * 10.0;
let longest = width.max(height);
let scale = if longest > 1.0 {
0.53125 / longest
} else {
0.53125
};
(spin, scale)
}
/// `WeightedList.getRandom`: one draw over the total weight, none when the
/// list weighs nothing.
pub fn weighted_index(