From ad4d836f6ff506eaf2d63ca1a4b0ca4eaf94cafb Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:16:28 +0200 Subject: [PATCH 1/9] Resolve sound events exactly as vanilla SoundManager does Add SoundRegistry (sounds.json with replace, subtitles, file validation and event references weighing as much as their event) and a SoundEngine model, with a differential harness resolving every sounds.json event against the real SoundManager.prepare and SimpleSoundInstance.getOrResolve. Co-Authored-By: Claude Opus 5.5 --- .../examples/sound_event_fixture.rs | 78 ++ crates/horizon-client/src/lib.rs | 2 + crates/horizon-client/src/sound_engine.rs | 936 ++++++++++++++++++ crates/horizon-client/src/sound_events.rs | 385 +++++++ .../parity/VanillaSoundEventOracle.java | 111 +++ tools/audio_harness.py | 88 ++ tools/test_sound_event_parity.py | 51 + 7 files changed, 1651 insertions(+) create mode 100644 crates/horizon-client/examples/sound_event_fixture.rs create mode 100644 crates/horizon-client/src/sound_engine.rs create mode 100644 crates/horizon-client/src/sound_events.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEventOracle.java create mode 100644 tools/audio_harness.py create mode 100644 tools/test_sound_event_parity.py diff --git a/crates/horizon-client/examples/sound_event_fixture.rs b/crates/horizon-client/examples/sound_event_fixture.rs new file mode 100644 index 000000000..57c6dd7be --- /dev/null +++ b/crates/horizon-client/examples/sound_event_fixture.rs @@ -0,0 +1,78 @@ +//! Resolves sound instances through Horizon's sound event registry for +//! `tools/test_sound_event_parity.py`: `sound_event_fixture ROOT INPUT OUTPUT [NAMES]`. +use horizon_client::sound_engine::{Attenuation, MASTER, SoundEngine, SoundInstance}; +use horizon_client::sound_events::{Sentinel, SoundRegistry}; +use horizon_core::random::{LegacyRandom, RandomSource}; +use std::io::Write; + +fn bits(v: f32) -> String { + format!("{:08x}", v.to_bits()) +} + +fn main() { + let args: Vec = std::env::args().collect(); + let registry = SoundRegistry::load(std::path::Path::new(&args[1])); + let mut engine = SoundEngine::new(registry); + let input = std::fs::read_to_string(&args[2]).expect("input"); + let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); + let mut names: Vec = engine.registry.names().cloned().collect(); + names.sort(); + for name in names { + writeln!(out, "registered {name}").expect("write"); + } + for line in input.lines() { + let f: Vec<&str> = line.split(' ').collect(); + let seed: i64 = f[1].parse().expect("seed"); + let volume = f32::from_bits(u32::from_str_radix(f[2], 16).expect("volume")); + let pitch = f32::from_bits(u32::from_str_radix(f[3], 16).expect("pitch")); + let event = horizon_client::sound_events::normalize(f[0]); + let instance = SoundInstance::new( + &event, + MASTER, + volume, + pitch, + LegacyRandom::new(seed), + false, + 0, + Attenuation::Linear, + [0.0; 3], + false, + ); + let id = engine.add(instance, true); + engine.resolve(id); + let weight = engine.registry.weight(&event); + let i = engine.instance_mut(id).expect("instance"); + let mut s = line.to_owned(); + match &i.event { + None => s.push_str(" event=none"), + Some(subtitle) => s.push_str(&format!( + " event weight={weight} subtitle={}", + subtitle.as_deref().unwrap_or("-") + )), + } + let v = i.get_volume(); + let p = i.get_pitch(); + let sound = i.sound.clone().expect("resolved"); + let (namespace, path) = sound.path(); + let sentinel = match sound.sentinel { + Sentinel::None => "-", + Sentinel::Empty => "empty", + Sentinel::IntentionallyEmpty => "intentionally_empty", + }; + s.push_str(&format!( + " sound={} path={namespace}:{path} sentinel={sentinel} weight={} type={} stream={} preload={} attenuation={} volume={} pitch={} range={} next={}", + sound.location, + sound.weight, + if sound.event { "SOUND_EVENT" } else { "FILE" }, + sound.stream, + sound.preload, + sound.attenuation_distance, + bits(v), + bits(p), + bits(sound.attenuation_distance(v)), + i.random.next_long() + )); + writeln!(out, "{s}").expect("write"); + engine.release(id); + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index e5080ea4a..01c135262 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -83,6 +83,8 @@ pub mod settings; pub mod shadows; pub mod signs; pub mod snbt; +pub mod sound_engine; +pub mod sound_events; pub mod sprint; pub mod sprites; pub mod stations; diff --git a/crates/horizon-client/src/sound_engine.rs b/crates/horizon-client/src/sound_engine.rs new file mode 100644 index 000000000..f51545595 --- /dev/null +++ b/crates/horizon-client/src/sound_engine.rs @@ -0,0 +1,936 @@ +//! Vanilla's `SoundEngine` bookkeeping, separated from the mixer: sound +//! instances resolved from the registry with their own random, the channel +//! pools (`Library.CountingChannelPool`), `calculateVolume`/`calculatePitch`, +//! the channel parameters a play sets (gain, pitch, linear attenuation, looping, +//! position, relative), the subtitle notifications, tickable instances, +//! delayed and manually looped sounds, the 20-tick minimum channel lifetime, +//! `isActive`, category gains and stopping by sound or source. +//! +//! The executor is modelled as running every channel task immediately (the +//! sound thread keeps up between ticks); a channel's own end is reported by the +//! backend through `stopped`. +use crate::sound_events::{INTENTIONALLY_EMPTY, Sentinel, Sound, SoundRegistry}; +use horizon_core::random::LegacyRandom; +use std::collections::HashMap; + +/// `SoundSource` indices (vanilla order). +pub const MASTER: usize = 0; +pub const MUSIC: usize = 1; +pub const RECORDS: usize = 2; +pub const AMBIENT: usize = 8; +pub const UI: usize = 10; +/// The pool sizes `Library.init` derives from OpenAL Soft's default 255 mono +/// sources: `clamp((int) sqrt(255), 2, 8)` streaming, the rest static. +pub const STATIC_CHANNELS: usize = 247; +pub const STREAMING_CHANNELS: usize = 8; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PlayResult { + Started, + StartedSilently, + NotStarted, +} +/// `SoundInstance.Attenuation`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Attenuation { + None, + Linear, +} +/// The tickable instance kinds Horizon plays (`TickableSoundInstance`). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Ticking { + /// Not tickable. + No, + /// `BiomeAmbientSoundsHandler.LoopSoundInstance`. + BiomeLoop { fade: i32, direction: i32 }, + /// `UnderLiquidAmbientSoundInstance`. + UnderLiquidLoop { fade: i32 }, + /// `UnderLiquidSubSound`. + UnderLiquidSub, +} +/// What tickable instances read about the player. +#[derive(Clone, Copy, Debug, Default)] +pub struct TickContext { + pub player_underwater: bool, + pub player_removed: bool, +} +/// `AbstractSoundInstance` and its subclasses' fields. +#[derive(Clone, Debug)] +pub struct SoundInstance { + pub identifier: String, + pub source: usize, + pub volume: f32, + pub pitch: f32, + pub position: [f64; 3], + pub looping: bool, + pub delay: i32, + pub attenuation: Attenuation, + pub relative: bool, + pub random: LegacyRandom, + pub can_start_silent: bool, + pub ticking: Ticking, + /// `AbstractTickableSoundInstance.stopped`. + pub stopped: bool, + /// `sound` after `getOrResolve`. + pub sound: Option, + /// `soundEvent != null` after `getOrResolve`, and its subtitle. + pub event: Option>, +} +impl SoundInstance { + #[allow(clippy::too_many_arguments)] + pub fn new( + identifier: &str, + source: usize, + volume: f32, + pitch: f32, + random: LegacyRandom, + looping: bool, + delay: i32, + attenuation: Attenuation, + position: [f64; 3], + relative: bool, + ) -> Self { + Self { + identifier: identifier.to_owned(), + source, + volume, + pitch, + position, + looping, + delay, + attenuation, + relative, + random, + can_start_silent: false, + ticking: Ticking::No, + stopped: false, + sound: None, + event: None, + } + } + /// `new SimpleSoundInstance(sound, source, volume, pitch, random, x, y, z)`. + pub fn at( + id: &str, + source: usize, + volume: f32, + pitch: f32, + random: LegacyRandom, + at: [f64; 3], + ) -> Self { + Self::new( + id, + source, + volume, + pitch, + random, + false, + 0, + Attenuation::Linear, + at, + false, + ) + } + /// `SimpleSoundInstance.forUI(sound, pitch, volume)`. + pub fn for_ui(id: &str, pitch: f32, volume: f32, random: LegacyRandom) -> Self { + Self::new( + id, + UI, + volume, + pitch, + random, + false, + 0, + Attenuation::None, + [0.0; 3], + true, + ) + } + /// `SimpleSoundInstance.forMusic`. + pub fn for_music(id: &str, random: LegacyRandom) -> Self { + Self::new( + id, + MUSIC, + 1.0, + 1.0, + random, + false, + 0, + Attenuation::None, + [0.0; 3], + true, + ) + } + /// `SimpleSoundInstance.forJukeboxSong`. + pub fn for_jukebox_song(id: &str, at: [f64; 3], random: LegacyRandom) -> Self { + Self::new( + id, + RECORDS, + 4.0, + 1.0, + random, + false, + 0, + Attenuation::Linear, + at, + false, + ) + } + /// `SimpleSoundInstance.forLocalAmbience`. + pub fn for_local_ambience(id: &str, pitch: f32, volume: f32, random: LegacyRandom) -> Self { + Self::new( + id, + AMBIENT, + volume, + pitch, + random, + false, + 0, + Attenuation::None, + [0.0; 3], + true, + ) + } + /// `SimpleSoundInstance.forAmbientAddition`. + pub fn for_ambient_addition(id: &str, random: LegacyRandom) -> Self { + Self::for_local_ambience(id, 1.0, 1.0, random) + } + /// `SimpleSoundInstance.forAmbientMood`. + pub fn for_ambient_mood(id: &str, random: LegacyRandom, at: [f64; 3]) -> Self { + Self::new( + id, + AMBIENT, + 1.0, + 1.0, + random, + false, + 0, + Attenuation::Linear, + at, + false, + ) + } + /// A relative looping ambient instance (the loop sound constructors). + fn ambient_loop(id: &str, random: LegacyRandom, looping: bool, ticking: Ticking) -> Self { + let mut s = Self::new( + id, + AMBIENT, + 1.0, + 1.0, + random, + looping, + 0, + Attenuation::Linear, + [0.0; 3], + true, + ); + s.ticking = ticking; + s + } + /// `new BiomeAmbientSoundsHandler.LoopSoundInstance(event)`. + pub fn biome_loop(id: &str, random: LegacyRandom) -> Self { + Self::ambient_loop( + id, + random, + true, + Ticking::BiomeLoop { + fade: 0, + direction: 0, + }, + ) + } + /// `UnderLiquidAmbientSoundInstance.underwater(player)`. + pub fn under_liquid_loop(id: &str, random: LegacyRandom) -> Self { + Self::ambient_loop(id, random, true, Ticking::UnderLiquidLoop { fade: 0 }) + } + /// `new UnderLiquidSubSound(player, event)`. + pub fn under_liquid_sub(id: &str, random: LegacyRandom) -> Self { + Self::ambient_loop(id, random, false, Ticking::UnderLiquidSub) + } + pub fn tickable(&self) -> bool { + self.ticking != Ticking::No + } + /// `AbstractSoundInstance.getVolume` (after `getOrResolve`). + pub fn get_volume(&mut self) -> f32 { + let sample = match &self.sound { + Some(s) => s.volume.sample(&mut self.random), + None => 1.0, + }; + self.volume * sample + } + /// `AbstractSoundInstance.getPitch`. + pub fn get_pitch(&mut self) -> f32 { + let sample = match &self.sound { + Some(s) => s.pitch.sample(&mut self.random), + None => 1.0, + }; + self.pitch * sample + } + /// `AbstractTickableSoundInstance.stop`. + fn stop(&mut self) { + self.stopped = true; + self.looping = false; + } + /// `TickableSoundInstance.tick`. + pub fn tick(&mut self, ctx: &TickContext) { + match &mut self.ticking { + Ticking::No => {} + Ticking::BiomeLoop { fade, direction } => { + let stop = *fade < 0; + *fade += *direction; + self.volume = (*fade as f32 / 40.0).clamp(0.0, 1.0); + if stop { + self.stop(); + } + } + Ticking::UnderLiquidLoop { fade } => { + if !ctx.player_removed && *fade >= 0 { + if ctx.player_underwater { + *fade += 1; + } else { + *fade -= 2; + } + *fade = (*fade).min(40); + self.volume = 0.0f32.max((*fade as f32 / 40.0).min(1.0)); + } else { + self.stop(); + } + } + Ticking::UnderLiquidSub => { + if ctx.player_removed || !ctx.player_underwater { + self.stop(); + } + } + } + } + /// `LoopSoundInstance.fadeOut`. + pub fn fade_out(&mut self) { + if let Ticking::BiomeLoop { fade, direction } = &mut self.ticking { + *fade = (*fade).min(40); + *direction = -1; + } + } + /// `LoopSoundInstance.fadeIn`. + pub fn fade_in(&mut self) { + if let Ticking::BiomeLoop { fade, direction } = &mut self.ticking { + *fade = 0.max(*fade); + *direction = 1; + } + } +} +/// A sound instance handle. +pub type InstanceId = u64; +/// A backend channel (an OpenAL source). +pub type ChannelId = u64; +/// The OpenAL side: `Channel` operations, all applied immediately. +pub trait Backend { + /// `Channel.create`. + fn create(&mut self, streaming: bool) -> Option; + /// `Channel.destroy`. + fn destroy(&mut self, channel: ChannelId); + fn set_pitch(&mut self, channel: ChannelId, pitch: f32); + fn set_volume(&mut self, channel: ChannelId, volume: f32); + /// `Some(max distance)` for `linearAttenuation`, None for `disableAttenuation`. + fn set_attenuation(&mut self, channel: ChannelId, linear: Option); + fn set_looping(&mut self, channel: ChannelId, looping: bool); + fn set_position(&mut self, channel: ChannelId, position: [f64; 3]); + fn set_relative(&mut self, channel: ChannelId, relative: bool); + /// Attach the sound's buffer or stream (when loaded) and play it. + fn start(&mut self, channel: ChannelId, sound: &Sound, looping: bool); + fn stop(&mut self, channel: ChannelId); + fn pause(&mut self, channel: ChannelId); + fn unpause(&mut self, channel: ChannelId); + /// `Channel.stopped`. + fn stopped(&mut self, channel: ChannelId) -> bool; +} +/// A `SoundEventListener.onPlaySound` call. +#[derive(Clone, Debug, PartialEq)] +pub struct Notification { + pub identifier: String, + pub subtitle: Option, + pub position: [f64; 3], + pub relative: bool, + pub looping: bool, + pub range: f32, +} +/// `ChannelAccess.ChannelHandle`. +#[derive(Clone, Copy, Debug)] +struct Handle { + channel: Option, + streaming: bool, + stopped: bool, +} +pub struct SoundEngine { + pub registry: SoundRegistry, + /// `loaded`: the library opened. + pub loaded: bool, + tick_count: i32, + instances: HashMap, + /// Instances their owner still refers to. + retained: HashMap, + next_instance: InstanceId, + /// `instanceToChannel` (insertion order). + instance_to_channel: Vec<(InstanceId, u64)>, + handles: HashMap, + next_handle: u64, + /// `instanceBySource`. + instance_by_source: Vec<(usize, InstanceId)>, + gain_by_source: [f32; 11], + ticking: Vec, + /// `queuedSounds` (insertion order). + queued: Vec<(InstanceId, i32)>, + delete_time: HashMap, + queued_tickable: Vec, + used: [usize; 2], + pub limits: [usize; 2], + /// `Options.getSoundSourceVolume` per source (index 0 is master). + pub source_volumes: [f32; 11], + /// A `SoundEventListener` is registered. + pub listening: bool, + pub notifications: Vec, +} +fn handle_channel(h: &Handle) -> Option { + h.channel +} +impl SoundEngine { + pub fn new(registry: SoundRegistry) -> Self { + Self { + registry, + loaded: true, + tick_count: 0, + instances: HashMap::new(), + retained: HashMap::new(), + next_instance: 1, + instance_to_channel: Vec::new(), + handles: HashMap::new(), + next_handle: 1, + instance_by_source: Vec::new(), + gain_by_source: [1.0; 11], + ticking: Vec::new(), + queued: Vec::new(), + delete_time: HashMap::new(), + queued_tickable: Vec::new(), + used: [0, 0], + limits: [STATIC_CHANNELS, STREAMING_CHANNELS], + source_volumes: [1.0; 11], + listening: false, + notifications: Vec::new(), + } + } + /// Hand an instance to the engine. A retained instance stays until + /// `release`; others go once the engine no longer refers to them. + pub fn add(&mut self, instance: SoundInstance, retain: bool) -> InstanceId { + let id = self.next_instance; + self.next_instance += 1; + self.instances.insert(id, instance); + if retain { + self.retained.insert(id, ()); + } + id + } + /// The owner drops its reference. + pub fn release(&mut self, id: InstanceId) { + self.retained.remove(&id); + self.collect(id); + } + fn referenced(&self, id: InstanceId) -> bool { + self.retained.contains_key(&id) + || self.instance_to_channel.iter().any(|(i, _)| *i == id) + || self.queued.iter().any(|(i, _)| *i == id) + || self.queued_tickable.contains(&id) + || self.ticking.contains(&id) + } + fn collect(&mut self, id: InstanceId) { + if !self.referenced(id) { + self.instances.remove(&id); + } + } + pub fn instance(&self, id: InstanceId) -> Option<&SoundInstance> { + self.instances.get(&id) + } + pub fn instance_mut(&mut self, id: InstanceId) -> Option<&mut SoundInstance> { + self.instances.get_mut(&id) + } + pub fn tick_count(&self) -> i32 { + self.tick_count + } + /// `Options.getFinalSoundSourceVolume`. + pub fn final_source_volume(&self, source: usize) -> f32 { + if source == MASTER { + self.source_volumes[MASTER] + } else { + self.source_volumes[source] * self.source_volumes[MASTER] + } + } + /// `calculateVolume(volume, source)`. + pub fn calculate_volume(&self, volume: f32, source: usize) -> f32 { + volume.clamp(0.0, 1.0) + * self.final_source_volume(source).clamp(0.0, 1.0) + * self.gain_by_source[source] + } + /// `calculatePitch`. + pub fn calculate_pitch(pitch: f32) -> f32 { + pitch.clamp(0.5, 2.0) + } + fn channel_of(&self, id: InstanceId) -> Option { + self.instance_to_channel + .iter() + .find(|(i, _)| *i == id) + .map(|(_, h)| *h) + } + /// `refreshCategoryVolume`. + pub fn refresh_category_volume(&mut self, source: usize, backend: &mut impl Backend) { + if !self.loaded { + return; + } + for (id, handle) in self.instance_to_channel.clone() { + let Some(instance) = self.instances.get_mut(&id) else { + continue; + }; + if source == instance.source || source == MASTER { + let (v, s) = (instance.get_volume(), instance.source); + let volume = self.calculate_volume(v, s); + if let Some(c) = self.handles.get(&handle).and_then(handle_channel) { + backend.set_volume(c, volume); + } + } + } + } + /// `updateCategoryVolume`. + pub fn update_category_volume(&mut self, source: usize, gain: f32, backend: &mut impl Backend) { + self.gain_by_source[source] = gain.clamp(0.0, 1.0); + self.refresh_category_volume(source, backend); + } + pub fn category_gain(&self, source: usize) -> f32 { + self.gain_by_source[source] + } + /// `stop(SoundInstance)`. + pub fn stop(&mut self, id: InstanceId, backend: &mut impl Backend) { + if !self.loaded { + return; + } + if let Some(handle) = self.channel_of(id) + && let Some(c) = self.handles.get(&handle).and_then(handle_channel) + { + backend.stop(c); + } + } + /// `ChannelHandle.release`. + fn release_handle(&mut self, handle: u64, backend: &mut impl Backend) { + if let Some(h) = self.handles.get_mut(&handle) { + h.stopped = true; + if let Some(c) = h.channel.take() { + self.used[usize::from(h.streaming)] -= 1; + backend.destroy(c); + } + } + } + /// `stopAll`. + pub fn stop_all(&mut self, backend: &mut impl Backend) { + if !self.loaded { + return; + } + let ids: Vec = self.instances.keys().copied().collect(); + self.instance_to_channel.clear(); + let handles: Vec = self.handles.keys().copied().collect(); + for h in handles { + self.release_handle(h, backend); + } + self.handles.clear(); + self.queued.clear(); + self.ticking.clear(); + self.instance_by_source.clear(); + self.delete_time.clear(); + self.queued_tickable.clear(); + self.gain_by_source = [1.0; 11]; + for id in ids { + self.collect(id); + } + } + /// `stop(Identifier sound, SoundSource source)`. + pub fn stop_matching( + &mut self, + sound: Option<&str>, + source: Option, + backend: &mut impl Backend, + ) { + let matches = |engine: &Self, id: InstanceId| { + sound.is_none_or(|s| engine.instances.get(&id).is_some_and(|i| i.identifier == s)) + }; + if let Some(source) = source { + let ids: Vec = self + .instance_by_source + .iter() + .filter(|(s, _)| *s == source) + .map(|(_, i)| *i) + .collect(); + for id in ids { + if matches(self, id) { + self.stop(id, backend); + } + } + } else if sound.is_none() { + self.stop_all(backend); + } else { + let ids: Vec = self.instance_to_channel.iter().map(|(i, _)| *i).collect(); + for id in ids { + if matches(self, id) { + self.stop(id, backend); + } + } + } + } + /// `getRange`. + fn range(relative: bool, attenuation: Attenuation, distance: f32) -> f32 { + if !relative && attenuation != Attenuation::None { + distance + } else { + f32::INFINITY + } + } + fn notify(&mut self, id: InstanceId, subtitle: Option, distance: f32) { + let Some(i) = self.instances.get(&id) else { + return; + }; + self.notifications.push(Notification { + identifier: i.identifier.clone(), + subtitle, + position: i.position, + relative: i.relative, + looping: i.looping, + range: Self::range(i.relative, i.attenuation, distance), + }); + } + /// `getOrResolve`. + pub fn resolve(&mut self, id: InstanceId) { + let Some(instance) = self.instances.get_mut(&id) else { + return; + }; + if instance.identifier == INTENTIONALLY_EMPTY { + instance.sound = Some(Sound::intentionally_empty()); + instance.event = Some(None); + return; + } + match self.registry.get(&instance.identifier) { + None => { + instance.event = None; + instance.sound = Some(Sound::empty()); + } + Some(event) => { + instance.event = Some(event.subtitle.clone()); + instance.sound = self + .registry + .sound(&instance.identifier, &mut instance.random); + } + } + } + /// `play(SoundInstance)`. + pub fn play(&mut self, id: InstanceId, backend: &mut impl Backend) -> PlayResult { + let result = self.play_inner(id, backend); + self.collect(id); + result + } + /// Add and play an instance. + pub fn play_new( + &mut self, + instance: SoundInstance, + retain: bool, + backend: &mut impl Backend, + ) -> (InstanceId, PlayResult) { + let id = self.add(instance, retain); + (id, self.play(id, backend)) + } + fn play_inner(&mut self, id: InstanceId, backend: &mut impl Backend) -> PlayResult { + if !self.loaded || !self.instances.contains_key(&id) { + return PlayResult::NotStarted; + } + self.resolve(id); + let instance = &self.instances[&id]; + let Some(subtitle) = instance.event.clone() else { + return PlayResult::NotStarted; + }; + let sound = instance.sound.clone().unwrap_or_else(Sound::empty); + if sound.sentinel != Sentinel::None { + return PlayResult::NotStarted; + } + let instance = self.instances.get_mut(&id).expect("present"); + let instance_volume = instance.get_volume(); + let attenuation_distance = sound.attenuation_distance(instance_volume); + if self.listening { + self.notify(id, subtitle, attenuation_distance); + } + let instance = &self.instances[&id]; + let source = instance.source; + let volume = self.calculate_volume(instance_volume, source); + let mut silently = false; + if volume == 0.0 { + if !instance.can_start_silent && source != MUSIC { + return PlayResult::NotStarted; + } + silently = true; + } + let position = instance.position; + let looping = instance.looping && instance.delay <= 0; + let streaming = sound.stream; + let pool = usize::from(streaming); + let channel = if self.used[pool] >= self.limits[pool] { + None + } else { + backend.create(streaming) + }; + let Some(channel) = channel else { + return PlayResult::NotStarted; + }; + self.used[pool] += 1; + let handle = self.next_handle; + self.next_handle += 1; + self.handles.insert( + handle, + Handle { + channel: Some(channel), + streaming, + stopped: false, + }, + ); + self.delete_time.insert(id, self.tick_count + 20); + if let Some(entry) = self.instance_to_channel.iter_mut().find(|(i, _)| *i == id) { + entry.1 = handle; + } else { + self.instance_to_channel.push((id, handle)); + } + if !self.instance_by_source.contains(&(source, id)) { + self.instance_by_source.push((source, id)); + } + let instance = self.instances.get_mut(&id).expect("present"); + let pitch = Self::calculate_pitch(instance.get_pitch()); + let (attenuation, relative, tickable) = + (instance.attenuation, instance.relative, instance.tickable()); + backend.set_pitch(channel, pitch); + backend.set_volume(channel, volume); + backend.set_attenuation( + channel, + (attenuation == Attenuation::Linear).then_some(attenuation_distance), + ); + backend.set_looping(channel, looping && !streaming); + backend.set_position(channel, position); + backend.set_relative(channel, relative); + backend.start(channel, &sound, looping); + if tickable { + self.ticking.push(id); + } + if silently { + PlayResult::StartedSilently + } else { + PlayResult::Started + } + } + /// `queueTickingSound`. + pub fn queue_ticking(&mut self, id: InstanceId) { + self.queued_tickable.push(id); + } + /// `playDelayed`. + pub fn play_delayed(&mut self, id: InstanceId, delay: i32) { + let at = self.tick_count + delay; + if let Some(entry) = self.queued.iter_mut().find(|(i, _)| *i == id) { + entry.1 = at; + } else { + self.queued.push((id, at)); + } + } + /// `isActive`. + pub fn is_active(&self, id: InstanceId) -> bool { + self.loaded && self.channel_of(id).is_some() + } + /// `tick(paused)`, then `ChannelAccess.scheduleTick`. + pub fn tick(&mut self, paused: bool, ctx: &TickContext, backend: &mut impl Backend) { + if !paused { + self.tick_in_game(ctx, backend); + } else { + self.tick_music_when_paused(); + } + self.schedule_tick(backend); + } + fn schedule_tick(&mut self, backend: &mut impl Backend) { + let live: Vec<(u64, ChannelId)> = self + .handles + .iter() + .filter_map(|(h, handle)| handle.channel.map(|c| (*h, c))) + .collect(); + for (h, c) in live { + if backend.stopped(c) { + self.release_handle(h, backend); + } + } + // Released handles nobody maps any more. + let mapped: Vec = self.instance_to_channel.iter().map(|(_, h)| *h).collect(); + self.handles + .retain(|h, handle| handle.channel.is_some() || mapped.contains(h)); + } + fn handle_stopped(&self, handle: u64) -> bool { + self.handles.get(&handle).is_none_or(|h| h.stopped) + } + fn tick_in_game(&mut self, ctx: &TickContext, backend: &mut impl Backend) { + self.tick_count += 1; + for id in std::mem::take(&mut self.queued_tickable) { + self.play(id, backend); + } + for id in self.ticking.clone() { + let Some(instance) = self.instances.get_mut(&id) else { + continue; + }; + instance.tick(ctx); + if instance.stopped { + self.stop(id, backend); + continue; + } + let (v, source) = (instance.get_volume(), instance.source); + let pitch = Self::calculate_pitch(instance.get_pitch()); + let position = instance.position; + let volume = self.calculate_volume(v, source); + let Some(handle) = self.channel_of(id) else { + continue; + }; + if let Some(c) = self.handles.get(&handle).and_then(handle_channel) { + backend.set_volume(c, volume); + backend.set_pitch(c, pitch); + backend.set_position(c, position); + } + let instance = self.instances.get_mut(&id).expect("present"); + if instance.looping + && self.tick_count % 10 == 0 + && volume > 0.0 + && self.listening + && let (Some(sound), Some(subtitle)) = + (instance.sound.clone(), instance.event.clone()) + { + let distance = sound.attenuation_distance(instance.get_volume()); + self.notify(id, subtitle, distance); + } + } + let mut removed = Vec::new(); + let mut index = 0; + while index < self.instance_to_channel.len() { + let (id, handle) = self.instance_to_channel[index]; + if self.handle_stopped(handle) + && self.delete_time.get(&id).copied().unwrap_or(0) <= self.tick_count + { + if let Some(i) = self.instances.get(&id) + && i.looping + && i.delay > 0 + { + let at = self.tick_count + i.delay; + if let Some(entry) = self.queued.iter_mut().find(|(q, _)| *q == id) { + entry.1 = at; + } else { + self.queued.push((id, at)); + } + } + self.instance_to_channel.remove(index); + self.handles.remove(&handle); + self.delete_time.remove(&id); + let source = self.instances.get(&id).map(|i| i.source); + self.instance_by_source + .retain(|e| Some(e.0) != source || e.1 != id); + if let Some(p) = self.ticking.iter().position(|t| *t == id) { + self.ticking.remove(p); + } + removed.push(id); + } else { + index += 1; + } + } + let mut index = 0; + while index < self.queued.len() { + let (id, at) = self.queued[index]; + if self.tick_count >= at { + self.queued.remove(index); + if let Some(i) = self.instances.get_mut(&id) + && i.tickable() + { + i.tick(ctx); + } + self.play(id, backend); + } else { + index += 1; + } + } + for id in removed { + self.collect(id); + } + } + fn tick_music_when_paused(&mut self) { + let mut index = 0; + while index < self.instance_to_channel.len() { + let (id, handle) = self.instance_to_channel[index]; + let music = self.instances.get(&id).is_some_and(|i| i.source == MUSIC); + if music && self.handle_stopped(handle) { + self.instance_to_channel.remove(index); + self.handles.remove(&handle); + self.delete_time.remove(&id); + self.instance_by_source + .retain(|e| e.0 != MUSIC || e.1 != id); + self.collect(id); + } else { + index += 1; + } + } + } + /// `pauseAllExcept`. + pub fn pause_all_except(&mut self, sources: &[usize], backend: &mut impl Backend) { + if !self.loaded { + return; + } + for (id, handle) in self.instance_to_channel.clone() { + let source = self.instances.get(&id).map_or(MASTER, |i| i.source); + if !sources.contains(&source) + && let Some(c) = self.handles.get(&handle).and_then(handle_channel) + { + backend.pause(c); + } + } + } + /// `resume`. + pub fn resume(&mut self, backend: &mut impl Backend) { + if !self.loaded { + return; + } + let channels: Vec = self.handles.values().filter_map(handle_channel).collect(); + for c in channels { + backend.unpause(c); + } + } + /// Channels in use (static, streaming). + pub fn used_channels(&self) -> [usize; 2] { + self.used + } + /// The live channel of an instance. + pub fn channel(&self, id: InstanceId) -> Option { + self.channel_of(id) + .and_then(|h| self.handles.get(&h)) + .and_then(handle_channel) + } + /// Instances with a channel, in insertion order. + pub fn active_instances(&self) -> Vec { + self.instance_to_channel.iter().map(|(i, _)| *i).collect() + } + /// A fresh unseeded random (`RandomSource.create()`). + pub fn unseeded() -> LegacyRandom { + LegacyRandom::new(unique_seed()) + } +} +/// `RandomSupport.generateUniqueSeed`. +pub fn unique_seed() -> i64 { + use std::sync::atomic::{AtomicI64, Ordering}; + static UNIQUIFIER: AtomicI64 = AtomicI64::new(8_682_522_807_148_012); + let mut current = UNIQUIFIER.load(Ordering::Relaxed); + let next = loop { + let next = current.wrapping_mul(1_181_783_497_276_652_981); + match UNIQUIFIER.compare_exchange(current, next, Ordering::Relaxed, Ordering::Relaxed) { + Ok(_) => break next, + Err(v) => current = v, + } + }; + let nanos = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |d| d.as_nanos() as i64); + next ^ nanos +} diff --git a/crates/horizon-client/src/sound_events.rs b/crates/horizon-client/src/sound_events.rs new file mode 100644 index 000000000..6a5e179c2 --- /dev/null +++ b/crates/horizon-client/src/sound_events.rs @@ -0,0 +1,385 @@ +//! `sounds.json` sound events as vanilla's `SoundManager.Preparations` builds +//! them: `WeighedSoundEvents` holding files and references to other events +//! (whose weight is the referenced event's total weight, resolved lazily), the +//! `replace` and `subtitle` fields, files that do not exist being dropped, and +//! `WeighedSoundEvents.getSound` drawing `nextInt(totalWeight)` from the sound +//! instance's random. +use horizon_core::random::RandomSource; +use serde_json::Value; +use std::{collections::HashMap, fs, path::Path}; + +/// `SoundManager.EMPTY_SOUND_LOCATION`. +pub const EMPTY: &str = "minecraft:empty"; +/// `SoundManager.INTENTIONALLY_EMPTY_SOUND_LOCATION`. +pub const INTENTIONALLY_EMPTY: &str = "minecraft:intentionally_empty"; + +/// `SampledFloat` as sounds use it: constants and `MultipliedFloats`. +#[derive(Clone, Debug, PartialEq)] +pub enum Sampled { + Constant(f32), + Product(Vec), +} +impl Sampled { + /// `SampledFloat.sample`: constants draw nothing. + pub fn sample(&self, random: &mut impl RandomSource) -> f32 { + match self { + Self::Constant(v) => *v, + Self::Product(values) => { + let mut result = 1.0f32; + for v in values { + result *= v.sample(random); + } + result + } + } + } +} +/// `Sound`. +#[derive(Clone, Debug, PartialEq)] +pub struct Sound { + /// The file identifier (`namespace:path`, under `sounds/` with `.ogg`). + pub location: String, + pub volume: Sampled, + pub pitch: Sampled, + pub weight: i32, + /// `Sound.Type.SOUND_EVENT` (a reference to another event). + pub event: bool, + pub stream: bool, + pub preload: bool, + pub attenuation_distance: i32, + /// The `EMPTY_SOUND` / `INTENTIONALLY_EMPTY_SOUND` singletons (vanilla + /// compares them by identity). + pub sentinel: Sentinel, +} +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum Sentinel { + #[default] + None, + Empty, + IntentionallyEmpty, +} +impl Sound { + fn file(location: &str) -> Self { + Self { + location: location.to_owned(), + volume: Sampled::Constant(1.0), + pitch: Sampled::Constant(1.0), + weight: 1, + event: false, + stream: false, + preload: false, + attenuation_distance: 16, + sentinel: Sentinel::None, + } + } + /// `SoundManager.EMPTY_SOUND`. + pub fn empty() -> Self { + Self { + sentinel: Sentinel::Empty, + ..Self::file(EMPTY) + } + } + /// `SoundManager.INTENTIONALLY_EMPTY_SOUND`. + pub fn intentionally_empty() -> Self { + Self { + sentinel: Sentinel::IntentionallyEmpty, + ..Self::file(INTENTIONALLY_EMPTY) + } + } + /// `Sound.getAttenuationDistance(volume)`. + pub fn attenuation_distance(&self, volume: f32) -> f32 { + volume.max(1.0) * self.attenuation_distance as f32 + } + /// `Sound.getPath`: the resource path (`namespace`, `sounds/.ogg`). + pub fn path(&self) -> (&str, String) { + let (namespace, path) = split(&self.location); + (namespace, format!("sounds/{path}.ogg")) + } +} +/// `WeighedSoundEvents`. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct WeighedSoundEvents { + /// Files, or references to events (`Sound.event`). + pub sounds: Vec, + /// The subtitle translation key. + pub subtitle: Option, +} +/// The sound event registry (`SoundManager.registry`). +#[derive(Clone, Debug, Default)] +pub struct SoundRegistry { + events: HashMap, +} +/// `Identifier.parse` with the default namespace. +fn split(id: &str) -> (&str, &str) { + match id.split_once(':') { + Some((namespace, path)) => ( + if namespace.is_empty() { + "minecraft" + } else { + namespace + }, + path, + ), + None => ("minecraft", id), + } +} +pub fn normalize(id: &str) -> String { + let (namespace, path) = split(id); + format!("{namespace}:{path}") +} +/// `GsonHelper.getAsFloat`: Gson parses the number's text as a float. +fn json_float(v: &Value, fallback: f32) -> f32 { + match v { + Value::Number(n) => n.to_string().parse().unwrap_or(fallback), + Value::String(s) => s.parse().unwrap_or(fallback), + _ => fallback, + } +} +fn json_int(v: &Value, fallback: i32) -> i32 { + match v { + Value::Number(n) => n + .as_i64() + .map(|i| i as i32) + .or_else(|| n.as_f64().map(|f| f as i32)) + .unwrap_or(fallback), + Value::String(s) => s.parse().unwrap_or(fallback), + _ => fallback, + } +} +fn json_bool(v: &Value, fallback: bool) -> bool { + match v { + Value::Bool(b) => *b, + Value::String(s) => s == "true", + _ => fallback, + } +} +/// `SoundEventRegistrationSerializer.getSound`; None for an invalid entry +/// (vanilla rejects the whole file). +fn parse_sound(v: &Value) -> Option { + if let Value::String(name) = v { + return Some(Sound::file(&normalize(name))); + } + let name = v.get("name")?.as_str()?; + let event = match v.get("type") { + None => false, + Some(t) => match t.as_str()? { + "file" => false, + "event" => true, + _ => return None, + }, + }; + let volume = json_float(v.get("volume").unwrap_or(&Value::Null), 1.0); + let pitch = json_float(v.get("pitch").unwrap_or(&Value::Null), 1.0); + let weight = json_int(v.get("weight").unwrap_or(&Value::Null), 1); + if !(volume > 0.0 && pitch > 0.0 && weight > 0) { + return None; + } + Some(Sound { + location: normalize(name), + volume: Sampled::Constant(volume), + pitch: Sampled::Constant(pitch), + weight, + event, + stream: json_bool(v.get("stream").unwrap_or(&Value::Null), false), + preload: json_bool(v.get("preload").unwrap_or(&Value::Null), false), + attenuation_distance: json_int(v.get("attenuation_distance").unwrap_or(&Value::Null), 16), + sentinel: Sentinel::None, + }) +} +impl SoundRegistry { + /// Every `assets//sounds.json` under a resource root, files + /// validated against `assets//sounds/`. + pub fn load(root: &Path) -> Self { + let assets = root.join("assets"); + let mut namespaces: Vec = fs::read_dir(&assets) + .into_iter() + .flatten() + .flatten() + .filter_map(|e| e.file_name().to_str().map(str::to_owned)) + .collect(); + namespaces.sort(); + let mut registry = Self::default(); + for namespace in namespaces { + let Ok(text) = fs::read(assets.join(&namespace).join("sounds.json")) else { + continue; + }; + let exists = |ns: &str, path: &str| assets.join(ns).join(path).is_file(); + registry.add_file(&namespace, &text, &exists); + } + registry + } + /// One `sounds.json` (`Preparations.handleRegistration` for each entry). + /// `exists(namespace, path)` says whether a sound file is present. + pub fn add_file(&mut self, namespace: &str, text: &[u8], exists: &dyn Fn(&str, &str) -> bool) { + let Ok(Value::Object(map)) = serde_json::from_slice::(text) else { + return; + }; + // A malformed entry makes Gson reject the whole file. + let mut parsed = Vec::new(); + for (name, def) in &map { + let Value::Object(object) = def else { return }; + let replace = json_bool(object.get("replace").unwrap_or(&Value::Null), false); + let subtitle = match object.get("subtitle") { + None | Some(Value::Null) => None, + Some(Value::String(s)) => Some(s.clone()), + Some(_) => return, + }; + let mut sounds = Vec::new(); + if let Some(list) = object.get("sounds") { + let Value::Array(list) = list else { return }; + for s in list { + let Some(sound) = parse_sound(s) else { return }; + sounds.push(sound); + } + } + parsed.push((format!("{namespace}:{name}"), replace, subtitle, sounds)); + } + for (location, replace, subtitle, sounds) in parsed { + let entry = match self.events.get_mut(&location) { + Some(entry) if !replace => entry, + _ => { + self.events.insert( + location.clone(), + WeighedSoundEvents { + sounds: Vec::new(), + subtitle, + }, + ); + self.events.get_mut(&location).expect("inserted") + } + }; + for sound in sounds { + if !sound.event { + let (ns, path) = sound.path(); + if !exists(ns, &path) { + continue; + } + } + entry.sounds.push(sound); + } + } + } + pub fn get(&self, event: &str) -> Option<&WeighedSoundEvents> { + self.events.get(event) + } + pub fn contains(&self, event: &str) -> bool { + self.events.contains_key(event) + } + /// Every registered event id. + pub fn names(&self) -> impl Iterator { + self.events.keys() + } + /// `Weighted.getWeight` of one entry. + fn entry_weight(&self, sound: &Sound, depth: u32) -> i32 { + if !sound.event { + return sound.weight; + } + if depth > 64 { + return 0; + } + self.events + .get(&sound.location) + .map_or(0, |e| self.total(e, depth + 1)) + } + fn total(&self, event: &WeighedSoundEvents, depth: u32) -> i32 { + event + .sounds + .iter() + .fold(0i32, |sum, s| sum.wrapping_add(self.entry_weight(s, depth))) + } + /// `WeighedSoundEvents.getWeight`. + pub fn weight(&self, event: &str) -> i32 { + self.events.get(event).map_or(0, |e| self.total(e, 0)) + } + /// `WeighedSoundEvents.getSound`: None when the event is not registered. + pub fn sound(&self, event: &str, random: &mut impl RandomSource) -> Option { + let e = self.events.get(event)?; + Some(self.pick(e, random, 0)) + } + fn pick( + &self, + event: &WeighedSoundEvents, + random: &mut impl RandomSource, + depth: u32, + ) -> Sound { + let weight = self.total(event, depth); + if event.sounds.is_empty() || weight == 0 { + return Sound::empty(); + } + let Ok(mut index) = random.next_int_bound(weight) else { + return Sound::empty(); + }; + for sound in &event.sounds { + index -= self.entry_weight(sound, depth); + if index < 0 { + if !sound.event { + return sound.clone(); + } + // The anonymous reference Weighted: the referenced event's + // sound with this entry's volume, pitch and stream folded in. + let Some(inner) = self.events.get(&sound.location) else { + return Sound::empty(); + }; + if depth > 64 { + return Sound::empty(); + } + let wrapped = self.pick(inner, random, depth + 1); + return Sound { + location: wrapped.location, + volume: Sampled::Product(vec![wrapped.volume, sound.volume.clone()]), + pitch: Sampled::Product(vec![wrapped.pitch, sound.pitch.clone()]), + weight: sound.weight, + event: false, + stream: wrapped.stream || sound.stream, + preload: wrapped.preload, + attenuation_distance: wrapped.attenuation_distance, + sentinel: Sentinel::None, + }; + } + } + Sound::empty() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use horizon_core::random::LegacyRandom; + + #[test] + fn references_weigh_as_much_as_their_event() { + let mut r = SoundRegistry::default(); + let json = br#"{ + "a": {"sounds": ["x", "y", "z"]}, + "b": {"sounds": [{"name": "a", "type": "event", "weight": 9, "volume": 0.5}, "w"], "subtitle": "s.b"} + }"#; + r.add_file("minecraft", json, &|_, _| true); + assert_eq!(r.weight("minecraft:b"), 4); + let mut random = LegacyRandom::new(1); + let mut seen = std::collections::HashSet::new(); + for _ in 0..64 { + let s = r.sound("minecraft:b", &mut random).unwrap(); + if s.location != "minecraft:w" { + assert_eq!(s.volume.sample(&mut random), 0.5); + } + seen.insert(s.location); + } + assert_eq!(seen.len(), 4); + assert_eq!( + r.get("minecraft:b").unwrap().subtitle.as_deref(), + Some("s.b") + ); + } + + #[test] + fn missing_files_are_dropped_and_empty_events_give_the_empty_sound() { + let mut r = SoundRegistry::default(); + r.add_file("minecraft", br#"{"a": {"sounds": ["gone"]}}"#, &|_, _| { + false + }); + assert_eq!(r.weight("minecraft:a"), 0); + let mut random = LegacyRandom::new(1); + assert_eq!(r.sound("minecraft:a", &mut random).unwrap(), Sound::empty()); + assert!(r.sound("minecraft:b", &mut random).is_none()); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEventOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEventOracle.java new file mode 100644 index 000000000..b02ef2783 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEventOracle.java @@ -0,0 +1,111 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import java.io.*; +import java.lang.reflect.*; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.Options; +import net.minecraft.client.resources.sounds.*; +import net.minecraft.client.sounds.*; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.contents.TranslatableContents; +import net.minecraft.resources.Identifier; +import net.minecraft.server.packs.*; +import net.minecraft.server.packs.repository.PackSource; +import net.minecraft.server.packs.resources.MultiPackResourceManager; +import net.minecraft.server.packs.resources.ResourceManager; +import net.minecraft.sounds.SoundSource; +import net.minecraft.util.RandomSource; +import net.minecraft.util.profiling.InactiveProfiler; + +/** + * Builds vanilla's sound event registry with the real SoundManager.prepare + * (sounds.json read through a resource manager over the client asset root, + * files validated against the listed .ogg resources) and Preparations.apply, + * then resolves SimpleSoundInstances: getOrResolve with a seeded random, + * getVolume/getPitch, and the instance random's next draw (to fix the number + * of draws). Lines: "event seed volume pitch". + */ +public final class VanillaSoundEventOracle { + static Field field(Class type, String name) throws Exception { + var f = type.getDeclaredField(name); + f.setAccessible(true); + return f; + } + + static String bits(float v) { + return String.format("%08x", Float.floatToRawIntBits(v)); + } + + static String sentinel(Sound sound) { + if (sound == SoundManager.EMPTY_SOUND) return "empty"; + if (sound == SoundManager.INTENTIONALLY_EMPTY_SOUND) return "intentionally_empty"; + return "-"; + } + + /** The real registry, prepared from an asset root. */ + @SuppressWarnings("unchecked") + static SoundManager load(Path root) throws Exception { + var info = new PackLocationInfo("horizon", Component.literal("horizon"), PackSource.BUILT_IN, Optional.empty()); + ResourceManager resources = new MultiPackResourceManager(PackType.CLIENT_RESOURCES, List.of(new PathPackResources(info, root))); + var u = Class.forName("sun.misc.Unsafe"); + Object unsafe = field(u, "theUnsafe").get(null); + Options options = (Options) u.getMethod("allocateInstance", Class.class).invoke(unsafe, Options.class); + var manager = new SoundManager(options); + Method prepare = SoundManager.class.getDeclaredMethod("prepare", ResourceManager.class, net.minecraft.util.profiling.ProfilerFiller.class); + prepare.setAccessible(true); + Object preparations = prepare.invoke(manager, resources, InactiveProfiler.INSTANCE); + Method apply = preparations.getClass().getDeclaredMethod("apply", Map.class, Map.class, SoundEngine.class); + apply.setAccessible(true); + apply.invoke(preparations, field(SoundManager.class, "registry").get(manager), field(SoundManager.class, "soundCache").get(manager), + field(SoundManager.class, "soundEngine").get(manager)); + return manager; + } + + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var manager = load(Path.of(args[0])); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2])))) { + var names = new ArrayList(); + for (var id : manager.getAvailableSounds()) names.add(id.toString()); + Collections.sort(names); + for (String name : names) out.println("registered " + name); + for (String line : Files.readAllLines(Path.of(args[1]))) { + String[] f = line.split(" "); + long seed = Long.parseLong(f[1]); + float volume = Float.intBitsToFloat(Integer.parseUnsignedInt(f[2], 16)); + float pitch = Float.intBitsToFloat(Integer.parseUnsignedInt(f[3], 16)); + RandomSource random = RandomSource.create(seed); + var instance = new SimpleSoundInstance(Identifier.parse(f[0]), SoundSource.MASTER, volume, pitch, random, false, 0, + SoundInstance.Attenuation.LINEAR, 0.0, 0.0, 0.0, false); + WeighedSoundEvents event = instance.getOrResolve(manager); + Sound sound = instance.getSound(); + StringBuilder sb = new StringBuilder(line); + if (event == null) { + sb.append(" event=none"); + } else { + String subtitle = "-"; + if (event.getSubtitle() != null && event.getSubtitle().getContents() instanceof TranslatableContents t) subtitle = t.getKey(); + sb.append(" event weight=").append(event.getWeight()).append(" subtitle=").append(subtitle); + } + float v = instance.getVolume(); + float p = instance.getPitch(); + sb.append(" sound=").append(sound.getLocation()).append(" path=").append(sound.getPath()) + .append(" sentinel=").append(sentinel(sound)) + .append(" weight=").append(sound.getWeight()) + .append(" type=").append(sound.getType().name()) + .append(" stream=").append(sound.shouldStream()) + .append(" preload=").append(sound.shouldPreload()) + .append(" attenuation=").append(sound.getAttenuationDistance()) + .append(" volume=").append(bits(v)) + .append(" pitch=").append(bits(p)) + .append(" range=").append(bits(sound.getAttenuationDistance(v))) + .append(" next=").append(random.nextLong()); + out.println(sb); + } + } + System.exit(0); + } +} diff --git a/tools/audio_harness.py b/tools/audio_harness.py new file mode 100644 index 000000000..bfd18e05e --- /dev/null +++ b/tools/audio_harness.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +"""Shared runner for the audio differential harnesses. + +Each harness writes an input file, runs a Java oracle against the pinned +client (the real SoundManager / SoundEngine / MusicManager / ambient handlers; +OpenAL runs on OpenAL Soft's "No Output" device so channel parameters can be +read back from real AL sources) and a Rust example replaying the same inputs +through Horizon's audio code, then requires byte-identical output. +""" +import json +import os +from pathlib import Path +import platform +import subprocess + +try: + from . import lab, test_rust_parity as base, test_model_baking_parity as baking +except ImportError: + import lab, test_rust_parity as base, test_model_baking_parity as baking + +RESOURCES = lab.LOCAL / 'horizon-client/26.3' +COMMON_SOURCES = [ + lab.ROOT / 'tools/audio_harness.py', + lab.ROOT / 'tools/test_rust_parity.py', + lab.ROOT / 'tools/lab.py', + lab.ROOT / 'Cargo.toml', + lab.ROOT / 'Cargo.lock', + lab.ROOT / 'crates/horizon-client/Cargo.toml', + lab.ROOT / 'crates/horizon-client/src/sound_events.rs', + lab.ROOT / 'crates/horizon-client/src/sound_engine.rs', +] + + +def require_sounds(): + if not (RESOURCES / 'assets/minecraft/sounds.json').is_file(): + raise SystemExit('Sound assets missing: run tools/fetch_sounds.py first') + + +def run_harness(name, oracle, example, inputs_text, extra_sources=(), java_args=(), rust_args=(), scope='', timeout=1800): + """Run oracle and example on inputs; returns the number of matched lines.""" + require_sounds() + lock, jars, _ = base.verify_artifacts() + libraries = baking.client_libraries() + build = lab.LOCAL / f'rust-{name}' + build.mkdir(parents=True, exist_ok=True) + report = build / 'report.json' + report.unlink(missing_ok=True) + oracle_path = lab.ROOT / f'mods/horizon/src/test/java/dev/horizonlab/parity/{oracle}.java' + example_path = lab.ROOT / f'crates/horizon-client/examples/{example}.rs' + sources = [*COMMON_SOURCES, oracle_path, example_path, *[Path(s) for s in extra_sources]] + tested = base.source_hashes(sources) + inputs = build / 'inputs.txt' + inputs.write_text(inputs_text) + input_hash = lab.digest(inputs, 'sha256') + + def run(command, log, env=None): + with (build / (log + '.log')).open('w') as out: + subprocess.run(list(map(str, command)), cwd=lab.ROOT, check=True, timeout=timeout, stdout=out, stderr=subprocess.STDOUT, env=env) + + classes = build / 'classes' + classes.mkdir(exist_ok=True) + dependencies = os.pathsep.join(map(str, [jars['client'], *libraries])) + run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-sourcepath', lab.ROOT / 'mods/horizon/src/test/java', + '-cp', dependencies, '-d', classes, oracle_path], 'compile-java') + run(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', example], 'compile-rust') + metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--locked', '--no-deps', '--format-version', '1'], cwd=lab.ROOT)) + binary = Path(metadata['target_directory']) / 'debug/examples' / (example + ('.exe' if os.name == 'nt' else '')) + run([binary, *rust_args, inputs, build / 'rust.txt'], 'rust') + env = dict(os.environ, ALSOFT_DRIVERS='null') + run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, f'dev.horizonlab.parity.{oracle}', *java_args, inputs, build / 'client.txt'], + 'client', env=env) + matched = base.compare(build / 'client.txt', build / 'rust.txt') + base.ensure_sources_unchanged(sources, tested) + if input_hash != lab.digest(inputs, 'sha256'): + raise AssertionError('Input fixtures changed') + lab.write_json(report, dict( + schema=1, minecraft=lock['minecraft']['version'], manifest_sha1=lock['minecraft']['manifest_sha1'], platform=platform.platform(), + rustc=subprocess.check_output(['rustc', '--version'], text=True).strip(), + java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0], + sources_sha256=tested, input_sha256=input_hash, client_jar_sha256=lab.digest(jars['client'], 'sha256'), + sounds_json_sha256=lab.digest(RESOURCES / 'assets/minecraft/sounds.json', 'sha256'), + matched_output_lines=matched, output_sha256=lab.digest(build / 'rust.txt', 'sha256'), scope=scope)) + return matched, report + + +def bits(value): + import struct + return struct.pack('>f', value).hex() diff --git a/tools/test_sound_event_parity.py b/tools/test_sound_event_parity.py new file mode 100644 index 000000000..49dc98a96 --- /dev/null +++ b/tools/test_sound_event_parity.py @@ -0,0 +1,51 @@ +#!/usr/bin/env python3 +"""Compare sound event resolution with the vanilla 26.3 client. + +The oracle builds the real `SoundManager` registry from the client asset root +(`SoundManager.prepare` + `Preparations.apply`: sounds.json, `replace`, +subtitles, file validation against the listed .ogg resources, event references +weighing as much as their event) and resolves seeded `SimpleSoundInstance`s: +`getOrResolve`, `getVolume`, `getPitch`, `Sound.getAttenuationDistance`, the +stream/preload/type fields and the instance random's next draw. Horizon's +`SoundRegistry` + `SoundEngine::resolve` replay the same inputs. +""" +import json +import random + +try: + from . import audio_harness as h +except ImportError: + import audio_harness as h + + +def fixtures(): + sounds = json.loads((h.RESOURCES / 'assets/minecraft/sounds.json').read_text()) + rng = random.Random(0x534f554e44) + volumes = [1.0, 0.5, 0.25, 2.0, 4.0, 0.0, 1e-3, 16.0] + pitches = [1.0, 0.5, 2.0, 0.8, 1.2, 3.0, 0.1] + lines = [] + for name in sorted(sounds): + event = 'minecraft:' + name + count = len(sounds[name].get('sounds', [])) + seeds = [0, 1, -1, 42] + [rng.getrandbits(64) - (1 << 63) for _ in range(max(4, 2 * count))] + for seed in seeds: + lines.append(f'{event} {seed} {h.bits(rng.choice(volumes))} {h.bits(rng.choice(pitches))}') + for event in ['minecraft:intentionally_empty', 'minecraft:empty', 'minecraft:not.a.sound', 'horizon:missing', 'block.stone.break', 'music.game']: + for seed in [0, 7, -99]: + lines.append(f'{event} {seed} {h.bits(1.0)} {h.bits(1.0)}') + return lines + + +def main(): + lines = fixtures() + matched, report = h.run_harness( + 'sound-events', 'VanillaSoundEventOracle', 'sound_event_fixture', ''.join(l + '\n' for l in lines), + java_args=[h.RESOURCES], rust_args=[h.RESOURCES], + scope='Real SoundManager.prepare/Preparations.apply over the client asset root and SimpleSoundInstance.getOrResolve/getVolume/getPitch ' + 'for every sounds.json event with seeded randoms (weighted choice, nested event references, MultipliedFloats volume/pitch, ' + 'stream/preload/attenuation fields, EMPTY and INTENTIONALLY_EMPTY sentinels, draw counts) and the full registered event list.') + print(f'{matched:,} sound event lines match the pinned client ({len(lines):,} resolutions): {report}', flush=True) + + +if __name__ == '__main__': + main() From d68efbabfc8b911919a04a776024f0c349514301 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:33:17 +0200 Subject: [PATCH 2/9] Compare the sound engine bookkeeping with the real vanilla SoundEngine The oracle runs vanilla SoundManager/SoundEngine on OpenAL Soft null device (inline executor, silent buffers) and replays scripts of plays, stops, category gains, option volumes, channel ends, pauses, queued, delayed and looping sounds and tickable ambient instances, printing every AL source parameter, isActive, subtitle notification and pool count per step. Co-Authored-By: Claude Opus 5.5 --- .../examples/sound_engine_fixture.rs | 273 ++++++++++++++++++ .../parity/VanillaSoundEngineOracle.java | 112 +++++++ .../horizonlab/parity/VanillaSoundRig.java | 204 +++++++++++++ tools/audio_harness.py | 7 +- tools/test_sound_engine_parity.py | 247 ++++++++++++++++ 5 files changed, 841 insertions(+), 2 deletions(-) create mode 100644 crates/horizon-client/examples/sound_engine_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java create mode 100644 tools/test_sound_engine_parity.py diff --git a/crates/horizon-client/examples/sound_engine_fixture.rs b/crates/horizon-client/examples/sound_engine_fixture.rs new file mode 100644 index 000000000..a9dfbbb02 --- /dev/null +++ b/crates/horizon-client/examples/sound_engine_fixture.rs @@ -0,0 +1,273 @@ +//! Replays `tools/test_sound_engine_parity.py` scripts through Horizon's +//! `SoundEngine` with a backend recording what an OpenAL source would hold: +//! `sound_engine_fixture ROOT INPUT OUTPUT`. +use horizon_client::sound_engine::{ + Attenuation, Backend, ChannelId, InstanceId, SoundEngine, SoundInstance, TickContext, +}; +use horizon_client::sound_events::{Sound, SoundRegistry}; +use horizon_core::random::LegacyRandom; +use std::collections::{BTreeMap, HashMap}; +use std::io::Write; + +const INITIAL: u32 = 0x1011; +const PLAYING: u32 = 0x1012; +const PAUSED: u32 = 0x1013; +const STOPPED: u32 = 0x1014; + +/// An OpenAL source's state as `alGetSource*` reports it. +#[derive(Clone)] +pub struct Source { + pub state: u32, + pub gain: f32, + pub pitch: f32, + pub position: [f32; 3], + pub relative: bool, + pub looping: bool, + pub model: u32, + pub max: f32, + pub rolloff: f32, + pub reference: f32, +} +impl Default for Source { + fn default() -> Self { + Self { + state: INITIAL, + gain: 1.0, + pitch: 1.0, + position: [0.0; 3], + relative: false, + looping: false, + model: 0xD002, + max: f32::MAX, + rolloff: 1.0, + reference: 1.0, + } + } +} +/// Buffers and streams are ready at once (silence in the oracle); stopping an +/// initial source leaves it initial, as in OpenAL Soft. +#[derive(Default)] +pub struct Fake { + pub sources: HashMap, + next: ChannelId, +} +impl Backend for Fake { + fn create(&mut self, _streaming: bool) -> Option { + self.next += 1; + self.sources.insert(self.next, Source::default()); + Some(self.next) + } + fn destroy(&mut self, channel: ChannelId) { + self.sources.remove(&channel); + } + fn set_pitch(&mut self, c: ChannelId, pitch: f32) { + self.sources.get_mut(&c).expect("source").pitch = pitch; + } + fn set_volume(&mut self, c: ChannelId, volume: f32) { + self.sources.get_mut(&c).expect("source").gain = volume; + } + fn set_attenuation(&mut self, c: ChannelId, linear: Option) { + let s = self.sources.get_mut(&c).expect("source"); + match linear { + Some(max) => { + s.model = 0xD003; + s.max = max; + s.rolloff = 1.0; + s.reference = 0.0; + } + None => s.model = 0, + } + } + fn set_looping(&mut self, c: ChannelId, looping: bool) { + self.sources.get_mut(&c).expect("source").looping = looping; + } + fn set_position(&mut self, c: ChannelId, p: [f64; 3]) { + self.sources.get_mut(&c).expect("source").position = + [p[0] as f32, p[1] as f32, p[2] as f32]; + } + fn set_relative(&mut self, c: ChannelId, relative: bool) { + self.sources.get_mut(&c).expect("source").relative = relative; + } + fn start(&mut self, c: ChannelId, _sound: &Sound, _looping: bool) { + self.sources.get_mut(&c).expect("source").state = PLAYING; + } + fn stop(&mut self, c: ChannelId) { + if let Some(s) = self.sources.get_mut(&c) + && s.state != INITIAL + { + s.state = STOPPED; + } + } + fn pause(&mut self, c: ChannelId) { + let s = self.sources.get_mut(&c).expect("source"); + if s.state == PLAYING { + s.state = PAUSED; + } + } + fn unpause(&mut self, c: ChannelId) { + let s = self.sources.get_mut(&c).expect("source"); + if s.state == PAUSED { + s.state = PLAYING; + } + } + fn stopped(&mut self, c: ChannelId) -> bool { + self.sources.get(&c).is_none_or(|s| s.state == STOPPED) + } +} +fn bits(v: f32) -> String { + format!("{:08x}", v.to_bits()) +} +fn f(hex: &str) -> f32 { + f32::from_bits(u32::from_str_radix(hex, 16).expect("float")) +} +fn d(hex: &str) -> f64 { + f64::from_bits(u64::from_str_radix(hex, 16).expect("double")) +} +/// The shared per-step dump (instances, notifications, pool counts). +pub fn describe(engine: &SoundEngine, backend: &Fake, name: &str, id: InstanceId) -> String { + let mut s = format!(" {name} active={}", engine.is_active(id)); + match engine.channel(id).and_then(|c| backend.sources.get(&c)) { + None => s.push_str(" channel=-"), + Some(src) => s.push_str(&format!( + " state={:x} gain={} pitch={} pos={},{},{} rel={} loop={} model={:x} max={} rolloff={} ref={}", + src.state, + bits(src.gain), + bits(src.pitch), + bits(src.position[0]), + bits(src.position[1]), + bits(src.position[2]), + u8::from(src.relative), + u8::from(src.looping), + src.model, + bits(src.max), + bits(src.rolloff), + bits(src.reference) + )), + } + s +} +pub fn flush(engine: &mut SoundEngine, out: &mut impl Write) { + for n in std::mem::take(&mut engine.notifications) { + writeln!( + out, + "notify {} {} {} {} {:016x} {:016x} {:016x}", + n.identifier, + n.subtitle.as_deref().unwrap_or("-"), + bits(n.range), + n.looping, + n.position[0].to_bits(), + n.position[1].to_bits(), + n.position[2].to_bits() + ) + .expect("write"); + } + let [used, streaming] = engine.used_channels(); + writeln!( + out, + " Sounds: {used}/{} + {streaming}/{}", + engine.limits[0], engine.limits[1] + ) + .expect("write"); +} + +fn main() { + let args: Vec = std::env::args().collect(); + let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1]))); + engine.listening = true; + let mut backend = Fake::default(); + let mut ctx = TickContext::default(); + let mut instances: BTreeMap = BTreeMap::new(); + let input = std::fs::read_to_string(&args[2]).expect("input"); + let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); + for line in input.lines() { + writeln!(out, "{line}").expect("write"); + let a: Vec<&str> = line.split(' ').collect(); + let source = |i: usize| a[i].parse::().expect("source"); + match a[0] { + "play" => { + let event = horizon_client::sound_events::normalize(a[3]); + let random = LegacyRandom::new(a[14].parse().expect("seed")); + let instance = match a[2] { + "simple" => SoundInstance::new( + &event, + source(4), + f(a[5]), + f(a[6]), + random, + a[10] == "1", + a[11].parse().expect("delay"), + if a[12] == "linear" { + Attenuation::Linear + } else { + Attenuation::None + }, + [d(a[7]), d(a[8]), d(a[9])], + a[13] == "1", + ), + "loop" => SoundInstance::biome_loop(&event, random), + "uloop" => SoundInstance::under_liquid_loop(&event, random), + "usub" => SoundInstance::under_liquid_sub(&event, random), + _ => panic!("{line}"), + }; + if let Some(old) = instances.remove(a[1]) { + engine.release(old); + } + let (id, result) = engine.play_new(instance, true, &mut backend); + instances.insert(a[1].to_owned(), id); + writeln!(out, " result {}", result_name(result)).expect("write"); + } + "replay" => { + let result = engine.play(instances[a[1]], &mut backend); + writeln!(out, " result {}", result_name(result)).expect("write"); + } + "queue" => engine.queue_ticking(instances[a[1]]), + "delayed" => engine.play_delayed(instances[a[1]], a[2].parse().expect("delay")), + "fade" => { + let i = engine.instance_mut(instances[a[1]]).expect("instance"); + if a[2] == "in" { + i.fade_in(); + } else { + i.fade_out(); + } + } + "stop" => engine.stop(instances[a[1]], &mut backend), + "stopmatch" => { + let sound = (a[1] != "-").then(|| horizon_client::sound_events::normalize(a[1])); + let src = (a[2] != "-").then(|| source(2)); + engine.stop_matching(sound.as_deref(), src, &mut backend); + } + "finish" => { + if let Some(c) = engine.channel(instances[a[1]]) { + backend.stop(c); + } + } + "gain" => engine.update_category_volume(source(1), f(a[2]), &mut backend), + "volume" => engine.source_volumes[source(1)] = f(a[2]), + "refresh" => engine.refresh_category_volume(source(1), &mut backend), + "pause" => engine.pause_all_except(&[1, 10], &mut backend), + "resume" => engine.resume(&mut backend), + "player" => { + ctx.player_underwater = a[1] == "1"; + ctx.player_removed = a[2] == "1"; + } + "tick" => engine.tick(a[1] == "1", &ctx, &mut backend), + "forget" => { + if let Some(id) = instances.remove(a[1]) { + engine.release(id); + } + } + _ => panic!("{line}"), + } + for (name, id) in &instances { + writeln!(out, "{}", describe(&engine, &backend, name, *id)).expect("write"); + } + flush(&mut engine, &mut out); + } +} +fn result_name(r: horizon_client::sound_engine::PlayResult) -> &'static str { + match r { + horizon_client::sound_engine::PlayResult::Started => "STARTED", + horizon_client::sound_engine::PlayResult::StartedSilently => "STARTED_SILENTLY", + horizon_client::sound_engine::PlayResult::NotStarted => "NOT_STARTED", + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java new file mode 100644 index 000000000..317dc177b --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java @@ -0,0 +1,112 @@ +package dev.horizonlab.parity; + +import java.io.PrintWriter; +import java.lang.reflect.Constructor; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.player.LocalPlayer; +import net.minecraft.client.resources.sounds.*; +import net.minecraft.resources.Identifier; +import net.minecraft.sounds.SoundEvent; +import net.minecraft.sounds.SoundSource; +import net.minecraft.util.RandomSource; +import net.minecraft.world.entity.Entity; + +/** + * Drives the real SoundEngine (see VanillaSoundRig) with a script of plays, + * stops, category gains, option volumes, channel ends, pauses and ticks, and + * prints after every step each instance's activity and AL source parameters, + * the subtitle notifications and the channel pool counts. + */ +public final class VanillaSoundEngineOracle { + /** The local player the underwater instances look at. */ + public static final class Actor extends LocalPlayer { + boolean underwater; + + Actor() { + super(null, null, null, null, null, null, false, null, null); + } + + @Override + public boolean isUnderWater() { + return underwater; + } + } + + static float f(String hex) { + return Float.intBitsToFloat(Integer.parseUnsignedInt(hex, 16)); + } + + static double d(String hex) { + return Double.longBitsToDouble(Long.parseUnsignedLong(hex, 16)); + } + + static void seed(SoundInstance instance, long seed) throws Exception { + VanillaSoundRig.set(instance, AbstractSoundInstance.class, "random", RandomSource.create(seed)); + } + + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var rig = new VanillaSoundRig(Path.of(args[0])); + var actor = VanillaSoundRig.make(Actor.class); + Constructor sub = UnderLiquidSubSound.class.getDeclaredConstructor(LocalPlayer.class, SoundEvent.class); + sub.setAccessible(true); + var instances = new TreeMap(); + var manager = rig.manager; + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2])))) { + for (String line : Files.readAllLines(Path.of(args[1]))) { + out.println(line); + String[] a = line.split(" "); + switch (a[0]) { + case "play" -> { + // play name kind event source volume pitch x y z looping delay attenuation relative seed + Identifier id = Identifier.parse(a[3]); + SoundEvent event = SoundEvent.createVariableRangeEvent(id); + long seed = Long.parseLong(a[14]); + SoundInstance instance = switch (a[2]) { + case "simple" -> new SimpleSoundInstance(id, SoundSource.values()[Integer.parseInt(a[4])], f(a[5]), f(a[6]), + RandomSource.create(seed), a[10].equals("1"), Integer.parseInt(a[11]), + a[12].equals("linear") ? SoundInstance.Attenuation.LINEAR : SoundInstance.Attenuation.NONE, d(a[7]), d(a[8]), d(a[9]), + a[13].equals("1")); + case "loop" -> new BiomeAmbientSoundsHandler.LoopSoundInstance(event); + case "uloop" -> new UnderLiquidAmbientSoundInstance(event, actor, LocalPlayer::isUnderWater); + case "usub" -> sub.newInstance(actor, event); + default -> throw new IllegalArgumentException(line); + }; + if (!a[2].equals("simple")) seed(instance, seed); + instances.put(a[1], instance); + out.println(" result " + manager.play(instance)); + } + case "replay" -> out.println(" result " + manager.play(instances.get(a[1]))); + case "queue" -> manager.queueTickingSound((TickableSoundInstance) instances.get(a[1])); + case "delayed" -> manager.playDelayed(instances.get(a[1]), Integer.parseInt(a[2])); + case "fade" -> { + if (instances.get(a[1]) instanceof BiomeAmbientSoundsHandler.LoopSoundInstance loop) { + if (a[2].equals("in")) loop.fadeIn(); else loop.fadeOut(); + } + } + case "stop" -> manager.stop(instances.get(a[1])); + case "stopmatch" -> manager.stop(a[1].equals("-") ? null : Identifier.parse(a[1]), + a[2].equals("-") ? null : SoundSource.values()[Integer.parseInt(a[2])]); + case "finish" -> rig.finish(instances.get(a[1])); + case "gain" -> manager.updateCategoryVolume(SoundSource.values()[Integer.parseInt(a[1])], f(a[2])); + case "volume" -> rig.volume(SoundSource.values()[Integer.parseInt(a[1])], f(a[2])); + case "refresh" -> manager.refreshCategoryVolume(SoundSource.values()[Integer.parseInt(a[1])]); + case "pause" -> manager.pauseAllExcept(SoundSource.MUSIC, SoundSource.UI); + case "resume" -> manager.resume(); + case "player" -> { + actor.underwater = a[1].equals("1"); + VanillaSoundRig.set(actor, Entity.class, "removalReason", a[2].equals("1") ? Entity.RemovalReason.DISCARDED : null); + } + case "tick" -> manager.tick(a[1].equals("1")); + case "forget" -> instances.remove(a[1]); + default -> throw new IllegalArgumentException(line); + } + for (var e : instances.entrySet()) out.println(rig.describe(e.getKey(), e.getValue())); + rig.flush(out); + } + } + System.exit(0); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java new file mode 100644 index 000000000..8edef9325 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java @@ -0,0 +1,204 @@ +package dev.horizonlab.parity; + +import com.mojang.blaze3d.audio.*; +import java.io.PrintWriter; +import java.lang.reflect.*; +import java.nio.ByteBuffer; +import java.nio.file.Path; +import java.util.*; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Executor; +import javax.sound.sampled.AudioFormat; +import net.minecraft.client.OptionInstance; +import net.minecraft.client.Options; +import net.minecraft.client.resources.sounds.SoundInstance; +import net.minecraft.client.sounds.*; +import net.minecraft.network.chat.contents.TranslatableContents; +import net.minecraft.resources.Identifier; +import net.minecraft.sounds.SoundSource; +import org.lwjgl.openal.AL10; + +/** + * A real vanilla SoundManager/SoundEngine running on OpenAL Soft's "No Output" + * device (ALSOFT_DRIVERS=null), shared by the audio oracles. + * + * Determinism: the sound executor runs each task inline (the model where the + * sound thread keeps up between client ticks); static sounds get one silent + * hour-long buffer (they play until stopped or "finished" by the script) and + * streams play endless silence. Everything else, the + * channel pools, AL source parameters, lifetimes and bookkeeping, is the real + * code and the real OpenAL implementation. + */ +public final class VanillaSoundRig { + static Object unsafe; + static Method allocate; + + static T make(Class type) throws Exception { + if (unsafe == null) { + var u = Class.forName("sun.misc.Unsafe"); + unsafe = field(u, "theUnsafe").get(null); + allocate = u.getMethod("allocateInstance", Class.class); + } + return type.cast(allocate.invoke(unsafe, type)); + } + + static Field field(Class type, String name) throws Exception { + var f = type.getDeclaredField(name); + f.setAccessible(true); + return f; + } + + static Object get(Object target, Class type, String name) throws Exception { + return field(type, name).get(target); + } + + static void set(Object target, Class type, String name, Object value) throws Exception { + field(type, name).set(target, value); + } + + /** Runs every task on the calling thread. */ + public static final class Inline extends SoundEngineExecutor { + @Override + public void execute(final Runnable command) { + command.run(); + } + + @Override + public void shutDown() { + } + + @Override + public void startUp() { + } + } + + static SoundBuffer silence; + + /** Static sounds: a silent hour; streams: endless silence. */ + public static final class Buffers extends SoundBufferLibrary { + Buffers() { + super(null); + } + + @Override + public CompletableFuture getCompleteBuffer(final Identifier location) { + return CompletableFuture.completedFuture(silence); + } + + @Override + public CompletableFuture getStream(final Identifier location, final boolean looping) { + return CompletableFuture.completedFuture(new Silence()); + } + } + + /** An endless silent stream, a minute per read (it never runs dry between ticks). */ + public static final class Silence implements AudioStream { + static final AudioFormat FORMAT = new AudioFormat(8000.0F, 8, 1, false, false); + + @Override + public AudioFormat getFormat() { + return FORMAT; + } + + @Override + public ByteBuffer read(final int expectedSize) { + ByteBuffer data = ByteBuffer.allocateDirect(8000 * 60); + for (int i = 0; i < data.capacity(); i++) data.put(i, (byte) 0x80); + return data; + } + + @Override + public void close() { + } + } + + public final SoundManager manager; + public final SoundEngine engine; + public final Options options; + public final List heard = new ArrayList<>(); + + public VanillaSoundRig(Path root) throws Exception { + manager = VanillaSoundEventOracle.load(root); + engine = (SoundEngine) get(manager, SoundManager.class, "soundEngine"); + options = (Options) get(engine, SoundEngine.class, "options"); + var inline = make(Inline.class); + set(engine, SoundEngine.class, "executor", inline); + set(get(engine, SoundEngine.class, "channelAccess"), ChannelAccess.class, "executor", inline); + set(engine, SoundEngine.class, "soundBuffers", make(Buffers.class)); + Library library = (Library) get(engine, SoundEngine.class, "library"); + library.init(null, DeviceList.query(), false); + ByteBuffer data = ByteBuffer.allocateDirect(8000 * 3600); + for (int i = 0; i < data.capacity(); i++) data.put(i, (byte) 0x80); + silence = new SoundBuffer(data, new AudioFormat(8000.0F, 8, 1, false, false)); + set(engine, SoundEngine.class, "loaded", true); + Method slider = Options.class.getDeclaredMethod("createSoundSliderOptionInstance", String.class, SoundSource.class); + slider.setAccessible(true); + var volumes = new EnumMap>(SoundSource.class); + for (SoundSource source : SoundSource.values()) { + volumes.put(source, (OptionInstance) slider.invoke(options, "soundCategory." + source.getName(), source)); + } + set(options, Options.class, "soundSourceVolumes", volumes); + manager.addListener((sound, event, range) -> { + String subtitle = "-"; + if (event.getSubtitle() != null && event.getSubtitle().getContents() instanceof TranslatableContents t) subtitle = t.getKey(); + heard.add(String.format("notify %s %s %08x %s %016x %016x %016x", sound.getIdentifier(), subtitle, Float.floatToRawIntBits(range), + sound.isLooping(), Double.doubleToRawLongBits(sound.getX()), Double.doubleToRawLongBits(sound.getY()), + Double.doubleToRawLongBits(sound.getZ()))); + }); + } + + /** Set a sound source volume option without its change callback. */ + public void volume(SoundSource source, double value) throws Exception { + set(options.getSoundSourceOptionInstance(source), OptionInstance.class, "value", value); + } + + /** The channel of an instance, or null. */ + @SuppressWarnings("unchecked") + public Channel channel(SoundInstance instance) throws Exception { + var map = (Map) get(engine, SoundEngine.class, "instanceToChannel"); + var handle = map.get(instance); + return handle == null ? null : (Channel) get(handle, ChannelAccess.ChannelHandle.class, "channel"); + } + + /** The channel's end: what OpenAL does when a non-looping buffer runs out. */ + public void finish(SoundInstance instance) throws Exception { + var channel = channel(instance); + if (channel != null) channel.stop(); + } + + static String fbits(float v) { + return String.format("%08x", Float.floatToRawIntBits(v)); + } + + /** One line describing an instance: activity and its AL source. */ + public String describe(String name, SoundInstance instance) throws Exception { + StringBuilder sb = new StringBuilder(" ").append(name).append(" active=").append(manager.isActive(instance)); + var channel = channel(instance); + if (channel == null) { + sb.append(" channel=-"); + } else { + int source = (int) get(channel, Channel.class, "source"); + boolean initialized = ((java.util.concurrent.atomic.AtomicBoolean) get(channel, Channel.class, "initialized")).get(); + if (!initialized) { + sb.append(" channel=released"); + } else { + float[] pos = new float[3]; + AL10.alGetSourcefv(source, AL10.AL_POSITION, pos); + sb.append(String.format(" state=%x gain=%s pitch=%s pos=%s,%s,%s rel=%d loop=%d model=%x max=%s rolloff=%s ref=%s", + AL10.alGetSourcei(source, AL10.AL_SOURCE_STATE), fbits(AL10.alGetSourcef(source, AL10.AL_GAIN)), + fbits(AL10.alGetSourcef(source, AL10.AL_PITCH)), fbits(pos[0]), fbits(pos[1]), fbits(pos[2]), + AL10.alGetSourcei(source, AL10.AL_SOURCE_RELATIVE), AL10.alGetSourcei(source, AL10.AL_LOOPING), + AL10.alGetSourcei(source, 0xD000), fbits(AL10.alGetSourcef(source, AL10.AL_MAX_DISTANCE)), + fbits(AL10.alGetSourcef(source, AL10.AL_ROLLOFF_FACTOR)), fbits(AL10.alGetSourcef(source, AL10.AL_REFERENCE_DISTANCE)))); + } + } + return sb.toString(); + } + + /** Print and clear the notifications, then the channel counts. */ + public void flush(PrintWriter out) { + for (String h : heard) out.println(h); + heard.clear(); + out.println(" " + manager.getChannelDebugString()); + } +} diff --git a/tools/audio_harness.py b/tools/audio_harness.py index bfd18e05e..41e0fa9dd 100644 --- a/tools/audio_harness.py +++ b/tools/audio_harness.py @@ -54,8 +54,11 @@ def run_harness(name, oracle, example, inputs_text, extra_sources=(), java_args= input_hash = lab.digest(inputs, 'sha256') def run(command, log, env=None): - with (build / (log + '.log')).open('w') as out: - subprocess.run(list(map(str, command)), cwd=lab.ROOT, check=True, timeout=timeout, stdout=out, stderr=subprocess.STDOUT, env=env) + with (build / (log + ".log")).open("w") as out: + try: + subprocess.run(list(map(str, command)), cwd=lab.ROOT, check=True, timeout=timeout, stdout=out, stderr=subprocess.STDOUT, env=env) + except subprocess.CalledProcessError: + raise SystemExit(f"{log} failed: see {build / (log + '.log')}") from None classes = build / 'classes' classes.mkdir(exist_ok=True) diff --git a/tools/test_sound_engine_parity.py b/tools/test_sound_engine_parity.py new file mode 100644 index 000000000..383ca24b2 --- /dev/null +++ b/tools/test_sound_engine_parity.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +"""Compare the sound engine's bookkeeping with the vanilla 26.3 client. + +The oracle runs the real `SoundManager`/`SoundEngine` on OpenAL Soft's "No +Output" device (see VanillaSoundRig) and replays scripts of plays (simple, +biome loop, underwater loop and sub-sound instances), stops (by instance, by +sound and/or source, all), category gains, source volume options and +refreshes, channel ends, delayed and queued sounds, pauses and client ticks. +After every step it prints each instance's `isActive` and the AL source the +engine configured (state, gain, pitch, position, relative, looping, distance +model, max distance, rolloff, reference distance), the subtitle notifications +and the channel pool counts. Horizon's `SoundEngine` replays the scripts +against a backend that records the same AL source fields. +""" +import json +import random + +try: + from . import audio_harness as h +except ImportError: + import audio_harness as h + + +def dbits(v): + import struct + return struct.pack('>d', v).hex() + + +class Script: + def __init__(self, events, streams): + self.lines = [] + self.events, self.streams = events, streams + + def add(self, *parts): + self.lines.append(' '.join(map(str, parts))) + + def play(self, name, event, source=4, volume=1.0, pitch=1.0, at=(0.0, 0.0, 0.0), looping=0, delay=0, linear=True, relative=0, seed=0, kind='simple'): + self.add('play', name, kind, event, source, h.bits(volume), h.bits(pitch), *map(dbits, at), looping, delay, + 'linear' if linear else 'none', relative, seed) + + def tick(self, n=1, paused=0): + for _ in range(n): + self.add('tick', paused) + + def reset(self): + self.add('stopmatch', '-', '-') + for source in range(11): + self.add('volume', source, h.bits(1.0)) + self.tick() + + +def scripted(s): + stone, cave, click = 'minecraft:block.stone.break', 'minecraft:ambient.cave', 'minecraft:ui.button.click' + music, loop, uloop = 'minecraft:music.game', 'minecraft:ambient.crimson_forest.loop', 'minecraft:ambient.underwater.loop' + # Positional and relative sounds, lifetimes and channel ends. + s.play('a', stone, 4, 1.0, 0.8, (10.5, 64.0, -3.25), seed=5) + s.play('b', click, 10, 0.25, 1.0, linear=False, relative=1, seed=6) + s.play('c', cave, 8, 4.0, 1.0, (100.0, 20.0, 100.0), seed=7) + s.play('d', stone, 4, 1.5, 3.0, (0.5, 0.5, 0.5), seed=8) + s.play('e', stone, 4, 0.5, 0.1, (1.0, 2.0, 3.0), seed=9) + s.tick(3) + s.add('finish', 'a') + s.tick(25) + s.add('finish', 'b') + s.add('stop', 'c') + s.tick(2) + s.reset() + # Volumes: options, category gains, refreshes, silent starts. + s.add('volume', 4, h.bits(0.5)) + s.add('volume', 0, h.bits(0.75)) + s.play('a', stone, 4, 1.0, 1.0, (1.0, 1.0, 1.0), seed=1) + s.add('volume', 4, h.bits(0.0)) + s.play('b', stone, 4, 1.0, 1.0, (1.0, 1.0, 1.0), seed=2) + s.add('volume', 1, h.bits(0.0)) + s.play('m', music, 1, 1.0, 1.0, linear=False, relative=1, seed=3) + s.add('refresh', 4) + s.add('volume', 4, h.bits(0.3)) + s.add('refresh', 0) + s.add('gain', 1, h.bits(0.5)) + s.add('gain', 1, h.bits(1.5)) + s.add('gain', 4, h.bits(-0.2)) + s.add('volume', 1, h.bits(1.0)) + s.add('refresh', 1) + s.tick(2) + s.add('volume', 0, h.bits(2.0)) + s.add('refresh', 0) + s.reset() + # Biome loops: fades, crossfade, stopping, removal. + s.play('l1', loop, kind='loop', seed=11) + s.add('fade', 'l1', 'in') + s.tick(45) + s.play('l2', 'minecraft:ambient.warped_forest.loop', kind='loop', seed=12) + s.add('fade', 'l1', 'out') + s.add('fade', 'l2', 'in') + s.tick(50) + s.add('fade', 'l2', 'out') + s.tick(10) + s.add('fade', 'l2', 'in') + s.tick(60) + s.add('volume', 8, h.bits(0.0)) + s.play('l3', loop, kind='loop', seed=13) + s.tick(3) + s.reset() + # Underwater loop and sub-sounds. + s.add('player', 1, 0) + s.play('u', uloop, kind='uloop', seed=21) + s.play('v', 'minecraft:ambient.underwater.loop.additions.rare', kind='usub', seed=22) + s.tick(50) + s.add('player', 0, 0) + s.tick(5) + s.add('player', 1, 0) + s.tick(5) + s.add('player', 0, 0) + s.tick(30) + s.add('player', 1, 1) + s.play('u2', uloop, kind='uloop', seed=23) + s.tick(3) + s.add('player', 0, 0) + s.reset() + # Queued tickables, delayed and manually looped sounds. + s.play('q', loop, kind='loop', seed=31) + s.add('stop', 'q') + s.tick(25) + s.add('queue', 'q') + s.add('fade', 'q', 'in') + s.tick(3) + s.play('w', stone, 4, 1.0, 1.0, (2.0, 2.0, 2.0), seed=32) + s.add('delayed', 'w', 5) + s.tick(7) + s.play('r', stone, 4, 1.0, 1.0, (3.0, 3.0, 3.0), looping=1, delay=4, seed=33) + s.tick(22) + s.add('finish', 'r') + s.tick(8) + s.add('finish', 'r') + s.tick(6) + s.play('n', stone, 4, 1.0, 1.0, (3.0, 3.0, 3.0), looping=1, seed=34) + s.tick(2) + s.reset() + # Stopping by source and sound, pauses. + s.play('a', stone, 4, seed=41) + s.play('b', stone, 5, seed=42) + s.play('c', cave, 8, seed=43) + s.play('m', music, 1, linear=False, relative=1, seed=44) + s.play('u', click, 10, linear=False, relative=1, seed=45) + s.add('pause') + s.tick(1, paused=1) + s.add('stop', 'm') + s.tick(1, paused=1) + s.add('resume') + s.add('stopmatch', stone, '-') + s.tick(25) + s.add('stopmatch', '-', 8) + s.add('stopmatch', click, 4) + s.add('stopmatch', click, 10) + s.tick(2) + s.reset() + # Unknown, empty and intentionally empty events; replaying an instance. + for i, event in enumerate(['minecraft:not.a.sound', 'minecraft:intentionally_empty', 'minecraft:empty', 'minecraft:entity.generic.eat']): + s.play(f'x{i}', event, 6, seed=50 + i) + s.add('replay', 'x3') + s.tick(25) + s.reset() + # Channel pools. + for i in range(252): + s.play('p', stone, 4, 1.0, 1.0, (float(i), 0.0, 0.0), seed=i) + for i in range(10): + s.play('s', music, 1, linear=False, relative=1, seed=i) + s.tick(2) + s.add('stopmatch', '-', '-') + s.tick(1) + + +def fuzz(s, rng, steps): + names = ['f0', 'f1', 'f2', 'f3', 'f4', 'f5'] + live = set() + for _ in range(steps): + op = rng.random() + name = rng.choice(names) + if op < 0.25: + kind = rng.choice(['simple', 'simple', 'simple', 'loop', 'uloop', 'usub']) + event = rng.choice(s.streams if kind != 'simple' and rng.random() < 0.5 else s.events) + at = tuple(rng.choice([0.0, rng.uniform(-200, 200)]) for _ in range(3)) + s.play(name, event, rng.randrange(11), rng.choice([1.0, 0.5, 2.0, 0.0, 4.0, rng.uniform(0, 3)]), rng.choice([1.0, 0.5, 2.5, rng.uniform(0.2, 3)]), + at, int(rng.random() < 0.2), rng.choice([0, 0, 0, 3]), rng.random() < 0.7, int(rng.random() < 0.3), rng.getrandbits(63), kind) + live.add(name) + elif not live: + s.tick() + elif op < 0.32: + s.add('finish', rng.choice(sorted(live))) + elif op < 0.36: + s.add('stop', rng.choice(sorted(live))) + elif op < 0.40: + s.add('fade', rng.choice(sorted(live)), rng.choice(['in', 'out'])) + elif op < 0.42: + s.add('stopmatch', rng.choice(['-', rng.choice(s.events)]), rng.choice(['-', rng.randrange(11)])) + elif op < 0.45: + s.add('volume', rng.randrange(11), h.bits(rng.choice([0.0, 1.0, 0.5, rng.random()]))) + elif op < 0.48: + s.add('refresh', rng.randrange(11)) + elif op < 0.51: + s.add('gain', rng.randrange(11), h.bits(rng.choice([0.0, 1.0, 0.3, 1.2]))) + elif op < 0.53: + s.add('player', int(rng.random() < 0.6), int(rng.random() < 0.05)) + elif op < 0.55: + s.add('replay', rng.choice(sorted(live))) + elif op < 0.56: + s.add('pause') + s.tick(rng.randrange(1, 4), paused=1) + s.add('resume') + elif op < 0.57: + s.add('forget', name) + live.discard(name) + else: + s.tick(rng.randrange(1, 6)) + + +def fixtures(): + sounds = json.loads((h.RESOURCES / 'assets/minecraft/sounds.json').read_text()) + names = sorted(sounds) + streams = sorted('minecraft:' + n for n in names if any(isinstance(e, dict) and e.get('stream') for e in sounds[n].get('sounds', []))) + rng = random.Random(0x454e47494e45) + events = sorted(set(['minecraft:' + rng.choice(names) for _ in range(60)] + ['minecraft:ambient.cave', 'minecraft:block.stone.break'])) + s = Script(events, streams) + scripted(s) + for _ in range(40): + s.reset() + fuzz(s, rng, 150) + return s.lines + + +def main(): + lines = fixtures() + matched, report = h.run_harness( + 'sound-engine', 'VanillaSoundEngineOracle', 'sound_engine_fixture', ''.join(l + '\n' for l in lines), + extra_sources=[h.lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java'], + java_args=[h.RESOURCES], rust_args=[h.RESOURCES], + scope='Real SoundEngine (OpenAL Soft null device, inline executor, silent static buffers, never-ready streams): play results, ' + 'AL source parameters set by play/tickInGameSound/refreshCategoryVolume (gain from calculateVolume, clamped pitch, linear ' + 'attenuation distance, looping, position, relative), isActive, the 20-tick minimum lifetime, channel ends, stop by instance/sound/source/all, ' + 'pauseAllExcept/resume, tickMusicWhenPaused, queued tickables, playDelayed and manual looping, LoopSoundInstance, ' + 'UnderLiquidAmbientSoundInstance and UnderLiquidSubSound ticks, subtitle notifications and ranges, and the 247/8 channel pools. ' + 'Not compared: decoded sample output, OpenAL panning/HRTF and distance gain inside the mixer, asset loading timing.') + print(f'{matched:,} sound engine lines match the pinned client ({len(lines):,} steps): {report}', flush=True) + + +if __name__ == '__main__': + main() From ccdf49d3e5aad447d3f987138115afaede2d7b41 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:44:58 +0200 Subject: [PATCH 3/9] Play every sound through the vanilla SoundEngine model Audio now keeps vanilla SoundEngine bookkeeping over a mixer that stands in for OpenAL sources (gain, pitch, linear distance attenuation, looping, relative, source states, the 247/8 channel pools), ticks once per client tick with pauseAllExcept/resume and stops everything when the world closes. MusicManager holds a forMusic instance and checks isActive as vanilla does; the ambient handlers play LoopSoundInstance, UnderLiquid* and mood instances, the enter/exit sounds seeded from the level random; jukebox songs use forJukeboxSong instead of a hand-made volume ramp. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/ambience.rs | 430 +++++------ crates/horizon-client/src/audio.rs | 847 +++++++++++----------- crates/horizon-client/src/game.rs | 12 +- crates/horizon-client/src/game/control.rs | 2 +- crates/horizon-client/src/game/jukebox.rs | 27 +- crates/horizon-client/src/game/music.rs | 104 +-- crates/horizon-client/src/music.rs | 254 ++++--- crates/horizon-client/src/sound_engine.rs | 83 +++ 8 files changed, 892 insertions(+), 867 deletions(-) diff --git a/crates/horizon-client/src/ambience.rs b/crates/horizon-client/src/ambience.rs index c447d1450..860a080a6 100644 --- a/crates/horizon-client/src/ambience.rs +++ b/crates/horizon-client/src/ambience.rs @@ -1,7 +1,9 @@ //! The player's ambient sound handlers: `BiomeAmbientSoundsHandler` (biome //! loops with 40-tick cross-fades, random additions, cave mood) driven by the //! `minecraft:audio/ambient_sounds` attribute, `UnderwaterAmbientSoundHandler` -//! and the underwater loop (`UnderLiquidAmbientSoundInstance`). +//! and `LocalPlayer.updateIsUnderwater` (enter/exit sounds and the +//! `UnderLiquidAmbientSoundInstance` loop), played through the sound engine. +use crate::sound_engine::{AMBIENT, InstanceId, SoundEngine, SoundInstance, Sounds}; use horizon_core::random::{LegacyRandom, RandomSource}; use serde_json::Value; use std::{collections::HashMap, fs, path::Path}; @@ -80,87 +82,35 @@ impl AmbientTables { .unwrap_or_default() } } -/// The sound engine side of the handlers. -pub trait AmbientOutput { - /// A relative tickable instance; None when it could not start. - fn play_tracked(&mut self, event: &str, volume: f32, looping: bool) -> Option; - fn set_volume(&mut self, id: u64, volume: f32); - fn stop(&mut self, id: u64); - fn is_active(&self, id: u64) -> bool; - /// A positional one-shot (`SimpleSoundInstance`, linear attenuation). - fn play_at(&mut self, event: &str, at: [f64; 3]); -} -impl AmbientOutput for crate::audio::Audio { - fn play_tracked(&mut self, event: &str, volume: f32, looping: bool) -> Option { - crate::audio::Audio::play_tracked(self, event, volume, looping) - } - fn set_volume(&mut self, id: u64, volume: f32) { - self.set_tracked_volume(id, volume); - } - fn stop(&mut self, id: u64) { - self.stop_tracked(id); - } - fn is_active(&self, id: u64) -> bool { - self.tracked_active(id) - } - fn play_at(&mut self, event: &str, at: [f64; 3]) { - self.play(event, Some(at), 1.0, 1.0); - } -} -/// `BiomeAmbientSoundsHandler.LoopSoundInstance`. -struct LoopSound { - id: Option, - fade: i32, - direction: i32, - stopped: bool, -} -impl LoopSound { - fn tick(&mut self) -> f32 { - if self.fade < 0 { - self.stopped = true; - } - self.fade += self.direction; - (self.fade as f32 / 40.0).clamp(0.0, 1.0) - } - fn fade_out(&mut self) { - self.fade = self.fade.min(40); - self.direction = -1; - } - fn fade_in(&mut self) { - self.fade = self.fade.max(0); - self.direction = 1; - } -} /// What the handlers read about the player and level each tick. pub struct AmbientContext<'a> { + /// `AMBIENT_SOUNDS` at the player's position. pub sounds: &'a AmbientSounds, - /// Feet and eye position. + /// The player's position (feet) and eye height. pub position: [f64; 3], pub eye_y: f64, + /// `isEyeInFluid(WATER)` this tick (`Entity.updateIsUnderwater`). pub underwater: bool, - /// Raw (sky, block) light at a block. + pub spectator: bool, + /// `Level.getBrightness` (sky, block) at a block. pub light: &'a dyn Fn([i32; 3]) -> (u8, u8), } /// The local player's ambient sound handlers. pub struct Ambience { /// The client level's random. - random: LegacyRandom, - loops: Vec<(String, LoopSound)>, + pub random: LegacyRandom, + /// `BiomeAmbientSoundsHandler.loopSounds` (insertion order). + loops: Vec<(String, InstanceId)>, previous_loop: Option, pub moodiness: f32, + /// `UnderwaterAmbientSoundHandler.tickDelay`. underwater_delay: i32, - /// The underwater loop instance and its fade. - underwater_loop: Option<(u64, i32)>, - /// UnderLiquidSubSound instances (stop when the player leaves the water). - sub_sounds: Vec, + /// `LocalPlayer.wasUnderwater`. was_underwater: bool, } impl Default for Ambience { fn default() -> Self { - let seed = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .map_or(0, |d| d.as_nanos() as i64); - Self::new(seed) + Self::new(crate::sound_engine::unique_seed()) } } impl Ambience { @@ -171,53 +121,54 @@ impl Ambience { previous_loop: None, moodiness: 0.0, underwater_delay: 0, - underwater_loop: None, - sub_sounds: Vec::new(), was_underwater: false, } } - /// Stop everything (leaving the world). - pub fn clear(&mut self, out: &mut impl AmbientOutput) { - for (_, l) in self.loops.drain(..) { - if let Some(id) = l.id { - out.stop(id); - } - } - if let Some((id, _)) = self.underwater_loop.take() { - out.stop(id); - } - for id in self.sub_sounds.drain(..) { - out.stop(id); + /// `LocalPlayer.isUnderWater`. + pub fn was_underwater(&self) -> bool { + self.was_underwater + } + /// A new player (leaving or changing worlds): fresh handlers. + pub fn clear(&mut self, sounds: &mut impl Sounds) { + for (_, id) in self.loops.drain(..) { + sounds.release(id); } self.previous_loop = None; self.moodiness = 0.0; + self.underwater_delay = 0; self.was_underwater = false; } - /// `LocalPlayer.updateIsUnderwater` enter/exit sounds and loop, then - /// `UnderwaterAmbientSoundHandler`, `BubbleColumn` (absent) and - /// `BiomeAmbientSoundsHandler` ticks, then the tickable instances. - pub fn tick(&mut self, ctx: &AmbientContext, out: &mut impl AmbientOutput) { - let feet = ctx.position; - if !self.was_underwater && ctx.underwater { - out.play_at("minecraft:ambient.underwater.enter", feet); - if let Some((id, _)) = self.underwater_loop.take() { - out.stop(id); - } - self.underwater_loop = out - .play_tracked("minecraft:ambient.underwater.loop", 0.0, true) - .map(|id| (id, 0)); - } - if self.was_underwater && !ctx.underwater { - out.play_at("minecraft:ambient.underwater.exit", feet); - } - self.was_underwater = ctx.underwater; - self.tick_underwater(ctx, out); - self.tick_biome(ctx, out); - self.tick_instances(ctx, out); + /// `ClientLevel.playLocalSound(x, y, z, sound, AMBIENT, 1, 1, false)`. + fn play_local(&mut self, event: &str, at: [f64; 3], sounds: &mut impl Sounds) { + let seed = self.random.next_long(); + let instance = SoundInstance::at(event, AMBIENT, 1.0, 1.0, LegacyRandom::new(seed), at); + sounds.play_instance(instance, false); } - fn tick_underwater(&mut self, ctx: &AmbientContext, out: &mut impl AmbientOutput) { + /// `LocalPlayer.updateIsUnderwater`, then the `ambientSoundHandlers` + /// (underwater, bubble column, biome) as `LocalPlayer.tick` runs them. + pub fn tick(&mut self, ctx: &AmbientContext, sounds: &mut impl Sounds) { + let old = self.was_underwater; + self.was_underwater = ctx.underwater; + if !ctx.spectator { + if !old && ctx.underwater { + self.play_local("minecraft:ambient.underwater.enter", ctx.position, sounds); + let instance = SoundInstance::under_liquid_loop( + "minecraft:ambient.underwater.loop", + SoundEngine::unseeded(), + ); + sounds.play_instance(instance, false); + } + if old && !ctx.underwater { + self.play_local("minecraft:ambient.underwater.exit", ctx.position, sounds); + } + } + self.tick_underwater(sounds); + self.tick_biome(ctx, sounds); + } + /// `UnderwaterAmbientSoundHandler.tick`. + fn tick_underwater(&mut self, sounds: &mut impl Sounds) { self.underwater_delay -= 1; - if self.underwater_delay <= 0 && ctx.underwater { + if self.underwater_delay <= 0 && self.was_underwater { let rand = self.random.next_float(); let sound = if rand < 1.0E-4 { Some("minecraft:ambient.underwater.loop.additions.ultra_rare") @@ -230,147 +181,121 @@ impl Ambience { }; if let Some(sound) = sound { self.underwater_delay = 0; - if let Some(id) = out.play_tracked(sound, 1.0, false) { - self.sub_sounds.push(id); - } + let instance = SoundInstance::under_liquid_sub(sound, SoundEngine::unseeded()); + sounds.play_instance(instance, false); } } } - fn tick_biome(&mut self, ctx: &AmbientContext, out: &mut impl AmbientOutput) { - self.loops.retain(|(_, l)| !l.stopped); - let sounds = ctx.sounds; - if sounds.r#loop != self.previous_loop { - self.previous_loop = sounds.r#loop.clone(); - for (_, l) in &mut self.loops { - l.fade_out(); + /// `BiomeAmbientSoundsHandler.tick`. + fn tick_biome(&mut self, ctx: &AmbientContext, sounds: &mut impl Sounds) { + let mut kept = Vec::new(); + for (event, id) in std::mem::take(&mut self.loops) { + if sounds.engine().instance(id).is_some_and(|i| i.stopped) { + sounds.release(id); + } else { + kept.push((event, id)); } - if let Some(event) = &sounds.r#loop { - if !self.loops.iter().any(|(e, _)| e == event) { - let id = out.play_tracked(event, 0.0, true); - self.loops.push(( - event.clone(), - LoopSound { - id, - fade: 0, - direction: 0, - stopped: false, - }, - )); + } + self.loops = kept; + let current = ctx + .sounds + .r#loop + .as_deref() + .map(crate::sound_events::normalize); + if current != self.previous_loop { + self.previous_loop = current.clone(); + for (_, id) in &self.loops { + if let Some(i) = sounds.engine().instance_mut(*id) { + i.fade_out(); } - if let Some((_, l)) = self.loops.iter_mut().find(|(e, _)| e == event) { - l.fade_in(); + } + if let Some(event) = current { + let id = match self.loops.iter().find(|(e, _)| *e == event) { + Some((_, id)) => *id, + None => { + let instance = SoundInstance::biome_loop(&event, SoundEngine::unseeded()); + let id = sounds.engine().add(instance, true); + sounds.play_id(id); + self.loops.push((event, id)); + id + } + }; + if let Some(i) = sounds.engine().instance_mut(id) { + i.fade_in(); } } } - for (sound, chance) in &sounds.additions { - if self.random.next_double() < *chance - && let Some(id) = out.play_tracked(sound, 1.0, false) - { - // forAmbientAddition: a one-shot nobody ticks. - let _ = id; + for (sound, chance) in &ctx.sounds.additions { + if self.random.next_double() < *chance { + let event = crate::sound_events::normalize(sound); + let instance = SoundInstance::for_ambient_addition(&event, SoundEngine::unseeded()); + sounds.play_instance(instance, false); } } - let Some(mood) = &sounds.mood else { return }; + let Some(mood) = &ctx.sounds.mood else { return }; let extent = mood.block_search_extent; let span = extent * 2 + 1; - let mut offset = || self.random.next_int_bound(span).unwrap_or(0) - extent; - let (dx, dy, dz) = (offset(), offset(), offset()); - let sample = [ - (ctx.position[0] + f64::from(dx)).floor() as i32, - (ctx.eye_y + f64::from(dy)).floor() as i32, - (ctx.position[2] + f64::from(dz)).floor() as i32, - ]; + let x = ctx.position[0] + f64::from(self.random.next_int_bound(span).unwrap_or(0)) + - f64::from(extent); + let y = ctx.eye_y + f64::from(self.random.next_int_bound(span).unwrap_or(0)) + - f64::from(extent); + let z = ctx.position[2] + f64::from(self.random.next_int_bound(span).unwrap_or(0)) + - f64::from(extent); + let sample = [x.floor() as i32, y.floor() as i32, z.floor() as i32]; let (sky, block) = (ctx.light)(sample); if sky > 0 { self.moodiness -= f32::from(sky) / 15.0 * 0.001; } else { - self.moodiness -= (f32::from(block) - 1.0) / mood.tick_delay as f32; + self.moodiness -= (i32::from(block) - 1) as f32 / mood.tick_delay as f32; } if self.moodiness >= 1.0 { - let d = [ - f64::from(sample[0]) + 0.5 - ctx.position[0], - f64::from(sample[1]) + 0.5 - ctx.eye_y, - f64::from(sample[2]) + 0.5 - ctx.position[2], - ]; - let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(); + let sample_x = f64::from(sample[0]) + 0.5; + let sample_y = f64::from(sample[1]) + 0.5; + let sample_z = f64::from(sample[2]) + 0.5; + let dx = sample_x - ctx.position[0]; + let dy = sample_y - ctx.eye_y; + let dz = sample_z - ctx.position[2]; + let distance = (dx * dx + dy * dy + dz * dz).sqrt(); let source = distance + mood.offset; - out.play_at( - &mood.sound, - [ - ctx.position[0] + d[0] / distance * source, - ctx.eye_y + d[1] / distance * source, - ctx.position[2] + d[2] / distance * source, - ], - ); + let at = [ + ctx.position[0] + dx / distance * source, + ctx.eye_y + dy / distance * source, + ctx.position[2] + dz / distance * source, + ]; + // The mood sound draws from the level random itself. + let event = crate::sound_events::normalize(&mood.sound); + let instance = SoundInstance::for_ambient_mood(&event, self.random.clone(), at); + let id = sounds.engine().add(instance, true); + sounds.play_id(id); + if let Some(i) = sounds.engine().instance(id) { + self.random = i.random.clone(); + } + sounds.release(id); self.moodiness = 0.0; } else { self.moodiness = self.moodiness.max(0.0); } } - /// The tickable instances' own ticks (SoundEngine.tickInGameSound). - fn tick_instances(&mut self, ctx: &AmbientContext, out: &mut impl AmbientOutput) { - for (_, l) in &mut self.loops { - let volume = l.tick(); - if let Some(id) = l.id { - if l.stopped { - out.stop(id); - } else { - out.set_volume(id, volume); - } - } - } - // UnderLiquidAmbientSoundInstance: +1 per tick under water, -2 out of it. - if let Some((id, fade)) = self.underwater_loop.as_mut() { - if *fade >= 0 { - *fade += if ctx.underwater { 1 } else { -2 }; - *fade = (*fade).min(40); - out.set_volume(*id, (*fade as f32 / 40.0).clamp(0.0, 1.0)); - } else { - out.stop(*id); - self.underwater_loop = None; - } - } - // UnderLiquidSubSound: stops when the player leaves the water. - self.sub_sounds.retain(|&id| { - let keep = ctx.underwater && out.is_active(id); - if !keep { - out.stop(id); - } - keep - }); - } } #[cfg(test)] mod tests { use super::*; + use crate::sound_engine::{Bound, TickContext, test_backend::Null}; + use crate::sound_events::SoundRegistry; - #[derive(Default)] - struct Fake { - next: u64, - live: HashMap, - at: Vec, - } - impl AmbientOutput for Fake { - fn play_tracked(&mut self, event: &str, volume: f32, _looping: bool) -> Option { - self.next += 1; - self.live.insert(self.next, (event.to_owned(), volume)); - Some(self.next) - } - fn set_volume(&mut self, id: u64, volume: f32) { - if let Some(v) = self.live.get_mut(&id) { - v.1 = volume; - } - } - fn stop(&mut self, id: u64) { - self.live.remove(&id); - } - fn is_active(&self, id: u64) -> bool { - self.live.contains_key(&id) - } - fn play_at(&mut self, event: &str, _at: [f64; 3]) { - self.at.push(event.to_owned()); - } + fn engine() -> SoundEngine { + let mut registry = SoundRegistry::default(); + registry.add_file( + "minecraft", + br#"{"crimson": {"sounds": ["c"]}, "warped": {"sounds": ["w"]}, + "ambient.cave": {"sounds": ["a", "b"]}, + "ambient.underwater.loop": {"sounds": ["u"]}, + "ambient.underwater.enter": {"sounds": ["e"]}, + "ambient.underwater.exit": {"sounds": ["x"]}}"#, + &|_, _| true, + ); + SoundEngine::new(registry) } fn ctx<'a>( sounds: &'a AmbientSounds, @@ -382,49 +307,58 @@ mod tests { position: [0.5, 10.0, 0.5], eye_y: 11.62, underwater, + spectator: false, light, } } #[test] fn loops_cross_fade_over_forty_ticks() { + let (mut engine, mut backend) = (engine(), Null::default()); let mut a = Ambience::new(1); - let mut out = Fake::default(); - let dark = |_: [i32; 3]| (15u8, 0u8); + let lit = |_: [i32; 3]| (15u8, 0u8); let crimson = AmbientSounds { - r#loop: Some("crimson".into()), + r#loop: Some("minecraft:crimson".into()), ..Default::default() }; - for _ in 0..40 { - a.tick(&ctx(&crimson, false, &dark), &mut out); - } - assert_eq!(out.live.values().map(|v| v.1).collect::>(), [1.0]); let warped = AmbientSounds { - r#loop: Some("warped".into()), + r#loop: Some("minecraft:warped".into()), ..Default::default() }; + let tick = + |a: &mut Ambience, s: &AmbientSounds, engine: &mut SoundEngine, backend: &mut Null| { + a.tick( + &ctx(s, false, &lit), + &mut Bound { + engine: &mut *engine, + backend: &mut *backend, + }, + ); + engine.tick(false, &TickContext::default(), backend); + }; + for _ in 0..40 { + tick(&mut a, &crimson, &mut engine, &mut backend); + } for _ in 0..20 { - a.tick(&ctx(&warped, false, &dark), &mut out); + tick(&mut a, &warped, &mut engine, &mut backend); } - let mut volumes: Vec<_> = out.live.values().map(|v| (v.0.clone(), v.1)).collect(); - volumes.sort_by(|x, y| x.0.cmp(&y.0)); - assert_eq!( - volumes, - [("crimson".to_owned(), 0.5), ("warped".to_owned(), 0.5)] - ); + let volumes: Vec = a + .loops + .iter() + .map(|(_, id)| engine.instance(*id).unwrap().volume) + .collect(); + assert_eq!(volumes, [0.5, 0.5]); for _ in 0..30 { - a.tick(&ctx(&warped, false, &dark), &mut out); + tick(&mut a, &warped, &mut engine, &mut backend); } - assert_eq!( - out.live.values().map(|v| v.0.as_str()).collect::>(), - ["warped"] - ); + assert_eq!(a.loops.len(), 1); } #[test] fn mood_builds_in_the_dark_and_plays_a_cave_sound() { + let (mut engine, mut backend) = (engine(), Null::default()); + engine.listening = true; let mut a = Ambience::new(2); - let mut out = Fake::default(); let cave = |_: [i32; 3]| (0u8, 0u8); let sounds = AmbientSounds { mood: Some(Mood { @@ -435,31 +369,19 @@ mod tests { }), ..Default::default() }; - // Block light 0: +1/6000 per tick (float), so the sound plays around tick 6000. let mut ticks = 0; - while out.at.is_empty() && ticks < 7000 { - a.tick(&ctx(&sounds, false, &cave), &mut out); + while engine.notifications.is_empty() && ticks < 7000 { + a.tick( + &ctx(&sounds, false, &cave), + &mut Bound { + engine: &mut engine, + backend: &mut backend, + }, + ); ticks += 1; } assert!((5990..=6010).contains(&ticks), "{ticks}"); - assert_eq!(out.at, ["minecraft:ambient.cave"]); + assert_eq!(engine.notifications[0].identifier, "minecraft:ambient.cave"); assert_eq!(a.moodiness, 0.0); } - - #[test] - fn entering_water_plays_enter_and_fades_the_loop_in() { - let mut a = Ambience::new(3); - let mut out = Fake::default(); - let lit = |_: [i32; 3]| (15u8, 0u8); - let none = AmbientSounds::default(); - a.tick(&ctx(&none, true, &lit), &mut out); - assert_eq!(out.at, ["minecraft:ambient.underwater.enter"]); - let id = a.underwater_loop.unwrap().0; - assert_eq!(out.live[&id].1, 1.0 / 40.0); - a.tick(&ctx(&none, false, &lit), &mut out); - assert_eq!(out.at.last().unwrap(), "minecraft:ambient.underwater.exit"); - // Fade 1 -> -1 stops on the next tick. - a.tick(&ctx(&none, false, &lit), &mut out); - assert!(!out.live.contains_key(&id)); - } } diff --git a/crates/horizon-client/src/audio.rs b/crates/horizon-client/src/audio.rs index d673d4031..773bf064d 100644 --- a/crates/horizon-client/src/audio.rs +++ b/crates/horizon-client/src/audio.rs @@ -1,9 +1,16 @@ -//! Sound playback: `sounds.json` events with weighted variants, Ogg/Vorbis -//! decoding, and a small mixer with vanilla's linear distance attenuation -//! (`SoundInstance.Attenuation.LINEAR`, default range 16 blocks) and stereo panning. +//! Sound playback: vanilla's `SoundEngine` bookkeeping (`sound_engine`) over a +//! small mixer standing in for OpenAL: one channel per source with its gain, +//! pitch, linear distance attenuation (`AL_LINEAR_DISTANCE`, reference 0, +//! rolloff 1), looping, relative flag and source state, Ogg/Vorbis decoding +//! (streams on a worker thread) and stereo panning. use crate::Result; +use crate::sound_engine::{ + Attenuation, Backend, Bound, ChannelId, InstanceId, PlayResult, SoundEngine, SoundInstance, + Sounds, TickContext, +}; +use crate::sound_events::{Sound, SoundRegistry}; use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; -use serde_json::Value; +use horizon_core::random::{LegacyRandom, RandomSource}; use std::{ collections::HashMap, fs, @@ -11,46 +18,32 @@ use std::{ sync::{Arc, Mutex}, }; -#[derive(Clone, Debug)] -struct Variant { - name: String, - volume: f32, - pitch: f32, - weight: u32, - attenuation: f32, - is_event: bool, +/// An OpenAL source's state. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum State { + Initial, + Playing, + Paused, + Stopped, } -struct Voice { - samples: Arc>, +/// An OpenAL source. +struct Channel { + samples: Option<(Arc>, u32)>, position: f64, - step: f64, - left: f32, - right: f32, - /// The sound event and `SoundSource` index (what `/stopsound` matches). - event: Arc, - source: usize, + state: State, + gain: f32, + pitch: f32, + /// `AL_LINEAR_DISTANCE` max distance, or no attenuation. + linear: Option, + looping: bool, + at: [f32; 3], + relative: bool, } #[derive(Default)] struct Mixer { - voices: Vec, - /// The streaming music track (`SoundSource.MUSIC`), kept apart from the - /// voice cap and scaled by `music_gain` (MusicManager's fade). - music: Option, - music_gain: f32, - /// Tickable sound instances the game keeps a handle to (ambient loops). - tracked: Vec, -} -struct Tracked { - id: u64, - voice: Voice, - looping: bool, - volume: f32, -} -/// The current music track: decoding on a worker until the voice exists. -struct MusicTrack { - event: String, - /// Set by the decoder thread once the voice is in the mixer (or failed). - ready: Arc, + channels: HashMap, + listener: [f64; 3], + listener_yaw: f32, } /// A sound the player could have heard (`SoundEventListener.onPlaySound`): /// what the subtitle overlay needs. @@ -58,30 +51,31 @@ struct MusicTrack { pub struct Heard { /// The `subtitle` translation key of the sound event. pub subtitle: String, - /// Where it played (None = relative to the listener, e.g. UI sounds). + /// The instance's position (relative sounds report their raw coordinates). pub at: Option<[f64; 3]>, /// `SoundEngine.getRange`: infinite for relative and non-attenuated sounds. pub range: f32, pub looping: bool, } +/// The mixer side of the engine (`Backend`). +pub struct MixerBackend { + mixer: Arc>, + root: PathBuf, + cache: HashMap>, u32)>>, + next: ChannelId, + live: bool, +} pub struct Audio { _stream: Option, - /// `subtitle` keys of `sounds.json` events. - subtitles: HashMap, + pub engine: SoundEngine, + backend: MixerBackend, /// Record `Heard` sounds (the subtitle overlay is listening). pub record_heard: bool, - heard: Vec, - mixer: Arc>, - rate: u32, - root: PathBuf, - events: HashMap>, - cache: HashMap>, u32)>>, - seed: u64, pub listener: [f64; 3], pub listener_yaw: f32, pub master: f32, - music: Option, - next_tracked: u64, + /// Seeds of positional plays (the client level random's `nextLong`). + random: LegacyRandom, /// A `SoundSource` index the next sound plays on (`/playsound`). source_override: Option, /// Positional sounds played since the last drain, kept while the world @@ -130,75 +124,242 @@ fn decode(path: &Path) -> Option<(Vec, u32)> { } Some((mono, rate)) } -impl Audio { - pub fn new(root: &Path) -> Self { - let mut events = HashMap::new(); - let mut subtitles = HashMap::new(); - if let Ok(text) = fs::read(root.join("assets/minecraft/sounds.json")) - && let Ok(Value::Object(map)) = serde_json::from_slice::(&text) +impl MixerBackend { + fn with(&self, channel: ChannelId, f: impl FnOnce(&mut Channel)) { + if let Ok(mut m) = self.mixer.lock() + && let Some(c) = m.channels.get_mut(&channel) { - for (name, def) in map { - let variants = def["sounds"] - .as_array() - .into_iter() - .flatten() - .map(|s| match s { - Value::String(n) => Variant { - name: n.clone(), - volume: 1.0, - pitch: 1.0, - weight: 1, - attenuation: 16.0, - is_event: false, - }, - _ => Variant { - name: s["name"].as_str().unwrap_or("").to_owned(), - volume: s["volume"].as_f64().unwrap_or(1.0) as f32, - pitch: s["pitch"].as_f64().unwrap_or(1.0) as f32, - weight: s["weight"].as_u64().unwrap_or(1) as u32, - attenuation: s["attenuation_distance"].as_f64().unwrap_or(16.0) as f32, - is_event: s["type"].as_str() == Some("event"), - }, - }) - .collect::>(); - if let Some(key) = def["subtitle"].as_str() { - subtitles.insert(format!("minecraft:{name}"), key.to_owned()); - } - events.insert(format!("minecraft:{name}"), variants); - } + f(c); } - let mixer = Arc::new(Mutex::new(Mixer { - music_gain: 1.0, - ..Mixer::default() - })); - let (stream, rate) = match Self::open(mixer.clone()) { - Ok(v) => (Some(v.0), v.1), - Err(e) => { - eprintln!("Horizon: audio unavailable: {e}"); - (None, 48_000) + } +} +impl Backend for MixerBackend { + fn create(&mut self, _streaming: bool) -> Option { + self.next += 1; + let id = self.next; + self.mixer.lock().ok()?.channels.insert( + id, + Channel { + samples: None, + position: 0.0, + state: State::Initial, + gain: 1.0, + pitch: 1.0, + linear: None, + looping: false, + at: [0.0; 3], + relative: false, + }, + ); + Some(id) + } + fn destroy(&mut self, channel: ChannelId) { + if let Ok(mut m) = self.mixer.lock() { + m.channels.remove(&channel); + } + } + fn set_pitch(&mut self, channel: ChannelId, pitch: f32) { + self.with(channel, |c| c.pitch = pitch); + } + fn set_volume(&mut self, channel: ChannelId, volume: f32) { + self.with(channel, |c| c.gain = volume); + } + fn set_attenuation(&mut self, channel: ChannelId, linear: Option) { + self.with(channel, |c| c.linear = linear); + } + fn set_looping(&mut self, channel: ChannelId, looping: bool) { + self.with(channel, |c| c.looping = looping); + } + fn set_position(&mut self, channel: ChannelId, p: [f64; 3]) { + self.with(channel, |c| c.at = [p[0] as f32, p[1] as f32, p[2] as f32]); + } + fn set_relative(&mut self, channel: ChannelId, relative: bool) { + self.with(channel, |c| c.relative = relative); + } + /// `getCompleteBuffer` (decoded now, cached) or `getStream` (decoded on a + /// worker), then attach and `alSourcePlay`. A sound that cannot load + /// leaves its source initial, as a failed buffer future does in vanilla. + fn start(&mut self, channel: ChannelId, sound: &Sound, looping: bool) { + if !self.live { + return; + } + let (namespace, path) = sound.path(); + let file = self.root.join("assets").join(namespace).join(&path); + let attach = move |mixer: &Mutex, samples: Option<(Arc>, u32)>| { + if let Some(samples) = samples + && let Ok(mut m) = mixer.lock() + && let Some(c) = m.channels.get_mut(&channel) + { + c.samples = Some(samples); + c.position = 0.0; + c.state = State::Playing; } }; + if sound.stream { + // A streamed sound loops by restarting its stream. + let mixer = self.mixer.clone(); + std::thread::spawn(move || { + let samples = decode(&file).map(|(s, r)| (Arc::new(s), r)); + if looping + && let Ok(mut m) = mixer.lock() + && let Some(c) = m.channels.get_mut(&channel) + { + c.looping = true; + } + attach(&mixer, samples); + }); + } else { + let samples = self + .cache + .entry(format!("{namespace}:{path}")) + .or_insert_with(|| decode(&file).map(|(s, r)| (Arc::new(s), r))) + .clone(); + attach(&self.mixer, samples); + } + } + fn stop(&mut self, channel: ChannelId) { + self.with(channel, |c| { + if c.state != State::Initial { + c.state = State::Stopped; + } + }); + } + fn pause(&mut self, channel: ChannelId) { + self.with(channel, |c| { + if c.state == State::Playing { + c.state = State::Paused; + } + }); + } + fn unpause(&mut self, channel: ChannelId) { + self.with(channel, |c| { + if c.state == State::Paused { + c.state = State::Playing; + } + }); + } + fn stopped(&mut self, channel: ChannelId) -> bool { + self.mixer + .lock() + .map(|m| { + m.channels + .get(&channel) + .is_none_or(|c| c.state == State::Stopped) + }) + .unwrap_or(true) + } +} +/// The gain OpenAL applies for distance (`AL_LINEAR_DISTANCE` with reference +/// distance 0 and rolloff 1: the distance clamps to the max distance). +fn distance_gain(linear: Option, distance: f32) -> f32 { + match linear { + None => 1.0, + Some(max) if max > 0.0 => (1.0 - distance.min(max) / max).clamp(0.0, 1.0), + Some(_) => 0.0, + } +} +fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) { + data.fill(0.0); + let listener = mixer.listener; + let yaw = mixer.listener_yaw.to_radians(); + // Gains and pans per source for this buffer. + let mut voices: Vec<(ChannelId, f32, f32, f64)> = Vec::new(); + for (id, c) in &mixer.channels { + let Some((_, source_rate)) = &c.samples else { + continue; + }; + if c.state != State::Playing { + continue; + } + let d = if c.relative { + [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])] + } else { + [ + f64::from(c.at[0]) - listener[0], + f64::from(c.at[1]) - listener[1], + f64::from(c.at[2]) - listener[2], + ] + }; + let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32; + let gain = c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance); + // The listener's right vector for a Minecraft yaw. + let side = if c.relative { + (d[0] as f32) / distance.max(0.001) + } else { + (-(yaw.cos()) as f64 * d[0] - (yaw.sin()) as f64 * d[2]) as f32 / distance.max(0.001) + }; + let pan = side.clamp(-1.0, 1.0); + let left = gain * (1.0 - pan.max(0.0) * 0.6); + let right = gain * (1.0 + pan.min(0.0) * 0.6); + let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0)); + voices.push((*id, left, right, step)); + } + for (id, left, right, step) in voices { + let Some(c) = mixer.channels.get_mut(&id) else { + continue; + }; + let Some((samples, _)) = c.samples.clone() else { + continue; + }; + for frame in data.chunks_mut(channels) { + let mut i = c.position as usize; + if i + 1 >= samples.len() { + if c.looping && samples.len() > 1 { + c.position = 0.0; + i = 0; + } else { + c.state = State::Stopped; + break; + } + } + let t = (c.position - i as f64) as f32; + let s = samples[i] * (1.0 - t) + samples[i + 1] * t; + if channels >= 2 { + frame[0] += s * left; + frame[1] += s * right; + } else { + frame[0] += s * (left + right) / 2.0; + } + c.position += step; + } + } + for s in data.iter_mut() { + *s = s.clamp(-1.0, 1.0); + } +} +impl Audio { + pub fn new(root: &Path) -> Self { + let registry = SoundRegistry::load(root); + let mixer = Arc::new(Mutex::new(Mixer::default())); + let (stream, live) = match Self::open(mixer.clone()) { + Ok(v) => (Some(v), true), + Err(e) => { + eprintln!("Horizon: audio unavailable: {e}"); + (None, false) + } + }; + let mut engine = SoundEngine::new(registry); + engine.loaded = live; Self { _stream: stream, - subtitles, + engine, + backend: MixerBackend { + mixer, + root: root.to_owned(), + cache: HashMap::new(), + next: 0, + live, + }, record_heard: false, - heard: Vec::new(), - mixer, - rate, - root: root.to_owned(), - events, - cache: HashMap::new(), - seed: 0x5DEE_CE66, listener: [0.0; 3], listener_yaw: 0.0, master: 1.0, - music: None, - next_tracked: 0, + random: LegacyRandom::new(crate::sound_engine::unique_seed()), source_override: None, capture: None, } } - fn open(mixer: Arc>) -> Result<(cpal::Stream, u32)> { + fn open(mixer: Arc>) -> Result { let host = cpal::default_host(); let device = host .default_output_device() @@ -209,269 +370,110 @@ impl Audio { let stream = device.build_output_stream( &config.into(), move |data: &mut [f32], _| { - data.fill(0.0); - let Ok(mut mixer) = mixer.lock() else { return }; - for frame in data.chunks_mut(channels) { - let (mut l, mut r) = (0.0f32, 0.0f32); - for v in mixer.voices.iter_mut() { - let i = v.position as usize; - if i + 1 >= v.samples.len() { - continue; - } - let t = (v.position - i as f64) as f32; - let s = v.samples[i] * (1.0 - t) + v.samples[i + 1] * t; - l += s * v.left; - r += s * v.right; - v.position += v.step; - } - for t in mixer.tracked.iter_mut() { - let v = &mut t.voice; - let mut i = v.position as usize; - if t.looping && i + 1 >= v.samples.len() { - v.position = 0.0; - i = 0; - } - if i + 1 < v.samples.len() { - let f = (v.position - i as f64) as f32; - let s = (v.samples[i] * (1.0 - f) + v.samples[i + 1] * f) * t.volume; - l += s * v.left; - r += s * v.right; - v.position += v.step; - } - } - let gain = mixer.music_gain; - if let Some(v) = mixer.music.as_mut() { - let i = v.position as usize; - if i + 1 < v.samples.len() { - let t = (v.position - i as f64) as f32; - let s = (v.samples[i] * (1.0 - t) + v.samples[i + 1] * t) * gain; - l += s * v.left; - r += s * v.right; - v.position += v.step; - } - } - if channels >= 2 { - frame[0] = l.clamp(-1.0, 1.0); - frame[1] = r.clamp(-1.0, 1.0); - } else { - frame[0] = ((l + r) / 2.0).clamp(-1.0, 1.0); - } - } - mixer - .voices - .retain(|v| (v.position as usize) + 1 < v.samples.len()); - mixer.tracked.retain(|t| { - t.looping || (t.voice.position as usize) + 1 < t.voice.samples.len() - }); - if mixer - .music - .as_ref() - .is_some_and(|v| (v.position as usize) + 1 >= v.samples.len()) - { - mixer.music = None; + if let Ok(mut m) = mixer.lock() { + mix(&mut m, data, channels, rate); + } else { + data.fill(0.0); } }, |e| eprintln!("Horizon: audio stream error: {e}"), None, )?; stream.play()?; - Ok((stream, rate)) + Ok(stream) } - fn random(&mut self) -> u64 { - self.seed ^= self.seed << 13; - self.seed ^= self.seed >> 7; - self.seed ^= self.seed << 17; - self.seed - } - fn resolve(&mut self, event: &str, depth: u32) -> Option { - let variants = self.events.get(event)?.clone(); - let total: u32 = variants.iter().map(|v| v.weight).sum(); - if total == 0 { - return None; + fn bound(&mut self) -> Bound<'_, MixerBackend> { + Bound { + engine: &mut self.engine, + backend: &mut self.backend, } - let mut pick = (self.random() % u64::from(total)) as u32; - let chosen = variants.into_iter().find(|v| { - if pick < v.weight { - true - } else { - pick -= v.weight; - false + } + /// `SoundManager.updateSource`: the camera position and yaw. + pub fn set_listener(&mut self, position: [f64; 3], yaw: f32) { + self.listener = position; + self.listener_yaw = yaw; + if let Ok(mut m) = self.backend.mixer.lock() { + m.listener = position; + m.listener_yaw = yaw; + } + } + /// Sync the volume options, refreshing the categories that changed + /// (the option sliders' `refreshCategoryVolume`). + fn sync_volumes(&mut self) { + let mut volumes = [self.master; 11]; + for (i, v) in volumes.iter_mut().enumerate().skip(1) { + *v = crate::settings::source_volume(i); + } + for source in 0..11 { + if self.engine.source_volumes[source] != volumes[source] { + self.engine.source_volumes[source] = volumes[source]; + self.engine + .refresh_category_volume(source, &mut self.backend); } - })?; - if chosen.is_event && depth < 4 { - let name = if chosen.name.contains(':') { - chosen.name.clone() - } else { - format!("minecraft:{}", chosen.name) - }; - let mut inner = self.resolve(&name, depth + 1)?; - inner.volume *= chosen.volume; - inner.pitch *= chosen.pitch; - return Some(inner); } - Some(chosen) + self.engine.listening = self.record_heard; } - /// Play a sound event at a world position (None = non-positional UI sound). + /// `SoundManager.tick(paused)`, once per client tick. + pub fn tick(&mut self, paused: bool, ctx: &TickContext) { + self.sync_volumes(); + self.engine.tick(paused, ctx, &mut self.backend); + } + /// `SoundManager.pauseAllExcept(MUSIC, UI)`. + pub fn pause(&mut self) { + self.engine.pause_all_except( + &[crate::sound_engine::MUSIC, crate::sound_engine::UI], + &mut self.backend, + ); + } + /// `SoundManager.resume`. + pub fn resume(&mut self) { + self.engine.resume(&mut self.backend); + } + /// `SoundManager.stop()`: every sound. + pub fn stop_all(&mut self) { + self.engine.stop_all(&mut self.backend); + } + /// Play a sound event at a world position, as `ClientLevel.playLocalSound` + /// (a `SimpleSoundInstance` seeded from the level random), or relative to + /// the listener without attenuation (`None`). pub fn play(&mut self, event: &str, at: Option<[f64; 3]>, volume: f32, pitch: f32) { + let seed = self.random.next_long(); + self.play_seeded(event, at, volume, pitch, seed); + } + /// `play` with the seed a sound packet carries. + pub fn play_seeded( + &mut self, + event: &str, + at: Option<[f64; 3]>, + volume: f32, + pitch: f32, + seed: i64, + ) { if let (Some(capture), Some(at)) = (self.capture.as_mut(), at) { capture.push((event.to_owned(), at, volume, pitch)); } - let Some(variant) = self.resolve(event, 0) else { - return; - }; - if self.record_heard - && let Some(key) = self.subtitles.get(event) - { - let range = if at.is_some() { - variant.attenuation * volume.max(1.0) - } else { - f32::INFINITY - }; - self.heard.push(Heard { - subtitle: key.clone(), - at, - range, - looping: false, - }); - } - if self._stream.is_none() { - return; - } - let file = variant.name.trim_start_matches("minecraft:").to_owned(); - let entry = self.cache.entry(file.clone()).or_insert_with(|| { - decode( - &self - .root - .join(format!("assets/minecraft/sounds/{file}.ogg")), - ) - .map(|(s, r)| (Arc::new(s), r)) - }); - let Some((samples, rate)) = entry.clone() else { - return; - }; + self.sync_volumes(); + let event = crate::sound_events::normalize(event); let source = self .source_override - .unwrap_or_else(|| crate::settings::sound_source(event)); - let volume = (volume * variant.volume).clamp(0.0, 1.0) - * self.master - * crate::settings::source_volume(source); - let pitch = (pitch * variant.pitch).clamp(0.5, 2.0); - let (mut left, mut right) = (volume, volume); - if let Some(p) = at { - let d = [ - p[0] - self.listener[0], - p[1] - self.listener[1], - p[2] - self.listener[2], - ]; - let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32; - let range = variant.attenuation * volume.max(1.0); - let gain = (1.0 - distance / range).clamp(0.0, 1.0); - if gain <= 0.0 { - return; - } - let yaw = self.listener_yaw.to_radians(); - // Right vector of a Minecraft yaw. - let side = (-(yaw.cos()) as f64 * d[0] - (yaw.sin()) as f64 * d[2]) as f32 - / distance.max(0.001); - let pan = side.clamp(-1.0, 1.0); - left = volume * gain * (1.0 - pan.max(0.0) * 0.6); - right = volume * gain * (1.0 + pan.min(0.0) * 0.6); - } - let step = f64::from(rate) / f64::from(self.rate) * f64::from(pitch); - if let Ok(mut m) = self.mixer.lock() { - if m.voices.len() > 64 { - m.voices.remove(0); - } - m.voices.push(Voice { - samples, - position: 0.0, - step, - left, - right, - event: event.into(), + .unwrap_or_else(|| crate::settings::sound_source(&event)); + let random = LegacyRandom::new(seed); + let instance = match at { + Some(at) => SoundInstance::at(&event, source, volume, pitch, random, at), + None => SoundInstance::new( + &event, source, - }); - } - } - /// `SoundManager.play` of a music instance (`SimpleSoundInstance.forMusic`: - /// non-positional, streamed). Decoding runs on a worker thread; the track - /// counts as active from now on. Returns false when nothing can play. - pub fn play_music(&mut self, event: &str) -> bool { - self.stop_music(); - if self._stream.is_none() { - return false; - } - let Some(variant) = self.resolve(event, 0) else { - return false; + volume, + pitch, + random, + false, + 0, + Attenuation::None, + [0.0; 3], + true, + ), }; - let path = self.root.join(format!( - "assets/minecraft/sounds/{}.ogg", - variant.name.trim_start_matches("minecraft:") - )); - let volume = - variant.volume.clamp(0.0, 1.0) * self.master * crate::settings::event_volume(event); - let step_scale = f64::from(variant.pitch.clamp(0.5, 2.0)) / f64::from(self.rate); - let ready = Arc::new(std::sync::atomic::AtomicBool::new(false)); - let (mixer, done) = (self.mixer.clone(), ready.clone()); - let music_event = event.to_owned(); - std::thread::spawn(move || { - if let Some((samples, rate)) = decode(&path) - && let Ok(mut m) = mixer.lock() - && !done.load(std::sync::atomic::Ordering::Acquire) - { - m.music = Some(Voice { - samples: Arc::new(samples), - position: 0.0, - step: f64::from(rate) * step_scale, - left: volume, - right: volume, - event: music_event.as_str().into(), - source: 1, - }); - } - done.store(true, std::sync::atomic::Ordering::Release); - }); - self.music = Some(MusicTrack { - event: event.to_owned(), - ready, - }); - true - } - /// `SoundManager.stop` of the music instance. - pub fn stop_music(&mut self) { - if let Some(track) = self.music.take() { - // A decoder still running sees the flag and drops its result. - track - .ready - .store(true, std::sync::atomic::Ordering::Release); - } - if let Ok(mut m) = self.mixer.lock() { - m.music = None; - } - } - /// `SoundManager.isActive`: decoding or still sounding. - pub fn music_active(&mut self) -> bool { - let Some(track) = &self.music else { - return false; - }; - if !track.ready.load(std::sync::atomic::Ordering::Acquire) { - return true; - } - let playing = self.mixer.lock().is_ok_and(|m| m.music.is_some()); - if !playing { - self.music = None; - } - playing - } - /// The event of the current music track. - pub fn music_event(&self) -> Option<&str> { - self.music.as_ref().map(|t| t.event.as_str()) - } - /// Every sound event id (for command completion). - pub fn event_names(&self) -> Vec { - let mut v: Vec = self.events.keys().cloned().collect(); - v.sort(); - v + self.play_instance(instance, false); } /// Play a sound on a given `SoundSource` index (`/playsound`). pub fn play_on( @@ -486,102 +488,67 @@ impl Audio { self.play(event, at, volume, pitch); self.source_override = None; } + /// `SimpleSoundInstance.forJukeboxSong` at a jukebox; the handle stays + /// until `release`. + pub fn play_jukebox_song(&mut self, event: &str, pos: [i32; 3]) -> InstanceId { + let at = [ + f64::from(pos[0]) + 0.5, + f64::from(pos[1]) + 0.5, + f64::from(pos[2]) + 0.5, + ]; + let event = crate::sound_events::normalize(event); + let instance = SoundInstance::for_jukebox_song(&event, at, SoundEngine::unseeded()); + self.play_instance(instance, true).0 + } + /// Stop and drop a held instance. + pub fn stop_and_release(&mut self, id: InstanceId) { + self.stop_instance(id); + self.release(id); + } + /// Every sound event id (for command completion). + pub fn event_names(&self) -> Vec { + let mut v: Vec = self.engine.registry.names().cloned().collect(); + v.sort(); + v + } /// `ClientboundStopSoundPacket`: stop the playing sounds of an event /// and/or a source. pub fn stop_sounds(&mut self, event: Option<&str>, source: Option) { - let matches = |v: &Voice| { - event.is_none_or(|e| &*v.event == e) && source.is_none_or(|s| v.source == s) - }; - if let Ok(mut m) = self.mixer.lock() { - m.voices.retain(|v| !matches(v)); - m.tracked.retain(|t| !matches(&t.voice)); - if m.music.as_ref().is_some_and(matches) { - m.music = None; - } - } - if self - .music - .as_ref() - .is_some_and(|t| event.is_none_or(|e| t.event == e) && source.is_none_or(|s| s == 1)) - { - self.music = None; - } + let event = event.map(crate::sound_events::normalize); + self.engine + .stop_matching(event.as_deref(), source, &mut self.backend); } /// The sounds played since the last call, for the subtitle overlay. pub fn take_heard(&mut self) -> Vec { - std::mem::take(&mut self.heard) - } - /// `SoundManager.updateCategoryVolume(MUSIC, gain)`. - pub fn set_music_gain(&mut self, gain: f32) { - if let Ok(mut m) = self.mixer.lock() { - m.music_gain = gain; - } - } - /// Play a relative (non-positional) tickable sound instance the caller - /// keeps a handle to: ambient loops (`looping`) and sub-sounds. - pub fn play_tracked(&mut self, event: &str, volume: f32, looping: bool) -> Option { - let variant = self.resolve(event, 0)?; - if self.record_heard - && let Some(key) = self.subtitles.get(event) - { - self.heard.push(Heard { - subtitle: key.clone(), - at: None, - range: f32::INFINITY, - looping, - }); - } - self._stream.as_ref()?; - let file = variant.name.trim_start_matches("minecraft:").to_owned(); - let root = &self.root; - let (samples, rate) = self - .cache - .entry(file.clone()) - .or_insert_with(|| { - decode(&root.join(format!("assets/minecraft/sounds/{file}.ogg"))) - .map(|(s, r)| (Arc::new(s), r)) + std::mem::take(&mut self.engine.notifications) + .into_iter() + .filter_map(|n| { + Some(Heard { + subtitle: n.subtitle?, + at: Some(n.position), + range: n.range, + looping: n.looping, + }) }) - .clone()?; - let gain = - variant.volume.clamp(0.0, 1.0) * self.master * crate::settings::event_volume(event); - let step = - f64::from(rate) / f64::from(self.rate) * f64::from(variant.pitch.clamp(0.5, 2.0)); - self.next_tracked += 1; - let id = self.next_tracked; - let mut m = self.mixer.lock().ok()?; - m.tracked.push(Tracked { - id, - voice: Voice { - samples, - position: 0.0, - step, - left: gain, - right: gain, - event: event.into(), - source: crate::settings::sound_source(event), - }, - looping, - volume: volume.clamp(0.0, 1.0), - }); - Some(id) - } - /// A tracked instance's volume (`AbstractTickableSoundInstance.volume`). - pub fn set_tracked_volume(&mut self, id: u64, volume: f32) { - if let Ok(mut m) = self.mixer.lock() - && let Some(t) = m.tracked.iter_mut().find(|t| t.id == id) - { - t.volume = volume.clamp(0.0, 1.0); - } - } - pub fn stop_tracked(&mut self, id: u64) { - if let Ok(mut m) = self.mixer.lock() { - m.tracked.retain(|t| t.id != id); - } - } - /// Still sounding (a finished one-shot is gone). - pub fn tracked_active(&self, id: u64) -> bool { - self.mixer - .lock() - .is_ok_and(|m| m.tracked.iter().any(|t| t.id == id)) + .collect() + } +} +impl Sounds for Audio { + fn engine(&mut self) -> &mut SoundEngine { + &mut self.engine + } + fn play_instance(&mut self, instance: SoundInstance, retain: bool) -> (InstanceId, PlayResult) { + self.sync_volumes(); + self.bound().play_instance(instance, retain) + } + fn play_id(&mut self, id: InstanceId) -> PlayResult { + self.sync_volumes(); + self.bound().play_id(id) + } + fn stop_instance(&mut self, id: InstanceId) { + self.bound().stop_instance(id); + } + fn update_category_volume(&mut self, source: usize, gain: f32) { + self.bound().update_category_volume(source, gain); } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b81c403fd..2fdaa712c 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -594,6 +594,8 @@ struct Game<'a> { audio: Audio, music: horizon_client::music::MusicManager, ambience: horizon_client::ambience::Ambience, + /// The sound engine was told the game paused (pauseAllExcept). + sound_paused: bool, dropped: Vec, next_entity: u32, particles: horizon_client::particles::ParticleEngine, @@ -5706,6 +5708,10 @@ impl Game<'_> { } fn close_world(&mut self) -> Result<()> { self.ambience.clear(&mut self.audio); + // updateLevelInEngines(null): every sound stops; the music manager + // lets go of its track. + self.music.stop_playing(None, &mut self.audio); + self.audio.stop_all(); if self.remote.is_some() { return self.leave_server(None); } @@ -7409,8 +7415,8 @@ impl Game<'_> { self.pitch, ), }; - self.audio.listener = [camera.x, camera.y, camera.z]; - self.audio.listener_yaw = view_yaw; + self.audio + .set_listener([camera.x, camera.y, camera.z], view_yaw); let block = [ camera.x.floor() as i32, camera.y.floor() as i32, @@ -8209,6 +8215,7 @@ impl ApplicationHandler for Game<'_> { self.tick_fov(); } self.tick_music(); + self.tick_sound_engine(); self.clock.record(started.elapsed()); if let Some(report) = self.clock.take_sprint_report() { self.sprint_report(&report); @@ -8507,6 +8514,7 @@ pub fn run() -> Result<()> { audio, music: Default::default(), ambience: Default::default(), + sound_paused: false, dropped: Vec::new(), next_entity: 0, particles, diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index b6f8c157d..60fbc737c 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -509,7 +509,7 @@ impl Game<'_> { "frames": self.frames, "ticks": self.ticks, "day_time": self.world.day_time, - "music": self.music.current(), + "music": self.music.current(&self.audio.engine), "fishing": self.hook_status(), "tridents": self.tridents.len(), "rockets": self.rockets.len(), diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs index e321a599b..f721e2352 100644 --- a/crates/horizon-client/src/game/jukebox.rs +++ b/crates/horizon-client/src/game/jukebox.rs @@ -12,9 +12,6 @@ use horizon_client::{ use horizon_core::{position::BlockPos, random::RandomSource}; use horizon_world::level::flags as level_flags; -/// Linear attenuation range of a song (`SimpleSoundInstance.forJukeboxSong`: volume 4). -const RANGE: f64 = 64.0; - impl Game<'_> { fn jukebox(&self, pos: [i32; 3]) -> Option<&Jukebox> { match self.world.block_entities.get(&(pos[0], pos[1], pos[2])) { @@ -101,9 +98,9 @@ impl Game<'_> { let Some(s) = self.res.items.songs.get(song).cloned() else { return; }; - if let Some(id) = self.audio.play_tracked(&s.sound, 0.0, false) { - self.jukebox_sounds.insert((pos[0], pos[1], pos[2]), id); - } + // LevelRenderer.playJukeboxSong: SimpleSoundInstance.forJukeboxSong. + let id = self.audio.play_jukebox_song(&s.sound, pos); + self.jukebox_sounds.insert((pos[0], pos[1], pos[2]), id); let description = horizon_client::component::to_text(&s.description, &mut |k| Text::literal(k)); self.titles @@ -113,7 +110,7 @@ impl Game<'_> { } fn stop_song(&mut self, pos: [i32; 3]) { if let Some(id) = self.jukebox_sounds.remove(&(pos[0], pos[1], pos[2])) { - self.audio.stop_tracked(id); + self.audio.stop_and_release(id); } } /// `popOutTheItem`: the disc above the jukebox, and the song stops. @@ -202,30 +199,20 @@ impl Game<'_> { } self.update_song_volumes(); } - /// Linear distance attenuation of each song at the listener. + /// Let go of songs that ended or whose jukebox stopped. fn update_song_volumes(&mut self) { - let Some(eye) = self.eye_position() else { - return; - }; let sounds: Vec<_> = self .jukebox_sounds .iter() .map(|(k, id)| (*k, *id)) .collect(); for (k, id) in sounds { - if !self.audio.tracked_active(id) + if !self.audio.engine.is_active(id) || !matches!(self.world.block_entities.get(&k), Some(BlockEntity::Jukebox(j)) if j.playing) { - self.audio.stop_tracked(id); + self.audio.stop_and_release(id); self.jukebox_sounds.remove(&k); - continue; } - let d = ((f64::from(k.0) + 0.5 - eye[0]).powi(2) - + (f64::from(k.1) + 0.5 - eye[1]).powi(2) - + (f64::from(k.2) + 0.5 - eye[2]).powi(2)) - .sqrt(); - self.audio - .set_tracked_volume(id, (1.0 - d / RANGE).clamp(0.0, 1.0) as f32); } } } diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs index 6ac336780..a7e054fdb 100644 --- a/crates/horizon-client/src/game/music.rs +++ b/crates/horizon-client/src/game/music.rs @@ -1,6 +1,11 @@ -//! `Minecraft.getSituationalMusic` and `getMusicVolume` for the music manager. +//! `Minecraft.getSituationalMusic` and `getMusicVolume` for the music manager, +//! the local player's ambient sound handlers and the sound engine tick. use super::Game; -use horizon_client::{blocks::Fluid, music::Music}; +use horizon_client::{ + blocks::Fluid, + music::Music, + sound_engine::TickContext, +}; impl Game<'_> { /// `Minecraft.tick` -> `MusicManager.tick`, once per client tick. @@ -11,6 +16,25 @@ impl Game<'_> { self.music .tick(music.as_ref(), volume, loading, &mut self.audio); } + /// `Minecraft.tick` -> `SoundManager.tick(pause)`, after the music, with + /// `pauseAllExcept(MUSIC, UI)` when the game pauses and `resume` when it + /// carries on. + pub(super) fn tick_sound_engine(&mut self) { + if self.pause != self.sound_paused { + if self.pause { + self.audio.pause(); + } else { + self.audio.resume(); + } + self.sound_paused = self.pause; + } + let ctx = TickContext { + player_underwater: self.ambience.was_underwater(), + player_removed: self.player.is_none(), + }; + self.audio.tick(self.pause, &ctx); + } + /// `getSituationalMusic` and `getMusicVolume`. fn situational_music(&self) -> (Option, f32) { // Title screen: no player, Musics.MENU at full volume. if self.title.is_some() { @@ -19,33 +43,44 @@ impl Game<'_> { let Some(eye) = self.eye_position() else { return (Some(Music::menu()), 1.0); }; - let (x, y, z) = ( - eye[0].floor() as i32, - eye[1].floor() as i32, - eye[2].floor() as i32, - ); - let biome = self - .world + let biome = self.biome_at(eye); + let dimension = self.dim.id(); + let tables = &self.res.music; + let volume = tables.volume(dimension, biome); + // Minecraft.getSituationalMusic: the boss overlay's music in the End. + if self.dim == super::Dim::End && self.boss_music() { + return (Some(Music::end_boss()), volume); + } + let music = tables + .background(dimension, biome) + .select(self.creative, self.ambience.was_underwater()) + .cloned(); + (music, volume) + } + /// `BiomeManager.getNoiseBiomeAtPosition`: the quart cell holding a position. + fn biome_at(&self, p: [f64; 3]) -> &str { + let (x, y, z) = (p[0].floor() as i32, p[1].floor() as i32, p[2].floor() as i32); + self.world .chunks .get(&(x >> 4, z >> 4)) .map_or("minecraft:plains", |c| { - self.res.biomes.list[c.biome(x, y, z) as usize] - .name - .as_str() - }); - // Minecraft.getSituationalMusic: the boss bar's music in the End. - if self.boss_music() { - return (Some(Music::end_boss()), 1.0); + self.res.biomes.list[c.biome(x, y, z) as usize].name.as_str() + }) + } + /// `isEyeInFluid(WATER)`: the eye inside the water of its block column. + fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool { + let (bx, by, bz) = (x.floor() as i32, eye_y.floor() as i32, z.floor() as i32); + let f = self.res.facts.get(self.world.block(bx, by, bz)); + if f.fluid != Fluid::Water { + return false; } - let dimension = self.dim.id(); - let tables = &self.res.music; - // Player.isUnderWater: eyes in water. - let underwater = self.res.facts.get(self.world.block(x, y, z)).fluid == Fluid::Water; - let music = tables - .background(dimension, biome) - .select(self.creative, underwater) - .cloned(); - (music, tables.volume(dimension, biome)) + let above = self.res.facts.get(self.world.block(bx, by + 1, bz)); + let height = if above.fluid == Fluid::Water { + 1.0 + } else { + f64::from(f.fluid_level) / 9.0 + }; + eye_y <= f64::from(by) + height } } @@ -57,23 +92,9 @@ impl Game<'_> { }; let feet = [p.position.x, p.position.y, p.position.z]; let eye_y = feet[1] + f64::from(p.dimensions.eye_height); - let (x, z) = (feet[0].floor() as i32, feet[2].floor() as i32); + let sounds = self.res.ambient.get(self.dim.id(), self.biome_at(feet)); + let underwater = self.eye_in_water(feet[0], eye_y, feet[2]); let world = &self.world; - let biome = world - .chunks - .get(&(x >> 4, z >> 4)) - .map_or("minecraft:plains", |c| { - self.res.biomes.list[c.biome(x, feet[1].floor() as i32, z) as usize] - .name - .as_str() - }); - let sounds = self.res.ambient.get(self.dim.id(), biome); - let underwater = self - .res - .facts - .get(world.block(x, eye_y.floor() as i32, z)) - .fluid - == Fluid::Water; let light = |b: [i32; 3]| { let l = world.light(b[0], b[1], b[2]); (l >> 4, l & 15) @@ -83,6 +104,7 @@ impl Game<'_> { position: feet, eye_y, underwater, + spectator: self.spectator(), light: &light, }; self.ambience.tick(&ctx, &mut self.audio); diff --git a/crates/horizon-client/src/music.rs b/crates/horizon-client/src/music.rs index ebc86ac44..94a7f87a0 100644 --- a/crates/horizon-client/src/music.rs +++ b/crates/horizon-client/src/music.rs @@ -2,6 +2,7 @@ //! `Minecraft.getSituationalMusic`, with the `minecraft:audio/background_music` //! and `minecraft:audio/music_volume` environment attributes of dimension //! types and biomes (a biome value overrides its dimension's). +use crate::sound_engine::{InstanceId, MUSIC, PlayResult, SoundEngine, SoundInstance, Sounds}; use horizon_core::random::{LegacyRandom, RandomSource}; use serde_json::Value; use std::{collections::HashMap, fs, path::Path}; @@ -15,7 +16,7 @@ pub struct Music { pub replace_current_music: bool, } impl Music { - fn new(sound: &str, min_delay: i32, max_delay: i32, replace_current_music: bool) -> Self { + pub fn new(sound: &str, min_delay: i32, max_delay: i32, replace_current_music: bool) -> Self { Self { sound: sound.to_owned(), min_delay, @@ -177,45 +178,23 @@ fn next_int(random: &mut LegacyRandom, min: i32, max: i32) -> i32 { random.next_int_bound(max - min + 1).unwrap_or(0) + min } } -/// What the music manager drives (the sound engine's music channel). -pub trait MusicOutput { - /// Start a track; false when nothing can play. - fn play(&mut self, event: &str) -> bool; - fn stop(&mut self); - fn is_active(&mut self) -> bool; - /// `SoundManager.updateCategoryVolume(MUSIC, gain)`. - fn set_gain(&mut self, gain: f32); -} -impl MusicOutput for crate::audio::Audio { - fn play(&mut self, event: &str) -> bool { - self.play_music(event) - } - fn stop(&mut self) { - self.stop_music(); - } - fn is_active(&mut self) -> bool { - self.music_active() - } - fn set_gain(&mut self, gain: f32) { - self.set_music_gain(gain); - } -} /// `MusicManager`. pub struct MusicManager { random: LegacyRandom, - /// The sound event of the current track. - current: Option, + /// `currentMusic`: the instance the manager holds. + current: Option, current_gain: f32, next_song_delay: i32, + toast_shown: bool, pub frequency: MusicFrequency, + /// `ToastManager.showNowPlayingToast` (true) / `hideNowPlayingToast` + /// (false) calls since the last drain. + pub toast_requests: Vec, } impl Default for MusicManager { fn default() -> Self { // RandomSource.create(): seeded from the clock, not the world. - let seed = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .map_or(0, |d| d.as_nanos() as i64); - Self::new(seed) + Self::new(crate::sound_engine::unique_seed()) } } impl MusicManager { @@ -225,35 +204,68 @@ impl MusicManager { current: None, current_gain: 1.0, next_song_delay: 100, + toast_shown: false, frequency: MusicFrequency::Default, + toast_requests: Vec::new(), } } - pub fn current(&self) -> Option<&str> { - self.current.as_deref() + /// The sound event of the current track. + pub fn current<'a>(&self, sounds: &'a SoundEngine) -> Option<&'a str> { + self.current + .and_then(|id| sounds.instance(id)) + .map(|i| i.identifier.as_str()) } - /// `MusicManager.tick` with the situational music and music volume; - /// `loading` holds back a new track (`LevelLoadingScreen`). + pub fn current_instance(&self) -> Option { + self.current + } + pub fn next_song_delay(&self) -> i32 { + self.next_song_delay + } + pub fn current_gain(&self) -> f32 { + self.current_gain + } + pub fn toast_shown(&self) -> bool { + self.toast_shown + } + fn set_current(&mut self, id: Option, sounds: &mut impl Sounds) { + if let Some(old) = self.current + && Some(old) != id + { + sounds.release(old); + } + self.current = id; + } + /// `MusicManager.tick` with `Minecraft.getMusicVolume` and + /// `getSituationalMusic`; `loading` is a `LevelLoadingScreen`. pub fn tick( &mut self, music: Option<&Music>, volume: f32, loading: bool, - out: &mut impl MusicOutput, + sounds: &mut impl Sounds, ) { - if self.current.is_some() && self.current_gain != volume && !self.fade(volume, music, out) { + if self.current.is_some() + && self.current_gain != volume + && !self.fade(volume, music, sounds) + { return; } let Some(music) = music else { self.next_song_delay = self.next_song_delay.max(100); return; }; - if let Some(current) = &self.current { - if music.replace_current_music && music.sound != *current { - out.stop(); + if let Some(current) = self.current { + // canReplace + let playing = sounds + .engine() + .instance(current) + .map(|i| i.identifier.clone()); + if music.replace_current_music && playing.as_deref() != Some(music.sound.as_str()) { + sounds.stop_instance(current); self.next_song_delay = next_int(&mut self.random, 0, music.min_delay / 2); } - if !out.is_active() { - self.current = None; + if !sounds.is_active(current) { + self.set_current(None, sounds); let delay = self .frequency .next_song_delay(Some(music), &mut self.random); @@ -264,35 +276,68 @@ impl MusicManager { if self.current.is_none() && !loading { self.next_song_delay -= 1; if self.next_song_delay <= 0 { - self.start(music, out); + self.start_playing(music, sounds); } } } /// `MusicManager.startPlaying`. - fn start(&mut self, music: &Music, out: &mut impl MusicOutput) { - // The instance is current even if it could not start; the next tick - // finds it inactive and schedules another. - out.play(&music.sound); - self.current = Some(music.sound.clone()); + pub fn start_playing(&mut self, music: &Music, sounds: &mut impl Sounds) { + let instance = SoundInstance::for_music(&music.sound, SoundEngine::unseeded()); + let (id, result) = sounds.play_instance(instance, true); + self.set_current(Some(id), sounds); + match result { + PlayResult::Started => { + self.toast_requests.push(true); + self.toast_shown = true; + } + PlayResult::StartedSilently => self.toast_shown = false, + PlayResult::NotStarted => {} + } self.next_song_delay = i32::MAX; } - /// `MusicManager.stopPlaying`. - pub fn stop(&mut self, situational: Option<&Music>, out: &mut impl MusicOutput) { - if self.current.take().is_some() { - out.stop(); + /// `MusicManager.showNowPlayingToastIfNeeded`. + pub fn show_now_playing_toast_if_needed(&mut self) { + if !self.toast_shown { + self.toast_requests.push(true); + self.toast_shown = true; + } + } + /// `MusicManager.stopPlaying(Music)`. + pub fn stop_playing_music( + &mut self, + music: &Music, + situational: Option<&Music>, + sounds: &mut impl Sounds, + ) { + if self.is_playing_music(music, sounds.engine()) { + self.stop_playing(situational, sounds); + } + } + /// `MusicManager.stopPlaying()`. + pub fn stop_playing(&mut self, situational: Option<&Music>, sounds: &mut impl Sounds) { + if let Some(current) = self.current { + sounds.stop_instance(current); + self.set_current(None, sounds); + self.toast_requests.push(false); } self.next_song_delay = self .frequency .next_song_delay(situational, &mut self.random) + 100; } + /// `MusicManager.isPlayingMusic`. + pub fn is_playing_music(&self, music: &Music, sounds: &SoundEngine) -> bool { + self.current(sounds) == Some(music.sound.as_str()) + } + /// `MusicManager.setMinutesBetweenSongs`. + pub fn set_frequency(&mut self, frequency: MusicFrequency, situational: Option<&Music>) { + self.frequency = frequency; + self.next_song_delay = self + .frequency + .next_song_delay(situational, &mut self.random); + } /// `MusicManager.fadePlaying`: false once the track faded out and stopped. - fn fade( - &mut self, - volume: f32, - situational: Option<&Music>, - out: &mut impl MusicOutput, - ) -> bool { + fn fade(&mut self, volume: f32, situational: Option<&Music>, sounds: &mut impl Sounds) -> bool { if self.current.is_none() { return false; } @@ -312,10 +357,10 @@ impl MusicManager { } self.current_gain = self.current_gain.clamp(0.0, 1.0); if self.current_gain <= 1.0E-4 { - self.stop(situational, out); + self.stop_playing(situational, sounds); false } else { - out.set_gain(self.current_gain); + sounds.update_category_volume(MUSIC, self.current_gain); true } } @@ -324,79 +369,70 @@ impl MusicManager { #[cfg(test)] mod tests { use super::*; + use crate::sound_engine::{Bound, test_backend::Null}; + use crate::sound_events::SoundRegistry; - #[derive(Default)] - struct Fake { - playing: Option, - started: Vec, - gain: f32, - } - impl MusicOutput for Fake { - fn play(&mut self, event: &str) -> bool { - self.playing = Some(event.to_owned()); - self.started.push(event.to_owned()); - true - } - fn stop(&mut self) { - self.playing = None; - } - fn is_active(&mut self) -> bool { - self.playing.is_some() - } - fn set_gain(&mut self, gain: f32) { - self.gain = gain; - } + fn engine() -> SoundEngine { + let mut registry = SoundRegistry::default(); + registry.add_file( + "minecraft", + br#"{"music.menu": {"sounds": [{"name": "m", "stream": true}]}, + "music.game": {"sounds": [{"name": "g", "stream": true}]}, + "music.end": {"sounds": [{"name": "e", "stream": true}]}}"#, + &|_, _| true, + ); + SoundEngine::new(registry) } #[test] fn menu_music_starts_within_its_delay_and_game_music_replaces_nothing() { + let (mut engine, mut backend) = (engine(), Null::default()); let mut m = MusicManager::new(1); - let mut out = Fake::default(); let menu = Music::menu(); + let tick = + |m: &mut MusicManager, music: &Music, engine: &mut SoundEngine, backend: &mut Null| { + m.tick(Some(music), 1.0, false, &mut Bound { engine, backend }); + }; // nextSongDelay starts at 100, capped to MENU's max delay 600: starts on tick 100. for _ in 0..99 { - m.tick(Some(&menu), 1.0, false, &mut out); + tick(&mut m, &menu, &mut engine, &mut backend); } - assert!(out.started.is_empty()); - m.tick(Some(&menu), 1.0, false, &mut out); - assert_eq!(out.started, ["minecraft:music.menu"]); + assert!(m.current(&engine).is_none()); + tick(&mut m, &menu, &mut engine, &mut backend); + assert_eq!(m.current(&engine), Some("minecraft:music.menu")); // Game music does not replace the current track. let game = Music::new("minecraft:music.game", 12000, 24000, false); - m.tick(Some(&game), 1.0, false, &mut out); - assert_eq!(m.current(), Some("minecraft:music.menu")); - // When the menu track ends, the next delay comes from the game music range. - out.playing = None; - m.tick(Some(&game), 1.0, false, &mut out); - assert!(m.current().is_none()); - assert!((12000..=24000).contains(&m.next_song_delay)); - } - - #[test] - fn replacing_music_stops_the_current_track() { - let mut m = MusicManager::new(2); - let mut out = Fake::default(); - m.start(&Music::menu(), &mut out); - let end = Music::new("minecraft:music.end", 6000, 24000, true); - m.tick(Some(&end), 1.0, false, &mut out); - assert!(out.playing.is_none()); - assert!(m.current().is_none()); - assert!(m.next_song_delay <= 3000); + tick(&mut m, &game, &mut engine, &mut backend); + assert_eq!(m.current(&engine), Some("minecraft:music.menu")); } #[test] fn zero_music_volume_fades_out_and_stops() { + let (mut engine, mut backend) = (engine(), Null::default()); let mut m = MusicManager::new(3); - let mut out = Fake::default(); let game = Music::new("minecraft:music.game", 12000, 24000, false); - m.start(&game, &mut out); + m.start_playing( + &game, + &mut Bound { + engine: &mut engine, + backend: &mut backend, + }, + ); let mut ticks = 0; - while m.current().is_some() && ticks < 1000 { - m.tick(Some(&game), 0.0, false, &mut out); + while m.current_instance().is_some() && ticks < 1000 { + m.tick( + Some(&game), + 0.0, + false, + &mut Bound { + engine: &mut engine, + backend: &mut backend, + }, + ); ticks += 1; } // 0.97^n < 1e-4 after ~303 ticks. assert!((290..=310).contains(&ticks), "{ticks}"); - assert!(out.playing.is_none()); } #[test] diff --git a/crates/horizon-client/src/sound_engine.rs b/crates/horizon-client/src/sound_engine.rs index f51545595..2a47b5db2 100644 --- a/crates/horizon-client/src/sound_engine.rs +++ b/crates/horizon-client/src/sound_engine.rs @@ -934,3 +934,86 @@ pub fn unique_seed() -> i64 { .map_or(0, |d| d.as_nanos() as i64); next ^ nanos } +/// The `SoundManager` calls game code makes. +pub trait Sounds { + fn engine(&mut self) -> &mut SoundEngine; + /// `SoundManager.play` of a new instance (`retain`: the caller keeps it). + fn play_instance(&mut self, instance: SoundInstance, retain: bool) -> (InstanceId, PlayResult); + /// `SoundManager.play` of an instance the caller holds. + fn play_id(&mut self, id: InstanceId) -> PlayResult; + /// `SoundManager.stop(SoundInstance)`. + fn stop_instance(&mut self, id: InstanceId); + /// `SoundManager.isActive`. + fn is_active(&mut self, id: InstanceId) -> bool { + self.engine().is_active(id) + } + /// `SoundManager.updateCategoryVolume`. + fn update_category_volume(&mut self, source: usize, gain: f32); + /// The caller drops its instance. + fn release(&mut self, id: InstanceId) { + self.engine().release(id); + } +} +/// An engine with its backend. +pub struct Bound<'a, B: Backend> { + pub engine: &'a mut SoundEngine, + pub backend: &'a mut B, +} +impl Sounds for Bound<'_, B> { + fn engine(&mut self) -> &mut SoundEngine { + self.engine + } + fn play_instance(&mut self, instance: SoundInstance, retain: bool) -> (InstanceId, PlayResult) { + self.engine.play_new(instance, retain, self.backend) + } + fn play_id(&mut self, id: InstanceId) -> PlayResult { + self.engine.play(id, self.backend) + } + fn stop_instance(&mut self, id: InstanceId) { + self.engine.stop(id, self.backend); + } + fn update_category_volume(&mut self, source: usize, gain: f32) { + self.engine + .update_category_volume(source, gain, self.backend); + } +} +#[cfg(test)] +pub mod test_backend { + use super::{Backend, ChannelId}; + use crate::sound_events::Sound; + use std::collections::HashMap; + /// Channels that play until stopped. + #[derive(Default)] + pub struct Null { + next: ChannelId, + pub stopped: HashMap, + pub volume: HashMap, + } + impl Backend for Null { + fn create(&mut self, _streaming: bool) -> Option { + self.next += 1; + self.stopped.insert(self.next, false); + Some(self.next) + } + fn destroy(&mut self, c: ChannelId) { + self.stopped.remove(&c); + } + fn set_pitch(&mut self, _: ChannelId, _: f32) {} + fn set_volume(&mut self, c: ChannelId, v: f32) { + self.volume.insert(c, v); + } + fn set_attenuation(&mut self, _: ChannelId, _: Option) {} + fn set_looping(&mut self, _: ChannelId, _: bool) {} + fn set_position(&mut self, _: ChannelId, _: [f64; 3]) {} + fn set_relative(&mut self, _: ChannelId, _: bool) {} + fn start(&mut self, _: ChannelId, _: &Sound, _: bool) {} + fn stop(&mut self, c: ChannelId) { + self.stopped.insert(c, true); + } + fn pause(&mut self, _: ChannelId) {} + fn unpause(&mut self, _: ChannelId) {} + fn stopped(&mut self, c: ChannelId) -> bool { + self.stopped.get(&c).copied().unwrap_or(true) + } + } +} From 13e434d49d48af726a8f4f9d09f98664953956e1 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:49:11 +0200 Subject: [PATCH 4/9] Compare the music manager tick by tick with the real vanilla MusicManager The oracle drives MusicManager over the real SoundEngine with the situation as input; the script covers delays, replacements, frequencies, fades, loading screens, pauses, silent starts, toasts and unplayable events. Co-Authored-By: Claude Opus 5.5 --- .../examples/audio_common/mod.rs | 176 +++++++++++++++++ .../horizon-client/examples/music_fixture.rs | 108 +++++++++++ .../examples/sound_engine_fixture.rs | 177 +----------------- crates/horizon-client/src/game/music.rs | 16 +- .../horizonlab/parity/VanillaMusicOracle.java | 145 ++++++++++++++ tools/test_music_parity.py | 167 +++++++++++++++++ 6 files changed, 611 insertions(+), 178 deletions(-) create mode 100644 crates/horizon-client/examples/audio_common/mod.rs create mode 100644 crates/horizon-client/examples/music_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMusicOracle.java create mode 100644 tools/test_music_parity.py diff --git a/crates/horizon-client/examples/audio_common/mod.rs b/crates/horizon-client/examples/audio_common/mod.rs new file mode 100644 index 000000000..3b177eba5 --- /dev/null +++ b/crates/horizon-client/examples/audio_common/mod.rs @@ -0,0 +1,176 @@ +//! Shared by the audio fixtures: a backend recording what an OpenAL source +//! would hold, and the per-step dump the Java oracles print. +#![allow(dead_code)] +use horizon_client::sound_engine::{Backend, ChannelId, InstanceId, PlayResult, SoundEngine}; +use horizon_client::sound_events::Sound; +use std::collections::HashMap; +use std::io::Write; + +const INITIAL: u32 = 0x1011; +const PLAYING: u32 = 0x1012; +const PAUSED: u32 = 0x1013; +const STOPPED: u32 = 0x1014; + +/// An OpenAL source's state as `alGetSource*` reports it. +#[derive(Clone)] +pub struct Source { + pub state: u32, + pub gain: f32, + pub pitch: f32, + pub position: [f32; 3], + pub relative: bool, + pub looping: bool, + pub model: u32, + pub max: f32, + pub rolloff: f32, + pub reference: f32, +} +impl Default for Source { + fn default() -> Self { + Self { + state: INITIAL, + gain: 1.0, + pitch: 1.0, + position: [0.0; 3], + relative: false, + looping: false, + model: 0xD002, + max: f32::MAX, + rolloff: 1.0, + reference: 1.0, + } + } +} +/// Buffers and streams are ready at once (silence in the oracle); stopping an +/// initial source leaves it initial, as in OpenAL Soft. +#[derive(Default)] +pub struct Fake { + pub sources: HashMap, + next: ChannelId, +} +impl Backend for Fake { + fn create(&mut self, _streaming: bool) -> Option { + self.next += 1; + self.sources.insert(self.next, Source::default()); + Some(self.next) + } + fn destroy(&mut self, channel: ChannelId) { + self.sources.remove(&channel); + } + fn set_pitch(&mut self, c: ChannelId, pitch: f32) { + self.sources.get_mut(&c).expect("source").pitch = pitch; + } + fn set_volume(&mut self, c: ChannelId, volume: f32) { + self.sources.get_mut(&c).expect("source").gain = volume; + } + fn set_attenuation(&mut self, c: ChannelId, linear: Option) { + let s = self.sources.get_mut(&c).expect("source"); + match linear { + Some(max) => { + s.model = 0xD003; + s.max = max; + s.rolloff = 1.0; + s.reference = 0.0; + } + None => s.model = 0, + } + } + fn set_looping(&mut self, c: ChannelId, looping: bool) { + self.sources.get_mut(&c).expect("source").looping = looping; + } + fn set_position(&mut self, c: ChannelId, p: [f64; 3]) { + self.sources.get_mut(&c).expect("source").position = + [p[0] as f32, p[1] as f32, p[2] as f32]; + } + fn set_relative(&mut self, c: ChannelId, relative: bool) { + self.sources.get_mut(&c).expect("source").relative = relative; + } + fn start(&mut self, c: ChannelId, _sound: &Sound, _looping: bool) { + self.sources.get_mut(&c).expect("source").state = PLAYING; + } + fn stop(&mut self, c: ChannelId) { + if let Some(s) = self.sources.get_mut(&c) + && s.state != INITIAL + { + s.state = STOPPED; + } + } + fn pause(&mut self, c: ChannelId) { + let s = self.sources.get_mut(&c).expect("source"); + if s.state == PLAYING { + s.state = PAUSED; + } + } + fn unpause(&mut self, c: ChannelId) { + let s = self.sources.get_mut(&c).expect("source"); + if s.state == PAUSED { + s.state = PLAYING; + } + } + fn stopped(&mut self, c: ChannelId) -> bool { + self.sources.get(&c).is_none_or(|s| s.state == STOPPED) + } +} +pub fn bits(v: f32) -> String { + format!("{:08x}", v.to_bits()) +} +pub fn f(hex: &str) -> f32 { + f32::from_bits(u32::from_str_radix(hex, 16).expect("float")) +} +pub fn d(hex: &str) -> f64 { + f64::from_bits(u64::from_str_radix(hex, 16).expect("double")) +} +/// The shared per-step dump (instances, notifications, pool counts). +pub fn describe(engine: &SoundEngine, backend: &Fake, name: &str, id: InstanceId) -> String { + let mut s = format!(" {name} active={}", engine.is_active(id)); + match engine.channel(id).and_then(|c| backend.sources.get(&c)) { + None => s.push_str(" channel=-"), + Some(src) => s.push_str(&format!( + " state={:x} gain={} pitch={} pos={},{},{} rel={} loop={} model={:x} max={} rolloff={} ref={}", + src.state, + bits(src.gain), + bits(src.pitch), + bits(src.position[0]), + bits(src.position[1]), + bits(src.position[2]), + u8::from(src.relative), + u8::from(src.looping), + src.model, + bits(src.max), + bits(src.rolloff), + bits(src.reference) + )), + } + s +} +pub fn flush(engine: &mut SoundEngine, out: &mut impl Write) { + for n in std::mem::take(&mut engine.notifications) { + writeln!( + out, + "notify {} {} {} {} {:016x} {:016x} {:016x}", + n.identifier, + n.subtitle.as_deref().unwrap_or("-"), + bits(n.range), + n.looping, + n.position[0].to_bits(), + n.position[1].to_bits(), + n.position[2].to_bits() + ) + .expect("write"); + } + let [used, streaming] = engine.used_channels(); + writeln!( + out, + " Sounds: {used}/{} + {streaming}/{}", + engine.limits[0], engine.limits[1] + ) + .expect("write"); +} + +pub fn result_name(r: PlayResult) -> &'static str { + match r { + PlayResult::Started => "STARTED", + PlayResult::StartedSilently => "STARTED_SILENTLY", + PlayResult::NotStarted => "NOT_STARTED", + } +} diff --git a/crates/horizon-client/examples/music_fixture.rs b/crates/horizon-client/examples/music_fixture.rs new file mode 100644 index 000000000..29ccb99b2 --- /dev/null +++ b/crates/horizon-client/examples/music_fixture.rs @@ -0,0 +1,108 @@ +//! Replays `tools/test_music_parity.py` scripts through Horizon's +//! `MusicManager` over its `SoundEngine`: `music_fixture ROOT INPUT OUTPUT`. +#[path = "audio_common/mod.rs"] +mod common; +use common::{Fake, describe, f, flush}; +use horizon_client::music::{Music, MusicFrequency, MusicManager}; +use horizon_client::sound_engine::{Bound, MUSIC, SoundEngine, TickContext}; +use horizon_client::sound_events::SoundRegistry; +use std::io::Write; + +fn music(spec: &str) -> Option { + if spec == "-" { + return None; + } + let p: Vec<&str> = spec.split(',').collect(); + Some(Music::new( + &horizon_client::sound_events::normalize(p[0]), + p[1].parse().expect("min"), + p[2].parse().expect("max"), + p[3] == "1", + )) +} + +fn main() { + let args: Vec = std::env::args().collect(); + let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1]))); + engine.listening = true; + let mut backend = Fake::default(); + let mut manager = MusicManager::new(0); + let (mut situation, mut volume) = (None::, 1.0f32); + let input = std::fs::read_to_string(&args[2]).expect("input"); + let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); + for line in input.lines() { + writeln!(out, "{line}").expect("write"); + let a: Vec<&str> = line.split(' ').collect(); + match a[0] { + "start" => { + if let Some(id) = manager.current_instance() { + engine.release(id); + } + manager = MusicManager::new(a[1].parse().expect("seed")); + manager.frequency = MusicFrequency::parse(a[2]); + engine.stop_all(&mut backend); + } + "situation" => { + situation = music(a[1]); + volume = f(a[2]); + } + "tick" => { + let mut sounds = Bound { + engine: &mut engine, + backend: &mut backend, + }; + manager.tick(situation.as_ref(), volume, a[1] == "1", &mut sounds); + engine.tick(a[2] == "1", &TickContext::default(), &mut backend); + } + "finish" => { + if let Some(c) = manager.current_instance().and_then(|id| engine.channel(id)) { + horizon_client::sound_engine::Backend::stop(&mut backend, c); + } + } + "stop" => manager.stop_playing( + situation.as_ref(), + &mut Bound { + engine: &mut engine, + backend: &mut backend, + }, + ), + "stopmusic" => { + let m = music(a[1]).expect("music"); + manager.stop_playing_music( + &m, + situation.as_ref(), + &mut Bound { + engine: &mut engine, + backend: &mut backend, + }, + ); + } + "freq" => manager.set_frequency(MusicFrequency::parse(a[1]), situation.as_ref()), + "toast" => manager.show_now_playing_toast_if_needed(), + "volume" => { + let source: usize = a[1].parse().expect("source"); + engine.source_volumes[source] = f(a[2]); + engine.refresh_category_volume(source, &mut backend); + } + "stopall" => engine.stop_all(&mut backend), + _ => panic!("{line}"), + } + writeln!( + out, + " current={} delay={} gain={:08x} toastShown={} musicGain={:08x}", + manager.current(&engine).unwrap_or("-"), + manager.next_song_delay(), + manager.current_gain().to_bits(), + manager.toast_shown(), + engine.category_gain(MUSIC).to_bits() + ) + .expect("write"); + for show in std::mem::take(&mut manager.toast_requests) { + writeln!(out, " toast {}", if show { "show" } else { "hide" }).expect("write"); + } + if let Some(id) = manager.current_instance() { + writeln!(out, "{}", describe(&engine, &backend, "music", id)).expect("write"); + } + flush(&mut engine, &mut out); + } +} diff --git a/crates/horizon-client/examples/sound_engine_fixture.rs b/crates/horizon-client/examples/sound_engine_fixture.rs index a9dfbbb02..5bc8f1a61 100644 --- a/crates/horizon-client/examples/sound_engine_fixture.rs +++ b/crates/horizon-client/examples/sound_engine_fixture.rs @@ -1,175 +1,17 @@ //! Replays `tools/test_sound_engine_parity.py` scripts through Horizon's //! `SoundEngine` with a backend recording what an OpenAL source would hold: //! `sound_engine_fixture ROOT INPUT OUTPUT`. +#[path = "audio_common/mod.rs"] +mod common; +use common::{Fake, d, describe, f, flush, result_name}; use horizon_client::sound_engine::{ - Attenuation, Backend, ChannelId, InstanceId, SoundEngine, SoundInstance, TickContext, + Attenuation, Backend, InstanceId, SoundEngine, SoundInstance, TickContext, }; -use horizon_client::sound_events::{Sound, SoundRegistry}; +use horizon_client::sound_events::SoundRegistry; use horizon_core::random::LegacyRandom; -use std::collections::{BTreeMap, HashMap}; +use std::collections::BTreeMap; use std::io::Write; -const INITIAL: u32 = 0x1011; -const PLAYING: u32 = 0x1012; -const PAUSED: u32 = 0x1013; -const STOPPED: u32 = 0x1014; - -/// An OpenAL source's state as `alGetSource*` reports it. -#[derive(Clone)] -pub struct Source { - pub state: u32, - pub gain: f32, - pub pitch: f32, - pub position: [f32; 3], - pub relative: bool, - pub looping: bool, - pub model: u32, - pub max: f32, - pub rolloff: f32, - pub reference: f32, -} -impl Default for Source { - fn default() -> Self { - Self { - state: INITIAL, - gain: 1.0, - pitch: 1.0, - position: [0.0; 3], - relative: false, - looping: false, - model: 0xD002, - max: f32::MAX, - rolloff: 1.0, - reference: 1.0, - } - } -} -/// Buffers and streams are ready at once (silence in the oracle); stopping an -/// initial source leaves it initial, as in OpenAL Soft. -#[derive(Default)] -pub struct Fake { - pub sources: HashMap, - next: ChannelId, -} -impl Backend for Fake { - fn create(&mut self, _streaming: bool) -> Option { - self.next += 1; - self.sources.insert(self.next, Source::default()); - Some(self.next) - } - fn destroy(&mut self, channel: ChannelId) { - self.sources.remove(&channel); - } - fn set_pitch(&mut self, c: ChannelId, pitch: f32) { - self.sources.get_mut(&c).expect("source").pitch = pitch; - } - fn set_volume(&mut self, c: ChannelId, volume: f32) { - self.sources.get_mut(&c).expect("source").gain = volume; - } - fn set_attenuation(&mut self, c: ChannelId, linear: Option) { - let s = self.sources.get_mut(&c).expect("source"); - match linear { - Some(max) => { - s.model = 0xD003; - s.max = max; - s.rolloff = 1.0; - s.reference = 0.0; - } - None => s.model = 0, - } - } - fn set_looping(&mut self, c: ChannelId, looping: bool) { - self.sources.get_mut(&c).expect("source").looping = looping; - } - fn set_position(&mut self, c: ChannelId, p: [f64; 3]) { - self.sources.get_mut(&c).expect("source").position = - [p[0] as f32, p[1] as f32, p[2] as f32]; - } - fn set_relative(&mut self, c: ChannelId, relative: bool) { - self.sources.get_mut(&c).expect("source").relative = relative; - } - fn start(&mut self, c: ChannelId, _sound: &Sound, _looping: bool) { - self.sources.get_mut(&c).expect("source").state = PLAYING; - } - fn stop(&mut self, c: ChannelId) { - if let Some(s) = self.sources.get_mut(&c) - && s.state != INITIAL - { - s.state = STOPPED; - } - } - fn pause(&mut self, c: ChannelId) { - let s = self.sources.get_mut(&c).expect("source"); - if s.state == PLAYING { - s.state = PAUSED; - } - } - fn unpause(&mut self, c: ChannelId) { - let s = self.sources.get_mut(&c).expect("source"); - if s.state == PAUSED { - s.state = PLAYING; - } - } - fn stopped(&mut self, c: ChannelId) -> bool { - self.sources.get(&c).is_none_or(|s| s.state == STOPPED) - } -} -fn bits(v: f32) -> String { - format!("{:08x}", v.to_bits()) -} -fn f(hex: &str) -> f32 { - f32::from_bits(u32::from_str_radix(hex, 16).expect("float")) -} -fn d(hex: &str) -> f64 { - f64::from_bits(u64::from_str_radix(hex, 16).expect("double")) -} -/// The shared per-step dump (instances, notifications, pool counts). -pub fn describe(engine: &SoundEngine, backend: &Fake, name: &str, id: InstanceId) -> String { - let mut s = format!(" {name} active={}", engine.is_active(id)); - match engine.channel(id).and_then(|c| backend.sources.get(&c)) { - None => s.push_str(" channel=-"), - Some(src) => s.push_str(&format!( - " state={:x} gain={} pitch={} pos={},{},{} rel={} loop={} model={:x} max={} rolloff={} ref={}", - src.state, - bits(src.gain), - bits(src.pitch), - bits(src.position[0]), - bits(src.position[1]), - bits(src.position[2]), - u8::from(src.relative), - u8::from(src.looping), - src.model, - bits(src.max), - bits(src.rolloff), - bits(src.reference) - )), - } - s -} -pub fn flush(engine: &mut SoundEngine, out: &mut impl Write) { - for n in std::mem::take(&mut engine.notifications) { - writeln!( - out, - "notify {} {} {} {} {:016x} {:016x} {:016x}", - n.identifier, - n.subtitle.as_deref().unwrap_or("-"), - bits(n.range), - n.looping, - n.position[0].to_bits(), - n.position[1].to_bits(), - n.position[2].to_bits() - ) - .expect("write"); - } - let [used, streaming] = engine.used_channels(); - writeln!( - out, - " Sounds: {used}/{} + {streaming}/{}", - engine.limits[0], engine.limits[1] - ) - .expect("write"); -} - fn main() { let args: Vec = std::env::args().collect(); let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1]))); @@ -264,10 +106,3 @@ fn main() { flush(&mut engine, &mut out); } } -fn result_name(r: horizon_client::sound_engine::PlayResult) -> &'static str { - match r { - horizon_client::sound_engine::PlayResult::Started => "STARTED", - horizon_client::sound_engine::PlayResult::StartedSilently => "STARTED_SILENTLY", - horizon_client::sound_engine::PlayResult::NotStarted => "NOT_STARTED", - } -} diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs index a7e054fdb..699996e11 100644 --- a/crates/horizon-client/src/game/music.rs +++ b/crates/horizon-client/src/game/music.rs @@ -1,11 +1,7 @@ //! `Minecraft.getSituationalMusic` and `getMusicVolume` for the music manager, //! the local player's ambient sound handlers and the sound engine tick. use super::Game; -use horizon_client::{ - blocks::Fluid, - music::Music, - sound_engine::TickContext, -}; +use horizon_client::{blocks::Fluid, music::Music, sound_engine::TickContext}; impl Game<'_> { /// `Minecraft.tick` -> `MusicManager.tick`, once per client tick. @@ -59,12 +55,18 @@ impl Game<'_> { } /// `BiomeManager.getNoiseBiomeAtPosition`: the quart cell holding a position. fn biome_at(&self, p: [f64; 3]) -> &str { - let (x, y, z) = (p[0].floor() as i32, p[1].floor() as i32, p[2].floor() as i32); + let (x, y, z) = ( + p[0].floor() as i32, + p[1].floor() as i32, + p[2].floor() as i32, + ); self.world .chunks .get(&(x >> 4, z >> 4)) .map_or("minecraft:plains", |c| { - self.res.biomes.list[c.biome(x, y, z) as usize].name.as_str() + self.res.biomes.list[c.biome(x, y, z) as usize] + .name + .as_str() }) } /// `isEyeInFluid(WATER)`: the eye inside the water of its block column. diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMusicOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMusicOracle.java new file mode 100644 index 000000000..19af845e5 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMusicOracle.java @@ -0,0 +1,145 @@ +package dev.horizonlab.parity; + +import java.io.PrintWriter; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.components.toasts.ToastManager; +import net.minecraft.client.gui.screens.LevelLoadingScreen; +import net.minecraft.client.resources.sounds.SoundInstance; +import net.minecraft.client.sounds.MusicManager; +import net.minecraft.client.sounds.SoundEngine; +import net.minecraft.client.sounds.SoundManager; +import net.minecraft.core.Holder; +import net.minecraft.resources.Identifier; +import net.minecraft.sounds.Music; +import net.minecraft.sounds.SoundEvent; +import net.minecraft.sounds.SoundSource; +import net.minecraft.util.RandomSource; + +/** + * Drives the real MusicManager over the real SoundEngine (VanillaSoundRig). + * The situation, Minecraft.getSituationalMusic and getMusicVolume, is the + * script's input; the loading screen is a LevelLoadingScreen in the Gui; the + * toast manager records showNowPlayingToast/hideNowPlayingToast. Each client + * tick is musicManager.tick() then soundManager.tick(pause), as Minecraft.tick + * runs them. Prints the manager's state and the music channel every step. + */ +public final class VanillaMusicOracle { + public static final class Mc extends Minecraft { + Music music; + float volume = 1.0F; + + Mc() { + super(null); + } + + @Override + public Music getSituationalMusic() { + return music; + } + + @Override + public float getMusicVolume() { + return volume; + } + } + + public static final class Toasts extends ToastManager { + final List calls = new ArrayList<>(); + + Toasts() { + super(null, null); + } + + @Override + public void showNowPlayingToast() { + calls.add("show"); + } + + @Override + public void hideNowPlayingToast() { + calls.add("hide"); + } + } + + static Music music(String spec) { + if (spec.equals("-")) return null; + String[] p = spec.split(","); + return new Music(Holder.direct(SoundEvent.createVariableRangeEvent(Identifier.parse(p[0]))), Integer.parseInt(p[1]), + Integer.parseInt(p[2]), p[3].equals("1")); + } + + static float f(String hex) { + return Float.intBitsToFloat(Integer.parseUnsignedInt(hex, 16)); + } + + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var rig = new VanillaSoundRig(Path.of(args[0])); + Mc mc = VanillaSoundRig.make(Mc.class); + Gui gui = VanillaSoundRig.make(Gui.class); + Toasts toasts = VanillaSoundRig.make(Toasts.class); + VanillaSoundRig.set(toasts, Toasts.class, "calls", new ArrayList()); + VanillaSoundRig.set(gui, Gui.class, "toastManager", toasts); + VanillaSoundRig.set(mc, Minecraft.class, "gui", gui); + VanillaSoundRig.set(mc, Minecraft.class, "soundManager", rig.manager); + var loading = VanillaSoundRig.make(LevelLoadingScreen.class); + MusicManager manager = null; + var gains = VanillaSoundRig.field(SoundEngine.class, "gainBySource"); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2])))) { + for (String line : Files.readAllLines(Path.of(args[1]))) { + out.println(line); + String[] a = line.split(" "); + switch (a[0]) { + case "start" -> { + // A fresh manager: MusicManager(minecraft) with a seeded random. + manager = VanillaSoundRig.make(MusicManager.class); + VanillaSoundRig.set(manager, MusicManager.class, "minecraft", mc); + VanillaSoundRig.set(manager, MusicManager.class, "random", RandomSource.create(Long.parseLong(a[1]))); + VanillaSoundRig.set(manager, MusicManager.class, "gameMusicFrequency", MusicManager.MusicFrequency.valueOf(a[2])); + VanillaSoundRig.set(manager, MusicManager.class, "currentGain", 1.0F); + VanillaSoundRig.set(manager, MusicManager.class, "nextSongDelay", 100); + rig.manager.stop(); + } + case "situation" -> { + mc.music = music(a[1]); + mc.volume = f(a[2]); + } + case "tick" -> { + VanillaSoundRig.set(gui, Gui.class, "screen", a[1].equals("1") ? loading : null); + manager.tick(); + rig.manager.tick(a[2].equals("1")); + } + case "finish" -> { + var current = (SoundInstance) VanillaSoundRig.get(manager, MusicManager.class, "currentMusic"); + if (current != null) rig.finish(current); + } + case "stop" -> manager.stopPlaying(); + case "stopmusic" -> manager.stopPlaying(music(a[1])); + case "freq" -> manager.setMinutesBetweenSongs(MusicManager.MusicFrequency.valueOf(a[1])); + case "toast" -> manager.showNowPlayingToastIfNeeded(); + case "volume" -> { + rig.volume(SoundSource.values()[Integer.parseInt(a[1])], f(a[2])); + rig.manager.refreshCategoryVolume(SoundSource.values()[Integer.parseInt(a[1])]); + } + case "stopall" -> rig.manager.stop(); + default -> throw new IllegalArgumentException(line); + } + var current = (SoundInstance) VanillaSoundRig.get(manager, MusicManager.class, "currentMusic"); + out.printf(" current=%s delay=%d gain=%08x toastShown=%s musicGain=%08x%n", current == null ? "-" : current.getIdentifier(), + (int) VanillaSoundRig.get(manager, MusicManager.class, "nextSongDelay"), + Float.floatToRawIntBits((float) VanillaSoundRig.get(manager, MusicManager.class, "currentGain")), + VanillaSoundRig.get(manager, MusicManager.class, "toastShown"), + Float.floatToRawIntBits(((it.unimi.dsi.fastutil.objects.Object2FloatMap) gains.get(rig.engine)).getFloat(SoundSource.MUSIC))); + for (String call : toasts.calls) out.println(" toast " + call); + toasts.calls.clear(); + if (current != null) out.println(rig.describe("music", current)); + rig.flush(out); + } + } + System.exit(0); + } +} diff --git a/tools/test_music_parity.py b/tools/test_music_parity.py new file mode 100644 index 000000000..7d41be5f1 --- /dev/null +++ b/tools/test_music_parity.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +"""Compare the music manager with the vanilla 26.3 client. + +The oracle runs the real `MusicManager` over the real `SoundEngine` (OpenAL +Soft "No Output" device, see VanillaSoundRig). The situation +(`getSituationalMusic`, `getMusicVolume`), the loading screen, pauses, the +end of a track, `stopPlaying`, `setMinutesBetweenSongs`, the music category +volume and `showNowPlayingToastIfNeeded` are script inputs; every step prints +the current track, `nextSongDelay`, `currentGain`, `toastShown`, the toast +calls, the MUSIC category gain and the music channel's AL source. Horizon's +`MusicManager` and `SoundEngine` replay the scripts. Tracks use events whose +variants share one volume, since `forMusic` resolves with an unseeded random. +""" +import random + +try: + from . import audio_harness as h +except ImportError: + import audio_harness as h + +TRACKS = ['minecraft:music.credits', 'minecraft:music.dragon', 'minecraft:music.end', 'minecraft:music.under_water', + 'minecraft:music.overworld.swamp', 'minecraft:music_disc.cat', 'minecraft:music_disc.13'] +ODD = ['minecraft:music.nether.warped_forest', 'minecraft:not.a.track'] + + +class Script: + def __init__(self): + self.lines = [] + + def add(self, *parts): + self.lines.append(' '.join(map(str, parts))) + + def situation(self, sound=None, lo=0, hi=0, replace=0, volume=1.0): + self.add('situation', '-' if sound is None else f'{sound},{lo},{hi},{replace}', h.bits(volume)) + + def tick(self, n=1, loading=0, paused=0): + for _ in range(n): + self.add('tick', loading, paused) + + +def scripted(s): + end, dragon, water, credits, cat = TRACKS[2], TRACKS[1], TRACKS[3], TRACKS[0], TRACKS[5] + s.add('start', 1, 'DEFAULT') + # Menu-like music: 20..600 ticks, replacing. + s.situation(end, 20, 600, 1) + s.tick(3, loading=1) + s.tick(120) + s.add('finish') + s.tick(650) + # Game music does not replace, and the next delay comes from its range. + s.situation(water, 12000, 24000, 0) + s.tick(5) + s.add('finish') + s.tick(30) + s.add('freq', 'FREQUENT') + s.tick(3) + s.add('freq', 'CONSTANT') + s.tick(110) + s.add('freq', 'DEFAULT') + s.tick(2) + # A replacing track stops the current one over the following ticks. + s.situation(dragon, 0, 0, 1) + s.tick(30) + s.situation(credits, 0, 0, 1) + s.tick(30) + s.situation(None) + s.tick(5) + s.add('finish') + s.tick(5) + s.situation(end, 6000, 24000, 1) + s.tick(130) + # Music volume fades: down to silence, then up from a partial volume. + s.situation(end, 6000, 24000, 1, volume=0.0) + s.tick(320) + s.situation(cat, 0, 0, 1, volume=0.25) + s.tick(5) + s.situation(cat, 0, 0, 1, volume=1.0) + s.tick(400) + s.situation(cat, 0, 0, 1, volume=0.6) + s.tick(80) + # Silent starts and the toast, stops, pauses. + s.add('volume', 1, h.bits(0.0)) + s.add('stop') + s.situation(dragon, 0, 0, 1) + s.tick(105) + s.add('toast') + s.add('volume', 1, h.bits(0.5)) + s.add('toast') + s.tick(2) + s.add('stopmusic', f'{end},0,0,1') + s.add('stopmusic', f'{dragon},0,0,1') + s.tick(105, paused=1) + s.add('finish') + s.tick(3, paused=1) + s.tick(5) + s.add('stopall') + s.tick(5) + # Events that cannot play. + for event in ODD: + s.add('start', 7, 'DEFAULT') + s.situation(event, 0, 40, 1) + s.tick(150) + # Real Musics delays over a long session. + s.add('start', 99, 'DEFAULT') + s.situation(water, 12000, 24000, 0) + s.tick(130) + s.add('finish') + s.tick(24100) + + +def fuzz(s, rng, steps): + s.add('start', rng.getrandbits(63), rng.choice(['DEFAULT', 'FREQUENT', 'CONSTANT'])) + for _ in range(steps): + op = rng.random() + if op < 0.08: + sound = rng.choice(TRACKS + ODD[:1]) if rng.random() < 0.9 else None + lo = rng.choice([0, 20, 100, 300]) + s.situation(sound, lo, lo + rng.choice([0, 50, 280, 600]), int(rng.random() < 0.5), + rng.choice([1.0, 1.0, 1.0, 0.0, 0.5, rng.random()])) + elif op < 0.13: + s.add('finish') + elif op < 0.15: + s.add('stop') + elif op < 0.16: + s.add('stopmusic', f'{rng.choice(TRACKS)},0,0,1') + elif op < 0.17: + s.add('freq', rng.choice(['DEFAULT', 'FREQUENT', 'CONSTANT'])) + elif op < 0.18: + s.add('toast') + elif op < 0.20: + s.add('volume', rng.choice([0, 1]), h.bits(rng.choice([0.0, 1.0, 0.5]))) + elif op < 0.21: + s.add('stopall') + elif op < 0.25: + s.tick(rng.randrange(1, 30), loading=1) + elif op < 0.28: + s.tick(rng.randrange(1, 30), paused=1) + else: + s.tick(rng.randrange(1, 60)) + + +def fixtures(): + s = Script() + scripted(s) + rng = random.Random(0x4d55534943) + for _ in range(60): + fuzz(s, rng, 120) + return s.lines + + +def main(): + lines = fixtures() + matched, report = h.run_harness( + 'music', 'VanillaMusicOracle', 'music_fixture', ''.join(l + '\n' for l in lines), + extra_sources=[h.lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java', + h.lab.ROOT / 'crates/horizon-client/src/music.rs', + h.lab.ROOT / 'crates/horizon-client/examples/audio_common/mod.rs'], + java_args=[h.RESOURCES], rust_args=[h.RESOURCES], + scope='Real MusicManager.tick/startPlaying/stopPlaying/fadePlaying/setMinutesBetweenSongs/showNowPlayingToastIfNeeded with a seeded ' + 'random over the real SoundEngine: track starts and replacements, nextSongDelay draws, the three music frequencies, the loading ' + 'screen hold, fades and the MUSIC category gain, silent starts, toasts, pauses, track ends and unplayable events. The situation ' + '(getSituationalMusic/getMusicVolume) is an input here; see test_audio_attributes_parity.py for the attribute values.') + print(f'{matched:,} music lines match the pinned client ({len(lines):,} steps): {report}', flush=True) + + +if __name__ == '__main__': + main() From 6eee2e32620d8cb7699dab091b98cc50a86652c1 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:52:28 +0200 Subject: [PATCH 5/9] Compare audio environment attributes and Musics with the vanilla data Co-Authored-By: Claude Opus 5.5 --- .../examples/audio_attributes_fixture.rs | 85 +++++++++++++ crates/horizon-client/src/music.rs | 16 +++ .../parity/VanillaAudioAttributesOracle.java | 112 ++++++++++++++++++ tools/test_audio_attributes_parity.py | 36 ++++++ 4 files changed, 249 insertions(+) create mode 100644 crates/horizon-client/examples/audio_attributes_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAudioAttributesOracle.java create mode 100644 tools/test_audio_attributes_parity.py diff --git a/crates/horizon-client/examples/audio_attributes_fixture.rs b/crates/horizon-client/examples/audio_attributes_fixture.rs new file mode 100644 index 000000000..73f463fc4 --- /dev/null +++ b/crates/horizon-client/examples/audio_attributes_fixture.rs @@ -0,0 +1,85 @@ +//! Audio environment attributes from Horizon's `MusicTables` and +//! `AmbientTables` for `tools/test_audio_attributes_parity.py`: +//! `audio_attributes_fixture ROOT INPUT OUTPUT`. +use horizon_client::ambience::AmbientTables; +use horizon_client::music::{Music, MusicTables}; +use horizon_client::sound_events::normalize; +use std::io::Write; + +fn music(m: Option<&Music>) -> String { + m.map_or("-".to_owned(), |m| { + format!( + "{},{},{},{}", + normalize(&m.sound), + m.min_delay, + m.max_delay, + m.replace_current_music + ) + }) +} + +fn main() { + let args: Vec = std::env::args().collect(); + let root = std::path::Path::new(&args[1]); + let tables = MusicTables::load(root); + let ambient = AmbientTables::load(root); + let input = std::fs::read_to_string(&args[2]).expect("input"); + let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); + for (name, m) in [ + ("MENU", Music::menu()), + ("CREDITS", Music::credits()), + ("END_BOSS", Music::end_boss()), + ("CREATIVE", Music::creative()), + ("END", Music::end()), + ("UNDER_WATER", Music::under_water()), + ("GAME", Music::game()), + ] { + writeln!(out, "{name} {}", music(Some(&m))).expect("write"); + } + for line in input.lines() { + let f: Vec<&str> = line.split(' ').collect(); + let (dimension, biome) = (f[0], f[1]); + let bg = tables.background(dimension, biome); + let mut s = format!( + "{line} default={} creative={} underwater={}", + music(bg.default.as_ref()), + music(bg.creative.as_ref()), + music(bg.underwater.as_ref()) + ); + for creative in [false, true] { + for underwater in [false, true] { + s.push_str(&format!( + " select={}", + music(bg.select(creative, underwater)) + )); + } + } + s.push_str(&format!( + " volume={:08x}", + tables.volume(dimension, biome).to_bits() + )); + let a = ambient.get(dimension, biome); + s.push_str(&format!( + " loop={}", + a.r#loop.as_deref().map_or("-".to_owned(), normalize) + )); + s.push_str(&format!( + " mood={}", + a.mood.as_ref().map_or("-".to_owned(), |m| format!( + "{},{},{},{:016x}", + normalize(&m.sound), + m.tick_delay, + m.block_search_extent, + m.offset.to_bits() + )) + )); + for (sound, chance) in &a.additions { + s.push_str(&format!( + " addition={},{:016x}", + normalize(sound), + chance.to_bits() + )); + } + writeln!(out, "{s}").expect("write"); + } +} diff --git a/crates/horizon-client/src/music.rs b/crates/horizon-client/src/music.rs index 94a7f87a0..08dbea125 100644 --- a/crates/horizon-client/src/music.rs +++ b/crates/horizon-client/src/music.rs @@ -36,6 +36,22 @@ impl Music { pub fn end_boss() -> Self { Self::new("minecraft:music.dragon", 0, 0, true) } + /// `Musics.CREATIVE`. + pub fn creative() -> Self { + Self::new("minecraft:music.creative", 12000, 24000, false) + } + /// `Musics.END`. + pub fn end() -> Self { + Self::new("minecraft:music.end", 6000, 24000, true) + } + /// `Musics.UNDER_WATER`. + pub fn under_water() -> Self { + Self::new("minecraft:music.under_water", 12000, 24000, false) + } + /// `Musics.GAME`. + pub fn game() -> Self { + Self::new("minecraft:music.game", 12000, 24000, false) + } /// `Music.CODEC`. fn parse(v: &Value) -> Option { let sound = v["sound"].as_str()?; diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAudioAttributesOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAudioAttributesOracle.java new file mode 100644 index 000000000..33cc38776 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAudioAttributesOracle.java @@ -0,0 +1,112 @@ +package dev.horizonlab.parity; + +import java.io.PrintWriter; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import net.minecraft.SharedConstants; +import net.minecraft.core.*; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.Identifier; +import net.minecraft.resources.RegistryDataLoader; +import net.minecraft.resources.ResourceKey; +import net.minecraft.server.Bootstrap; +import net.minecraft.server.RegistryLayer; +import net.minecraft.server.packs.PackType; +import net.minecraft.server.packs.repository.ServerPacksSource; +import net.minecraft.server.packs.resources.MultiPackResourceManager; +import net.minecraft.sounds.Music; +import net.minecraft.sounds.Musics; +import net.minecraft.tags.TagLoader; +import net.minecraft.world.attribute.*; +import net.minecraft.world.clock.*; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.dimension.DimensionType; +import net.minecraft.world.phys.Vec3; + +/** + * The audio environment attributes as the vanilla EnvironmentAttributeSystem + * evaluates them from the vanilla data pack (dimension layer, the biome's + * positional layer, the dimension timelines and weather layers): + * BACKGROUND_MUSIC with BackgroundMusic.select for every creative/underwater + * combination, MUSIC_VOLUME and AMBIENT_SOUNDS, for lines "dimension biome + * ticks"; plus the Musics constants. + */ +public final class VanillaAudioAttributesOracle { + static String music(Music m) { + return m == null ? "-" : m.sound().value().location() + "," + m.minDelay() + "," + m.maxDelay() + "," + m.replaceCurrentMusic(); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private static void addBiome(EnvironmentAttributeSystem.Builder b, EnvironmentAttribute attr, Biome biome) { + b.addPositionalLayer(attr, (base, pos, w) -> biome.getAttributes().applyModifier(attr, base)); + } + + public static void main(String[] args) throws Exception { + SharedConstants.tryDetectVersion(); + Bootstrap.bootStrap(); + var repo = ServerPacksSource.createVanillaTrustedRepository(); + repo.reload(); + repo.setSelected(List.of("vanilla")); + var resources = new MultiPackResourceManager(PackType.SERVER_DATA, repo.openAllSelected()); + var layers = RegistryLayer.createRegistryAccess(); + var staticTags = TagLoader.loadTagsForExistingRegistries(resources, layers.getLayer(RegistryLayer.STATIC)); + var context = TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD), staticTags); + RegistryAccess.Frozen world = RegistryDataLoader.load(resources, context, RegistryDataLoader.WORLD_REGISTRIES, Runnable::run).join(); + staticTags.forEach(Registry.PendingTags::apply); + var dimensions = world.lookupOrThrow(Registries.DIMENSION_TYPE); + var biomes = world.lookupOrThrow(Registries.BIOME); + try (var w = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) { + w.println("MENU " + music(Musics.MENU)); + w.println("CREDITS " + music(Musics.CREDITS)); + w.println("END_BOSS " + music(Musics.END_BOSS)); + w.println("CREATIVE " + music(Musics.CREATIVE)); + w.println("END " + music(Musics.END)); + w.println("UNDER_WATER " + music(Musics.UNDER_WATER)); + w.println("GAME " + music(Musics.GAME)); + for (String line : Files.readAllLines(Path.of(args[0]), StandardCharsets.UTF_8)) { + String[] f = line.split(" "); + DimensionType dim = dimensions.getOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, Identifier.parse(f[0]))).value(); + Biome biome = biomes.getOrThrow(ResourceKey.create(Registries.BIOME, Identifier.parse(f[1]))).value(); + long ticks = Long.parseLong(f[2]); + ClockManager clocks = h -> new ClockInstance() { + public long totalTicks() { return ticks; } + public float partialTick() { return 0.0F; } + public float rate() { return 1.0F; } + public boolean isPaused() { return false; } + }; + var b = EnvironmentAttributeSystem.builder(); + b.addConstantLayer(dim.attributes()); + for (EnvironmentAttribute attr : biome.getAttributes().keySet()) addBiome(b, attr, biome); + dim.timelines().forEach(t -> b.addTimelineLayer(t, clocks)); + if (dim.hasSkyLight() && !dim.hasCeiling()) { + WeatherAttributes.addBuiltinLayers(b, new WeatherAttributes.WeatherAccess() { + public float rainLevel() { return 0.0F; } + public float thunderLevel() { return 0.0F; } + }); + } + var system = b.build(); + BackgroundMusic bg = system.getValue(EnvironmentAttributes.BACKGROUND_MUSIC, Vec3.ZERO); + StringBuilder sb = new StringBuilder(line); + sb.append(" default=").append(music(bg.defaultMusic().orElse(null))) + .append(" creative=").append(music(bg.creativeMusic().orElse(null))) + .append(" underwater=").append(music(bg.underwaterMusic().orElse(null))); + for (boolean creative : new boolean[]{false, true}) { + for (boolean underwater : new boolean[]{false, true}) { + sb.append(" select=").append(music(bg.select(creative, underwater).orElse(null))); + } + } + sb.append(String.format(" volume=%08x", Float.floatToRawIntBits(system.getValue(EnvironmentAttributes.MUSIC_VOLUME, Vec3.ZERO)))); + AmbientSounds ambient = system.getValue(EnvironmentAttributes.AMBIENT_SOUNDS, Vec3.ZERO); + sb.append(" loop=").append(ambient.loop().map(s -> s.value().location().toString()).orElse("-")); + sb.append(" mood=").append(ambient.mood().map(m -> m.soundEvent().value().location() + "," + m.tickDelay() + "," + + m.blockSearchExtent() + "," + String.format("%016x", Double.doubleToRawLongBits(m.soundPositionOffset()))).orElse("-")); + for (AmbientAdditionsSettings a : ambient.additions()) { + sb.append(" addition=").append(a.soundEvent().value().location()).append(String.format(",%016x", Double.doubleToRawLongBits(a.tickChance()))); + } + w.println(sb); + } + } + System.exit(0); + } +} diff --git a/tools/test_audio_attributes_parity.py b/tools/test_audio_attributes_parity.py new file mode 100644 index 000000000..78b28ecbe --- /dev/null +++ b/tools/test_audio_attributes_parity.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +"""Compare the audio environment attributes with the vanilla 26.3 data pack. + +The oracle evaluates vanilla's `EnvironmentAttributeSystem` (dimension layer, +biome positional layer, dimension timelines, weather layers) for every +dimension type and biome and prints `BACKGROUND_MUSIC` (all three tracks and +`BackgroundMusic.select` for each creative/underwater combination), +`MUSIC_VOLUME` and `AMBIENT_SOUNDS` (loop, mood, additions), plus the +`Musics` constants. Horizon's `MusicTables` and `AmbientTables` answer the same. +""" +try: + from . import audio_harness as h +except ImportError: + import audio_harness as h + + +def fixtures(): + data = h.RESOURCES / 'data/minecraft' + biomes = sorted('minecraft:' + p.stem for p in (data / 'worldgen/biome').glob('*.json')) + dimensions = sorted('minecraft:' + p.stem for p in (data / 'dimension_type').glob('*.json')) + return [f'{d} {b} {t}' for d in dimensions for b in biomes for t in (0, 13000)] + + +def main(): + lines = fixtures() + matched, report = h.run_harness( + 'audio-attributes', 'VanillaAudioAttributesOracle', 'audio_attributes_fixture', ''.join(l + '\n' for l in lines), + extra_sources=[h.lab.ROOT / 'crates/horizon-client/src/music.rs', h.lab.ROOT / 'crates/horizon-client/src/ambience.rs'], + rust_args=[h.RESOURCES], + scope='Vanilla EnvironmentAttributeSystem values of audio/background_music (with BackgroundMusic.select), audio/music_volume and ' + 'audio/ambient_sounds for every dimension type x biome at two times of day, and the Musics constants.') + print(f'{matched:,} audio attribute lines match the pinned data ({len(lines):,} cases): {report}', flush=True) + + +if __name__ == '__main__': + main() From 9e4811dd6eb4d2982b7b343c2e414d1036c0d55d Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 21:57:02 +0200 Subject: [PATCH 6/9] Compare the ambient sound handlers tick by tick with vanilla LocalPlayer The oracle runs the real updateIsUnderwater, UnderwaterAmbientSoundHandler and BiomeAmbientSoundsHandler over the real SoundEngine, comparing every level random draw, loop fade, mood sample and playing instance. Co-Authored-By: Claude Opus 5.5 --- .../examples/ambient_fixture.rs | 161 +++++++++++++ crates/horizon-client/src/ambience.rs | 8 + .../parity/VanillaAmbientOracle.java | 216 ++++++++++++++++++ tools/test_ambient_sound_parity.py | 168 ++++++++++++++ 4 files changed, 553 insertions(+) create mode 100644 crates/horizon-client/examples/ambient_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java create mode 100644 tools/test_ambient_sound_parity.py diff --git a/crates/horizon-client/examples/ambient_fixture.rs b/crates/horizon-client/examples/ambient_fixture.rs new file mode 100644 index 000000000..70a50fd87 --- /dev/null +++ b/crates/horizon-client/examples/ambient_fixture.rs @@ -0,0 +1,161 @@ +//! Replays `tools/test_ambient_sound_parity.py` scripts through Horizon's +//! ambient sound handlers over its `SoundEngine`: +//! `ambient_fixture ROOT INPUT OUTPUT`. +#[path = "audio_common/mod.rs"] +mod common; +use common::{Fake, d, f, flush}; +use horizon_client::ambience::{Ambience, AmbientContext, AmbientSounds, Mood}; +use horizon_client::sound_engine::{Bound, SoundEngine, TickContext, Ticking}; +use horizon_client::sound_events::{SoundRegistry, normalize}; +use horizon_core::random::RandomSource; +use std::io::Write; + +/// The oracle's scripted brightness. +fn light(mode: i32, x: i32, y: i32, z: i32) -> (u8, u8) { + let h = x.wrapping_mul(73856093) ^ y.wrapping_mul(19349663) ^ z.wrapping_mul(83492791); + let u = h as u32; + match mode { + 0 => (15, 0), + 1 => (0, 0), + 2 => (0, ((u >> 4) & 15) as u8), + _ => ( + if h & 3 == 0 { ((u >> 8) & 15) as u8 } else { 0 }, + ((u >> 12) & 15) as u8, + ), + } +} + +fn sounds(a: &[&str]) -> AmbientSounds { + AmbientSounds { + r#loop: (a[1] != "-").then(|| normalize(a[1])), + mood: (a[2] != "-").then(|| { + let m: Vec<&str> = a[2].split(',').collect(); + Mood { + sound: normalize(m[0]), + tick_delay: m[1].parse().expect("delay"), + block_search_extent: m[2].parse().expect("extent"), + offset: d(m[3]), + } + }), + additions: a[3..] + .iter() + .map(|s| { + let p: Vec<&str> = s.split(',').collect(); + (normalize(p[0]), d(p[1])) + }) + .collect(), + } +} + +fn main() { + let args: Vec = std::env::args().collect(); + let mut engine = SoundEngine::new(SoundRegistry::load(std::path::Path::new(&args[1]))); + engine.listening = true; + let mut backend = Fake::default(); + let mut ambience = Ambience::new(0); + let mut current = AmbientSounds::default(); + let (mut position, mut eye, mut eye_in_water, mut spectator, mut removed, mut mode) = + ([0.0f64; 3], 0.0f32, false, false, false, 0); + let input = std::fs::read_to_string(&args[2]).expect("input"); + let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); + for line in input.lines() { + writeln!(out, "{line}").expect("write"); + let a: Vec<&str> = line.split(' ').collect(); + match a[0] { + "start" => { + engine.stop_all(&mut backend); + ambience.clear(&mut Bound { + engine: &mut engine, + backend: &mut backend, + }); + ambience = Ambience::new(a[1].parse().expect("seed")); + current = AmbientSounds::default(); + (position, eye, eye_in_water, spectator, removed, mode) = + ([0.0; 3], 0.0, false, false, false, 0); + } + "sounds" => current = sounds(&a), + "player" => { + position = [d(a[1]), d(a[2]), d(a[3])]; + eye = f(a[4]); + eye_in_water = a[5] == "1"; + spectator = a[6] == "1"; + removed = a[7] == "1"; + mode = a[8].parse().expect("mode"); + } + "volume" => { + let source: usize = a[1].parse().expect("source"); + engine.source_volumes[source] = f(a[2]); + engine.refresh_category_volume(source, &mut backend); + } + "tick" => { + let light = |b: [i32; 3]| light(mode, b[0], b[1], b[2]); + let ctx = AmbientContext { + sounds: ¤t, + position, + eye_y: position[1] + f64::from(eye), + underwater: eye_in_water, + spectator, + light: &light, + }; + ambience.tick( + &ctx, + &mut Bound { + engine: &mut engine, + backend: &mut backend, + }, + ); + let tick = TickContext { + player_underwater: ambience.was_underwater(), + player_removed: removed, + }; + engine.tick(false, &tick, &mut backend); + } + _ => panic!("{line}"), + } + writeln!( + out, + " rand={} mood={:08x} underwater={} delay={}", + ambience.random.clone().next_long(), + ambience.moodiness.to_bits(), + ambience.was_underwater(), + ambience.underwater_delay() + ) + .expect("write"); + for (event, id) in ambience.loops() { + let i = engine.instance(*id).expect("loop"); + let Ticking::BiomeLoop { fade, direction } = i.ticking else { + panic!("loop kind"); + }; + writeln!( + out, + " loop {event} fade={fade} direction={direction} stopped={} active={}", + i.stopped, + engine.is_active(*id) + ) + .expect("write"); + } + let mut playing: Vec = engine + .active_instances() + .into_iter() + .map(|id| { + let i = engine.instance(id).expect("instance"); + format!( + " playing {} volume={:08x} looping={} relative={} at={:016x},{:016x},{:016x} stopped={}", + i.identifier, + i.volume.to_bits(), + i.looping, + i.relative, + i.position[0].to_bits(), + i.position[1].to_bits(), + i.position[2].to_bits(), + i.tickable() && i.stopped + ) + }) + .collect(); + playing.sort(); + for p in playing { + writeln!(out, "{p}").expect("write"); + } + flush(&mut engine, &mut out); + } +} diff --git a/crates/horizon-client/src/ambience.rs b/crates/horizon-client/src/ambience.rs index 860a080a6..e6014cedc 100644 --- a/crates/horizon-client/src/ambience.rs +++ b/crates/horizon-client/src/ambience.rs @@ -128,6 +128,14 @@ impl Ambience { pub fn was_underwater(&self) -> bool { self.was_underwater } + /// `BiomeAmbientSoundsHandler.loopSounds`. + pub fn loops(&self) -> &[(String, InstanceId)] { + &self.loops + } + /// `UnderwaterAmbientSoundHandler.tickDelay`. + pub fn underwater_delay(&self) -> i32 { + self.underwater_delay + } /// A new player (leaving or changing worlds): fresh handlers. pub fn clear(&mut self, sounds: &mut impl Sounds) { for (_, id) in self.loops.drain(..) { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java new file mode 100644 index 000000000..af8b82be6 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java @@ -0,0 +1,216 @@ +package dev.horizonlab.parity; + +import java.io.PrintWriter; +import java.lang.reflect.Method; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.Camera; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.ClientLevel; +import net.minecraft.client.player.LocalPlayer; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.resources.sounds.*; +import net.minecraft.client.sounds.ChannelAccess; +import net.minecraft.client.sounds.SoundEngine; +import net.minecraft.core.BlockPos; +import net.minecraft.core.Holder; +import net.minecraft.resources.Identifier; +import net.minecraft.sounds.SoundEvent; +import net.minecraft.sounds.SoundSource; +import net.minecraft.tags.FluidTags; +import net.minecraft.tags.TagKey; +import net.minecraft.util.RandomSource; +import net.minecraft.world.attribute.*; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.level.Level; +import net.minecraft.world.level.LightLayer; +import net.minecraft.world.level.material.Fluid; +import net.minecraft.world.phys.Vec3; + +/** + * Runs the local player's real ambient sound path over the real SoundEngine + * (VanillaSoundRig): LocalPlayer.updateIsUnderwater (enter/exit sounds through + * ClientLevel.playLocalSound and the UnderLiquidAmbientSoundInstance), the + * UnderwaterAmbientSoundHandler and the BiomeAmbientSoundsHandler, then + * SoundManager.tick, once per client tick. Inputs: the AMBIENT_SOUNDS value + * (a constant attribute layer), the player's position, eye height, whether + * its eyes are in water, spectator and removed flags, and the level's sky and + * block brightness (a hash of the position). Prints the level random's next + * long (without drawing it), the handlers' state and every playing instance. + */ +public final class VanillaAmbientOracle { + public static final class Actor extends LocalPlayer { + boolean eyeInWater, spectator; + + Actor() { + super(null, null, null, null, null, null, false, null, null); + } + + @Override + public boolean isEyeInFluid(final TagKey type) { + return type == FluidTags.WATER && eyeInWater; + } + + @Override + public boolean isSpectator() { + return spectator; + } + } + + public static final class Lvl extends ClientLevel { + int mode; + + Lvl() { + super(null, null, null, null, 0, 0, null, false, 0L, 0); + } + + @Override + public int getBrightness(final LightLayer layer, final BlockPos pos) { + return light(mode, pos.getX(), pos.getY(), pos.getZ())[layer == LightLayer.SKY ? 0 : 1]; + } + } + + /** The scripted brightness: (sky, block) for a light mode and block. */ + static int[] light(int mode, int x, int y, int z) { + int h = x * 73856093 ^ y * 19349663 ^ z * 83492791; + return switch (mode) { + case 0 -> new int[]{15, 0}; + case 1 -> new int[]{0, 0}; + case 2 -> new int[]{0, (h >>> 4) & 15}; + default -> new int[]{(h & 3) == 0 ? (h >>> 8) & 15 : 0, (h >>> 12) & 15}; + }; + } + + static float f(String hex) { + return Float.intBitsToFloat(Integer.parseUnsignedInt(hex, 16)); + } + + static double d(String hex) { + return Double.longBitsToDouble(Long.parseUnsignedLong(hex, 16)); + } + + static Holder event(String id) { + return Holder.direct(SoundEvent.createVariableRangeEvent(Identifier.parse(id))); + } + + /** "loop|- mood|- addition..." with mood "sound,delay,extent,offsetbits" and additions "sound,chancebits". */ + static AmbientSounds sounds(String[] a) { + Optional> loop = a[1].equals("-") ? Optional.empty() : Optional.of(event(a[1])); + Optional mood = Optional.empty(); + if (!a[2].equals("-")) { + String[] m = a[2].split(","); + mood = Optional.of(new AmbientMoodSettings(event(m[0]), Integer.parseInt(m[1]), Integer.parseInt(m[2]), d(m[3]))); + } + var additions = new ArrayList(); + for (int i = 3; i < a.length; i++) { + String[] p = a[i].split(","); + additions.add(new AmbientAdditionsSettings(event(p[0]), d(p[1]))); + } + return new AmbientSounds(loop, mood, additions); + } + + /** LegacyRandomSource's next nextLong(), read from its state. */ + static long peek(RandomSource random) throws Exception { + long s = ((java.util.concurrent.atomic.AtomicLong) VanillaSoundRig.get(random, + Class.forName("net.minecraft.world.level.levelgen.LegacyRandomSource"), "seed")).get(); + long m = 0x5DEECE66DL, mask = (1L << 48) - 1; + long s1 = (s * m + 0xBL) & mask; + long s2 = (s1 * m + 0xBL) & mask; + return ((long) (int) (s1 >>> 16) << 32) + (int) (s2 >>> 16); + } + + static String bits(double v) { + return String.format("%016x", Double.doubleToRawLongBits(v)); + } + + @SuppressWarnings("unchecked") + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var rig = new VanillaSoundRig(Path.of(args[0])); + var mc = VanillaSoundRig.make(Minecraft.class); + VanillaSoundRig.set(mc, Minecraft.class, "soundManager", rig.manager); + var renderer = VanillaSoundRig.make(GameRenderer.class); + VanillaSoundRig.set(renderer, GameRenderer.class, "mainCamera", VanillaSoundRig.make(Camera.class)); + VanillaSoundRig.set(VanillaSoundRig.get(renderer, GameRenderer.class, "mainCamera"), Camera.class, "position", Vec3.ZERO); + VanillaSoundRig.set(mc, Minecraft.class, "gameRenderer", renderer); + Method update = LocalPlayer.class.getDeclaredMethod("updateIsUnderwater"); + update.setAccessible(true); + var instanceToChannel = VanillaSoundRig.field(SoundEngine.class, "instanceToChannel"); + Lvl level = null; + Actor actor = null; + UnderwaterAmbientSoundHandler underwater = null; + BiomeAmbientSoundsHandler biome = null; + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2])))) { + for (String line : Files.readAllLines(Path.of(args[1]))) { + out.println(line); + String[] a = line.split(" "); + switch (a[0]) { + case "start" -> { + // A new level and player: fresh handlers on a seeded level random. + rig.manager.stop(); + level = VanillaSoundRig.make(Lvl.class); + VanillaSoundRig.set(level, Level.class, "random", RandomSource.create(Long.parseLong(a[1]))); + VanillaSoundRig.set(level, ClientLevel.class, "minecraft", mc); + VanillaSoundRig.set(level, ClientLevel.class, "environmentAttributes", EnvironmentAttributeSystem.builder().build()); + actor = VanillaSoundRig.make(Actor.class); + VanillaSoundRig.set(actor, Entity.class, "level", level); + VanillaSoundRig.set(actor, Entity.class, "position", Vec3.ZERO); + VanillaSoundRig.set(actor, LocalPlayer.class, "minecraft", mc); + underwater = new UnderwaterAmbientSoundHandler(actor, rig.manager); + biome = new BiomeAmbientSoundsHandler(actor, rig.manager); + } + case "sounds" -> { + AmbientSounds value = sounds(a); + var system = EnvironmentAttributeSystem.builder() + .addConstantLayer(EnvironmentAttributes.AMBIENT_SOUNDS, base -> value) + .build(); + VanillaSoundRig.set(level, ClientLevel.class, "environmentAttributes", system); + } + case "player" -> { + // player x y z eyeHeight eyeInWater spectator removed lightMode + VanillaSoundRig.set(actor, Entity.class, "position", new Vec3(d(a[1]), d(a[2]), d(a[3]))); + VanillaSoundRig.set(actor, Entity.class, "eyeHeight", f(a[4])); + actor.eyeInWater = a[5].equals("1"); + actor.spectator = a[6].equals("1"); + VanillaSoundRig.set(actor, Entity.class, "removalReason", a[7].equals("1") ? Entity.RemovalReason.DISCARDED : null); + level.mode = Integer.parseInt(a[8]); + } + case "volume" -> { + rig.volume(SoundSource.values()[Integer.parseInt(a[1])], f(a[2])); + rig.manager.refreshCategoryVolume(SoundSource.values()[Integer.parseInt(a[1])]); + } + case "tick" -> { + update.invoke(actor); + underwater.tick(); + biome.tick(); + rig.manager.tick(false); + } + default -> throw new IllegalArgumentException(line); + } + out.printf(" rand=%d mood=%08x underwater=%s delay=%d%n", peek(level.getRandom()), Float.floatToRawIntBits(biome.getMoodiness()), + actor.isUnderWater(), (int) VanillaSoundRig.get(underwater, UnderwaterAmbientSoundHandler.class, "tickDelay")); + var loops = (Map, BiomeAmbientSoundsHandler.LoopSoundInstance>) VanillaSoundRig.get(biome, + BiomeAmbientSoundsHandler.class, "loopSounds"); + for (var e : loops.entrySet()) { + var loop = e.getValue(); + out.printf(" loop %s fade=%d direction=%d stopped=%s active=%s%n", e.getKey().value().location(), + (int) VanillaSoundRig.get(loop, BiomeAmbientSoundsHandler.LoopSoundInstance.class, "fade"), + (int) VanillaSoundRig.get(loop, BiomeAmbientSoundsHandler.LoopSoundInstance.class, "fadeDirection"), loop.isStopped(), + rig.manager.isActive(loop)); + } + var playing = new ArrayList(); + for (SoundInstance i : ((Map) instanceToChannel.get(rig.engine)).keySet()) { + float volume = (float) VanillaSoundRig.get(i, AbstractSoundInstance.class, "volume"); + playing.add(String.format(" playing %s volume=%08x looping=%s relative=%s at=%s,%s,%s stopped=%s", i.getIdentifier(), + Float.floatToRawIntBits(volume), i.isLooping(), i.isRelative(), bits(i.getX()), bits(i.getY()), bits(i.getZ()), + i instanceof TickableSoundInstance t && t.isStopped())); + } + Collections.sort(playing); + for (String p : playing) out.println(p); + rig.flush(out); + } + } + System.exit(0); + } +} diff --git a/tools/test_ambient_sound_parity.py b/tools/test_ambient_sound_parity.py new file mode 100644 index 000000000..8fffae013 --- /dev/null +++ b/tools/test_ambient_sound_parity.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 +"""Compare the local player's ambient sounds with the vanilla 26.3 client. + +The oracle runs the real `LocalPlayer.updateIsUnderwater` (enter/exit sounds +seeded from the level random, the `UnderLiquidAmbientSoundInstance`), +`UnderwaterAmbientSoundHandler` and `BiomeAmbientSoundsHandler` over the real +`SoundEngine` (see VanillaSoundRig), then `SoundManager.tick`, once per client +tick. The `AMBIENT_SOUNDS` value (loops, moods and additions from the biomes +and dimensions of the data pack plus faster custom moods), the player's +position, eye height, eyes in water, spectator and removed flags and the +level's brightness are script inputs. Every step prints the level random's +next long (so every draw is compared), moodiness, the underwater state and +delay, the handler's loop instances (fade, direction, stopped, active), each +playing instance and the subtitle notifications. Horizon's `Ambience` and +`SoundEngine` replay the scripts. +""" +import json +import random +import struct + +try: + from . import audio_harness as h +except ImportError: + import audio_harness as h + + +def dbits(v): + return struct.pack('>d', v).hex() + + +def settings(): + """Every AMBIENT_SOUNDS value in the data pack.""" + data = h.RESOURCES / 'data/minecraft' + values = [] + for path in sorted(list((data / 'worldgen/biome').glob('*.json')) + list((data / 'dimension_type').glob('*.json'))): + v = json.loads(path.read_text()).get('attributes', {}).get('minecraft:audio/ambient_sounds') + if v is None: + continue + additions = v.get('additions', []) + if isinstance(additions, dict): + additions = [additions] + mood = v.get('mood') + values.append(dict(loop=v.get('loop'), mood=None if mood is None else (mood['sound'], mood['tick_delay'], mood['block_search_extent'], mood['offset']), + additions=[(a['sound'], a['tick_chance']) for a in additions])) + return values + + +class Script: + def __init__(self): + self.lines = [] + + def add(self, *parts): + self.lines.append(' '.join(map(str, parts))) + + def sounds(self, value): + mood = '-' if value['mood'] is None else '{},{},{},{}'.format(value['mood'][0], value['mood'][1], value['mood'][2], dbits(value['mood'][3])) + self.add('sounds', value['loop'] or '-', mood, *[f'{s},{dbits(c)}' for s, c in value['additions']]) + + def player(self, at=(0.5, 64.0, 0.5), eye=1.62, water=0, spectator=0, removed=0, mode=0): + self.add('player', *map(dbits, at), h.bits(eye), water, spectator, removed, mode) + + def tick(self, n=1): + for _ in range(n): + self.add('tick') + + +def scripted(s, values): + by_loop = [v for v in values if v['loop']] + cave = next(v for v in values if v['mood'] and v['mood'][0] == 'minecraft:ambient.cave' and not v['loop']) + s.add('start', 1) + s.sounds(cave) + s.player(mode=1) + s.tick(6100) + s.player((100.25, -20.0, -7.75), mode=2) + s.tick(400) + s.player((3.5, 12.0, 3.5), mode=3) + s.tick(400) + # Biome loops cross-fading, back and forth. + s.add('start', 2) + for v in by_loop: + s.sounds(v) + s.tick(30) + s.sounds(by_loop[0]) + s.tick(20) + s.sounds(by_loop[1]) + s.tick(5) + s.sounds(by_loop[0]) + s.tick(60) + s.sounds(dict(loop=None, mood=None, additions=[])) + s.tick(60) + # Water: enter, the loop's fade, sub-sounds, exit, re-entering mid-fade, spectators. + s.add('start', 3) + s.sounds(cave) + s.player(water=1, mode=0) + s.tick(300) + s.player(water=0) + s.tick(10) + s.player(water=1) + s.tick(3) + s.player(water=0) + s.tick(2) + s.player(water=1) + s.tick(60) + s.player(water=1, spectator=1) + s.tick(5) + s.player(water=0, spectator=1) + s.tick(5) + s.player(water=1, removed=1) + s.tick(5) + s.player(water=0) + s.tick(25) + # Silent ambient category: loops never start and linger. + s.add('start', 4) + s.add('volume', 8, h.bits(0.0)) + s.sounds(by_loop[0]) + s.tick(50) + s.add('volume', 8, h.bits(1.0)) + s.sounds(by_loop[1]) + s.tick(50) + s.sounds(by_loop[0]) + s.tick(50) + + +def fuzz(s, rng, values, steps): + s.add('start', rng.getrandbits(63)) + for _ in range(steps): + op = rng.random() + if op < 0.05: + v = rng.choice(values + [dict(loop=None, mood=None, additions=[])]) + if rng.random() < 0.5 and v['mood']: + v = dict(v, mood=(v['mood'][0], rng.choice([20, 60, 150]), rng.choice([1, 4, 8, 16]), rng.choice([0.0, 2.0, 5.5]))) + s.sounds(v) + elif op < 0.12: + at = (rng.uniform(-3e4, 3e4) if rng.random() < 0.2 else rng.uniform(-200, 200), rng.uniform(-64, 320), rng.uniform(-200, 200)) + s.player(at, rng.choice([1.62, 1.27, 0.4, 0.2]), int(rng.random() < 0.4), int(rng.random() < 0.05), int(rng.random() < 0.03), rng.randrange(4)) + elif op < 0.13: + s.add('volume', rng.choice([0, 8]), h.bits(rng.choice([0.0, 1.0, 0.5]))) + else: + s.tick(rng.randrange(1, 40)) + + +def fixtures(): + values = settings() + s = Script() + scripted(s, values) + rng = random.Random(0x414d4249) + for _ in range(40): + fuzz(s, rng, values, 150) + return s.lines + + +def main(): + lines = fixtures() + matched, report = h.run_harness( + 'ambient', 'VanillaAmbientOracle', 'ambient_fixture', ''.join(l + '\n' for l in lines), + extra_sources=[h.lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundRig.java', + h.lab.ROOT / 'crates/horizon-client/src/ambience.rs', + h.lab.ROOT / 'crates/horizon-client/examples/audio_common/mod.rs'], + java_args=[h.RESOURCES], rust_args=[h.RESOURCES], + scope='Real LocalPlayer.updateIsUnderwater, UnderwaterAmbientSoundHandler and BiomeAmbientSoundsHandler (loop cross-fades, additions, ' + 'cave mood sampling, moodiness and the mood sound position) with UnderLiquidAmbientSoundInstance/UnderLiquidSubSound/LoopSoundInstance ' + 'ticking in the real SoundEngine: every level random draw, handler state, playing instance and notification per tick. The ' + 'AMBIENT_SOUNDS value, eyes-in-water state and brightness are inputs. BubbleColumnAmbientSoundHandler is not compared.') + print(f'{matched:,} ambient lines match the pinned client ({len(lines):,} steps): {report}', flush=True) + + +if __name__ == '__main__': + main() From b93f72c0da6b33ea1cbd42993dc6ae81b4a6b473 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 22:03:51 +0200 Subject: [PATCH 7/9] Play bubble column inside sounds as BubbleColumnAmbientSoundHandler does Co-Authored-By: Claude Opus 5.5 --- .../examples/ambient_fixture.rs | 26 ++++- crates/horizon-client/src/ambience.rs | 94 +++++++++++++++++-- crates/horizon-client/src/game/music.rs | 26 +++++ crates/horizon-client/src/sound_engine.rs | 1 + .../parity/VanillaAmbientOracle.java | 33 +++++++ tools/test_ambient_sound_parity.py | 36 ++++++- 6 files changed, 204 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/examples/ambient_fixture.rs b/crates/horizon-client/examples/ambient_fixture.rs index 70a50fd87..666235008 100644 --- a/crates/horizon-client/examples/ambient_fixture.rs +++ b/crates/horizon-client/examples/ambient_fixture.rs @@ -4,7 +4,7 @@ #[path = "audio_common/mod.rs"] mod common; use common::{Fake, d, f, flush}; -use horizon_client::ambience::{Ambience, AmbientContext, AmbientSounds, Mood}; +use horizon_client::ambience::{Ambience, AmbientContext, AmbientSounds, Mood, bubble_column_in}; use horizon_client::sound_engine::{Bound, SoundEngine, TickContext, Ticking}; use horizon_client::sound_events::{SoundRegistry, normalize}; use horizon_core::random::RandomSource; @@ -56,6 +56,8 @@ fn main() { let mut current = AmbientSounds::default(); let (mut position, mut eye, mut eye_in_water, mut spectator, mut removed, mut mode) = ([0.0f64; 3], 0.0f32, false, false, false, 0); + let mut height = 1.8f32; + let mut columns: Vec<([i32; 3], bool)> = Vec::new(); let input = std::fs::read_to_string(&args[2]).expect("input"); let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); for line in input.lines() { @@ -72,6 +74,8 @@ fn main() { current = AmbientSounds::default(); (position, eye, eye_in_water, spectator, removed, mode) = ([0.0; 3], 0.0, false, false, false, 0); + height = 1.8; + columns.clear(); } "sounds" => current = sounds(&a), "player" => { @@ -81,6 +85,15 @@ fn main() { spectator = a[6] == "1"; removed = a[7] == "1"; mode = a[8].parse().expect("mode"); + height = f(a[9]); + columns = a[10..] + .iter() + .map(|c| { + let p: Vec<&str> = c.split(',').collect(); + let n = |i: usize| p[i].parse::().expect("column"); + ([n(0), n(1), n(2)], p[3] == "1") + }) + .collect(); } "volume" => { let source: usize = a[1].parse().expect("source"); @@ -96,6 +109,17 @@ fn main() { underwater: eye_in_water, spectator, light: &light, + bubble_column: bubble_column_in( + [ + position[0] - f64::from(0.3f32), + position[1], + position[2] - f64::from(0.3f32), + position[0] + f64::from(0.3f32), + position[1] + f64::from(height), + position[2] + f64::from(0.3f32), + ], + |b| columns.iter().find(|c| c.0 == b).map(|c| c.1), + ), }; ambience.tick( &ctx, diff --git a/crates/horizon-client/src/ambience.rs b/crates/horizon-client/src/ambience.rs index e6014cedc..f3cbeb0e1 100644 --- a/crates/horizon-client/src/ambience.rs +++ b/crates/horizon-client/src/ambience.rs @@ -3,7 +3,7 @@ //! `minecraft:audio/ambient_sounds` attribute, `UnderwaterAmbientSoundHandler` //! and `LocalPlayer.updateIsUnderwater` (enter/exit sounds and the //! `UnderLiquidAmbientSoundInstance` loop), played through the sound engine. -use crate::sound_engine::{AMBIENT, InstanceId, SoundEngine, SoundInstance, Sounds}; +use crate::sound_engine::{AMBIENT, InstanceId, PLAYERS, SoundEngine, SoundInstance, Sounds}; use horizon_core::random::{LegacyRandom, RandomSource}; use serde_json::Value; use std::{collections::HashMap, fs, path::Path}; @@ -94,6 +94,51 @@ pub struct AmbientContext<'a> { pub spectator: bool, /// `Level.getBrightness` (sky, block) at a block. pub light: &'a dyn Fn([i32; 3]) -> (u8, u8), + /// The bubble column in the player's box (its `drag` property), from + /// `bubble_column_in`. + pub bubble_column: Option, +} +/// `BubbleColumnAmbientSoundHandler`'s lookup: the first bubble column +/// (x fastest, then y, then z) in the player's bounding box inflated by +/// (0, -0.4F, 0) and deflated by 1.0E-6, as `drag_down`. `state` gives the +/// bubble column at a block (None for anything else). +pub fn bubble_column_in(bb: [f64; 6], state: impl Fn([i32; 3]) -> Option) -> Option { + // AABB keeps min <= max on every construction. + let make = |a: [f64; 6]| { + [ + a[0].min(a[3]), + a[1].min(a[4]), + a[2].min(a[5]), + a[0].max(a[3]), + a[1].max(a[4]), + a[2].max(a[5]), + ] + }; + let inflate = |b: [f64; 6], x: f64, y: f64, z: f64| { + make([b[0] - x, b[1] - y, b[2] - z, b[3] + x, b[4] + y, b[5] + z]) + }; + let b = inflate(make(bb), 0.0, f64::from(-0.4f32), 0.0); + let b = inflate(b, -1.0E-6, -1.0E-6, -1.0E-6); + let (x0, y0, z0) = ( + b[0].floor() as i32, + b[1].floor() as i32, + b[2].floor() as i32, + ); + let (x1, y1, z1) = ( + b[3].floor() as i32, + b[4].floor() as i32, + b[5].floor() as i32, + ); + for z in z0..=z1 { + for y in y0..=y1 { + for x in x0..=x1 { + if let Some(drag) = state([x, y, z]) { + return Some(drag); + } + } + } + } + None } /// The local player's ambient sound handlers. pub struct Ambience { @@ -107,6 +152,9 @@ pub struct Ambience { underwater_delay: i32, /// `LocalPlayer.wasUnderwater`. was_underwater: bool, + /// `BubbleColumnAmbientSoundHandler.wasInBubbleColumn` / `firstTick`. + was_in_bubble_column: bool, + first_tick: bool, } impl Default for Ambience { fn default() -> Self { @@ -122,6 +170,8 @@ impl Ambience { moodiness: 0.0, underwater_delay: 0, was_underwater: false, + was_in_bubble_column: false, + first_tick: true, } } /// `LocalPlayer.isUnderWater`. @@ -145,11 +195,13 @@ impl Ambience { self.moodiness = 0.0; self.underwater_delay = 0; self.was_underwater = false; + self.was_in_bubble_column = false; + self.first_tick = true; } - /// `ClientLevel.playLocalSound(x, y, z, sound, AMBIENT, 1, 1, false)`. - fn play_local(&mut self, event: &str, at: [f64; 3], sounds: &mut impl Sounds) { + /// `ClientLevel.playLocalSound(x, y, z, sound, source, 1, 1, false)`. + fn play_local(&mut self, event: &str, source: usize, at: [f64; 3], sounds: &mut impl Sounds) { let seed = self.random.next_long(); - let instance = SoundInstance::at(event, AMBIENT, 1.0, 1.0, LegacyRandom::new(seed), at); + let instance = SoundInstance::at(event, source, 1.0, 1.0, LegacyRandom::new(seed), at); sounds.play_instance(instance, false); } /// `LocalPlayer.updateIsUnderwater`, then the `ambientSoundHandlers` @@ -159,7 +211,12 @@ impl Ambience { self.was_underwater = ctx.underwater; if !ctx.spectator { if !old && ctx.underwater { - self.play_local("minecraft:ambient.underwater.enter", ctx.position, sounds); + self.play_local( + "minecraft:ambient.underwater.enter", + AMBIENT, + ctx.position, + sounds, + ); let instance = SoundInstance::under_liquid_loop( "minecraft:ambient.underwater.loop", SoundEngine::unseeded(), @@ -167,12 +224,36 @@ impl Ambience { sounds.play_instance(instance, false); } if old && !ctx.underwater { - self.play_local("minecraft:ambient.underwater.exit", ctx.position, sounds); + self.play_local( + "minecraft:ambient.underwater.exit", + AMBIENT, + ctx.position, + sounds, + ); } } self.tick_underwater(sounds); + self.tick_bubble_column(ctx, sounds); self.tick_biome(ctx, sounds); } + /// `BubbleColumnAmbientSoundHandler.tick`: entering a column plays its + /// inside sound (`LocalPlayer.playSound`, on PLAYERS). + fn tick_bubble_column(&mut self, ctx: &AmbientContext, sounds: &mut impl Sounds) { + if let Some(drag_down) = ctx.bubble_column { + if !self.was_in_bubble_column && !self.first_tick && !ctx.spectator { + let event = if drag_down { + "minecraft:block.bubble_column.whirlpool_inside" + } else { + "minecraft:block.bubble_column.upwards_inside" + }; + self.play_local(event, PLAYERS, ctx.position, sounds); + } + self.was_in_bubble_column = true; + } else { + self.was_in_bubble_column = false; + } + self.first_tick = false; + } /// `UnderwaterAmbientSoundHandler.tick`. fn tick_underwater(&mut self, sounds: &mut impl Sounds) { self.underwater_delay -= 1; @@ -317,6 +398,7 @@ mod tests { underwater, spectator: false, light, + bubble_column: None, } } diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs index 699996e11..463dbce1c 100644 --- a/crates/horizon-client/src/game/music.rs +++ b/crates/horizon-client/src/game/music.rs @@ -101,6 +101,31 @@ impl Game<'_> { let l = world.light(b[0], b[1], b[2]); (l >> 4, l & 15) }; + let (half, height) = ( + f64::from(p.dimensions.width / 2.0), + f64::from(p.dimensions.height), + ); + let registry = &self.res.assets.registry; + let facts = &self.res.facts; + let bubble_column = horizon_client::ambience::bubble_column_in( + [ + feet[0] - half, + feet[1], + feet[2] - half, + feet[0] + half, + feet[1] + height, + feet[2] + half, + ], + |b| { + let state = world.block(b[0], b[1], b[2]); + (&*facts.get(state).name == "minecraft:bubble_column").then(|| { + registry + .state(state) + .and_then(|s| s.properties.get("drag")) + .is_some_and(|d| d == "true") + }) + }, + ); let ctx = horizon_client::ambience::AmbientContext { sounds: &sounds, position: feet, @@ -108,6 +133,7 @@ impl Game<'_> { underwater, spectator: self.spectator(), light: &light, + bubble_column, }; self.ambience.tick(&ctx, &mut self.audio); } diff --git a/crates/horizon-client/src/sound_engine.rs b/crates/horizon-client/src/sound_engine.rs index 2a47b5db2..288e85faf 100644 --- a/crates/horizon-client/src/sound_engine.rs +++ b/crates/horizon-client/src/sound_engine.rs @@ -17,6 +17,7 @@ use std::collections::HashMap; pub const MASTER: usize = 0; pub const MUSIC: usize = 1; pub const RECORDS: usize = 2; +pub const PLAYERS: usize = 7; pub const AMBIENT: usize = 8; pub const UI: usize = 10; /// The pool sizes `Library.init` derives from OpenAL Soft's default 255 mono diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java index af8b82be6..d20c5f892 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaAmbientOracle.java @@ -24,6 +24,10 @@ import net.minecraft.world.attribute.*; import net.minecraft.world.entity.Entity; import net.minecraft.world.level.Level; import net.minecraft.world.level.LightLayer; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.block.BubbleColumnBlock; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.phys.AABB; import net.minecraft.world.level.material.Fluid; import net.minecraft.world.phys.Vec3; @@ -59,6 +63,7 @@ public final class VanillaAmbientOracle { public static final class Lvl extends ClientLevel { int mode; + final Map columns = new HashMap<>(); Lvl() { super(null, null, null, null, 0, 0, null, false, 0L, 0); @@ -68,6 +73,17 @@ public final class VanillaAmbientOracle { public int getBrightness(final LightLayer layer, final BlockPos pos) { return light(mode, pos.getX(), pos.getY(), pos.getZ())[layer == LightLayer.SKY ? 0 : 1]; } + + @Override + public BlockState getBlockState(final BlockPos pos) { + Boolean drag = columns.get(pos); + return drag == null ? Blocks.AIR.defaultBlockState() : Blocks.BUBBLE_COLUMN.defaultBlockState().setValue(BubbleColumnBlock.DRAG_DOWN, drag); + } + + @Override + public boolean hasChunksAt(final int x0, final int y0, final int z0, final int x1, final int y1, final int z1) { + return true; + } } /** The scripted brightness: (sky, block) for a light mode and block. */ @@ -81,6 +97,11 @@ public final class VanillaAmbientOracle { }; } + /** The player's box (EntityDimensions.makeBoundingBox, width 0.6F). */ + static AABB box(Vec3 at, float height) { + return new AABB(at.x - 0.3F, at.y, at.z - 0.3F, at.x + 0.3F, at.y + height, at.z + 0.3F); + } + static float f(String hex) { return Float.intBitsToFloat(Integer.parseUnsignedInt(hex, 16)); } @@ -141,6 +162,7 @@ public final class VanillaAmbientOracle { Actor actor = null; UnderwaterAmbientSoundHandler underwater = null; BiomeAmbientSoundsHandler biome = null; + BubbleColumnAmbientSoundHandler bubble = null; try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2])))) { for (String line : Files.readAllLines(Path.of(args[1]))) { out.println(line); @@ -156,8 +178,11 @@ public final class VanillaAmbientOracle { actor = VanillaSoundRig.make(Actor.class); VanillaSoundRig.set(actor, Entity.class, "level", level); VanillaSoundRig.set(actor, Entity.class, "position", Vec3.ZERO); + VanillaSoundRig.set(actor, Entity.class, "bb", box(Vec3.ZERO, 1.8F)); + VanillaSoundRig.set(level, Lvl.class, "columns", new HashMap()); VanillaSoundRig.set(actor, LocalPlayer.class, "minecraft", mc); underwater = new UnderwaterAmbientSoundHandler(actor, rig.manager); + bubble = new BubbleColumnAmbientSoundHandler(actor); biome = new BiomeAmbientSoundsHandler(actor, rig.manager); } case "sounds" -> { @@ -175,6 +200,13 @@ public final class VanillaAmbientOracle { actor.spectator = a[6].equals("1"); VanillaSoundRig.set(actor, Entity.class, "removalReason", a[7].equals("1") ? Entity.RemovalReason.DISCARDED : null); level.mode = Integer.parseInt(a[8]); + var at = new Vec3(d(a[1]), d(a[2]), d(a[3])); + VanillaSoundRig.set(actor, Entity.class, "bb", box(at, f(a[9]))); + level.columns.clear(); + for (int i = 10; i < a.length; i++) { + String[] c = a[i].split(","); + level.columns.put(new BlockPos(Integer.parseInt(c[0]), Integer.parseInt(c[1]), Integer.parseInt(c[2])), c[3].equals("1")); + } } case "volume" -> { rig.volume(SoundSource.values()[Integer.parseInt(a[1])], f(a[2])); @@ -183,6 +215,7 @@ public final class VanillaAmbientOracle { case "tick" -> { update.invoke(actor); underwater.tick(); + bubble.tick(); biome.tick(); rig.manager.tick(false); } diff --git a/tools/test_ambient_sound_parity.py b/tools/test_ambient_sound_parity.py index 8fffae013..8906d2d7a 100644 --- a/tools/test_ambient_sound_parity.py +++ b/tools/test_ambient_sound_parity.py @@ -3,7 +3,8 @@ The oracle runs the real `LocalPlayer.updateIsUnderwater` (enter/exit sounds seeded from the level random, the `UnderLiquidAmbientSoundInstance`), -`UnderwaterAmbientSoundHandler` and `BiomeAmbientSoundsHandler` over the real +`UnderwaterAmbientSoundHandler`, `BubbleColumnAmbientSoundHandler` and +`BiomeAmbientSoundsHandler` over the real `SoundEngine` (see VanillaSoundRig), then `SoundManager.tick`, once per client tick. The `AMBIENT_SOUNDS` value (loops, moods and additions from the biomes and dimensions of the data pack plus faster custom moods), the player's @@ -56,8 +57,9 @@ class Script: mood = '-' if value['mood'] is None else '{},{},{},{}'.format(value['mood'][0], value['mood'][1], value['mood'][2], dbits(value['mood'][3])) self.add('sounds', value['loop'] or '-', mood, *[f'{s},{dbits(c)}' for s, c in value['additions']]) - def player(self, at=(0.5, 64.0, 0.5), eye=1.62, water=0, spectator=0, removed=0, mode=0): - self.add('player', *map(dbits, at), h.bits(eye), water, spectator, removed, mode) + def player(self, at=(0.5, 64.0, 0.5), eye=1.62, water=0, spectator=0, removed=0, mode=0, height=1.8, columns=()): + self.add('player', *map(dbits, at), h.bits(eye), water, spectator, removed, mode, h.bits(height), + *[f'{x},{y},{z},{d}' for x, y, z, d in columns]) def tick(self, n=1): for _ in range(n): @@ -119,6 +121,25 @@ def scripted(s, values): s.tick(50) s.sounds(by_loop[0]) s.tick(50) + # Bubble columns: entering, staying, the first tick, spectators, small boxes. + s.add('start', 5) + column = [(0, 64, 0, 1), (0, 65, 0, 1)] + s.player((0.5, 64.0, 0.5), water=1, columns=column) + s.tick(3) + s.player((3.5, 64.0, 0.5), water=1, columns=column) + s.tick(2) + s.player((0.5, 64.0, 0.5), water=1, columns=column) + s.tick(2) + s.player((0.5, 64.0, 0.5), water=1, columns=[(0, 64, 0, 0), (1, 64, 0, 1)]) + s.tick(2) + s.player((3.5, 64.0, 0.5)) + s.tick(2) + s.player((0.9, 64.5, 0.5), water=1, height=0.6, columns=[(1, 64, 0, 0), (0, 64, 0, 1)]) + s.tick(2) + s.player((3.5, 64.0, 0.5)) + s.tick(1) + s.player((0.5, 63.7, 0.5), spectator=1, columns=column) + s.tick(2) def fuzz(s, rng, values, steps): @@ -132,7 +153,12 @@ def fuzz(s, rng, values, steps): s.sounds(v) elif op < 0.12: at = (rng.uniform(-3e4, 3e4) if rng.random() < 0.2 else rng.uniform(-200, 200), rng.uniform(-64, 320), rng.uniform(-200, 200)) - s.player(at, rng.choice([1.62, 1.27, 0.4, 0.2]), int(rng.random() < 0.4), int(rng.random() < 0.05), int(rng.random() < 0.03), rng.randrange(4)) + columns = [] + if rng.random() < 0.3: + bx, by, bz = int(at[0] // 1), int(at[1] // 1), int(at[2] // 1) + columns = [(bx + rng.randrange(-1, 2), by + rng.randrange(-1, 3), bz + rng.randrange(-1, 2), rng.randrange(2)) for _ in range(rng.randrange(1, 4))] + s.player(at, rng.choice([1.62, 1.27, 0.4, 0.2]), int(rng.random() < 0.4), int(rng.random() < 0.05), int(rng.random() < 0.03), rng.randrange(4), + rng.choice([1.8, 1.5, 0.6]), columns) elif op < 0.13: s.add('volume', rng.choice([0, 8]), h.bits(rng.choice([0.0, 1.0, 0.5]))) else: @@ -160,7 +186,7 @@ def main(): scope='Real LocalPlayer.updateIsUnderwater, UnderwaterAmbientSoundHandler and BiomeAmbientSoundsHandler (loop cross-fades, additions, ' 'cave mood sampling, moodiness and the mood sound position) with UnderLiquidAmbientSoundInstance/UnderLiquidSubSound/LoopSoundInstance ' 'ticking in the real SoundEngine: every level random draw, handler state, playing instance and notification per tick. The ' - 'AMBIENT_SOUNDS value, eyes-in-water state and brightness are inputs. BubbleColumnAmbientSoundHandler is not compared.') + 'AMBIENT_SOUNDS value, eyes-in-water state and brightness are inputs. BubbleColumnAmbientSoundHandler runs on a scripted block world.') print(f'{matched:,} ambient lines match the pinned client ({len(lines):,} steps): {report}', flush=True) From 1357e2f01b0475b06cff6870ece1497892beab69 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 22:10:06 +0200 Subject: [PATCH 8/9] Choose situational music exactly as Minecraft.getSituationalMusic does Situation captures the screen music, the menu without a player, End boss music, creative abilities and underwater selection and the music volume; the harness calls the real getSituationalMusic/getMusicVolume with a real camera attribute probe for every dimension and biome. Co-Authored-By: Claude Opus 5.5 --- .../examples/situational_music_fixture.rs | 47 +++++++ crates/horizon-client/src/game/music.rs | 53 ++++--- crates/horizon-client/src/music.rs | 45 ++++++ .../parity/VanillaSituationalMusicOracle.java | 130 ++++++++++++++++++ tools/test_situational_music_parity.py | 45 ++++++ 5 files changed, 300 insertions(+), 20 deletions(-) create mode 100644 crates/horizon-client/examples/situational_music_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSituationalMusicOracle.java create mode 100644 tools/test_situational_music_parity.py diff --git a/crates/horizon-client/examples/situational_music_fixture.rs b/crates/horizon-client/examples/situational_music_fixture.rs new file mode 100644 index 000000000..ae47426bb --- /dev/null +++ b/crates/horizon-client/examples/situational_music_fixture.rs @@ -0,0 +1,47 @@ +//! `getSituationalMusic`/`getMusicVolume` through Horizon's `Situation` for +//! `tools/test_situational_music_parity.py`: +//! `situational_music_fixture ROOT INPUT OUTPUT`. +use horizon_client::music::{BackgroundMusic, Music, MusicTables, Situation}; +use horizon_client::sound_events::normalize; +use std::io::Write; + +fn main() { + let args: Vec = std::env::args().collect(); + let tables = MusicTables::load(std::path::Path::new(&args[1])); + let input = std::fs::read_to_string(&args[2]).expect("input"); + let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3]).expect("output")); + for line in input.lines() { + let f: Vec<&str> = line.split(' ').collect(); + let in_world = f[1] == "1"; + let (background, probe_volume) = if in_world { + (tables.background(f[2], f[3]), tables.volume(f[2], f[3])) + } else { + (BackgroundMusic::default(), 1.0) + }; + let situation = Situation { + screen_music: (f[0] == "win").then(Music::credits), + in_world, + in_end: f[2] == "minecraft:the_end", + boss_music: f[4].contains("music"), + background: &background, + probe_volume, + creative: f[5] == "1" && f[6] == "1", + underwater: f[7] == "1", + }; + let music = situation.music().map_or("-".to_owned(), |m| { + format!( + "{},{},{},{}", + normalize(&m.sound), + m.min_delay, + m.max_delay, + m.replace_current_music + ) + }); + writeln!( + out, + "{line} music={music} volume={:08x}", + situation.volume().to_bits() + ) + .expect("write"); + } +} diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs index 463dbce1c..59c14f998 100644 --- a/crates/horizon-client/src/game/music.rs +++ b/crates/horizon-client/src/game/music.rs @@ -1,7 +1,11 @@ //! `Minecraft.getSituationalMusic` and `getMusicVolume` for the music manager, //! the local player's ambient sound handlers and the sound engine tick. use super::Game; -use horizon_client::{blocks::Fluid, music::Music, sound_engine::TickContext}; +use horizon_client::{ + blocks::Fluid, + music::{BackgroundMusic, Music, Situation}, + sound_engine::TickContext, +}; impl Game<'_> { /// `Minecraft.tick` -> `MusicManager.tick`, once per client tick. @@ -32,26 +36,35 @@ impl Game<'_> { } /// `getSituationalMusic` and `getMusicVolume`. fn situational_music(&self) -> (Option, f32) { - // Title screen: no player, Musics.MENU at full volume. - if self.title.is_some() { - return (Some(Music::menu()), 1.0); - } - let Some(eye) = self.eye_position() else { - return (Some(Music::menu()), 1.0); + let empty = BackgroundMusic::default(); + // The title screen has no player (and no level for the camera probe). + let eye = if self.title.is_some() { + None + } else { + self.eye_position() }; - let biome = self.biome_at(eye); - let dimension = self.dim.id(); - let tables = &self.res.music; - let volume = tables.volume(dimension, biome); - // Minecraft.getSituationalMusic: the boss overlay's music in the End. - if self.dim == super::Dim::End && self.boss_music() { - return (Some(Music::end_boss()), volume); - } - let music = tables - .background(dimension, biome) - .select(self.creative, self.ambience.was_underwater()) - .cloned(); - (music, volume) + let (background, probe_volume) = match eye { + Some(eye) => { + let (dimension, biome) = (self.dim.id(), self.biome_at(eye)); + let tables = &self.res.music; + ( + tables.background(dimension, biome), + tables.volume(dimension, biome), + ) + } + None => (empty, 1.0), + }; + let situation = Situation { + screen_music: None, + in_world: eye.is_some(), + in_end: self.dim == super::Dim::End, + boss_music: self.boss_music(), + background: &background, + probe_volume, + creative: self.creative, + underwater: self.ambience.was_underwater(), + }; + (situation.music(), situation.volume()) } /// `BiomeManager.getNoiseBiomeAtPosition`: the quart cell holding a position. fn biome_at(&self, p: [f64; 3]) -> &str { diff --git a/crates/horizon-client/src/music.rs b/crates/horizon-client/src/music.rs index 08dbea125..caa8edb3e 100644 --- a/crates/horizon-client/src/music.rs +++ b/crates/horizon-client/src/music.rs @@ -107,6 +107,51 @@ impl Layer { } } } +/// What `Minecraft.getSituationalMusic` and `getMusicVolume` read. +#[derive(Clone, Debug)] +pub struct Situation<'a> { + /// `Screen.getBackgroundMusic` of the open screen. + pub screen_music: Option, + /// `Minecraft.player != null`. + pub in_world: bool, + /// The player's level is the End. + pub in_end: bool, + /// `BossHealthOverlay.shouldPlayMusic`: a boss bar asks for music. + pub boss_music: bool, + /// `BACKGROUND_MUSIC` at the camera. + pub background: &'a BackgroundMusic, + /// `MUSIC_VOLUME` at the camera (1 without a level). + pub probe_volume: f32, + /// `abilities.instabuild && abilities.mayfly`. + pub creative: bool, + /// `LocalPlayer.isUnderWater`. + pub underwater: bool, +} +impl Situation<'_> { + /// `Minecraft.getSituationalMusic`. + pub fn music(&self) -> Option { + if let Some(music) = &self.screen_music { + return Some(music.clone()); + } + if !self.in_world { + return Some(Music::menu()); + } + if self.in_end && self.boss_music { + return Some(Music::end_boss()); + } + self.background + .select(self.creative, self.underwater) + .cloned() + } + /// `Minecraft.getMusicVolume`. + pub fn volume(&self) -> f32 { + if self.screen_music.is_some() { + 1.0 + } else { + self.probe_volume + } + } +} /// Music attributes by dimension type and biome. #[derive(Clone, Debug, Default)] pub struct MusicTables { diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSituationalMusicOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSituationalMusicOracle.java new file mode 100644 index 000000000..e3bf5e6df --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSituationalMusicOracle.java @@ -0,0 +1,130 @@ +package dev.horizonlab.parity; + +import java.io.PrintWriter; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import net.minecraft.SharedConstants; +import net.minecraft.client.Camera; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.Hud; +import net.minecraft.client.gui.components.BossHealthOverlay; +import net.minecraft.client.gui.components.LerpingBossEvent; +import net.minecraft.client.gui.screens.WinScreen; +import net.minecraft.client.multiplayer.ClientLevel; +import net.minecraft.client.player.LocalPlayer; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.core.*; +import net.minecraft.core.registries.Registries; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.Identifier; +import net.minecraft.resources.RegistryDataLoader; +import net.minecraft.resources.ResourceKey; +import net.minecraft.server.Bootstrap; +import net.minecraft.server.RegistryLayer; +import net.minecraft.server.packs.PackType; +import net.minecraft.server.packs.repository.ServerPacksSource; +import net.minecraft.server.packs.resources.MultiPackResourceManager; +import net.minecraft.sounds.Music; +import net.minecraft.tags.TagLoader; +import net.minecraft.world.BossEvent; +import net.minecraft.world.attribute.*; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.player.Abilities; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.level.Level; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.dimension.DimensionType; +import net.minecraft.world.phys.Vec3; + +/** + * Calls the real Minecraft.getSituationalMusic and getMusicVolume on shells + * holding the open screen (none or the credits' WinScreen), the boss overlay's + * events, the player (its level's dimension, abilities and underwater state) + * and a real camera EnvironmentAttributeProbe over the dimension and biome's + * attribute layers from the vanilla data pack. Lines: "screen player + * dimension biome boss instabuild mayfly underwater". + */ +public final class VanillaSituationalMusicOracle { + static String music(Music m) { + return m == null ? "-" : m.sound().value().location() + "," + m.minDelay() + "," + m.maxDelay() + "," + m.replaceCurrentMusic(); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + private static void addBiome(EnvironmentAttributeSystem.Builder b, EnvironmentAttribute attr, Biome biome) { + b.addPositionalLayer(attr, (base, pos, w) -> biome.getAttributes().applyModifier(attr, base)); + } + + static LerpingBossEvent bar(boolean darken, boolean music) { + return new LerpingBossEvent(UUID.randomUUID(), Component.empty(), 1.0F, BossEvent.BossBarColor.PINK, BossEvent.BossBarOverlay.PROGRESS, + darken, music, false); + } + + public static void main(String[] args) throws Exception { + SharedConstants.tryDetectVersion(); + Bootstrap.bootStrap(); + var repo = ServerPacksSource.createVanillaTrustedRepository(); + repo.reload(); + repo.setSelected(List.of("vanilla")); + var resources = new MultiPackResourceManager(PackType.SERVER_DATA, repo.openAllSelected()); + var layers = RegistryLayer.createRegistryAccess(); + var staticTags = TagLoader.loadTagsForExistingRegistries(resources, layers.getLayer(RegistryLayer.STATIC)); + var context = TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD), staticTags); + RegistryAccess.Frozen world = RegistryDataLoader.load(resources, context, RegistryDataLoader.WORLD_REGISTRIES, Runnable::run).join(); + staticTags.forEach(Registry.PendingTags::apply); + var dimensions = world.lookupOrThrow(Registries.DIMENSION_TYPE); + var biomes = world.lookupOrThrow(Registries.BIOME); + + Minecraft mc = VanillaSoundRig.make(Minecraft.class); + Gui gui = VanillaSoundRig.make(Gui.class); + Hud hud = VanillaSoundRig.make(Hud.class); + BossHealthOverlay overlay = VanillaSoundRig.make(BossHealthOverlay.class); + Map events = new LinkedHashMap<>(); + VanillaSoundRig.set(overlay, BossHealthOverlay.class, "events", events); + VanillaSoundRig.set(hud, Hud.class, "bossOverlay", overlay); + VanillaSoundRig.set(gui, Gui.class, "hud", hud); + VanillaSoundRig.set(mc, Minecraft.class, "gui", gui); + GameRenderer renderer = VanillaSoundRig.make(GameRenderer.class); + Camera camera = VanillaSoundRig.make(Camera.class); + VanillaSoundRig.set(renderer, GameRenderer.class, "mainCamera", camera); + VanillaSoundRig.set(mc, Minecraft.class, "gameRenderer", renderer); + WinScreen credits = VanillaSoundRig.make(WinScreen.class); + try (var w = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) { + for (String line : Files.readAllLines(Path.of(args[0]), StandardCharsets.UTF_8)) { + String[] f = line.split(" "); + VanillaSoundRig.set(gui, Gui.class, "screen", f[0].equals("win") ? credits : null); + events.clear(); + if (f[4].contains("dark")) events.put(UUID.randomUUID(), bar(true, false)); + if (f[4].contains("music")) events.put(UUID.randomUUID(), bar(false, true)); + var probe = new EnvironmentAttributeProbe(); + VanillaSoundRig.set(camera, Camera.class, "attributeProbe", probe); + if (f[1].equals("1")) { + DimensionType dim = dimensions.getOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, Identifier.parse(f[2]))).value(); + Biome biome = biomes.getOrThrow(ResourceKey.create(Registries.BIOME, Identifier.parse(f[3]))).value(); + var b = EnvironmentAttributeSystem.builder(); + b.addConstantLayer(dim.attributes()); + for (EnvironmentAttribute attr : biome.getAttributes().keySet()) addBiome(b, attr, biome); + ClientLevel level = VanillaSoundRig.make(ClientLevel.class); + VanillaSoundRig.set(level, ClientLevel.class, "environmentAttributes", b.build()); + VanillaSoundRig.set(level, Level.class, "dimension", f[2].equals("minecraft:the_end") ? Level.END + : f[2].equals("minecraft:the_nether") ? Level.NETHER : Level.OVERWORLD); + VanillaSoundRig.set(probe, EnvironmentAttributeProbe.class, "level", level); + VanillaSoundRig.set(probe, EnvironmentAttributeProbe.class, "position", new Vec3(0.5, 64.0, 0.5)); + LocalPlayer player = VanillaSoundRig.make(LocalPlayer.class); + VanillaSoundRig.set(player, Entity.class, "level", level); + var abilities = new Abilities(); + abilities.instabuild = f[5].equals("1"); + abilities.mayfly = f[6].equals("1"); + VanillaSoundRig.set(player, Player.class, "abilities", abilities); + VanillaSoundRig.set(player, Player.class, "wasUnderwater", f[7].equals("1")); + mc.player = player; + } else { + mc.player = null; + } + w.printf("%s music=%s volume=%08x%n", line, music(mc.getSituationalMusic()), Float.floatToRawIntBits(mc.getMusicVolume())); + } + } + System.exit(0); + } +} diff --git a/tools/test_situational_music_parity.py b/tools/test_situational_music_parity.py new file mode 100644 index 000000000..3ba6b0102 --- /dev/null +++ b/tools/test_situational_music_parity.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""Compare the situational music choice with the vanilla 26.3 client. + +The oracle calls the real `Minecraft.getSituationalMusic` and +`getMusicVolume` with the open screen (none or the credits), the boss +overlay's bars (none, darkening, music), the player (absent, or in a dimension +with creative abilities and an underwater state) and a real camera +`EnvironmentAttributeProbe` over the dimension and biome attribute layers of +the vanilla data pack. Horizon's `Situation` with `MusicTables` answers the +same, for every dimension type x biome and every combination of the rest. +""" +import itertools + +try: + from . import audio_harness as h +except ImportError: + import audio_harness as h + + +def fixtures(): + data = h.RESOURCES / 'data/minecraft' + biomes = sorted('minecraft:' + p.stem for p in (data / 'worldgen/biome').glob('*.json')) + dimensions = ['minecraft:overworld', 'minecraft:the_nether', 'minecraft:the_end'] + lines = [] + for screen, boss in itertools.product(['none', 'win'], ['none', 'dark', 'music', 'dark+music']): + lines.append(f'{screen} 0 minecraft:overworld minecraft:plains {boss} 0 0 0') + for d, b in itertools.product(dimensions, biomes): + for screen, boss, instabuild, mayfly, water in itertools.product(['none', 'win'], ['none', 'dark', 'music'], '01', '01', '01'): + lines.append(f'{screen} 1 {d} {b} {boss} {instabuild} {mayfly} {water}') + return lines + + +def main(): + lines = fixtures() + matched, report = h.run_harness( + 'situational-music', 'VanillaSituationalMusicOracle', 'situational_music_fixture', ''.join(l + '\n' for l in lines), + extra_sources=[h.lab.ROOT / 'crates/horizon-client/src/music.rs'], rust_args=[h.RESOURCES], + scope='Real Minecraft.getSituationalMusic/getMusicVolume: screen music (credits), menu without a player, End boss music from ' + 'the boss overlay, BACKGROUND_MUSIC and MUSIC_VOLUME through a real camera EnvironmentAttributeProbe, creative abilities ' + '(instabuild && mayfly) and underwater selection, for every dimension x biome.') + print(f'{matched:,} situational music lines match the pinned client: {report}', flush=True) + + +if __name__ == '__main__': + main() From f77a22177a9dda3789ecf511a3e646d25fff49fa Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 22:13:40 +0200 Subject: [PATCH 9/9] Click recipe book buttons at forUI volume and test the mixer Recipe book widgets play SimpleSoundInstance.forUI(UI_BUTTON_CLICK, 1.0F), whose volume is 0.25. Unit tests cover the mixer distance gain and the stopped/looping source states. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/audio.rs | 44 +++++++++++++++++++ crates/horizon-client/src/game/recipe_book.rs | 10 ++--- crates/horizon-client/src/sound_events.rs | 4 +- 3 files changed, 52 insertions(+), 6 deletions(-) diff --git a/crates/horizon-client/src/audio.rs b/crates/horizon-client/src/audio.rs index 773bf064d..5d99c4858 100644 --- a/crates/horizon-client/src/audio.rs +++ b/crates/horizon-client/src/audio.rs @@ -552,3 +552,47 @@ impl Sounds for Audio { self.bound().update_category_volume(source, gain); } } + +#[cfg(test)] +mod tests { + use super::*; + + fn channel(samples: Vec, linear: Option, at: [f32; 3], looping: bool) -> Channel { + Channel { + samples: Some((Arc::new(samples), 48_000)), + position: 0.0, + state: State::Playing, + gain: 1.0, + pitch: 1.0, + linear, + looping, + at, + relative: false, + } + } + + #[test] + fn linear_attenuation_reaches_zero_at_the_max_distance() { + assert_eq!(distance_gain(None, 100.0), 1.0); + assert_eq!(distance_gain(Some(16.0), 0.0), 1.0); + assert_eq!(distance_gain(Some(16.0), 8.0), 0.5); + assert_eq!(distance_gain(Some(16.0), 16.0), 0.0); + assert_eq!(distance_gain(Some(16.0), 40.0), 0.0); + } + + #[test] + fn sources_play_attenuated_then_stop_or_loop() { + let mut m = Mixer::default(); + m.channels + .insert(1, channel(vec![1.0; 4], Some(16.0), [8.0, 0.0, 0.0], false)); + m.channels + .insert(2, channel(vec![1.0; 4], None, [0.0; 3], true)); + let mut data = [0.0f32; 16]; + mix(&mut m, &mut data, 2, 48_000); + assert_eq!(m.channels[&1].state, State::Stopped); + assert_eq!(m.channels[&2].state, State::Playing); + // Mono sum of the two at the first frame: the far one is half as loud. + let first = data[0] + data[1]; + assert!(first > 1.4 && first < 3.1, "{first}"); + } +} diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs index 60fc4ec50..95470203d 100644 --- a/crates/horizon-client/src/game/recipe_book.rs +++ b/crates/horizon-client/src/game/recipe_book.rs @@ -490,7 +490,7 @@ impl Game<'_> { if !open { self.recipe_ui.overlay = None; } - self.audio.play("minecraft:ui.button.click", None, 1.0, 1.0); + self.audio.play("minecraft:ui.button.click", None, 0.25, 1.0); return true; } if !self.book_open(book_type) || self.spectator() { @@ -518,12 +518,12 @@ impl Game<'_> { if self.recipe_ui.page + 1 < pages && inside(cursor, xo + 93.0, yo + 137.0, 12.0, 17.0) { self.recipe_ui.page += 1; - self.audio.play("minecraft:ui.button.click", None, 1.0, 1.0); + self.audio.play("minecraft:ui.button.click", None, 0.25, 1.0); return true; } if self.recipe_ui.page > 0 && inside(cursor, xo + 38.0, yo + 137.0, 12.0, 17.0) { self.recipe_ui.page -= 1; - self.audio.play("minecraft:ui.button.click", None, 1.0, 1.0); + self.audio.play("minecraft:ui.button.click", None, 0.25, 1.0); return true; } } @@ -570,7 +570,7 @@ impl Game<'_> { let filtering = !self.book_filtering(book_type); self.level.recipe_book.filtering[book_type.index()] = filtering; self.recipe_ui.page = 0; - self.audio.play("minecraft:ui.button.click", None, 1.0, 1.0); + self.audio.play("minecraft:ui.button.click", None, 0.25, 1.0); return true; } // Tabs. @@ -581,7 +581,7 @@ impl Game<'_> { self.recipe_ui.tab = Some(tab); self.recipe_ui.page = 0; } - self.audio.play("minecraft:ui.button.click", None, 1.0, 1.0); + self.audio.play("minecraft:ui.button.click", None, 0.25, 1.0); return true; } } diff --git a/crates/horizon-client/src/sound_events.rs b/crates/horizon-client/src/sound_events.rs index 6a5e179c2..4f1af3670 100644 --- a/crates/horizon-client/src/sound_events.rs +++ b/crates/horizon-client/src/sound_events.rs @@ -20,7 +20,9 @@ pub enum Sampled { Product(Vec), } impl Sampled { - /// `SampledFloat.sample`: constants draw nothing. + /// `SampledFloat.sample`: constants draw nothing (sounds.json only has + /// constants, but the random stays part of the call as in vanilla). + #[allow(clippy::only_used_in_recursion)] pub fn sample(&self, random: &mut impl RandomSource) -> f32 { match self { Self::Constant(v) => *v,