From adb19abd4ca53bd772fb6900b45ca983d2013db0 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 15 Oct 2026 11:29:15 +0200 Subject: [PATCH] Minecarts roll, rattle when ridden, and take hits with the attack sounds MinecartSoundInstance follows every minecart in the level (entity.minecart.riding, louder with speed, silent when the tick rate is frozen), and getting in one starts RidingMinecartSoundInstance's two inside sounds (normal and underwater). Hitting a minecart or a boat plays Player.attack's strong/weak (and knockback) sounds. The sound_engine harness now replays both instances against the vanilla client. Fixes #227 Co-Authored-By: Claude Opus 5.5 --- .../examples/ambient_fixture.rs | 1 + .../examples/sound_engine_fixture.rs | 40 ++++++- crates/horizon-client/src/clock.rs | 4 + crates/horizon-client/src/game.rs | 45 +++++-- crates/horizon-client/src/game/boats.rs | 1 + crates/horizon-client/src/game/minecarts.rs | 38 ++++++ crates/horizon-client/src/game/music.rs | 4 + crates/horizon-client/src/sound_engine.rs | 112 +++++++++++++++++- .../parity/VanillaSoundEngineOracle.java | 42 +++++++ tools/test_sound_engine_parity.py | 54 ++++++++- 10 files changed, 324 insertions(+), 17 deletions(-) diff --git a/crates/horizon-client/examples/ambient_fixture.rs b/crates/horizon-client/examples/ambient_fixture.rs index 666235008..d75a1b568 100644 --- a/crates/horizon-client/examples/ambient_fixture.rs +++ b/crates/horizon-client/examples/ambient_fixture.rs @@ -131,6 +131,7 @@ fn main() { let tick = TickContext { player_underwater: ambience.was_underwater(), player_removed: removed, + ..TickContext::default() }; engine.tick(false, &tick, &mut backend); } diff --git a/crates/horizon-client/examples/sound_engine_fixture.rs b/crates/horizon-client/examples/sound_engine_fixture.rs index 5bc8f1a61..c42ea8bf9 100644 --- a/crates/horizon-client/examples/sound_engine_fixture.rs +++ b/crates/horizon-client/examples/sound_engine_fixture.rs @@ -5,7 +5,7 @@ mod common; use common::{Fake, d, describe, f, flush, result_name}; use horizon_client::sound_engine::{ - Attenuation, Backend, InstanceId, SoundEngine, SoundInstance, TickContext, + Attenuation, Backend, CartSound, InstanceId, SoundEngine, SoundInstance, TickContext, }; use horizon_client::sound_events::SoundRegistry; use horizon_core::random::LegacyRandom; @@ -19,6 +19,9 @@ fn main() { let mut backend = Fake::default(); let mut ctx = TickContext::default(); let mut instances: BTreeMap = BTreeMap::new(); + // Script cart names to entity ids (a removed cart leaves the level). + let mut cart_ids: BTreeMap = BTreeMap::new(); + let mut removed: 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() { @@ -49,6 +52,21 @@ fn main() { "loop" => SoundInstance::biome_loop(&event, random), "uloop" => SoundInstance::under_liquid_loop(&event, random), "usub" => SoundInstance::under_liquid_sub(&event, random), + "cart" | "rcart" | "rcartu" => { + let id = cart_ids[a[3]]; + let cart = ctx + .carts + .iter() + .find(|c| c.id == id) + .or_else(|| removed.get(&id)) + .copied() + .expect("cart"); + if a[2] == "cart" { + SoundInstance::minecart(&cart, random) + } else { + SoundInstance::riding_minecart(&cart, a[2] == "rcartu", random) + } + } _ => panic!("{line}"), }; if let Some(old) = instances.remove(a[1]) { @@ -92,6 +110,26 @@ fn main() { ctx.player_underwater = a[1] == "1"; ctx.player_removed = a[2] == "1"; } + "cart" => { + let next = cart_ids.len() as u32 + 1; + let id = *cart_ids.entry(a[1].to_owned()).or_insert(next); + ctx.carts.retain(|c| c.id != id); + let cart = CartSound { + id, + position: [d(a[2]), d(a[3]), d(a[4])], + // Vec3.horizontalDistance. + speed: (d(a[5]) * d(a[5]) + d(a[7]) * d(a[7])).sqrt(), + }; + if a[8] == "1" { + // Out of the level, still there for a later play. + removed.insert(id, cart); + } else { + removed.remove(&id); + ctx.carts.push(cart); + } + } + "ride" => ctx.vehicle = cart_ids.get(a[1]).copied(), + "freeze" => ctx.frozen = a[1] == "1", "tick" => engine.tick(a[1] == "1", &ctx, &mut backend), "forget" => { if let Some(id) = instances.remove(a[1]) { diff --git a/crates/horizon-client/src/clock.rs b/crates/horizon-client/src/clock.rs index 57e66e5fc..865a348bc 100644 --- a/crates/horizon-client/src/clock.rs +++ b/crates/horizon-client/src/clock.rs @@ -393,6 +393,10 @@ impl FixedStep { pub fn frozen(&self) -> bool { self.manager.base.is_frozen() } + /// `runsNormally` as of the last `world_runs`. + pub fn runs_normally(&self) -> bool { + self.manager.base.runs_normally() + } pub fn set_frozen(&mut self, frozen: bool) { self.manager.base.set_frozen(frozen); } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b406c5766..6ba3095e3 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -750,6 +750,10 @@ struct Game<'a> { ambience: horizon_client::ambience::Ambience, /// The sound engine was told the game paused (pauseAllExcept). sound_paused: bool, + /// Minecarts whose `MinecartSoundInstance` is playing. + cart_sounds: HashSet, + /// The minecart the riding sounds were started for (`LocalPlayer.startRiding`). + riding_cart_sounds: Option, dropped: Vec, next_entity: u32, particles: horizon_client::particles::ParticleEngine, @@ -5387,6 +5391,33 @@ impl Game<'_> { } best } + /// `Player.getAttackStrengthScale(0.5)`. + fn attack_strength_scale(&self) -> f32 { + let speed = self + .held() + .and_then(|h| self.res.items.get(&h.item)) + .map_or(0.0, |i| i.attack_speed); + let delay = 20.0 / (4.0 + speed).max(0.1); + ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0) + } + /// `Player.attack`'s sounds when a vehicle takes the hit (it always does, + /// and can't be hit critically): knockback when sprinting at full + /// strength, then strong or weak. Before `swing_arm` resets the charge. + pub(super) fn vehicle_attack_sounds(&mut self) { + let full = self.attack_strength_scale() > 0.9; + let player = self.player.as_ref(); + let from = player.map(|p| [p.position.x, p.position.y, p.position.z]); + if full && player.is_some_and(|p| p.sprinting) { + self.audio + .play("minecraft:entity.player.attack.knockback", from, 1.0, 1.0); + } + let sound = if full { + "minecraft:entity.player.attack.strong" + } else { + "minecraft:entity.player.attack.weak" + }; + self.audio.play(sound, from, 1.0, 1.0); + } /// Player.attack with the attack-strength charge, crits and knockback. fn attack(&mut self) -> bool { if self.spectator() { @@ -5433,16 +5464,8 @@ impl Game<'_> { return false; } } - let held = self.held().cloned(); - let modifiers = held - .as_ref() - .and_then(|h| self.res.items.get(&h.item)) - .map(|i| (i.attack_damage, i.attack_speed)) - .unwrap_or((0.0, 0.0)); - let damage = 1.0 + modifiers.0 + self.effect_attack_bonus(); - let speed = (4.0 + modifiers.1).max(0.1); - let delay = 20.0 / speed; - let scale = ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0); + let damage = hand_damage + self.effect_attack_bonus(); + let scale = self.attack_strength_scale(); let mut amount = damage * (0.2 + scale * scale * 0.8); let target_kind = self.mobs[index].kind.id.clone(); let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:")); @@ -9484,6 +9507,8 @@ pub fn run() -> Result<()> { music: Default::default(), ambience: Default::default(), sound_paused: false, + cart_sounds: HashSet::new(), + riding_cart_sounds: None, dropped: Vec::new(), next_entity: 0, particles, diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs index 5f2897c67..9a06c6777 100644 --- a/crates/horizon-client/src/game/boats.rs +++ b/crates/horizon-client/src/game/boats.rs @@ -666,6 +666,7 @@ impl Game<'_> { if !self.before_block(d) || self.mob_hit().is_some_and(|m| m.1 < d) { return false; } + self.vehicle_attack_sounds(); let b = &mut self.boats[i]; b.hurt_dir = -b.hurt_dir; b.hurt_time = 10; diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs index 47b1ab053..06d5466da 100644 --- a/crates/horizon-client/src/game/minecarts.rs +++ b/crates/horizon-client/src/game/minecarts.rs @@ -13,6 +13,7 @@ use horizon_client::{ mesher::Vertex, mobs::{Part, anim::Poses}, particles::{ParticleOptions, ParticleType}, + sound_engine::{CartSound, SoundEngine, SoundInstance, Sounds}, }; use horizon_core::{ geometry::{Aabb, Vec3}, @@ -786,6 +787,42 @@ impl Game<'_> { } } } + /// `ClientPacketListener.postAddEntitySoundInstance` for the carts that + /// joined the level since the last tick, and `LocalPlayer.startRiding`'s + /// two inside sounds when the player got in one; then what the sound + /// instances read this tick (the ridden cart and every cart). + pub(super) fn start_cart_sounds(&mut self) -> (Option, Vec) { + let carts: Vec = self + .carts + .iter() + .map(|c| CartSound { + id: c.id, + position: [c.position.x, c.position.y, c.position.z], + // Vec3.horizontalDistance. + speed: (c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z).sqrt(), + }) + .collect(); + self.cart_sounds + .retain(|id| carts.iter().any(|c| c.id == *id)); + for cart in &carts { + if self.cart_sounds.insert(cart.id) { + let instance = SoundInstance::minecart(cart, SoundEngine::unseeded()); + self.audio.play_instance(instance, false); + } + } + let vehicle = self.riding.filter(|id| carts.iter().any(|c| c.id == *id)); + if vehicle != self.riding_cart_sounds + && let Some(cart) = carts.iter().find(|c| Some(c.id) == vehicle) + { + for underwater in [true, false] { + let instance = + SoundInstance::riding_minecart(cart, underwater, SoundEngine::unseeded()); + self.audio.play_instance(instance, false); + } + } + self.riding_cart_sounds = vehicle; + (vehicle, carts) + } /// The rider's tick: the cart moves with the rider's input as its push. pub(super) fn tick_cart_riding(&mut self, keys: Keys) -> bool { let Some(i) = self.carts.iter().position(|c| Some(c.id) == self.riding) else { @@ -1044,6 +1081,7 @@ impl Game<'_> { let burning = self .held() .is_some_and(|s| s.enchantment_level("minecraft:fire_aspect") > 0); + self.vehicle_attack_sounds(); self.hurt_cart(i, damage, self.creative, burning); self.swing_arm(); true diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs index 59c14f998..43607ab44 100644 --- a/crates/horizon-client/src/game/music.rs +++ b/crates/horizon-client/src/game/music.rs @@ -28,9 +28,13 @@ impl Game<'_> { } self.sound_paused = self.pause; } + let (vehicle, carts) = self.start_cart_sounds(); let ctx = TickContext { player_underwater: self.ambience.was_underwater(), player_removed: self.player.is_none(), + vehicle, + carts, + frozen: !self.clock.runs_normally(), }; self.audio.tick(self.pause, &ctx); } diff --git a/crates/horizon-client/src/sound_engine.rs b/crates/horizon-client/src/sound_engine.rs index 64092f3e6..562b14100 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 NEUTRAL: usize = 6; pub const PLAYERS: usize = 7; pub const AMBIENT: usize = 8; pub const UI: usize = 10; @@ -48,12 +49,30 @@ pub enum Ticking { UnderLiquidLoop { fade: i32 }, /// `UnderLiquidSubSound`. UnderLiquidSub, + /// `MinecartSoundInstance` following a minecart. + Minecart { cart: u32 }, + /// `RidingMinecartSoundInstance` for the player riding a minecart. + RidingMinecart { cart: u32, underwater: bool }, } -/// What tickable instances read about the player. -#[derive(Clone, Copy, Debug, Default)] +/// What a minecart's sound instances read about it. +#[derive(Clone, Copy, Debug)] +pub struct CartSound { + pub id: u32, + pub position: [f64; 3], + /// `getDeltaMovement().horizontalDistance()`. + pub speed: f64, +} +/// What tickable instances read about the player and the entities they follow. +#[derive(Clone, Debug, Default)] pub struct TickContext { pub player_underwater: bool, pub player_removed: bool, + /// The minecart the player rides. + pub vehicle: Option, + /// The minecarts in the level (a missing one has been removed). + pub carts: Vec, + /// `!tickRateManager().runsNormally()`. + pub frozen: bool, } /// `AbstractSoundInstance` and its subclasses' fields. #[derive(Clone, Debug)] @@ -247,6 +266,55 @@ impl SoundInstance { pub fn under_liquid_sub(id: &str, random: LegacyRandom) -> Self { Self::ambient_loop(id, random, false, Ticking::UnderLiquidSub) } + /// `new MinecartSoundInstance(minecart)`: silent until the cart rolls. + pub fn minecart(cart: &CartSound, random: LegacyRandom) -> Self { + let [x, y, z] = cart.position; + let mut s = Self::new( + "minecraft:entity.minecart.riding", + NEUTRAL, + 0.0, + 1.0, + random, + true, + 0, + Attenuation::Linear, + [ + f64::from(x as f32), + f64::from(y as f32), + f64::from(z as f32), + ], + false, + ); + s.can_start_silent = true; + s.ticking = Ticking::Minecart { cart: cart.id }; + s + } + /// `new RidingMinecartSoundInstance(player, minecart, underwater, event, 0, 0.75, 1)`. + pub fn riding_minecart(cart: &CartSound, underwater: bool, random: LegacyRandom) -> Self { + let id = if underwater { + "minecraft:entity.minecart.inside.underwater" + } else { + "minecraft:entity.minecart.inside" + }; + let mut s = Self::new( + id, + NEUTRAL, + 0.0, + 1.0, + random, + true, + 0, + Attenuation::None, + cart.position, + false, + ); + s.can_start_silent = true; + s.ticking = Ticking::RidingMinecart { + cart: cart.id, + underwater, + }; + s + } pub fn tickable(&self) -> bool { self.ticking != Ticking::No } @@ -301,6 +369,46 @@ impl SoundInstance { self.stop(); } } + Ticking::Minecart { cart } => { + let id = *cart; + let Some(cart) = ctx.carts.iter().find(|c| c.id == id) else { + self.stop(); + return; + }; + let [x, y, z] = cart.position; + self.position = [ + f64::from(x as f32), + f64::from(y as f32), + f64::from(z as f32), + ]; + // Its own `pitch` field shadows the instance's, which stays 1. + let speed = cart.speed as f32; + self.volume = if speed >= 0.01 && !ctx.frozen { + speed.clamp(0.0, 0.5) * 0.7 + } else { + 0.0 + }; + } + Ticking::RidingMinecart { cart, underwater } => { + let (id, underwater) = (*cart, *underwater); + let found = ctx.carts.iter().find(|c| c.id == id); + let Some(cart) = found.filter(|c| ctx.vehicle == Some(c.id)) else { + self.stop(); + return; + }; + if underwater != ctx.player_underwater { + self.volume = 0.0; + } else { + // Mth.clampedLerp(speed, 0, 0.75), amplified by 1. + let speed = cart.speed as f32; + self.volume = if speed >= 0.01 { + if speed > 1.0 { 0.75 } else { speed * 0.75 } + } else { + 0.0 + }; + self.position = cart.position; + } + } } } /// `LoopSoundInstance.fadeOut`. diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java index 317dc177b..7454a36fb 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaSoundEngineOracle.java @@ -4,13 +4,19 @@ import java.io.PrintWriter; import java.lang.reflect.Constructor; import java.nio.file.*; import java.util.*; +import net.minecraft.client.multiplayer.ClientLevel; 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.SoundEvents; import net.minecraft.sounds.SoundSource; import net.minecraft.util.RandomSource; +import net.minecraft.world.TickRateManager; import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.vehicle.minecart.Minecart; +import net.minecraft.world.level.Level; +import net.minecraft.world.phys.Vec3; /** * Drives the real SoundEngine (see VanillaSoundRig) with a script of plays, @@ -33,6 +39,18 @@ public final class VanillaSoundEngineOracle { } } + /** A minecart the minecart sound instances follow. */ + public static final class Cart extends Minecart { + Cart() { + super(null, null); + } + + @Override + public boolean isSilent() { + return false; + } + } + static float f(String hex) { return Float.intBitsToFloat(Integer.parseUnsignedInt(hex, 16)); } @@ -53,6 +71,10 @@ public final class VanillaSoundEngineOracle { Constructor sub = UnderLiquidSubSound.class.getDeclaredConstructor(LocalPlayer.class, SoundEvent.class); sub.setAccessible(true); var instances = new TreeMap(); + var carts = new TreeMap(); + var level = VanillaSoundRig.make(ClientLevel.class); + var tickRate = new TickRateManager(); + VanillaSoundRig.set(level, ClientLevel.class, "tickRateManager", tickRate); var manager = rig.manager; try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2])))) { for (String line : Files.readAllLines(Path.of(args[1]))) { @@ -72,6 +94,9 @@ public final class VanillaSoundEngineOracle { case "loop" -> new BiomeAmbientSoundsHandler.LoopSoundInstance(event); case "uloop" -> new UnderLiquidAmbientSoundInstance(event, actor, LocalPlayer::isUnderWater); case "usub" -> sub.newInstance(actor, event); + case "cart" -> new MinecartSoundInstance(carts.get(a[3])); + case "rcart", "rcartu" -> new RidingMinecartSoundInstance(actor, carts.get(a[3]), a[2].equals("rcartu"), + a[2].equals("rcartu") ? SoundEvents.MINECART_INSIDE_UNDERWATER : SoundEvents.MINECART_INSIDE, 0.0F, 0.75F, 1.0F); default -> throw new IllegalArgumentException(line); }; if (!a[2].equals("simple")) seed(instance, seed); @@ -99,6 +124,23 @@ public final class VanillaSoundEngineOracle { actor.underwater = a[1].equals("1"); VanillaSoundRig.set(actor, Entity.class, "removalReason", a[2].equals("1") ? Entity.RemovalReason.DISCARDED : null); } + case "cart" -> { + // cart name x y z dx dy dz removed + Cart cart = carts.get(a[1]); + if (cart == null) { + cart = VanillaSoundRig.make(Cart.class); + VanillaSoundRig.set(cart, Entity.class, "level", level); + carts.put(a[1], cart); + } + VanillaSoundRig.set(cart, Entity.class, "position", new Vec3(d(a[2]), d(a[3]), d(a[4]))); + VanillaSoundRig.set(cart, Entity.class, "deltaMovement", new Vec3(d(a[5]), d(a[6]), d(a[7]))); + VanillaSoundRig.set(cart, Entity.class, "removalReason", a[8].equals("1") ? Entity.RemovalReason.DISCARDED : null); + } + case "ride" -> VanillaSoundRig.set(actor, Entity.class, "vehicle", a[1].equals("-") ? null : carts.get(a[1])); + case "freeze" -> { + tickRate.setFrozen(a[1].equals("1")); + tickRate.tick(); + } case "tick" -> manager.tick(a[1].equals("1")); case "forget" -> instances.remove(a[1]); default -> throw new IllegalArgumentException(line); diff --git a/tools/test_sound_engine_parity.py b/tools/test_sound_engine_parity.py index 383ca24b2..36095542c 100644 --- a/tools/test_sound_engine_parity.py +++ b/tools/test_sound_engine_parity.py @@ -3,9 +3,10 @@ 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. +biome loop, underwater loop, sub-sound, minecart and riding-minecart +instances), stops (by instance, by sound and/or source, all), category gains, +source volume options and refreshes, channel ends, delayed and queued sounds, +pauses, minecart states 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 @@ -13,6 +14,7 @@ and the channel pool counts. Horizon's `SoundEngine` replays the scripts against a backend that records the same AL source fields. """ import json +import math import random try: @@ -38,6 +40,9 @@ class Script: 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 cart(self, name, at, delta, removed=0): + self.add('cart', name, *map(dbits, at), *map(dbits, delta), removed) + def tick(self, n=1, paused=0): for _ in range(n): self.add('tick', paused) @@ -117,6 +122,30 @@ def scripted(s): s.tick(3) s.add('player', 0, 0) s.reset() + # Minecarts: the rolling sound and the two riding sounds, by speed, + # underwater, frozen ticks, getting out and the cart's removal. + s.cart('k', (10.3, 64.0, 5.7), (0.0, 0.0, 0.0)) + s.play('m', 'k', kind='cart', seed=61) + s.tick(2) + for i, v in enumerate([0.005, 0.0099, 0.01, 0.1, 0.3, 0.5, 0.51, 0.8, 1.0, 1.2, 2.0, 0.0]): + s.cart('k', (10.3 + i * 0.37123, 64.0625, 5.7 - i * 0.1), (v * 0.6, -0.04, v * 0.8)) + s.tick(2) + if i == 4: + s.add('freeze', 1) + s.tick(3) + s.add('freeze', 0) + s.add('ride', 'k') + s.play('r', 'k', kind='rcartu', seed=62) + s.play('i', 'k', kind='rcart', seed=63) + if i == 8: + s.add('player', 1, 0) + s.tick(3) + s.add('player', 0, 0) + s.add('ride', '-') + s.tick(3) + s.cart('k', (1.0, 2.0, 3.0), (0.2, 0.0, 0.0), removed=1) + s.tick(3) + s.reset() # Queued tickables, delayed and manually looped sounds. s.play('q', loop, kind='loop', seed=31) s.add('stop', 'q') @@ -173,6 +202,10 @@ def scripted(s): def fuzz(s, rng, steps): names = ['f0', 'f1', 'f2', 'f3', 'f4', 'f5'] live = set() + for cart in ('k0', 'k1'): + s.cart(cart, (0.0, 64.0, 0.0), (0.0, 0.0, 0.0)) + s.add('ride', '-') + s.add('freeze', 0) for _ in range(steps): op = rng.random() name = rng.choice(names) @@ -210,6 +243,18 @@ def fuzz(s, rng, steps): elif op < 0.57: s.add('forget', name) live.discard(name) + elif op < 0.62: + speed = rng.choice([0.0, 0.005, 0.01, 0.3, 0.5, 1.0, rng.uniform(0, 1.5)]) + angle = rng.uniform(0, 6.3) + at = (rng.uniform(-50, 50), rng.uniform(0, 80), rng.uniform(-50, 50)) + s.cart(rng.choice(['k0', 'k1']), at, (speed * math.cos(angle), rng.uniform(-0.1, 0.1), speed * math.sin(angle)), int(rng.random() < 0.08)) + elif op < 0.65: + s.add('ride', rng.choice(['k0', 'k1', '-'])) + elif op < 0.66: + s.add('freeze', int(rng.random() < 0.5)) + elif op < 0.70: + s.play(name, rng.choice(['k0', 'k1']), kind=rng.choice(['cart', 'rcart', 'rcartu']), seed=rng.getrandbits(63)) + live.add(name) else: s.tick(rng.randrange(1, 6)) @@ -238,7 +283,8 @@ def main(): '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. ' + 'UnderLiquidAmbientSoundInstance and UnderLiquidSubSound ticks, MinecartSoundInstance and RidingMinecartSoundInstance ticks (speed, ' + 'riding, underwater, frozen ticks, removal), 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)