The user wants a Minecraft mod for Simple Voice Chat soundboard. Let me think about what this entails. Simple Voice Chat is a popular Minecraft mod by henkelmax. It has an API that allows other mods to add custom audio sources. The typical way to build a soundboard is to create a custom `AudioChannel` implementation or use `VoicechatApi` to register a custom audio channel / player. Actually, let me think about what's realistic. Simple Voice Chat API provides: - `VoicechatApi` with methods to register custom audio channels, get voicechat server, etc. - Custom audio channels via `AudioChannel` interface. - There's also "locational audio" API. For a soundboard mod, the common approach: 1. Client plays a sound file locally and sends audio data over the voice chat network via a custom audio channel, so other players hear it in 3D positioned audio. Actually there's an easier approach used by some mods: "Simple Voice Chat Soundboard" mod exists? There might be. But the user wants us to build one. Let me design: **Architecture:** - Common module: packet definitions, sound registry/config. - Client: GUI (soundboard screen), keybind, plays audio locally + sends to server via voice chat's custom audio channel. - Server: handles sound requests, broadcasts to players within range. Simple Voice Chat API: - `de.maxhenkel.voicechat.api.VoicechatApi` - `de.maxhenkel.voicechat.api.VoicechatPlugin` — entrypoint via `voicechat` plugin entrypoint in fabric.mod.json - `de.maxhenkel.voicechat.api.audiochannel.AudioChannel` - `VoicechatServerApi#createAudioChannel(ServerLevel, ...)` — actually `createLocationalAudioChannel(UUID, ServerLevel, Position)` and `createEntityAudioChannel(UUID, Entity)`. - Sending audio: `AudioChannel#send(short[] audioData)` where audio data is 16-bit signed PCM, mono, at 48kHz sample rate (Simple Voice Chat uses 48kHz mono 16-bit). - Client-side: `VoicechatClientApi#createAudioChannel(UUID)` for client-local audio channel that sends to server. Actually there's `createAudioChannel(UUID)` on client which sends audio to the server, and the server routes it. Hmm. Let me recall the actual API. In Simple Voice Chat API: ```java public interface VoicechatClientApi { AudioChannel createAudioChannel(UUID channelId); AudioChannel createAudioChannel(UUID channelId, Consumer onConnection); // maybe AudioChannel createAudioChannel(UUID channelId, AudioChannel.OnAudioListener listener); AudioChannel createAudioChannel(UUID channelId, AudioChannel.OnAudioListener listener, Consumer onConnection); } ``` And `VoicechatServerApi`: ```java AudioChannel createAudioChannel(UUID channelId, ServerLevel level, Position position); // locational AudioChannel createAudioChannel(UUID channelId, ServerLevel level, Entity entity); AudioChannel createAudioChannel(UUID channelId, ServerLevel level); // static/global ``` Hmm, actually I think the server API methods are: ```java LocationalAudioChannel createLocationalAudioChannel(UUID channelId, ServerLevel level, Position position); EntityAudioChannel createEntityAudioChannel(UUID channelId, Entity entity); StaticAudioChannel createStaticAudioChannel(UUID channelId, ServerLevel level); ``` And client: ```java AudioChannel createAudioChannel(UUID channelId); // sends to server ``` Hmm. Let me just be honest — I should write this with reasonable API usage and note version specifics. Since I can't verify against the exact API version, I'll write it carefully and mention that the API surface may differ slightly by version. Actually — there's an important consideration. A "soundboard" where a player plays a sound that everyone hears. The simplest robust design that doesn't require deep voice chat API knowledge: **Server-side approach using voice chat's locational audio:** The server creates a locational audio channel at the player's position and sends PCM data to nearby players. The audio file lives... where? On the server. So the sound files need to be shipped with the mod (resources) or uploaded. For simplicity: ship a few .wav/.ogg files in the mod jar, decode to PCM on the server. Hmm, but Minecraft's sound system already does positional audio for regular sounds. Why use voice chat at all? Because voice chat audio goes through its own pipeline with proximity and its own volume settings, and it works well for voice-like audio. But honestly a "soundboard" could just use Minecraft's `level.playSound`. However the request explicitly says "Simple Voice Chat soundboard" — meaning integration with SVC so audio goes over the voice chat channel (so people who have voice chat at low volume, or want it routed through voice chat's audio device/positional system). Let me do the proper thing: use SVC's API to send PCM audio over a locational audio channel. Key design: - **Sound library**: server-side. Register sounds via a JSON config or datapack? Let's keep it simple: a `SoundboardSound` registry loaded from mod resources (`assets//soundboard/*.wav`) plus a datapack-loadable JSON list. Actually to keep code manageable, let's just have sounds in the mod jar and a config for volume/range. Hmm, but actually a nicer design that's very practical: **client-side sound library, client sends audio**. The client decodes its local audio file and streams PCM to the server through SVC's client audio channel, then SVC... no, SVC's client audio channel sends to the server and the server relays to nearby players? I believe `VoicechatClientApi.createAudioChannel(UUID)` creates an audio channel that sends audio to the server, and the server's `VoicechatServerApi` handles it... Actually no. I recall that the client-side audio channel is for playing audio *locally* (e.g., for a client-side voice effect), and the server-side locational audio channel sends to nearby clients. Let me reconsider. In SVC API docs: - `VoicechatClientApi` has `createAudioChannel(UUID channelId)` — "Creates an audio channel. Audio played on this channel will be sent to the server." Hmm. - Also `VoicechatClientApi` has `registerAudioChannel(...)`? I remember there being something like `VoicechatClientApi#createAudioChannel(UUID, AudioChannel.OnAudioListener)`. Honestly, I'm fairly confident about the server-side locational audio channel approach: ```java VoicechatServerApi api = (VoicechatServerApi) VoicechatApi.instance(); LocationalAudioChannel channel = api.createLocationalAudioChannel( UUID.randomUUID(), serverLevel, new Position(x, y, z)); channel.setDistance(48f); channel.send(pcmData); // short[] ``` That definitely exists and is the documented way to make server-driven positional audio. And `AudioChannel#send(short[])` takes 48kHz 16-bit mono PCM. Hmm wait, actually I think it's `AudioChannel#send(short[] data)` — yes. And there's `AudioPlayer` class in the API? There's `de.maxhenkel.voicechat.api.audiochannel.AudioPlayer` for playing a stream with `AudioPlayer.create(...)`. Hmm. Let me just write it with the locational audio channel and a simple streaming thread that pushes PCM frames. I'll note that the API may need adjusting. Actually, thinking about it more — for a soundboard, we want to play a whole sound file once. The API's `AudioChannel.send(short[])` sends a chunk of audio. So we'd send the whole thing at once, or stream it in frames. Sending a huge array at once might be problematic. SVC's AudioPlayer handles this. But `AudioPlayer` might be client-only... Actually `de.maxhenkel.voicechat.api.audiochannel.AudioPlayer` — "Creates a new audio player for playing audio on an audio channel" — I believe it's in the API and takes an `AudioSupplier`. Hmm, actually I recall `AudioPlayer.create(voicechat, audioChannel, audioSupplier)` and `audioPlayer.startPlaying()`, `stopPlaying()`. Let me structure the code so the streaming logic is in one place and easily swappable. OK, let me now decide on the platform. Fabric is the most common for SVC. Let's do **Fabric 1.20.1** (or 1.21.1). SVC API is available as a Maven dependency: `de.maxhenkel.voicechat:voicechat-api:2.5.0` (or similar). Let me use 1.21.1 with SVC API 2.5.x. Hmm, honestly version numbers vary. I'll use placeholders and note it. Actually let me pick: **Minecraft 1.20.1, Fabric, Java 17, SVC API 2.4.0**. That's a well-trodden combination. Hmm, but 1.21.1 is newer. Let me go with 1.20.1 since it's still hugely popular and SVC API is stable there. Actually, I'll go with 1.20.1 to be safe with mappings knowledge. Hmm, let me reconsider — I should probably keep the build config generic and focus on the actual mod logic. Let me write: **Project structure:** ``` soundboard/ ├── build.gradle ├── gradle.properties ├── settings.gradle └── src/main/ ├── java/com/example/soundboard/ │ ├── SoundboardMod.java (common init, registers plugin) │ ├── SoundboardVoicechatPlugin.java (VoicechatPlugin impl) │ ├── SoundboardSound.java (record: id, path, volume, distance) │ ├── SoundboardSounds.java (registry/loader) │ ├── audio/PcmAudio.java (WAV decoding, resampling) │ ├── audio/SoundboardPlayer.java (streams PCM to channel) │ ├── net/PlaySoundPayload.java (C2S packet) │ ├── net/StopSoundPayload.java (C2S) │ └── net/SoundboardNetworking.java └── resources/ ├── fabric.mod.json ├── soundboard.mixins.json (maybe not needed) └── assets/soundboard/sounds/*.wav ``` Hmm, decoding WAV manually — Java has `javax.sound.sampled` in the JDK but it's not always available in a Minecraft server environment... Actually it is available in standard JDK. But it's module `java.desktop` which is present. Should be fine. But safer: write a minimal WAV parser. Let's write a minimal WAV parser — it's not much code and avoids any module issues. Actually, `javax.sound.sampled` is in `java.desktop` which is part of the standard JDK and present in Minecraft's runtime. But some server hosts use headless JREs — java.desktop is still included. Fine either way. Let me write a small manual parser to be safe and dependency-free. Actually manual parser for WAV PCM 16-bit is like 60 lines. Let's do it. Hmm, but then we also need OGG support if people want to use ogg... Let's just require 16-bit PCM WAV. Simple. Hmm, actually — that's a constraint users might hate. Alternative: use `javax.sound.sampled.AudioSystem` which supports WAV/AU/AIFF and can convert to 48kHz 16-bit PCM mono. It doesn't support OGG without extra libs. Either way, WAV-only. Let me use `javax.sound.sampled` since it handles format conversion (resampling) for free. That's a big win. `AudioSystem.getAudioInputStream(InputStream)`, then `AudioSystem.getAudioInputStream(AudioFormat targetFormat, AudioInputStream sourceStream)` — this converts. Target: 48000 Hz, 16-bit, mono, signed, little-endian. Yes! That's much better. Let's use that. Note: requires `java.desktop` module but that's fine. Now, SVC audio format: 48 kHz, 16-bit signed, mono, **little endian**? SVC's `short[]` — it's just signed 16-bit PCM samples at 48kHz mono. The endianness doesn't matter for `short[]` since we handle bytes→shorts ourselves. Good. Now the plugin registration. In Fabric: `fabric.mod.json`: ```json "entrypoints": { "main": ["com.example.soundboard.SoundboardMod"], "voicechat": ["com.example.soundboard.SoundboardVoicechatPlugin"] } ``` The "voicechat" entrypoint key is `voicechat` for the voicechat plugin. Yes — SVC looks for entrypoint "voicechat" with `VoicechatPlugin`. Hmm, I should double check. I believe SVC's Fabric integration uses `FabricLoader.getInstance().getEntrypointContainers("voicechat", VoicechatPlugin.class)`. Yes, that's right. For Forge/NeoForge it's `@VoicechatPlugin` annotation... Actually there's `de.maxhenkel.voicechat.api.ForgeVoicechatPlugin` annotation. Let's stick with Fabric. Now the plugin: ```java public class SoundboardVoicechatPlugin implements VoicechatPlugin { @Override public String getPluginId() { return SoundboardMod.MOD_ID; } @Override public void initialize(VoicechatApi api) { SoundboardMod.LOGGER.info("Soundboard voicechat plugin initialized"); } } ``` Now server side: we need to handle a C2S packet "play sound X at position Y". Server checks permissions/config, looks up sound, creates a locational audio channel at the player's position (or the requested position), and streams PCM to nearby players. Wait — does `LocationalAudioChannel` handle "nearby players only"? Yes: `setDistance(float)` sets the max distance; players farther away won't hear it. And the audio is attenuated by distance. But there's a subtlety: `createLocationalAudioChannel(UUID, ServerLevel, Position)` — the channel is tied to a level and position. Audio is sent to players in that level within distance. Now streaming: we need to send audio in real time. SVC's `AudioChannel.send(short[])` — how much can we send at once? Looking at SVC source: `AudioChannel.send` sends the audio to all listeners. If we send a big array, it's chunked internally? I think there's a limit on packet size. SVC's voice packets have a max size. Actually, in SVC's implementation, `AudioChannel.send` will split the audio into packets of a certain size. Hmm, I'm not 100% sure. The safe approach: stream in frames of 960 samples (20ms at 48kHz), sleeping 20ms between sends. That's how the AudioPlayer works. Let's do that with a dedicated thread or a scheduled executor. Actually, SVC API does provide `AudioPlayer`: ```java AudioPlayer player = AudioPlayer.create(voicechatApi, audioChannel, audioSupplier); player.startPlaying(); ``` Hmm. `AudioSupplier` has `short[] getAudio()` or something. Not sure of exact signature. Let me just implement my own streaming with a `ScheduledExecutorService`. That's more portable and I'm confident it works with `channel.send()`. Hmm, but there's a concern about `send()` being thread-safe. It should be. Let's go with it but note it. Actually, let me reconsider and just send the whole PCM at once but chunked into e.g. 960-sample frames delivered by a scheduler. Yeah. Let me now write the code. ### Files **gradle.properties** ```properties org.gradle.jvmargs=-Xmx2G minecraft_version=1.20.1 yarn_mappings=1.20.1+build.10 loader_version=0.15.11 fabric_version=0.92.2+1.20.1 mod_version=1.0.0 maven_group=com.example archives_base_name=soundboard ``` **build.gradle** ```groovy plugins { id 'fabric-loom' version '1.7-SNAPSHOT' id 'maven-publish' } version = project.mod_version group = project.maven_group base { archivesName = project.archives_base_name } repositories { maven { url = "https://maven.maxhenkel.de/repository/public" } maven { url = "https://api.modrinth.com/maven" } mavenCentral() } dependencies { minecraft "com.mojang:minecraft:${project.minecraft_version}" mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2" modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}" // Simple Voice Chat API (compile only - the real mod provides it at runtime) modCompileOnly "de.maxhenkel.voicechat:voicechat-api:2.4.0" } ``` Hmm — `voicechat-api` on `maven.maxhenkel.de` — the artifact is `de.maxhenkel.voicechat:voicechat-api:2.4.0`. I think that's right. It's provided as a Fabric mod so `modCompileOnly` works. Actually the API jar is a plain jar I think... Let me use `compileOnly` and also add it to the `voicechat` mod? Hmm. Better: `modCompileOnly` — Loom can handle it. But for dev runtime we'd want `modLocalRuntime "de.maxhenkel.voicechat:voicechat:..."`? Not needed. Hmm, but wait: since the plugin needs `VoicechatPlugin` interface at runtime, and SVC mod provides it — yes, `modCompileOnly` (or `compileOnly`) is correct. At dev runtime it won't be present, so the plugin just won't load. Fine. Actually there might be an issue: if SVC isn't installed, our `SoundboardVoicechatPlugin` class won't load — but Fabric only loads entrypoints lazily, so it's fine. But our main mod class shouldn't reference SVC classes directly. So keep SVC references isolated in the plugin class and audio classes. Hmm, but the server-side play handler needs SVC. If SVC isn't installed we should no-op. So use a separate class `VoicechatBridge` that is only touched when SVC is present. Let's structure: - `SoundboardMod` — common init, no SVC imports. - `SoundboardVoicechatPlugin` — SVC imports. - `VoicechatIntegration` — holds a static reference to `VoicechatServerApi` set by the plugin; methods that use SVC types... hmm, method signatures would leak SVC types. Simplest: `SoundboardVoicechatPlugin` sets a boolean/flag and registers the server-side handler. The packet handler checks a flag `VoicechatIntegration.isAvailable()` — but that method's class must not reference SVC types in its static initializer... Actually, referencing a class only triggers loading when a method/field is used. If `VoicechatIntegration` has a field `private static Object api;` — no SVC types in signatures — then it's safe to reference `VoicechatIntegration.isAvailable()` from common code. Then SVC-specific logic goes in `VoicechatIntegration.play(...)` which casts `Object` to `VoicechatServerApi`. But the method body references SVC types — that's fine, class loading happens at first use of the class... no wait, JVM verification may load referenced classes eagerly. Hmm. Actually verification is lazy in HotSpot for method bodies. It should be fine. But to be safest, put the SVC-using code in a separate class `SoundboardAudio` and only call it from the plugin path. Let me simplify: since we're targeting Fabric and SVC is basically required for this mod to be useful, I'll just declare SVC as a required dependency... but SVC API is client/server optional. Hmm. Actually SVC itself: `voicechat` mod. If we make it a required dependency in fabric.mod.json, then no SVC = mod won't load. That's acceptable and much simpler. Let's do: ```json "depends": { "fabricloader": ">=0.15.0", "fabric": "*", "minecraft": "~1.20.1", "voicechat": ">=2.4.0" } ``` Hmm, but SVC's mod id is `voicechat`. Yes. But if SVC is server-only (SVC can be server-only? no, SVC is both). Actually SVC can be installed server-side only? I think SVC requires client. Whatever. Let's make it a required dep — simpler and clearer. But we still need to handle the case where the plugin initializes. OK. But actually, `voicechat` as a dependency means the API jar isn't enough — Loom's `modCompileOnly` gives us the API classes for compiling. Good. Hmm, one more: I'd like the mod to work even without SVC installed on the client (fallback to regular Minecraft sound). That's nice-to-have. Let's keep it simple: require SVC. Hmm, but honestly — maybe a cleaner approach: keep SVC optional and put all SVC usage in classes that are only loaded when SVC is present. This is more robust and more "proper". I'll do the optional approach but keep it tidy. Actually, you know what — let's just require it. The user asked for a "Simple Voice Chat soundboard". Requiring SVC is fine. But I'll add the "optional" note. Hmm, I'll make it optional actually — it's not much harder and makes for a better mod. Let me use the plugin pattern: ```java public class SoundboardVoicechatPlugin implements VoicechatPlugin { @Override public String getPluginId() { return SoundboardMod.MOD_ID; } @Override public void initialize(VoicechatApi api) { SoundboardVoicechatPlugin.api = api; } } ``` And a separate class `VoicechatAudio` with static methods taking SVC types. Common code calls into a wrapper that checks availability first. Since the wrapper's check method doesn't mention SVC types in its signature... but the JVM needs to resolve `VoicechatAudio` class only when called. If `VoicechatAudio` is only referenced from a branch guarded by `if (VoicechatAvailable)`, and the class reference is in the constant pool... Class resolution is lazy in HotSpot. Should be OK. But Verifier might load classes for type-checking assignability. Since we're assigning to SVC types within `VoicechatAudio`'s own methods, verification of *other* classes doesn't involve them. Hmm, the call site `VoicechatAudio.play(...)` where play takes only primitives/Strings — the call site verification needs to check the return type but not load SVC classes. Should be fine. OK let's just do it. Actually, simplest and safest: use a small interface + service loader pattern. Overkill. Let's just do direct calls guarded by availability. Hmm, actually — I realize there's a much bigger design question I should settle: **where do the sounds come from?** Option A: Sounds bundled in the mod jar. Everyone has them. Server-side decoding. ✅ Simple, works. Option B: Client-side files. Player drops .wav into a folder. Client streams to server. More flexible but way more complex (need to transfer PCM over network, or client streams via SVC's client channel — but SVC's client audio channel sends to server for *voice* proxying... hmm, actually SVC's client channel does relay). Let's do Option A + a server config folder for custom sounds. Actually, let's do: **sounds are loaded from a folder on the server** (`config/soundboard/`) plus bundled defaults. Server sends the sound *list* to clients so the GUI shows available sounds. Clients just send "play sound X" and the server does the audio. That's clean, secure (server controls what's playable), and no big file transfers. But then the server needs to decode audio. Fine — server-side WAV decoding with `javax.sound.sampled`. Server JREs have java.desktop. OK. Hmm, but many server owners run headless minimal JREs... java.desktop is still bundled in standard JDK distributions. Fine. Actually — wait. Better idea to avoid all decoding hassle AND server-side audio: **client-side decoding + streaming PCM to server via SVC's client audio channel**? No, too complex. Alternative simpler: **client plays the sound locally with Minecraft's sound engine** — but then we don't need SVC at all. The point of using SVC is that the audio goes through the voice chat audio device & mixing. Hmm, why would you want a soundboard on SVC? Because: people often have their Minecraft "Music & Sound" volume turned down but "Voice" up; also SVC's proximity audio and the "voice chat" volume slider applies. Also SVC's audio goes through its own opus-encoded network channel which is efficient. So yes, SVC soundboard = play sound through SVC. So: server decodes WAV → PCM → streams to nearby players via locational audio channel. Let's write it. ### Sound registry ```java public record SoundboardEntry(Identifier id, String name, float volume, float distance, ResourceLocation? ...) ``` Hmm, let's keep it as: id (String, e.g. "airhorn"), display name, default volume (0-2), default distance in blocks. Loading: from `config/soundboard/*.wav` on the server. ID = filename without extension. Plus bundled defaults copied to the config dir on first run? Or just read from jar resources. Let's do: on server start, create `config/soundboard/`, copy bundled example wavs if the folder is empty (hmm, or just read bundled ones as "built-in" and allow overrides from the folder). Actually simpler: read from the folder only, and on first run copy the bundled ones from the jar. But we don't want to ship binary .wav files in this answer (can't). So: read from folder; if folder doesn't exist, create it with a README. Also support built-in "test" sound? Hmm, we can't ship audio. Hmm, we could generate a tone programmatically as a demo! A "beep" sound. That's cute but weird. Let's just document that users drop .wav files in. Actually — let me support reading from the mod's own resources too, so a modpack author can add sounds to the jar. But primarily the config folder. Let's design: ```java public class SoundLibrary { private static final Map SOUNDS = new ConcurrentHashMap<>(); public static void load(Path dir) { ... } public static Optional get(String id) { ... } public static Collection all() { ... } } ``` `SoundboardSound` holds id, display name, PCM data (short[]), durationMs, default volume, default range. Loading PCM eagerly for all sounds could be memory heavy (48kHz * 2 bytes * seconds). A 3-second sound = 288KB. Fine. But 100 sounds = 28MB. Hmm. Let's lazy-load: store the path, decode on first play and cache. Good. Let's do: ```java public class SoundboardSound { private final String id; private final Path file; private short[] pcm; // lazily loaded, cached private final float volume; private final float range; public synchronized short[] pcm() { if (pcm == null) pcm = AudioIO.decode(file); return pcm; } } ``` Hmm, and config for per-sound volume/range — let's use a JSON config file `config/soundboard/config.json`? Or just a `.txt`? Let's keep it simple: a JSON file mapping id → {volume, range}. Or use a `soundboard.json` where each entry has file, name, volume, range. Let's do that — cleaner: ```json { "sounds": [ { "id": "airhorn", "file": "airhorn.wav", "name": "Air Horn", "volume": 1.0, "range": 32.0 } ] } ``` Hmm, but then users must edit JSON to add sounds. Alternatively auto-scan the folder and use filename as id/name. Let's do auto-scan + optional overrides file. That's the friendliest. OK: auto-scan `config/soundboard/` for `*.wav`. id = lowercase filename sans extension. Optional `soundboard.json` in same dir for metadata overrides. Let's just do auto-scan and keep volume/range global (configurable in a main config). Simpler. Hmm, but different sounds want different ranges (airhorn loud vs. quiet). Let me do: auto-scan + optional `.json` sidecar per sound? No. Decision: **auto-scan folder; optional single JSON config file `config/soundboard/sounds.json`** where you can define entries with volume/range/name. Any .wav in the folder not listed in the JSON gets defaults. Clean enough. Actually that's more code. Hmm, let me simplify to reduce answer length while keeping quality: auto-scan folder, filename = id and display name. Global default volume/range from mod config. Per-sound overrides via JSON. OK I'll include the JSON because it's genuinely useful... Actually no. Let me cut it. Auto-scan only, with a simple config for defaults. If users want per-sound tuning, they can... hmm. OK compromise: I'll parse an optional `sounds.json` but keep it minimal. Eh. Let me just do auto-scan and move on. Actually — I'll include per-sound config in a simple properties-ish JSON. Ugh, decisions. FINAL: Auto-scan `config/soundboard/` for `.wav` files. Optional `config/soundboard/sounds.json` for metadata. I'll write it — it's like 40 lines with Gson. Hmm, actually, let me reconsider the whole scope. This is going to be a long answer already. Let me be efficient: Core files: 1. `gradle.properties`, `build.gradle`, `settings.gradle`, `fabric.mod.json` 2. `SoundboardMod.java` — mod init, server lifecycle events, config 3. `SoundboardConfig.java` — simple config 4. `SoundboardVoicechatPlugin.java` — SVC plugin entrypoint 5. `SoundLibrary.java` — sound registry 6. `SoundboardSound.java` — sound entry 7. `AudioIO.java` — WAV decode to 48kHz 16-bit mono PCM 8. `VoicechatAudio.java` — SVC integration (play/stop) 9. `PlaySoundPayload.java` + `SoundboardNetworking.java` — C2S packet 10. `SoundboardScreen.java` — client GUI 11. `SoundboardClient.java` — client init, keybind 12. `lang/en_us.json` 13. README That's a lot but manageable. Let me write it well. Let me reconsider the client GUI. A simple list of buttons in a scrollable list. Plus search? Keep it simple: a scrollable list of buttons. Also need to send the sound list from server to client. So S2C packet `SoundListPayload(List)`. On join, server sends the list. On `/soundboard reload`, resend. Let's use Fabric's `PayloadTypeRegistry` (1.20.5+) or the older `ClientPlayNetworking.registerGlobalReceiver` with `PacketByteBuf` (1.20.1). Since I chose 1.20.1, I'll use the older networking API: `ServerPlayNetworking.registerGlobalReceiver(Identifier, PlayChannelHandler)`. Hmm, in 1.20.1 Fabric API that's the way. Actually, 1.20.1 also has `ServerPlayNetworking.registerGlobalReceiver(ResourceLocation, ...)`. And custom payloads via `PacketByteBufs`. Let's use that — it's simpler and version-appropriate. Hmm, but 1.20.1's custom payload API: `ClientPlayNetworking.send(ResourceLocation, PacketByteBuf)` and `ServerPlayNetworking.registerGlobalReceiver(ResourceLocation id, PlayReceiver)`. Yes. Need `PacketByteBufs.create()`. And the channel must be registered — in 1.20.1 you just use an Identifier; Fabric handles it via `minecraft:register`? Actually Fabric API's `ClientPlayNetworking.registerGlobalReceiver` with an Identifier works without explicit registration in 1.20.1. Yes. Actually, hmm, in 1.20.1 you need to be careful — Fabric API 0.92 for 1.20.1 supports `ClientPlayNetworking.registerGlobalReceiver(ResourceLocation, PlayChannelHandler)`. Yes it does. Good. Let me write it. Now SVC integration details: ```java public final class VoicechatAudio { private static final Map ACTIVE = new ConcurrentHashMap<>(); public static void play(ServerLevel level, Vec3 pos, SoundboardSound sound, float volume, float range, ServerPlayer source) { VoicechatServerApi api = SoundboardVoicechatPlugin.serverApi(); if (api == null) return; LocationalAudioChannel channel = api.createLocationalAudioChannel( UUID.randomUUID(), level, api.createPosition(pos.x, pos.y, pos.z)); channel.setDistance(range); channel.setVolume(volume); // does this exist? hmm ... } } ``` Does `LocationalAudioChannel` have `setDistance`? I believe `AudioChannel` has `setDistance(float)` in newer API versions. And volume — there's `AudioChannel#setVolume`? Hmm. I'm not sure volume is settable on a channel. I recall `LocationalAudioChannel#setDistance(float distance)` exists. For volume, we can just scale the PCM samples ourselves. That's safe and always works. Let's do that: apply volume by multiplying samples. Actually careful — multiplying 16-bit samples: clamp to Short.MIN_VALUE/MAX_VALUE. Yes. So: ```java short[] scaled = new short[pcm.length]; for (int i = 0; i < pcm.length; i++) { scaled[i] = (short) Math.max(Short.MIN_VALUE, Math.min(Short.MAX_VALUE, Math.round(pcm[i] * volume))); } ``` Hmm, but if volume changes we need to redo. Fine, compute at play time. Streaming: ```java public static void play(...) { short[] pcm = sound.pcm(); if (pcm == null) return; // scale ... AudioChannel channel = api.createLocationalAudioChannel(...); channel.setDistance(range); UUID channelId = channel.getId(); // schedule ScheduledExecutorService exec = ...; int frameSize = 960; // 20 ms long periodMs = 20; final int[] offset = {0}; ScheduledFuture task = exec.scheduleAtFixedRate(() -> { int off = offset[0]; if (off >= pcm.length) { cleanup(); return; } int len = Math.min(frameSize, pcm.length - off); short[] frame = Arrays.copyOfRange(pcm, off, off + len); channel.send(frame); offset[0] += len; }, 0, periodMs, TimeUnit.MILLISECONDS); } ``` Hmm, `Arrays.copyOfRange` each frame is a bit wasteful but fine. Concern: `channel.send()` from a non-main thread. SVC should handle it. OK. Also `AudioChannel#getId()` — does that exist? Hmm. Maybe not. We can just keep our own UUID. Let me also handle stopping: keep a map of channelId → future, and cancel. Alright. But wait — do we even need a separate thread per sound? If 5 people play sounds simultaneously we get 5 threads. Use a shared `ScheduledExecutorService` with 2 threads. Fine. Actually, one concern: SVC's `LocationalAudioChannel.send()` — if the channel's listeners change (player moves out of range), SVC handles it. Good. Another concern: creating a locational audio channel — is it `createLocationalAudioChannel(UUID, ServerLevel, Position)`? I'm fairly confident. Let me write it that way and add a note that the exact signature depends on the API version. Also: `api.createPosition(double x, double y, double z)` — `VoicechatServerApi` extends `VoicechatApi`? I think there's `de.maxhenkel.voicechat.api.Position` interface and the server api has `createPosition(double,double,double)`. Yes. Let me also handle "the sound should follow the player" — optional. Locational channel with a fixed position is fine; but for a soundboard played by a player, we could use `createEntityAudioChannel(UUID, Entity)` so it follows. Let's use locational at the player's position — simpler. Hmm, actually there's a nice option: use the entity channel if `follow` config is on. Let's just do locational and mention it. Hmm, actually I realize there might be an issue with `createLocationalAudioChannel` requiring the channel UUID to be unique per... whatever. Fine. ### Permissions Use a simple permission check: ops only by default, or everyone. Config option. Also rate limiting to prevent spam. Let's add a simple cooldown. ### Now let's write the actual code. #### gradle.properties ```properties org.gradle.jvmargs=-Xmx2G org.gradle.parallel=true minecraft_version=1.20.1 yarn_mappings=1.20.1+build.10 loader_version=0.15.11 fabric_version=0.92.2+1.20.1 voicechat_api_version=2.4.0 mod_version=1.0.0 maven_group=com.example archives_base_name=soundboard ``` #### settings.gradle ```groovy pluginManagement { repositories { maven { name = 'Fabric'; url = 'https://maven.fabricmc.net/' } mavenCentral() gradlePluginPortal() } } rootProject.name = 'soundboard' ``` #### build.gradle ```groovy plugins { id 'fabric-loom' version '1.7-SNAPSHOT' id 'maven-publish' } version = project.mod_version group = project.maven_group base { archivesName = project.archives_base_name } repositories { maven { url = 'https://maven.maxhenkel.de/repository/public' } mavenCentral() } dependencies { minecraft "com.mojang:minecraft:${project.minecraft_version}" mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2" modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}" modCompileOnly "de.maxhenkel.voicechat:voicechat-api:${project.voicechat_api_version}" // Optional: run the real mod in dev // modLocalRuntime "de.maxhenkel.voicechat:voicechat:${project.voicechat_api_version}" } processResources { inputs.property "version", project.version filesMatching("fabric.mod.json") { expand "version": project.version } } tasks.withType(JavaCompile).configureEach { it.options.release = 17 } java { withSourcesJar() sourceCompatibility = JavaVersion.VERSION_17 targetCompatibility = JavaVersion.VERSION_17 } jar { from("LICENSE") { rename { "${it}_${project.base.archivesName.get()}" } } } ``` #### fabric.mod.json ```json { "schemaVersion": 1, "id": "soundboard", "version": "${version}", "name": "Simple Voice Chat Soundboard", "description": "Play sound files to nearby players through Simple Voice Chat.", "authors": ["You"], "license": "MIT", "environment": "*", "entrypoints": { "main": ["com.example.soundboard.SoundboardMod"], "client": ["com.example.soundboard.client.SoundboardClient"], "voicechat": ["com.example.soundboard.voicechat.SoundboardVoicechatPlugin"] }, "depends": { "fabricloader": ">=0.15.0", "fabric-api": "*", "minecraft": "~1.20.1", "java": ">=17" }, "suggests": { "voicechat": ">=2.4.0" } } ``` Hmm — "voicechat" should be in "depends" if we require it. Since we're doing optional integration, "suggests" is right. But actually if SVC isn't present the soundboard does nothing. Let's put it in `depends` to be honest... but then a server without SVC can't load the mod. Meh. Let's require it. Actually — hmm, if the client has SVC but server doesn't... SVC must be on both. Let's just require it. I'll put `"voicechat": ">=2.4.0"` in depends and mention how to make it optional. Hmm, wait. Actually the plugin entrypoint "voicechat" — if SVC isn't installed, Fabric will just try to load the class and fail (ClassNotFoundException) when someone queries that entrypoint. SVC won't query it. So it's fine either way. I'll put it in `depends` for clarity. Hmm, no — `depends` on a mod that isn't there prevents loading entirely. That's the desired behavior for a mod that's useless without SVC? Sort of. But it's nicer to let it load and just show "Simple Voice Chat not installed" in the GUI. Ugh. Decision: **`suggests`**, and the mod gracefully degrades (client shows "Voice chat unavailable" in the GUI, packets are ignored). This is more robust. Actually if it's in suggests and SVC is missing, the client GUI would be empty/useless. Fine — I'll show a message. Hmm, actually — hold on. Let me reconsider. For the mod to be *useful*, SVC must be present. Let's just require it. Simpler code paths. But then `suggests` vs `depends`... OK you know what, I'll put it in `depends` — this is a Simple Voice Chat addon, requiring SVC is completely normal. And the plugin entrypoint loads fine. Wait, but the plugin's `initialize()` — we need to guard against SVC not being present only if optional. With depends, no guard needed. Let me finalize: **depends on voicechat**. Hmm, but the "voicechat" mod id... Let me double-check. Simple Voice Chat's mod id is `voicechat`. Yes, I'm confident (`de.maxhenkel.voicechat`). #### SoundboardMod.java ```java package com.example.soundboard; import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; import net.fabricmc.loader.api.FabricLoader; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.nio.file.Path; public class SoundboardMod implements ModInitializer { public static final String MOD_ID = "soundboard"; public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); private static SoundboardConfig config; @Override public void onInitialize() { config = SoundboardConfig.load(); SoundboardNetworking.registerServer(); SoundboardCommands.register(); // optional ServerLifecycleEvents.SERVER_STARTING.register(server -> { SoundLibrary.load(configDir()); }); ServerLifecycleEvents.SERVER_STOPPING.register(server -> { VoicechatAudio.stopAll(); }); ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> { SoundboardNetworking.sendSoundList(handler.getPlayer()); }); } public static Path configDir() { return FabricLoader.getInstance().getConfigDir().resolve(MOD_ID); } public static SoundboardConfig config() { return config; } } ``` Hmm, commands — `/soundboard reload`. Needs fabric-command-api. Let's include it. #### SoundboardConfig.java Simple JSON config using Gson (available via Minecraft's bundled Gson). ```java package com.example.soundboard; import com.google.gson.*; import net.fabricmc.loader.api.FabricLoader; import java.io.IOException; import java.nio.file.*; public class SoundboardConfig { public boolean opsOnly = false; public int cooldownTicks = 40; public float defaultVolume = 1.0f; public float defaultRange = 48.0f; public float globalVolumeMultiplier = 1.0f; ... } ``` Hmm, keep it simple with public fields and Gson. Actually, let me trim: config with `opsOnly`, `cooldownSeconds`, `defaultRange`, `volume`. Let me write it. #### AudioIO.java ```java package com.example.soundboard.audio; import javax.sound.sampled.*; import java.io.*; import java.nio.file.*; public final class AudioIO { public static final float SAMPLE_RATE = 48000f; private AudioIO() {} public static short[] decodeMono16(Path file) throws IOException, UnsupportedAudioFileException { try (AudioInputStream in = AudioSystem.getAudioInputStream(file.toFile())) { AudioFormat src = in.getFormat(); AudioFormat target = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, SAMPLE_RATE, 16, 1, 2, SAMPLE_RATE, false); if (!AudioSystem.isConversionSupported(target, src)) { throw new UnsupportedAudioFileException("Cannot convert " + src + " to 48kHz mono 16-bit PCM"); } try (AudioInputStream converted = AudioSystem.getAudioInputStream(target, in)) { byte[] bytes = converted.readAllBytes(); short[] samples = new short[bytes.length / 2]; for (int i = 0; i < samples.length; i++) { int lo = bytes[i * 2] & 0xFF; int hi = bytes[i * 2 + 1]; // signed samples[i] = (short) ((hi << 8) | lo); } return samples; } } } } ``` Wait — `AudioSystem.getAudioInputStream(target, in)` returns a converted stream. But if `src` is already the target format, it returns the same stream — and closing it closes the original. That's handled by try-with-resources nesting... Actually if it returns the same object, double-closing is fine (AudioInputStream.close is idempotent-ish). Should be OK. Hmm, actually it might return the same instance and then we'd close `in` twice — `AudioInputStream.close()` calls `stream.close()`, and closing a FileInputStream twice is fine. OK. Hmm, one issue: `AudioSystem.getAudioInputStream(File)` requires a `File` or `URL`. We have a `Path`. Fine, `.toFile()`. Also: `converted.readAllBytes()` on an `AudioInputStream` — `AudioInputStream` extends `InputStream` so `readAllBytes()` works (Java 9+). Good. But careful: `AudioInputStream.read()` returns -1 at end. `readAllBytes` should work. Hmm, actually there's a subtlety: `AudioInputStream.read(byte[])` returns the number of bytes read, and `readAllBytes()` uses `read(byte[], int, int)`. Should be fine. Note about memory: a 30-second sound = 30 * 48000 * 2 = 2.88 MB as bytes, plus short[]. Acceptable. Now — endianness: target format has `bigEndian = false` → little-endian. So bytes[i*2] is low, bytes[i*2+1] is high. Correct above. Let me double check the sign handling: `bytes[i*2+1]` is a signed byte, cast to int sign-extends. `(hi << 8) | lo` gives the correct signed 16-bit value. Yes. Actually simpler: `samples[i] = (short) ((bytes[i*2+1] << 8) | (bytes[i*2] & 0xFF));` — careful, `bytes[i*2+1] << 8` — byte promoted to int, shifted. Fine. Let me use `(short) ((bytes[i * 2 + 1] << 8) | (bytes[i * 2] & 0xFF))`. Hmm, edge: bytes.length odd → ignore last byte. Fine. Also — we should be careful that `AudioSystem` doesn't support MP3/OGG without SPI. So WAV only. Document it. Actually Java supports WAV, AIFF, AU natively. So we can support `.wav`, `.aif`, `.aiff`, `.au`. But for simplicity scan `.wav` only. Let's allow wav + aiff + au? Just wav. Keep it simple. Hmm, actually many soundboard sounds are mp3/ogg. Java doesn't support those natively. I could mention adding `jorbis`/`mp3spi` dependencies. Let me mention it in the README but not implement. Actually — supporting OGG would be really valuable for a soundboard mod. Hmm. But adding `com.googlecode.soundlibs:jorbis` + `tritonus-share`... it's doable but adds complexity. Let me mention it as an optional extension. Hmm — actually, maybe I should mention that users can just convert to WAV. Fine. #### SoundboardSound.java ```java package com.example.soundboard; import com.example.soundboard.audio.AudioIO; import java.nio.file.Path; public class SoundboardSound { private final String id; private final String displayName; private final Path file; private final float volume; private final float range; private short[] pcm; private long durationMs; public SoundboardSound(String id, String displayName, Path file, float volume, float range) { ... } public synchronized short[] pcm() { if (pcm == null) { try { pcm = AudioIO.decodeMono16(file); durationMs = (long) (pcm.length * 1000L / (long) AudioIO.SAMPLE_RATE); } catch (Exception e) { SoundboardMod.LOGGER.error("Failed to load sound {}", id, e); pcm = new short[0]; } } return pcm; } ... } ``` #### SoundLibrary.java ```java package com.example.soundboard; public final class SoundLibrary { private static final Map SOUNDS = new LinkedHashMap<>(); public static void load(Path dir) { ... } public static void reload(Path dir) { ... } public static SoundboardSound get(String id) { ... } public static Collection all() { ... } } ``` Use `ConcurrentHashMap`? Since reload can happen while playing. Let's use `ConcurrentHashMap` and keep order with sorting by id. Scanning: `Files.list(dir)` filter `.wav` (case-insensitive), sorted. ID sanitization: lowercase, replace non `[a-z0-9_-]` with `_`. Also enforce unique. Also copy example sounds? Can't ship binary. Instead, on first load, create the folder and a `README.txt`. Good. #### VoicechatAudio.java ```java package com.example.soundboard.voicechat; import de.maxhenkel.voicechat.api.VoicechatServerApi; import de.maxhenkel.voicechat.api.audiochannel.LocationalAudioChannel; import ... public final class VoicechatAudio { private static final Map PLAYING = new ConcurrentHashMap<>(); private static final ScheduledExecutorService EXECUTOR = Executors.newScheduledThreadPool(2, r -> { Thread t = new Thread(r, "Soundboard-Audio"); t.setDaemon(true); return t; }); public static boolean isAvailable() { return SoundboardVoicechatPlugin.serverApi() != null; } public static void play(ServerLevel level, Vec3 pos, SoundboardSound sound, float volume, float range) { ... } public static void stopAll() { ... } public static void stopForLevel(...) } ``` Hmm, wait — `VoicechatServerApi` is obtained in the plugin's `initialize`. But the plugin initializes once when SVC starts. `api` is available for both client and server. We need the server API — `VoicechatServerApi` is `(VoicechatServerApi) api` on the server. On the client, it'd be `VoicechatClientApi` and the cast fails. So we should store it and only cast when needed, or check `instanceof`. Actually, the `voicechat` entrypoint is called on both client and server. So: ```java public class SoundboardVoicechatPlugin implements VoicechatPlugin { private static VoicechatApi api; private static VoicechatServerApi serverApi; @Override public String getPluginId() { return SoundboardMod.MOD_ID; } @Override public void initialize(VoicechatApi api) { SoundboardVoicechatPlugin.api = api; if (api instanceof VoicechatServerApi s) { serverApi = s; } } } ``` Hmm, `VoicechatApi.instance()` static also exists. Let's just use that where needed. Actually `VoicechatApi.instance()` returns the api singleton — nice. But it might be null before init. Let's store it in the plugin and expose. Wait, but if we require SVC as a dependency, does the plugin always get initialized? Yes, on both client and server. Hmm, but the class `SoundboardVoicechatPlugin` references `VoicechatServerApi` in its field type → class loading requires SVC present. Since SVC is a hard dependency, fine. Now — the actual play logic. Let me write: ```java public static void play(ServerLevel level, double x, double y, double z, SoundboardSound sound, float volume, float range) { VoicechatServerApi api = SoundboardVoicechatPlugin.serverApi(); if (api == null) return; short[] pcm = sound.pcm(); if (pcm.length == 0) return; UUID channelId = UUID.randomUUID(); LocationalAudioChannel channel = api.createLocationalAudioChannel( channelId, level, api.createPosition(x, y, z)); if (channel == null) return; channel.setDistance(range); channel.setCategory(SoundboardVoicechatPlugin.AUDIO_CATEGORY); // optional, hmm ... } ``` Hmm, `setCategory` — SVC API has audio categories? There's `VoicechatApi#audioCategoryBuilder()`. Hmm, might be overkill. Skip. Volume scaling: precompute scaled array. ```java short[] scaled = applyVolume(pcm, volume); Playing playing = new Playing(channel, scaled); PLAYING.put(channelId, playing); ``` Then streaming: ```java private static final int FRAME_SAMPLES = 960; // 20 ms @ 48 kHz final AtomicInteger offset = new AtomicInteger(); ScheduledFuture future = EXECUTOR.scheduleAtFixedRate(() -> { Playing p = PLAYING.get(channelId); if (p == null) return; // cancelled int off = offset.get(); if (off >= scaled.length) { stop(channelId); return; } int len = Math.min(FRAME_SAMPLES, scaled.length - off); short[] frame = new short[len]; System.arraycopy(scaled, off, frame, 0, len); offset.addAndGet(len); try { channel.send(frame); } catch (Exception e) { LOGGER.warn(...); stop(channelId); } }, 0, 20, TimeUnit.MILLISECONDS); ``` Hmm, `scheduleAtFixedRate` with a task that might take longer than 20ms — could pile up. Use `scheduleWithFixedDelay`? No — that drifts. Actually for audio we want fixed rate. If sending takes longer than 20ms occasionally, that's a hiccup but acceptable. Alternatively use a dedicated thread per sound with precise timing. Let's keep scheduleAtFixedRate but note it. Actually, a cleaner approach: one dedicated thread per playing sound that sleeps. But that's N threads. Hmm. Or use SVC's own `AudioPlayer` if available. Let me just use the scheduled executor — it's fine. Hmm, actually, there's a subtle issue: `channel.send()` on the first tick sends audio immediately; the client plays it. Fine. But wait — SVC's `AudioChannel.send(short[])`: does it expect the full buffer each time or just the next chunk? It's just "here's some audio, play it". So chunking is right. Hmm — actually I want to double check. In SVC API 2.x, `AudioChannel.send(short[] audioData)` — "Sends audio data to the channel. The audio data will be played back to the listeners. The audio data must be 48kHz, 16-bit, mono." And it's a *stream* — consecutive sends append. Yes. Hmm, but actually I vaguely recall that `send()` might replace/interrupt? No, I'm fairly sure it's streaming. There's also `AudioPlayer` which wraps a supplier. OK. Also — SVC's Opus encoder works on frames. SVC's `AudioChannel.send` internally buffers. Should be fine with 960-sample frames. Actually hold on — I recall SVC's voice packets are 960 samples (20ms). Yes. So sending 960-sample frames is exactly right. Alright. Now, one more thing: the sound is played "at" the position. SVC will attenuate by distance for each listener. But there's a wrinkle: SVC's locational audio channels apply distance attenuation only to *listeners in the same level*? I think yes. Also: the volume we pass — since SVC applies distance attenuation, and our PCM is already volume-scaled, we get volume * attenuation. Good. Now — **stop**: `PLAYING.remove(channelId)` and cancel future. Also should we call `channel.flush()`? There might be a method to flush buffered audio so it stops immediately. Hmm. In SVC API, `AudioChannel` might have no flush. Let's just stop sending; the already-sent audio will finish playing (up to ~20ms + jitter buffer). Acceptable. Actually SVC buffers up to some amount on the client. Meh, fine. #### Networking ```java package com.example.soundboard.net; public final class SoundboardNetworking { public static final Identifier PLAY_SOUND = new Identifier(MOD_ID, "play_sound"); public static final Identifier SOUND_LIST = new Identifier(MOD_ID, "sound_list"); public static void registerServer() { ServerPlayNetworking.registerGlobalReceiver(PLAY_SOUND, (server, player, handler, buf, sender) -> { String id = buf.readString(32767); server.execute(() -> handlePlay(player, id)); }); } ... } ``` Hmm, in 1.20.1 the signature is `ServerPlayNetworking.registerGlobalReceiver(ResourceLocation id, PlayReceiver)` where `PlayReceiver` is `(MinecraftServer server, ServerPlayer player, ServerPlayNetworkHandler handler, PacketByteBuf buf, PacketSender responseSender) -> void`. Yes. And `ClientPlayNetworking.registerGlobalReceiver(ResourceLocation, PlayReceiver)` where `PlayReceiver` is `(MinecraftClient client, ClientPlayNetworkHandler handler, PacketByteBuf buf, PacketSender sender) -> void`. And sending S2C: `ServerPlayNetworking.send(ServerPlayer player, ResourceLocation id, PacketByteBuf buf)`. And `PacketByteBufs.create()` / `PacketByteBufs.toByteArray()`. OK. Also — `Identifier` vs `ResourceLocation`: Yarn 1.20.1 uses `net.minecraft.util.Identifier`. Yes (ResourceLocation is the Mojang name). Good. Let me write the packets inline in one class to save space. ```java public final class SoundboardNetworking { public static final Identifier PLAY_SOUND = new Identifier(SoundboardMod.MOD_ID, "play_sound"); public static final Identifier SOUND_LIST = new Identifier(SoundboardMod.MOD_ID, "sound_list"); public static final Identifier STOP_SOUND = new Identifier(SoundboardMod.MOD_ID, "stop_sound"); // ---- server side ---- public static void registerServer() { ServerPlayNetworking.registerGlobalReceiver(PLAY_SOUND, (server, player, handler, buf, responseSender) -> { String soundId = buf.readString(32767); float volume = buf.readFloat(); server.execute(() -> playSound(player, soundId, volume)); }); ServerPlayNetworking.registerGlobalReceiver(STOP_SOUND, (server, player, handler, buf, responseSender) -> { server.execute(() -> VoicechatAudio.stopAll()); }); } public static void sendSoundList(ServerPlayer player) { List sounds = new ArrayList<>(SoundLibrary.all()); PacketByteBuf buf = PacketByteBufs.create(); buf.writeVarInt(sounds.size()); for (SoundboardSound s : sounds) { buf.writeString(s.id(), 64); buf.writeString(s.displayName(), 128); } ServerPlayNetworking.send(player, SOUND_LIST, buf); } ... } ``` Hmm, `STOP_SOUND` global stop by any player — bad. Let's make stop only stop sounds the player started. Need to track ownership. Let's add owner UUID to Playing. Then `stopOwned(player.getUuid())`. Actually simpler: skip the stop button entirely? No, it's useful. Let's track owner. OK, `VoicechatAudio.Playing` holds `owner` UUID. `stopAll(UUID owner)`. Hmm, but admins might want to stop everything: `/soundboard stop` command. Let's add that. #### playSound handler ```java private static void playSound(ServerPlayer player, String soundId, float volume) { SoundboardConfig cfg = SoundboardMod.config(); if (cfg.opsOnly && !player.hasPermissionLevel(2)) { ... } // cooldown if (!Cooldowns.tryUse(player.getUuid(), cfg.cooldownMillis)) return; SoundboardSound sound = SoundLibrary.get(soundId).orElse(null); if (sound == null) return; float vol = MathHelper.clamp(volume <= 0 ? sound.volume() : volume, 0f, 4f) * cfg.volumeMultiplier; float range = sound.range() > 0 ? sound.range() : cfg.defaultRange; VoicechatAudio.play(player.serverLevel(), player.getX(), player.getEyeY(), player.getZ(), sound, vol, range, player.getUuid()); } ``` Hmm — the sound plays at the player's position. But the player might move; the sound stays put. That's fine and typical for soundboards. Alternatively use an entity audio channel so it follows. Let's keep locational. Hmm — actually, a nicer touch: use the player's *eye* position so it's at head level. Yes, `getEyeY()`. #### Client `SoundboardClient.java`: ```java public class SoundboardClient implements ClientModInitializer { public static KeyBinding OPEN_KEY; @Override public void onInitializeClient() { OPEN_KEY = KeyBindingHelper.registerKeyBinding(new KeyBinding( "key.soundboard.open", InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_P, "category.soundboard")); ClientTickEvents.END_CLIENT_TICK.register(client -> { while (OPEN_KEY.wasPressed()) { if (client.currentScreen == null && client.player != null) { client.setScreen(new SoundboardScreen()); } } }); SoundboardNetworking.registerClient(); } } ``` `SoundboardScreen` — a `Screen` with a scrollable list of sound buttons. In 1.20.1, `Screen` with `ElementList` / `EntryListWidget`. Let's build a simple `EntryListWidget`. Hmm, this is getting long. Let me write a compact but working screen. Actually — simpler alternative that avoids a lot of GUI boilerplate: use a `Screen` with a `TextFieldWidget` for search and a scrollable list. Let me just do the list. In 1.20.1: ```java public class SoundboardScreen extends Screen { private final List sounds = new ArrayList<>(SoundboardClient.SOUNDS); private SoundListWidget list; ... } ``` And `SoundListWidget extends EntryListWidget`. Let me write it. Actually, in 1.20.1 `EntryListWidget` constructor: `EntryListWidget(MinecraftClient client, int width, int height, int top, int bottom, int itemHeight)`. Yes, that's the 1.20.1 signature. In 1.20.2+ it changed to `(client, width, height, y, itemHeight)`. Since I'm targeting 1.20.1, use the 6-arg one. Let me write the screen: ```java package com.example.soundboard.client; import ... public class SoundboardScreen extends Screen { private static final Text TITLE = Text.translatable("soundboard.title"); private final List sounds; private SoundListWidget list; private TextFieldWidget search; public SoundboardScreen() { super(TITLE); this.sounds = SoundboardClient.getSounds(); } @Override protected void init() { this.search = new TextFieldWidget(this.textRenderer, this.width / 2 - 100, 32, 200, 20, Text.empty()); this.search.setPlaceholder(Text.translatable("soundboard.search")); this.search.setChangedListener(s -> this.list.filter(s)); this.addDrawableChild(this.search); this.setInitialFocus(this.search); this.list = new SoundListWidget(this.client, this.width, this.height, 56, this.height - 40, 24); this.list.setSounds(this.sounds); this.addDrawableChild(this.list); } @Override public void render(DrawContext ctx, int mouseX, int mouseY, float delta) { this.renderBackground(ctx); this.list.render(ctx, mouseX, mouseY, delta); ctx.drawCenteredTextWithShadow(this.textRenderer, this.title, this.width / 2, 12, 0xFFFFFF); this.search.render(ctx, mouseX, mouseY, delta); super.render(ctx, mouseX, mouseY, delta); } @Override public boolean shouldPause() { return false; } } ``` Careful: `renderBackground` in 1.20.1 `Screen` takes `(DrawContext, int, int, float)`. Yes. Also the list is added as a drawable child AND rendered manually — that would double-render. Let me just add it to `addDrawableChild` and not call render manually. But `super.render` renders children. Hmm, `Screen.render` calls `super.render` which renders `drawables`? Actually in 1.20.1, `Screen.render()` renders widgets via `renderBackground` etc... Let me recall: `Screen.render(DrawContext, int, int, float)` calls `super.render(...)` → `Element.render`? Actually `Screen extends AbstractParentElement implements Drawable`. `Screen.render` renders all `drawables` that are `Drawable` via the `selectableElements`? Hmm. In 1.20.1: `Screen.render(DrawContext context, int mouseX, int mouseY, float delta)`: ```java public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Drawable drawable : this.drawables) { drawable.render(context, mouseX, mouseY, delta); } } ``` Hmm, actually `Screen` implements `ParentElement` and has `renderBackground`. And `Drawable` children in `this.drawables` are rendered... Actually I think it's: ```java @Override public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Drawable drawable : this.drawables) { ... } } ``` Hmm, no. Let me recall properly. In `Screen`: ```java protected final List drawables = Lists.newArrayList(); protected final List selectables = ...; protected final List children = ...; public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); this.renderWidgets? ... } ``` Hmm. Actually in 1.20.1, `Screen.render`: ```java public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Drawable drawable : this.drawables) { drawable.render(context, mouseX, mouseY, delta); } } ``` Hmm — no, I think that's `Screen.render` calls `super.render()` which is `AbstractParentElement.render`? `AbstractParentElement` doesn't have render. OK — actual 1.20.1 `Screen.java`: ```java @Override public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); this.renderWidgets? no... } ``` Hmm. I'm fairly sure it's: ```java public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Drawable drawable : this.drawables) { drawable.render(context, mouseX, mouseY, delta); } } ``` Hmm, but `renderBackground` renders the blur/dirt. And children rendered in the loop. Then subclasses call `super.render(...)` at the end and it works. Actually in many 1.20.1 mod screens you see: ```java @Override public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); super.render(context, mouseX, mouseY, delta); // renders children ...custom... } ``` Yes — `super.render()` renders the children. And `renderBackground` is called by `super.render` too. Hmm, if `super.render` calls `renderBackground`, calling it twice is wasteful but harmless. Let me just write: ```java @Override public void render(DrawContext context, int mouseX, int mouseY, float delta) { super.render(context, mouseX, mouseY, delta); context.drawCenteredTextWithShadow(this.textRenderer, this.title, this.width / 2, 12, 0xFFFFFF); } ``` And add children via `addDrawableChild`. That's clean. `Screen.render` → `renderBackground` + drawables. Actually `Screen.render`: ```java public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Drawable drawable : this.drawables) { drawable.render(context, mouseX, mouseY, delta); } } ``` Hmm, but then `addDrawableChild` adds to both `children` and `drawables`. And the loop renders them. But `Screen` also has `renderBackground` which is called first. OK so `super.render(context, mouseX, mouseY, delta)` does everything. Hmm, one thing: `Screen.renderBackground(DrawContext)` in 1.20.1 — the signature is `renderBackground(DrawContext context)` and there's also `renderBackground(DrawContext, int, int, float)` which calls the first. OK. Good. Let me now handle the `EntryListWidget` — it's added via `addDrawableChild(list)` and rendered by the parent's loop. But `EntryListWidget` also needs to be told to render its background — it does that itself. And scrolling needs mouse events — `Screen.mouseScrolled` dispatches to children. Yes. Hmm — actually, `EntryListWidget` added as a drawable child: does it receive scroll events? `Screen.mouseScrolled` iterates `selectables`/`children` via `mouseScrolled`. In 1.20.1 `Screen.mouseScrolled` calls `super.mouseScrolled(...)` → `AbstractParentElement.mouseScrolled` which checks `getChildAt`... Actually `ParentElement.mouseScrolled` iterates `children()` and calls `Element.mouseScrolled`. `EntryListWidget` overrides `mouseScrolled`. Should work. OK, I'll write the list widget. Let me simplify further — instead of a custom `EntryListWidget`, I could just lay out buttons in a grid. But with many sounds that overflows. A scrollable list is better. Let's do it. ```java package com.example.soundboard.client; import com.example.soundboard.net.SoundboardNetworking; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.gui.widget.EntryListWidget; import net.minecraft.text.Text; import net.minecraft.util.Formatting; import java.util.ArrayList; import java.util.List; import java.util.Locale; public class SoundListWidget extends EntryListWidget { private final List allSounds = new ArrayList<>(); private String filter = ""; public SoundListWidget(MinecraftClient client, int width, int height, int top, int bottom, int itemHeight) { super(client, width, height, top, bottom, itemHeight); } public void setSounds(List sounds) { this.allSounds.clear(); this.allSounds.addAll(sounds); rebuild(); } public void setFilter(String filter) { this.filter = filter.toLowerCase(Locale.ROOT); rebuild(); } private void rebuild() { this.clearEntries(); for (SoundInfo info : allSounds) { if (!filter.isEmpty() && !info.displayName().toLowerCase(Locale.ROOT).contains(filter) && !info.id().toLowerCase(Locale.ROOT).contains(filter)) continue; this.addEntry(new SoundEntry(info)); } } @Override public int getRowWidth() { return 220; } @Override protected int getScrollbarPositionX() { return this.width / 2 + 130; } public class SoundEntry extends EntryListWidget.Entry { private final SoundInfo info; private final ButtonWidget button; public SoundEntry(SoundInfo info) { this.info = info; this.button = ButtonWidget.builder(Text.literal(info.displayName()), b -> { SoundboardNetworking.sendPlay(info.id()); }).dimensions(0, 0, 200, 20).build(); } @Override public void render(DrawContext ctx, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float delta) { this.button.setPosition(x + (entryWidth - 200) / 2, y); this.button.render(ctx, mouseX, mouseY, delta); } @Override public boolean mouseClicked(double mouseX, double mouseY, int button) { return this.button.mouseClicked(mouseX, mouseY, button); } } } ``` Hmm, `EntryListWidget.Entry` in 1.20.1: `render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta)`. Yes. And `mouseClicked(double, double, int)` returns boolean. Yes. Hmm, `EntryListWidget.Entry` is a non-static inner interface/class? In 1.20.1, `EntryListWidget.Entry>` is a non-static abstract class? Let me recall... In 1.20.1: ```java public abstract static class Entry> implements Element { ... } ``` Hmm, actually I believe in older versions it was non-static (`public class Entry`), requiring `SoundListWidget.this`. Let me check: In 1.19/1.20.1, `EntryListWidget.Entry>` is a **non-static** inner class. So `new SoundEntry(info)` from within `SoundListWidget` works (implicit `SoundListWidget.this`). And the class declaration should be `public class SoundEntry extends EntryListWidget.Entry` — but that's an inner class of `SoundListWidget` extending a non-static inner class of `EntryListWidget`. Hmm, that's not allowed in Java — an inner class can't extend another class's inner class... Actually it can if it has an enclosing instance. `class SoundEntry extends EntryListWidget.Entry` — the superclass is an inner class of `EntryListWidget`, so its constructor requires an `EntryListWidget` instance. From within `SoundListWidget` (which IS an `EntryListWidget`), `super()` implicitly passes `SoundListWidget.this`. Yes, this works. Hmm, but actually — I'm now not sure whether it's static or not. Let me just define `SoundEntry` as a **static nested class** and pass the widget... no, then it can't extend the non-static Entry. Safest: make `SoundEntry` a non-static inner class of `SoundListWidget`, declaring `public class SoundEntry extends EntryListWidget.Entry`. If `Entry` is static in 1.20.1, this still works (just no enclosing instance needed). Actually no — if `Entry` is static, then `SoundEntry` (inner, non-static) extending it is fine too. So this works either way. Hmm, wait. If `Entry` is non-static and we're in `SoundListWidget` which extends `EntryListWidget`, then `SoundEntry` is an inner class of `SoundListWidget`, and its superclass `EntryListWidget.Entry` needs an `EntryListWidget` enclosing instance = `SoundListWidget.this`. Java handles this. ✓. Actually hmm, one gotcha: if `Entry` is static, `SoundEntry` being non-static means `new SoundEntry(...)` captures `this`. Fine. OK. But `this.button.render(ctx, mouseX, mouseY, delta)` — `ButtonWidget.render` is `Renderable.render`. Yes it exists. Hmm, actually `ClickableWidget.render(DrawContext, int, int, float)` is public. Yes. Alright. Now — `SoundInfo` record on the client. Let me define `com.example.soundboard.client.SoundInfo(String id, String displayName)` and store the list in a static field in `SoundboardClient`. Hmm, or just reuse a common class. Let's make a common `SoundInfo` record in `com.example.soundboard.net` or `com.example.soundboard`. Let's put it in `com.example.soundboard` as a record. Hmm, actually `SoundboardSound` already has id + displayName. But it's server-side (holds a Path). Let's make a separate tiny record `SoundInfo(String id, String displayName)` in the common package. OK. #### Client networking ```java public static void registerClient() { ClientPlayNetworking.registerGlobalReceiver(SOUND_LIST, (client, handler, buf, responseSender) -> { int count = buf.readVarInt(); List list = new ArrayList<>(count); for (int i = 0; i < count; i++) { String id = buf.readString(64); String name = buf.readString(128); list.add(new SoundInfo(id, name)); } client.execute(() -> SoundboardClient.setSounds(list)); }); } ``` #### Sending play ```java public static void sendPlay(String soundId, float volume) { PacketByteBuf buf = PacketByteBufs.create(); buf.writeString(soundId, 64); buf.writeFloat(volume); ClientPlayNetworking.send(PLAY_SOUND, buf); } ``` #### Commands ```java public final class SoundboardCommands { public static void register() { CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> { dispatcher.register(CommandManager.literal("soundboard") .requires(src -> src.hasPermissionLevel(2)) .then(CommandManager.literal("reload").executes(ctx -> { SoundLibrary.load(SoundboardMod.configDir()); // resend to all players for (ServerPlayer p : ctx.getSource().getServer().getPlayerManager().getPlayerList()) { SoundboardNetworking.sendSoundList(p); } ctx.getSource().sendFeedback(() -> Text.literal("Reloaded " + SoundLibrary.all().size() + " sounds"), true); return 1; })) .then(CommandManager.literal("stop").executes(ctx -> { VoicechatAudio.stopAll(); ... })) ); }); } } ``` Careful: `VoicechatAudio` references SVC classes. Since SVC is a hard dependency, fine. Hmm — `ctx.getSource().sendFeedback(() -> ..., true)` — in 1.20.1, `sendFeedback(Supplier, boolean)`. Yes. OK, now let me think about whether `VoicechatAudio.stopAll()` being called from common code when SVC isn't present... With `depends`, SVC is always present. Fine. Hmm, but actually, there's still the client-side case: on a client, `SoundboardVoicechatPlugin.serverApi` would be null (it's a client API). And `VoicechatAudio.play` would just return. But `play` is only called server-side. Fine. Hmm — but wait. There's a subtlety: the `voicechat` entrypoint is called on the client too, and `SoundboardVoicechatPlugin.initialize` gets a `VoicechatClientApi`. If we cast to `VoicechatServerApi` it fails. So we use `instanceof`. ✓. Let me now write `SoundboardVoicechatPlugin`: ```java package com.example.soundboard.voicechat; import com.example.soundboard.SoundboardMod; import de.maxhenkel.voicechat.api.VoicechatApi; import de.maxhenkel.voicechat.api.VoicechatPlugin; import de.maxhenkel.voicechat.api.VoicechatServerApi; import de.maxhenkel.voicechat.api.events.EventRegistration; public class SoundboardVoicechatPlugin implements VoicechatPlugin { private static VoicechatApi api; private static VoicechatServerApi serverApi; @Override public String getPluginId() { return SoundboardMod.MOD_ID; } @Override public void initialize(VoicechatApi api) { SoundboardVoicechatPlugin.api = api; SoundboardVoicechatPlugin.serverApi = api instanceof VoicechatServerApi s ? s : null; SoundboardMod.LOGGER.info("Soundboard registered with Simple Voice Chat ({})", serverApi != null ? "server" : "client"); } @Override public void registerEvents(EventRegistration registration) { // Optional: hook into voice events (e.g. mute soundboard audio when a player is deafened) } public static VoicechatApi api() { return api; } public static VoicechatServerApi serverApi() { return serverApi; } } ``` Hmm — `VoicechatPlugin.registerEvents` signature. I think it's `void registerEvents(EventRegistration registration)`. Yes. I'll leave it out or keep it minimal. Actually, omitting the override is fine — `VoicechatPlugin` has default methods? Hmm, in SVC API 2.x, `VoicechatPlugin` is: ```java public interface VoicechatPlugin { default String getPluginId() { return ...; } default void initialize(VoicechatApi api) {} default void registerEvents(EventRegistration registration) {} } ``` I believe `getPluginId()` is abstract and the others have defaults. Hmm, actually I think all three are default methods except `getPluginId`. Let me just override `getPluginId` and `initialize`. Should be safe. Hmm, but if `initialize` is abstract... it's fine, we override it. OK. Now — is there a risk that `SoundboardVoicechatPlugin` fails to load if SVC isn't present? Yes, but SVC is a hard dep. Fine. #### VoicechatAudio ```java package com.example.soundboard.voicechat; import com.example.soundboard.SoundboardMod; import com.example.soundboard.SoundboardSound; import com.example.soundboard.audio.AudioIO; import de.maxhenkel.voicechat.api.VoicechatServerApi; import de.maxhenkel.voicechat.api.audiochannel.LocationalAudioChannel; import net.minecraft.server.level.ServerLevel; ... ``` Wait — Yarn names: `net.minecraft.server.world.ServerWorld`, not `ServerLevel`. Right! Yarn uses `ServerWorld`. And `net.minecraft.util.math.Vec3d`. And `net.minecraft.entity.player.PlayerEntity`. Let me use Yarn names consistently. So: `ServerWorld`, `Vec3d`. Hmm — does SVC's API accept a `ServerLevel`/`ServerWorld`? The API takes `de.maxhenkel.voicechat.api.ServerLevel` — SVC's own interface! Yes: ```java LocationalAudioChannel createLocationalAudioChannel(UUID id, ServerLevel level, Position position); ``` where `ServerLevel` is `de.maxhenkel.voicechat.api.ServerLevel`. And SVC's `ServerLevel` interface has `fromServerLevel(Object serverLevel)` static? Hmm. Actually I recall `ServerLevel` interface with a method to get the wrapped object. The typical usage: ```java ServerLevel svcLevel = (ServerLevel) voicechatApi.fromServerLevel(serverWorld); ``` Hmm. Let me think. In SVC API there's `de.maxhenkel.voicechat.api.ServerLevel` and the `VoicechatServerApi` has... Hmm. Actually I recall usage like: ```java LocationalAudioChannel channel = voicechatServerApi.createLocationalAudioChannel( UUID.randomUUID(), voicechatServerApi.fromServerLevel(level), voicechatServerApi.createPosition(x, y, z) ); ``` Hmm, does `VoicechatServerApi` have `fromServerLevel`? I'm not sure. There's definitely a way. In SVC's own code, `VoicechatServerApiImpl` uses the server level object directly. Hmm. Let me think about the actual API. I believe `de.maxhenkel.voicechat.api.VoicechatApi` (or the server api) has: ```java ServerLevel fromServerLevel(Object serverLevel); ``` Hmm. Actually — I recall in the SVC API docs, the `ServerLevel` interface is obtained via `voicechatServerApi.fromServerLevel(serverWorld)`. Hmm, or maybe it's just passed directly as an Object and SVC casts. Hmm. Let me search my memory... SVC API `VoicechatServerApi`: ```java public interface VoicechatServerApi extends VoicechatApi { Entity fromEntity(Object entity); ServerLevel fromServerLevel(Object level); ServerPlayer fromServerPlayer(Object player); Position createPosition(double x, double y, double z); StaticAudioChannel createStaticAudioChannel(UUID channelId, ServerLevel level); EntityAudioChannel createEntityAudioChannel(UUID channelId, Entity entity); LocationalAudioChannel createLocationalAudioChannel(UUID channelId, ServerLevel level, Position position); } ``` Hmm, something like that. I'm reasonably confident about `createLocationalAudioChannel(UUID, ServerLevel, Position)` and `createPosition(double,double,double)`. And for getting SVC's `ServerLevel` from a Minecraft `ServerWorld`... I think there's `voicechatApi.fromServerLevel(...)`. Hmm. Alternatively, maybe `createLocationalAudioChannel` just takes the raw Minecraft level object as `Object`. Hmm. I'll write it with a helper and note in a comment that the exact bridging call may differ by API version. Let me write: ```java private static de.maxhenkel.voicechat.api.ServerLevel svcLevel(VoicechatServerApi api, ServerWorld world) { return api.fromServerLevel(world); } ``` Hmm, but if the API doesn't have `fromServerLevel`, it won't compile. Let me think harder. Actually — I now recall more specifically. In SVC API 2.x, there IS a class `de.maxhenkel.voicechat.api.ServerLevel` and the method to get it... Let me recall the example plugin from SVC's own repo. Hmm. I remember seeing code like: ```java @Override public void initialize(VoicechatApi api) { voicechatApi = (VoicechatServerApi) api; } ... LocationalAudioChannel channel = voicechatApi.createLocationalAudioChannel( UUID.randomUUID(), voicechatApi.fromServerLevel(player.getServerWorld()), voicechatApi.createPosition(x, y, z)); ``` Hmm, yes, I'm fairly confident `fromServerLevel` exists on `VoicechatServerApi`. Hmm, but actually I'm now second-guessing — maybe it's `ServerLevel.fromServerLevel(Object)`. Hmm. Let me hedge: I'll write the code using `api.fromServerLevel(world)` and add a comment: "Depending on your SVC API version, this may be `ServerLevel.fromServerLevel(world)`." That's honest and helpful. Actually — hmm. Let me reconsider. I have a vague memory of SVC API's `VoicechatServerApi` having: ```java ServerLevel fromServerLevel(Object serverLevel); ``` Hmm, actually no — I think I remember it being in the `VoicechatApi` interface as a set of "from" converters. Hmm, but `VoicechatApi` is shared between client and server... Honestly, let me just present the code and clearly flag the version-sensitive parts. That's the responsible thing. I'll add a "API compatibility notes" section. Hmm, alternatively — I could avoid the SVC `ServerLevel` bridge entirely... no way around it. OK, let me also double check `LocationalAudioChannel` methods: `setDistance(float)`, `getDistance()`. Hmm, or is distance set at creation? I'm fairly confident `AudioChannel` has `setDistance(float distance)` — used to change how far the audio reaches. Hmm. Hmm, hold on. Actually maybe I'm confusing it. Let me think about SVC's `LocationalAudioChannel`: ```java public interface LocationalAudioChannel extends AudioChannel { Position getLocation(); void setLocation(Position position); } ``` And `AudioChannel`: ```java public interface AudioChannel { UUID getId(); void send(short[] audioData); void setDistance(float distance); float getDistance(); void setFilter(...); // ? void flush(); // ? } ``` Hmm. I think `setDistance` might be on `LocationalAudioChannel` only. And `getDistance` default 16 or so. Hmm, and `StaticAudioChannel extends AudioChannel` with `setDistance`. And `EntityAudioChannel` — audio follows the entity. Hmm — actually, I have a stronger memory now: SVC's `AudioChannel` interface: ```java public interface AudioChannel { UUID getId(); void send(short[] audioData); void setDistance(float distance); float getDistance(); void setVolume(float volume); // hmm? } ``` I'm not confident about setVolume. Let's just not use it and scale PCM. Safe. And there might be `flush()` — "Clears the audio buffer". Let's call it if it exists... risky. Skip it, or wrap in try/catch? Can't call a nonexistent method. Skip. OK. I'll note in the README that API method names should be checked against the SVC API javadoc for the version used. Hmm, actually — this makes me want to reduce the risk. What if I just use `StaticAudioChannel`... no, same interface. Alright, let's just write it and add clear notes. The core logic is sound; the reader can adapt method names. Actually, let me reconsider `setDistance` vs. constructor. I'll write: ```java LocationalAudioChannel channel = api.createLocationalAudioChannel(channelId, svcLevel, svcPos); if (channel == null) return; channel.setDistance(range); ``` If `setDistance` isn't there... hmm. Let me hedge with a comment. Hmm — OK. Actually you know what, I just remembered: SVC API's `AudioChannel` does NOT have setDistance. Instead, `LocationalAudioChannel#setDistance(float)` — hmm. Let me just go with it. I'm ~80% confident `setDistance` is on the channel. Alright, writing the final answer now. Let me also think about the **AudioPlayer** class — SVC API has `de.maxhenkel.voicechat.api.audiochannel.AudioPlayer`: ```java AudioPlayer player = AudioPlayer.create(voicechatApi, audioChannel, audioSupplier); player.startPlaying(); ``` Hmm. If that exists, it'd be cleaner. But I'll do my own streaming — more transparent. Now, let me reconsider the "cooldown" implementation. Simple: ```java public final class Cooldowns { private static final Map LAST = new ConcurrentHashMap<>(); public static boolean tryUse(UUID id, long cooldownMs) { long now = System.currentTimeMillis(); Long last = LAST.get(id); if (last != null && now - last < cooldownMs) return false; LAST.put(id, now); return true; } } ``` Need cleanup on player disconnect. Eh, minor. Let's just clear on server stop. Or use a bounded map. Fine. Alright, also — should the sound be heard by the player who played it? Yes, locational channel includes all players in range including the source. Good. Hmm — one more thought: should we also play the sound to players who *don't* have SVC? SVC is required, so all have it. Let me also handle the case where the sound list is empty — GUI shows "No sounds found". Let me write the final code now. I'll try to keep it tight. One more: `SoundboardClient` needs a static list + setter, and the screen needs to refresh. Let me store in `SoundboardClient.SOUNDS` as a `List` and the screen copies at open time. Simple. Also add a "Refresh" — no, the server pushes on join and on reload. Let me write `SoundboardScreen` to handle the empty case and show a hint. Now let me write out everything. Actually, one more consideration on `EntryListWidget` rendering: since `EntryListWidget` is added via `addDrawableChild`, and `Screen.render` renders all `drawables`... wait, does `Screen.render` render `drawables`? Let me be sure. In 1.20.1 `Screen`: ```java public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Drawable drawable : this.drawables) { drawable.render(context, mouseX, mouseY, delta); } } ``` Hmm, actually I think it's: ```java @Override public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackground(context); for (Element element : this.children) { if (element instanceof Drawable drawable) { drawable.render(context, mouseX, mouseY, delta); } } } ``` Hmm. Either way, `addDrawableChild` results in rendering. And `renderBackground` — subclasses shouldn't call it again. So `super.render(...)` handles it. Hmm, but many 1.20.1 screens do: ```java this.renderBackground(context); super.render(context, mouseX, mouseY, delta); ``` which double-renders background. Whatever, harmless. I'll just call `super.render(...)`. Hmm, but `Screen.renderBackground` in 1.20.1 — the `Screen.render` calls `renderBackground(context)`. If I call `super.render(...)`, background gets rendered. ✓ Also need `Screen.init()` to call `super.init()`? Usually yes but it's empty-ish. I'll call it. Hmm — careful: `Screen.init()` doesn't call `clearChildren`. Fine. Let me finalize the widget's `Entry` class. Actually, in 1.20.1, I'm now fairly sure `EntryListWidget.Entry` is: ```java public abstract static class Entry> implements Element { ``` Hmm, no... Let me just look at how mods do it. Common 1.20.1 mod code: ```java public class MyListWidget extends EntryListWidget { ... public class Entry extends EntryListWidget.Entry { ... } } ``` Hmm, I've definitely seen `private class Entry extends EntryListWidget.Entry`. And also `public static class Entry extends ...`. Ugh. In 1.20.1 Yarn, `EntryListWidget.Entry` is declared as: ```java public abstract static class Entry> implements Element { ``` Hmm. Actually — I'm now recalling that in 1.19.x, `EntryListWidget.Entry` was NOT static (it was `public class Entry> implements Element`), because it needed `EntryListWidget.this` for... hmm, no. Let me check 1.20.1 source in memory... In 1.20.1 `EntryListWidget`: ```java public abstract static class Entry> implements Element { public abstract void render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta); ... } ``` Hmm, actually I think in 1.20.1 it IS static. In 1.20.2+ it definitely is static. Hmm, in 1.19.4/1.20 it's... OK — safest approach: make `SoundEntry` a **static nested class** extending `EntryListWidget.Entry`. If `Entry` is static → works. If `Entry` is non-static → compile error. Alternatively, avoid `EntryListWidget` entirely and write my own scrollable list widget. That's more code but zero API risk. Hmm. Let me just use `EntryListWidget` with a static nested entry — I'm now ~85% confident it's static in 1.20.1. Actually... Let me think about `ElementListWidget.Entry` in 1.20.1 — I'm quite sure those are static. And `EntryListWidget.Entry`... Hmm, in 1.20.1 Yarn `EntryListWidget.java`: ```java public abstract static class Entry> extends EntryListWidget ... ``` No. OK. I'll go with static. And I'll mention in the README that GUI mappings differ across versions. Hmm, actually, hold on. I just realized there's an even simpler approach that avoids all this: **render the buttons manually in the Screen** with a scroll offset, handling `mouseScrolled` and `mouseClicked` myself. That's ~60 lines and zero mapping risk. Let me do that instead — more robust and educational. Hmm, but then I need to handle clipping and scrollbar. It's not too bad. Let me do a middle ground: a simple custom `Widget` that draws N buttons in a scrolled viewport. Actually, simplest: extend `EntryListWidget`... ugh. OK let me just write a self-contained scroll list. Here's the plan: ```java public class SoundboardScreen extends Screen { private final List allSounds = new ArrayList<>(); private final List visible = new ArrayList<>(); private String filter = ""; private double scroll = 0; private static final int ROW_HEIGHT = 24; private static final int LIST_WIDTH = 220; ... @Override protected void init() { allSounds.clear(); allSounds.addAll(SoundboardClient.getSounds()); search = new TextFieldWidget(...); refresh(); } @Override public boolean mouseClicked(double mx, double my, int button) { int index = indexAt(mx, my); if (index >= 0) { play(visible.get(index)); return true; } return super.mouseClicked(mx, my, button); } @Override public boolean mouseScrolled(double mx, double my, double amount) { ... } } ``` Hmm, `mouseScrolled(double mouseX, double mouseY, double amount)` — in 1.20.1 that's the signature (the horizontal amount param was added in 1.20.2). Yes, 1.20.1: `public boolean mouseScrolled(double mouseX, double mouseY, double amount)`. ✓ And rendering: `context.fill(...)` for backgrounds, `context.drawCenteredTextWithShadow(...)` for labels. And hover highlight. This is clean. Let's do it. Also need `drawContext.fill(int,int,int,int,int)` — yes, `DrawContext.fill(int x1, int y1, int x2, int y2, int color)`. Also `DrawContext.drawBorder(int,int,int,int,int)`. Exists in 1.20.1? I think `DrawContext.drawBorder` exists. Let's use `fill` to be safe. Also `enableScissor`/`disableScissor` on DrawContext: `context.enableScissor(x1,y1,x2,y2)` and `context.disableScissor()`. These exist in 1.20.1 DrawContext. ✓ Great, let's write it. Now for the list geometry: - List area: x from `width/2 - 110` to `width/2 + 110`, y from `LIST_TOP = 60` to `LIST_BOTTOM = height - 40`. - Rows: `ROW_HEIGHT = 22`. - Scroll offset in pixels. - `maxScroll = max(0, visible.size() * ROW_HEIGHT - listHeight)`. Let me write. Also a "Stop all" button at the bottom for the player's own sounds. Let's add a `ButtonWidget` at the bottom center: "Stop". Sends STOP packet. Hmm, `addDrawableChild(ButtonWidget.builder(...).dimensions(...).build())` — in 1.20.1, `ButtonWidget.builder(Text, PressAction).dimensions(x,y,w,h).build()`. Yes. ✓ Alright. Let me write the final code. One more: the search field. `new TextFieldWidget(this.textRenderer, x, y, w, h, Text.empty())`. And `setChangedListener`. And `setPlaceholder`. ✓ And `setMaxLength(64)`. Also we need the text field to render — since we call `super.render(...)`, children render. ✓ But we're not adding the list as a child (we render it manually), so we must render it *before* `super.render` (so widgets draw on top) — or after. Let's render the list first, then call `super.render(...)` for the text field/buttons. Actually `super.render` also draws the background. So order: ```java @Override public void render(DrawContext ctx, int mouseX, int mouseY, float delta) { super.render(ctx, mouseX, mouseY, delta); // background + widgets renderList(ctx, mouseX, mouseY); // list on top ctx.drawCenteredTextWithShadow(textRenderer, title, width/2, 12, 0xFFFFFF); } ``` Hmm, but then the title draws over... fine. But the list would draw over the text field if they overlap — they don't (list starts at y=60, search at y=32..52). Wait, the search field is at y=32 with height 20 → 32..52. List top at 60. OK good. Hmm, but `super.render` draws the background *after*? No, background first. OK, order is fine. Hmm, one problem: `super.render` renders widgets, and then we render the list on top — but the list region might overlap the "Stop" button at the bottom. Let's put the stop button at y = height - 32, and the list ends at height - 40. No overlap. ✓ Alright. Let me write everything out now. I'll be reasonably concise in comments. Let me write the final files. Also — `SoundboardClient.getSounds()` should return an immutable copy. Let me write: ```java public class SoundboardClient implements ClientModInitializer { private static volatile List sounds = List.of(); public static KeyBinding openKey; @Override public void onInitializeClient() { openKey = KeyBindingHelper.registerKeyBinding(new KeyBinding( "key.soundboard.open", InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_P, "category.soundboard")); ClientTickEvents.END_CLIENT_TICK.register(client -> { while (openKey.wasPressed()) { if (client.currentScreen == null) { client.setScreen(new SoundboardScreen()); } } }); SoundboardNetworking.registerClient(); } public static List getSounds() { return sounds; } public static void setSounds(List list) { sounds = List.copyOf(list); } } ``` `KeyBindingHelper.registerKeyBinding` — `net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper`. ✓ `KeyBinding` — `net.minecraft.client.option.KeyBinding`. ✓ `InputUtil.Type.KEYSYM` — `net.minecraft.client.util.InputUtil.Type.KEYSYM`. ✓ OK. Writing now. Let me make sure `SoundboardMod.config()` returns a non-null config. And `SoundLibrary` load path: `FabricLoader.getInstance().getConfigDir().resolve("soundboard")`. Let me write `SoundLibrary`: ```java public final class SoundLibrary { private static final Map SOUNDS = new ConcurrentHashMap<>(); public static void load(Path dir) { SOUNDS.clear(); try { if (!Files.isDirectory(dir)) { Files.createDirectories(dir); writeReadme(dir); } try (Stream stream = Files.list(dir)) { List files = stream .filter(Files::isRegularFile) .filter(p -> p.getFileName().toString().toLowerCase(Locale.ROOT).endsWith(".wav")) .sorted() .toList(); for (Path file : files) { String name = file.getFileName().toString(); String id = sanitize(name.substring(0, name.length() - 4)); if (SOUNDS.containsKey(id)) { LOGGER.warn(...); continue; } SOUNDS.put(id, new SoundboardSound(id, prettify(id), file, ...)); } } LOGGER.info("Loaded {} soundboard sound(s)", SOUNDS.size()); } catch (IOException e) { LOGGER.error("Failed to load soundboard sounds", e); } } } ``` Hmm, per-sound volume/range — I said auto-scan only. Let's give each sound default volume 1.0 and range 0 (meaning "use config default"). Fine. Hmm, actually — how about reading optional metadata from the filename? Like `airhorn [vol=1.5 range=64].wav`? Nah, too hacky. Just defaults + global config. Good enough. I'll mention that per-sound tuning could be added via JSON. Hmm, actually, let me just add the JSON metadata support. It's not that much code and makes the mod much more usable. Hmm... no. Cut it. I'll mention it as an extension idea. Keeps the answer focused. Hmm, actually, let me reconsider once more: a soundboard where all sounds have the same volume/range is annoying. But it's a demo. Fine. Moving on. Actually — you know what, I'll add a tiny bit: allow `name.txt` sidecar? No. Moving on for real. Let me write the README too. Final check on `fabric.mod.json` — "voicechat" in depends. Also add `"soundboard"` ... no. Also `environment: "*"`. Let me write it all out. Actually, one more important detail — SVC API's `createLocationalAudioChannel` returns null if... something. Handle null. And `Position` — `api.createPosition(x, y, z)`. Let me write `VoicechatAudio.play`: ```java public static void play(ServerWorld world, double x, double y, double z, SoundboardSound sound, float volume, float range, UUID owner) { VoicechatServerApi api = SoundboardVoicechatPlugin.serverApi(); if (api == null) return; short[] pcm = sound.pcm(); if (pcm == null || pcm.length == 0) return; short[] scaled = scale(pcm, volume); UUID channelId = UUID.randomUUID(); LocationalAudioChannel channel; try { channel = api.createLocationalAudioChannel(channelId, api.fromServerLevel(world), api.createPosition(x, y, z)); } catch (Throwable t) { LOGGER.error("Could not create voice chat audio channel", t); return; } if (channel == null) return; channel.setDistance(range); Playing playing = new Playing(channel, scaled, owner); PLAYING.put(channelId, playing); ScheduledFuture future = EXECUTOR.scheduleAtFixedRate(() -> tick(channelId, playing), 0, FRAME_MILLIS, TimeUnit.MILLISECONDS); playing.future = future; } ``` And: ```java private static void tick(UUID channelId, Playing playing) { if (playing.finished) return; short[] data = playing.data; int offset = playing.offset; if (offset >= data.length) { stop(channelId); return; } int len = Math.min(FRAME_SAMPLES, data.length - offset); short[] frame = new short[len]; System.arraycopy(data, offset, frame, 0, len); playing.offset = offset + len; try { playing.channel.send(frame); } catch (Throwable t) { LOGGER.warn("Error sending soundboard audio", t); stop(channelId); } } ``` Hmm, `playing.offset` mutated from the executor thread — but `scheduleAtFixedRate` won't run the same task concurrently. Fine. Actually it's only accessed by the executor thread. Fine. `stop`: ```java private static void stop(UUID channelId) { Playing playing = PLAYING.remove(channelId); if (playing == null) return; playing.finished = true; if (playing.future != null) playing.future.cancel(false); } ``` Hmm — race: `playing.future` is set after scheduling; the first tick may run before `future` is assigned. Then `stop` is called from the tick, `playing.future` is null → we just remove from map. Then `play` assigns the future afterwards → orphan task that keeps running. Bug! Fix: use a `volatile boolean cancelled` on `Playing` and have the tick check `PLAYING.containsKey(channelId)`; and in `play`, after scheduling, check if it was cancelled already and cancel then. Or simpler: set `playing.future` inside the task on first run? Hmm. Simplest fix: use `scheduleWithFixedDelay` won't help. Let's restructure: schedule a task that checks a flag, and store the future in a holder object that we create before scheduling. ```java Playing playing = new Playing(channel, scaled, owner); PLAYING.put(channelId, playing); playing.future = EXECUTOR.scheduleAtFixedRate(() -> tick(channelId), 0, FRAME_MILLIS, TimeUnit.MILLISECONDS); ``` The race: the task might execute and call `stop(channelId)` before `playing.future` is assigned. Then `playing.future` is set to a non-cancelled future → the task keeps running forever, but `tick` checks `PLAYING.get(channelId) == null` → returns immediately. So it's a zombie task that does nothing. Slight leak but harmless. Better: in `play`, after assigning the future, check `if (playing.finished) playing.future.cancel(false);`. Hmm — but `scheduleAtFixedRate` won't run concurrently with itself. The initial delay is 0, so the first execution may happen immediately in another thread while `play` is still running. So yes, race exists. Let's handle it: ```java ScheduledFuture future = EXECUTOR.scheduleAtFixedRate(...); synchronized (playing) { playing.future = future; if (playing.finished) future.cancel(false); } ``` And in `stop`, synchronize on playing too. That's clean. Or just use `AtomicReference>` + a `cancelled` flag checked after assignment. Let me use a small synchronized block. Fine. Actually simpler: make the scheduled task cancel *itself* via a holder: ```java final AtomicReference> ref = new AtomicReference<>(); ScheduledFuture f = EXECUTOR.scheduleAtFixedRate(() -> { ... }, 0, FRAME_MILLIS, TimeUnit.MILLISECONDS); ref.set(f); ``` Meh. Let me just do the synchronized approach with a `Playing` that has `volatile boolean cancelled`. ```java static final class Playing { final LocationalAudioChannel channel; final short[] data; final UUID owner; volatile int offset; volatile boolean cancelled; volatile ScheduledFuture future; void cancel() { cancelled = true; ScheduledFuture f = future; if (f != null) f.cancel(false); } } ``` And in `play`: ```java Playing playing = new Playing(channel, scaled, owner); PLAYING.put(channelId, playing); playing.future = EXECUTOR.scheduleAtFixedRate(() -> tick(channelId), 0, FRAME_MILLIS, TimeUnit.MILLISECONDS); if (playing.cancelled) playing.future.cancel(false); ``` The `if (playing.cancelled) playing.future.cancel(false)` handles the race where the task already called `cancel()` before `future` was assigned. ✓ And `tick` checks `if (playing.cancelled) return;` at the top. ✓ Good. Also, `stopAll(UUID owner)`: ```java public static void stopOwned(UUID owner) { PLAYING.values().removeIf(p -> { if (p.owner.equals(owner)) { p.cancel(); return true; } return false; }); } ``` Hmm, `removeIf` on `ConcurrentHashMap.values()` — supported. OK. But careful about concurrent modification; ConcurrentHashMap's `values().removeIf` should be OK-ish. Let's iterate over a snapshot of entries: ```java for (Map.Entry e : new ArrayList<>(PLAYING.entrySet())) { if (e.getValue().owner.equals(owner)) { PLAYING.remove(e.getKey()); e.getValue().cancel(); } } ``` Safer. Let's do that. OK, writing the final answer. Also need to handle `SoundboardMod.config()` being used in `VoicechatAudio` — no. Let me now also write the README with instructions on adding sounds, config, commands, and API notes. Let me draft the config class: ```java package com.example.soundboard; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import net.fabricmc.loader.api.FabricLoader; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; public class SoundboardConfig { private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create(); private static final Path PATH = FabricLoader.getInstance().getConfigDir().resolve("soundboard.json"); /** Only operators (permission level 2) may play sounds. */ public boolean opsOnly = false; /** Minimum time between plays per player, in milliseconds. */ public long cooldownMillis = 3000; /** How far sounds carry, in blocks, when a sound doesn't define its own range. */ public float defaultRange = 48.0f; /** Global multiplier applied to every sound's volume. */ public float volumeMultiplier = 1.0f; /** Stop playback when a player leaves the server / changes dimension. */ public boolean stopOnDisconnect = true; public static SoundboardConfig load() { SoundboardConfig config = new SoundboardConfig(); if (Files.exists(PATH)) { try (var reader = Files.newBufferedReader(PATH)) { SoundboardConfig loaded = GSON.fromJson(reader, SoundboardConfig.class); if (loaded != null) config = loaded; } catch (IOException e) { SoundboardMod.LOGGER.error("Could not read soundboard config", e); } } config.save(); return config; } public void save() { try { Files.createDirectories(PATH.getParent()); try (var writer = Files.newBufferedWriter(PATH)) { GSON.toJson(this, writer); } } catch (IOException e) { SoundboardMod.LOGGER.error("Could not write soundboard config", e); } } } ``` Good. Now, `SoundboardMod` — `config()` static accessor. Alright. Also need `SoundboardMod.MOD_ID` public static final. Let me write out the final response. I'll structure it as: 1. Short intro on what it does 2. Project layout 3. Gradle files 4. fabric.mod.json 5. Java sources 6. Resources (lang) 7. How to use 8. Notes/caveats on SVC API version Let me keep prose tight. One more check — `ServerPlayConnectionEvents.JOIN` gives `(ServerPlayNetworkHandler handler, PacketSender sender, MinecraftServer server)`. So `handler.getPlayer()` → `ServerPlayerEntity` (Yarn: `ServerPlayerEntity`). Right! Yarn uses `ServerPlayerEntity`, not `ServerPlayer`. And `ServerWorld`, `Vec3d`, `Identifier`, `Text`, `DrawContext`, `ButtonWidget`, `TextFieldWidget`, `Screen`, `MinecraftClient`, `KeyBinding`, `InputUtil`, `Formatting`, `MathHelper`. Let me use Yarn names throughout. Good catch. - `net.minecraft.server.network.ServerPlayerEntity` - `net.minecraft.server.world.ServerWorld` - `net.minecraft.util.math.Vec3d` - `net.minecraft.util.Identifier` - `net.minecraft.text.Text` - `net.minecraft.client.gui.DrawContext` - `net.minecraft.client.gui.screen.Screen` - `net.minecraft.client.gui.widget.ButtonWidget` - `net.minecraft.client.gui.widget.TextFieldWidget` - `net.minecraft.client.MinecraftClient` - `net.minecraft.client.option.KeyBinding` - `net.minecraft.client.util.InputUtil` - `net.minecraft.util.Formatting` - `net.minecraft.util.math.MathHelper` - `net.minecraft.server.MinecraftServer` And Fabric API: - `net.fabricmc.api.ModInitializer` - `net.fabricmc.api.ClientModInitializer` - `net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking` - `net.fabricmc.fabric.api.networking.v1.ClientPlayNetworking` - `net.fabricmc.fabric.api.networking.v1.PacketByteBufs` - `net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents` - `net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents` - `net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback` - `net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper` - `net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents` Good. Now writing. I'll be careful with the `ServerPlayNetworking.registerGlobalReceiver` lambda param order in 1.20.1: `(MinecraftServer server, ServerPlayerEntity player, ServerPlayNetworkHandler handler, PacketByteBuf buf, PacketSender responseSender)`. ✓ And `ClientPlayNetworking.registerGlobalReceiver(Identifier, (MinecraftClient client, ClientPlayNetworkHandler handler, PacketByteBuf buf, PacketSender responseSender))`. ✓ Let's go. Oh — one thing. `buf.readString(maxLength)` — in 1.20.1, `PacketByteBuf.readString(int maxLength)`. ✓ (readString() no-arg was removed in 1.19.4ish; use readString(maxLength)). And `buf.writeString(String)` and `writeString(String, int)`. ✓ Let me write it. Final structure of files: ``` src/main/java/com/example/soundboard/ ├── SoundboardMod.java ├── SoundboardConfig.java ├── SoundInfo.java ├── SoundLibrary.java ├── SoundboardSound.java ├── audio/AudioIO.java ├── net/SoundboardNetworking.java ├── voicechat/SoundboardVoicechatPlugin.java ├── voicechat/VoicechatAudio.java ├── command/SoundboardCommand.java └── client/SoundboardClient.java └── client/SoundboardScreen.java ``` Good. Let's write. For `SoundboardSound`, I need `id()`, `displayName()`, `pcm()`, plus maybe `lengthSamples()`. Let me write the code. Also — for the `SoundLibrary`, I'll use `Map` + `LinkedHashMap` guarded by synchronization. Since reload happens on the main thread and reads happen on the server thread / executor thread, use `ConcurrentHashMap` and sort on read. Fine. Let me write it all out now, final. One last thing about the `fabric.mod.json` — since I'm using `modCompileOnly` for SVC API and putting `voicechat` in `depends`, if a user runs the dev client without SVC, it'll crash. That's expected. I'll note to add `modLocalRuntime`. Also I should double-check: is the SVC API artifact on `maven.maxhenkel.de`? Yes: https://maven.maxhenkel.de/repository/public/de/maxhenkel/voicechat/voicechat-api/. Group `de.maxhenkel.voicechat`, artifact `voicechat-api`. Version like `2.4.0`. Hmm, or is it `de.maxhenkel.voicechat:voicechat-api:2.4.0`? I'll note that users should check the latest version. Alright, writing. Actually — hmm, `modCompileOnly` for the API: Loom needs to remap it? The SVC API is not a Minecraft mod per se... Actually it IS distributed as a jar without mappings issues since it uses its own API types (not MC types)... except `ServerLevel.fromServerLevel(Object)`. Right — the SVC API deliberately avoids MC types by using `Object` params. So no remapping needed. `modCompileOnly` might try to remap it and fail/warn. Safer: `compileOnly` + `include`? No — we don't want to bundle it. Hmm. Actually since the API is remap-free (it's a pure Java API), `compileOnly "de.maxhenkel.voicechat:voicechat-api:2.4.0"` would work but Loom might complain about non-remapped mod deps at runtime. Since it's `compileOnly`, it's not on the runtime classpath anyway. So `compileOnly` is safest. But then Loom won't know it's a mod dep — which is fine since we get it from the real SVC mod at runtime. Hmm, but `compileOnly` for a Fabric mod dependency: Loom's `modCompileOnly` handles it. Honestly both usually work. I'll use `modCompileOnly` and note the alternative. Actually — since the SVC API jar has no MC classes, `modCompileOnly` may attempt remapping and produce a "remapped" jar that's identical. Should be fine. Let me use `modCompileOnly`. Hmm, wait — actually I recall that the voicechat API is published as a regular jar (not a Fabric mod jar), so Loom might fail to find `fabric.mod.json` in it. `modCompileOnly` would then throw "not a mod jar". Hmm. Actually Loom's `modCompileOnly` just adds it to the remap classpath; it doesn't require fabric.mod.json... it might. Safest: `compileOnly "de.maxhenkel.voicechat:voicechat-api:2.4.0"`. That definitely works for compiling. And at runtime SVC's mod jar provides the classes. Hmm, but does SVC's actual mod jar contain the API classes? Yes — SVC ships the API classes inside the mod jar. ✓ So `compileOnly` is correct and clean. Let me use: ```groovy compileOnly "de.maxhenkel.voicechat:voicechat-api:${project.voicechat_api_version}" ``` And note that for dev runtime you'd want to also install the real SVC mod. Hmm — actually the SVC API artifact might be published as `voicechat-api` with classifier or as `voicechat-api` plain. I'll go with `de.maxhenkel.voicechat:voicechat-api:2.4.0`. Hmm, but actually — hold on. Is SVC's API also published on the Fabric maven? No, it's on maxhenkel's maven. OK. Hmm, actually, I want to double check whether it's `de.maxhenkel.voicechat:voicechat-api` or `de.maxhenkel.voicechat:api`. I'm fairly confident it's `voicechat-api`. Let me note in the README to check. OK writing for real now. Let me keep the answer well-organized and not overly long in prose. # Simple Voice Chat Soundboard — Fabric Mod A server-side soundboard that streams `.wav` files to nearby players through Simple Voice Chat's proximity audio pipeline (so it respects each player's voice-chat volume, distance attenuation, and audio device). **How it works:** the server decodes a WAV into 48 kHz / 16-bit / mono PCM and streams it in 20 ms frames into a `LocationalAudioChannel`. Clients just request "play sound *X*" — the audio never leaves the server, so it's cheat-proof and needs no file transfer. --- ## 1. Project layout ``` soundboard/ ├── build.gradle ├── gradle.properties ├── settings.gradle └── src/main/ ├── java/com/example/soundboard/ │ ├── SoundboardMod.java │ ├── SoundboardConfig.java │ ├── SoundInfo.java │ ├── SoundLibrary.java │ ├── SoundboardSound.java │ ├── audio/AudioIO.java │ ├── command/SoundboardCommand.java │ ├── net/SoundboardNetworking.java │ ├── voicechat/SoundboardVoicechatPlugin.java │ ├── voicechat/VoicechatAudio.java │ ├── client/SoundboardClient.java │ └── client/SoundboardScreen.java └── resources/ ├── fabric.mod.json └── assets/soundboard/lang/en_us.json ``` --- ## 2. Build files ### `gradle.properties` ```properties org.gradle.jvmargs=-Xmx2G org.gradle.parallel=true minecraft_version=1.20.1 yarn_mappings=1.20.1+build.10 loader_version=0.15.11 fabric_version=0.92.2+1.20.1 # Check https://maven.maxhenkel.de/#/releases/de/maxhenkel/voicechat/voicechat-api for the latest voicechat_api_version=2.4.0 mod_version=1.0.0 maven_group=com.example archives_base_name=soundboard ``` ### `settings.gradle` ```groovy pluginManagement { repositories { maven { name = 'Fabric'; url = 'https://maven.fabricmc.net/' } mavenCentral() gradlePluginPortal() } } rootProject.name = 'soundboard' ``` ### `build.gradle` ```groovy plugins { id 'fabric-loom' version '1.7-SNAPSHOT' id 'maven-publish' } version = project.mod_version group = project.maven_group base { archivesName = project.archives_base_name } repositories { maven { url = 'https://maven.maxhenkel.de/repository/public' } mavenCentral() } dependencies { minecraft "com.mojang:minecraft:${project.minecraft_version}" mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2" modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}" // Compile against the Simple Voice Chat API only. At runtime the real mod provides these classes. compileOnly "de.maxhenkel.voicechat:voicechat-api:${project.voicechat_api_version}" // Uncomment to run Simple Voice Chat in the dev environment: // modLocalRuntime "de.maxhenkel.voicechat:voicechat:${project.voicechat_api_version}" } processResources { inputs.property "version", project.version filesMatching("fabric.mod.json") { expand "version": project.version } } tasks.withType(JavaCompile).configureEach { it.options.release = 17 } java { withSourcesJar() sourceCompatibility = JavaVersion.VERSION_17 targetCompatibility = JavaVersion.VERSION_17 } ``` ### `src/main/resources/fabric.mod.json` ```json { "schemaVersion": 1, "id": "soundboard", "version": "${version}", "name": "Simple Voice Chat Soundboard", "description": "Play sound files to nearby players over Simple Voice Chat's proximity audio.", "authors": ["You"], "license": "MIT", "environment": "*", "entrypoints": { "main": ["com.example.soundboard.SoundboardMod"], "client": ["com.example.soundboard.client.SoundboardClient"], "voicechat": ["com.example.soundboard.voicechat.SoundboardVoicechatPlugin"] }, "depends": { "fabricloader": ">=0.15.0", "fabric-api": "*", "minecraft": "~1.20.1", "java": ">=17", "voicechat": ">=2.4.0" } } ``` > The `voicechat` entrypoint key is what Simple Voice Chat scans for `VoicechatPlugin` implementations. --- ## 3. Java sources ### `SoundboardMod.java` ```java package com.example.soundboard; import com.example.soundboard.command.SoundboardCommand; import com.example.soundboard.net.SoundboardNetworking; import com.example.soundboard.voicechat.VoicechatAudio; import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents; import net.fabricmc.loader.api.FabricLoader; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.nio.file.Path; public class SoundboardMod implements ModInitializer { public static final String MOD_ID = "soundboard"; public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); private static SoundboardConfig config; @Override public void onInitialize() { config = SoundboardConfig.load(); SoundboardNetworking.registerServer(); SoundboardCommand.register(); ServerLifecycleEvents.SERVER_STARTING.register(server -> SoundLibrary.load(configDir())); ServerLifecycleEvents.SERVER_STOPPING.register(server -> VoicechatAudio.stopEverything()); ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> SoundboardNetworking.sendSoundList(handler.getPlayer())); ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> VoicechatAudio.stopOwned(handler.getPlayer().getUuid())); } public static Path configDir() { return FabricLoader.getInstance().getConfigDir().resolve(MOD_ID); } public static SoundboardConfig config() { return config; } } ``` ### `SoundboardConfig.java` ```java package com.example.soundboard; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import net.fabricmc.loader.api.FabricLoader; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; public class SoundboardConfig { private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create(); private static final Path PATH = FabricLoader.getInstance().getConfigDir().resolve("soundboard.json"); /** Only players with permission level 2+ may trigger sounds. */ public boolean opsOnly = false; /** Minimum delay between plays, per player, in milliseconds. */ public long cooldownMillis = 3000; /** How far sound carries (blocks) when a sound does not define its own range. */ public float defaultRange = 48.0f; /** Global multiplier applied to every sound's volume. */ public float volumeMultiplier = 1.0f; /** Stop a player's audio when they disconnect. */ public boolean stopOnDisconnect = true; public static SoundboardConfig load() { SoundboardConfig result = new SoundboardConfig(); if (Files.exists(PATH)) { try (var reader = Files.newBufferedReader(PATH)) { SoundboardConfig loaded = GSON.fromJson(reader, SoundboardConfig.class); if (loaded != null) result = loaded; } catch (IOException e) { SoundboardMod.LOGGER.error("Could not read soundboard config, using defaults", e); } } result.save(); return result; } public void save() { try { Files.createDirectories(PATH.getParent()); try (var writer = Files.newBufferedWriter(PATH)) { GSON.toJson(this, writer); } } catch (IOException e) { SoundboardMod.LOGGER.error("Could not write soundboard config", e); } } } ``` ### `SoundInfo.java` ```java package com.example.soundboard; /** The lightweight id/name pair that gets shipped to clients. */ public record SoundInfo(String id, String displayName) { } ``` ### `SoundboardSound.java` ```java package com.example.soundboard; import com.example.soundboard.audio.AudioIO; import java.nio.file.Path; public class SoundboardSound { private final String id; private final String displayName; private final Path file; private final float volume; private final float range; private volatile short[] pcm; private volatile long durationMillis; public SoundboardSound(String id, String displayName, Path file, float volume, float range) { this.id = id; this.displayName = displayName; this.file = file; this.volume = volume; this.range = range; } /** Lazily decodes the file into 48 kHz / 16-bit / mono PCM. Cached after the first call. */ public short[] pcm() { short[] local = this.pcm; if (local != null) return local; synchronized (this) { if (this.pcm == null) { try { short[] decoded = AudioIO.decodeToVoicechatFormat(file); this.durationMillis = decoded.length * 1000L / (long) AudioIO.SAMPLE_RATE; this.pcm = decoded; } catch (Exception e) { SoundboardMod.LOGGER.error("Failed to decode soundboard sound '{}' ({})", id, file, e); this.pcm = new short[0]; } } return this.pcm; } } public String id() { return id; } public String displayName() { return displayName; } public Path file() { return file; } public float volume() { return volume; } public float range() { return range; } public long durationMillis() { return durationMillis; } public SoundInfo toInfo() { return new SoundInfo(id, displayName); } } ``` ### `audio/AudioIO.java` ```java package com.example.soundboard.audio; import javax.sound.sampled.AudioFormat; import javax.sound.sampled.AudioInputStream; import javax.sound.sampled.AudioSystem; import javax.sound.sampled.UnsupportedAudioFileException; import java.io.IOException; import java.nio.file.Path; public final class AudioIO { /** Simple Voice Chat expects 48 kHz, 16-bit signed, mono PCM. */ public static final float SAMPLE_RATE = 48000f; private AudioIO() { } /** * Decodes any format the JDK's audio SPI understands (WAV, AIFF, AU) and converts it * to 48 kHz / 16-bit signed / mono little-endian PCM. */ public static short[] decodeToVoicechatFormat(Path file) throws IOException, UnsupportedAudioFileException { try (AudioInputStream source = AudioSystem.getAudioInputStream(file.toFile())) { AudioFormat target = new AudioFormat( AudioFormat.Encoding.PCM_SIGNED, SAMPLE_RATE, 16, 1, 2, // frame size in bytes SAMPLE_RATE, false // little endian ); if (!AudioSystem.isConversionSupported(target, source.getFormat())) { throw new UnsupportedAudioFileException( "Cannot convert " + source.getFormat() + " to 48kHz mono 16-bit PCM"); } try (AudioInputStream converted = AudioSystem.getAudioInputStream(target, source)) { byte[] bytes = converted.readAllBytes(); short[] samples = new short[bytes.length / 2]; for (int i = 0; i < samples.length; i++) { int lo = bytes[i * 2] & 0xFF; int hi = bytes[i * 2 + 1]; // sign-extended samples[i] = (short) ((hi << 8) | lo); } return samples; } } } } ``` > Only WAV/AIFF/AU are supported out of the box. For MP3/OGG you'd add a JLayer / JOrbis SPI on the classpath. ### `SoundLibrary.java` ```java package com.example.soundboard; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Stream; public final class SoundLibrary { private static final Map SOUNDS = new ConcurrentHashMap<>(); private SoundLibrary() { } public static void load(Path dir) { SOUNDS.clear(); try { if (!Files.isDirectory(dir)) { Files.createDirectories(dir); Files.writeString(dir.resolve("README.txt"), """ Drop 16-bit PCM .wav files here to add soundboard sounds. The file name (without extension) becomes the sound id. Use /soundboard reload to pick up new files without restarting. """); } List files; try (Stream stream = Files.list(dir)) { files = stream .filter(Files::isRegularFile) .filter(p -> p.getFileName().toString().toLowerCase(Locale.ROOT).endsWith(".wav")) .sorted(Comparator.comparing(p -> p.getFileName().toString())) .toList(); } for (Path file : files) { String fileName = file.getFileName().toString(); String id = sanitize(fileName.substring(0, fileName.length() - 4)); if (SOUNDS.containsKey(id)) { SoundboardMod.LOGGER.warn("Duplicate soundboard id '{}' - skipping {}", id, fileName); continue; } SOUNDS.put(id, new SoundboardSound(id, prettify(id), file, 1.0f, 0.0f)); } SoundboardMod.LOGGER.info("Loaded {} soundboard sound(s) from {}", SOUNDS.size(), dir); } catch (IOException e) { SoundboardMod.LOGGER.error("Failed to load soundboard sounds from {}", dir, e); } } public static SoundboardSound get(String id) { return SOUNDS.get(id); } public static Collection all() { List list = new ArrayList<>(SOUNDS.values()); list.sort(Comparator.comparing(SoundboardSound::displayName, String.CASE_INSENSITIVE_ORDER)); return list; } public static List allInfos() { return all().stream().map(SoundboardSound::toInfo).toList(); } private static String sanitize(String raw) { return raw.toLowerCase(Locale.ROOT).replaceAll("[^a-z0-9_\\-]", "_"); } private static String prettify(String id) { StringBuilder sb = new StringBuilder(); for (String part : id.split("[_\\-]+")) { if (part.isEmpty()) continue; if (!sb.isEmpty()) sb.append(' '); sb.append(Character.toUpperCase(part.charAt(0))).append(part.substring(1)); } return sb.isEmpty() ? id : sb.toString(); } } ``` ### `voicechat/SoundboardVoicechatPlugin.java` ```java package com.example.soundboard.voicechat; import com.example.soundboard.SoundboardMod; import de.maxhenkel.voicechat.api.VoicechatApi; import de.maxhenkel.voicechat.api.VoicechatPlugin; import de.maxhenkel.voicechat.api.VoicechatServerApi; public class SoundboardVoicechatPlugin implements VoicechatPlugin { private static volatile VoicechatApi api; private static volatile VoicechatServerApi serverApi; @Override public String getPluginId() { return SoundboardMod.MOD_ID; } @Override public void initialize(VoicechatApi api) { SoundboardVoicechatPlugin.api = api; SoundboardVoicechatPlugin.serverApi = api instanceof VoicechatServerApi s ? s : null; SoundboardMod.LOGGER.info("Soundboard attached to Simple Voice Chat ({})", serverApi != null ? "server" : "client"); } public static VoicechatApi api() { return api; } public static VoicechatServerApi serverApi() { return serverApi; } } ``` ### `voicechat/VoicechatAudio.java` ```java package com.example.soundboard.voicechat; import com.example.soundboard.SoundboardMod; import com.example.soundboard.SoundboardSound; import de.maxhenkel.voicechat.api.VoicechatServerApi; import de.maxhenkel.voicechat.api.audiochannel.LocationalAudioChannel; import net.minecraft.server.world.ServerWorld; import java.util.ArrayList; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; public final class VoicechatAudio { /** Simple Voice Chat voice packets carry 20 ms of 48 kHz audio. */ private static final int FRAME_SAMPLES = 960; private static final long FRAME_MILLIS = 20L; private static final ScheduledExecutorService EXECUTOR = Executors.newScheduledThreadPool(2, r -> { Thread t = new Thread(r, "Soundboard-Audio"); t.setDaemon(true); return t; }); private static final Map PLAYING = new ConcurrentHashMap<>(); private VoicechatAudio() { } public static boolean isAvailable() { return SoundboardVoicechatPlugin.serverApi() != null; } public static void play(ServerWorld world, double x, double y, double z, SoundboardSound sound, float volume, float range, UUID owner) { VoicechatServerApi api = SoundboardVoicechatPlugin.serverApi(); if (api == null) return; short[] pcm = sound.pcm(); if (pcm.length == 0) return; short[] scaled = scale(pcm, volume); UUID channelId = UUID.randomUUID(); LocationalAudioChannel channel; try { channel = api.createLocationalAudioChannel( channelId, api.fromServerLevel(world), api.createPosition(x, y, z)); } catch (Throwable t) { SoundboardMod.LOGGER.error("Could not create voice chat audio channel", t); return; } if (channel == null) return; // Distance attenuation is handled by Simple Voice Chat; volume is baked into the PCM. channel.setDistance(range); Playing playing = new Playing(channel, scaled, owner); PLAYING.put(channelId, playing); ScheduledFuture future = EXECUTOR.scheduleAtFixedRate( () -> tick(channelId), 0L, FRAME_MILLIS, TimeUnit.MILLISECONDS); playing.future = future; // The first tick may have already fired and cancelled us before we stored the future. if (playing.cancelled) future.cancel(false); } private static void tick(UUID channelId) { Playing playing = PLAYING.get(channelId); if (playing == null || playing.cancelled) return; short[] data = playing.data; int offset = playing.offset; if (offset >= data.length) { stop(channelId); return; } int length = Math.min(FRAME_SAMPLES, data.length - offset); short[] frame = new short[length]; System.arraycopy(data, offset, frame, 0, length); playing.offset = offset + length; try { playing.channel.send(frame); } catch (Throwable t) { SoundboardMod.LOGGER.warn("Error streaming soundboard audio", t); stop(channelId); } } public static void stop(UUID channelId) { Playing playing = PLAYING.remove(channelId); if (playing == null) return; playing.cancelled = true; ScheduledFuture future = playing.future; if (future != null) future.cancel(false); } public static void stopOwned(UUID owner) { for (Map.Entry entry : new ArrayList<>(PLAYING.entrySet())) { if (entry.getValue().owner.equals(owner)) { stop(entry.getKey()); } } } public static void stopEverything() { for (UUID id : new ArrayList<>(PLAYING.keySet())) { stop(id); } } private static short[] scale(short[] pcm, float volume) { if (volume == 1.0f) return pcm; short[] out = new short[pcm.length]; for (int i = 0; i < pcm.length; i++) { int v = Math.round(pcm[i] * volume); out[i] = (short) Math.max(Short.MIN_VALUE, Math.min(Short.MAX_VALUE, v)); } return out; } private static final class Playing { final LocationalAudioChannel channel; final short[] data; final UUID owner; volatile int offset; volatile boolean cancelled; volatile ScheduledFuture future; Playing(LocationalAudioChannel channel, short[] data, UUID owner) { this.channel = channel; this.data = data; this.owner = owner; } } } ``` ### `net/SoundboardNetworking.java` ```java package com.example.soundboard.net; import com.example.soundboard.SoundInfo; import com.example.soundboard.SoundLibrary; import com.example.soundboard.SoundboardMod; import com.example.soundboard.SoundboardSound; import com.example.soundboard.client.SoundboardClient; import com.example.soundboard.voicechat.VoicechatAudio; import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking; import net.fabricmc.fabric.api.networking.v1.PacketByteBufs; import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; import net.minecraft.network.PacketByteBuf; import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.text.Text; import net.minecraft.util.Formatting; import net.minecraft.util.Identifier; import net.minecraft.util.math.MathHelper; import java.util.List; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; public final class SoundboardNetworking { public static final Identifier PLAY_SOUND = new Identifier(SoundboardMod.MOD_ID, "play_sound"); public static final Identifier STOP_SOUND = new Identifier(SoundboardMod.MOD_ID, "stop_sound"); public static final Identifier SOUND_LIST = new Identifier(SoundboardMod.MOD_ID, "sound_list"); private static final Map LAST_PLAY = new ConcurrentHashMap<>(); private SoundboardNetworking() { } // ------------------------------------------------------------------ server public static void registerServer() { ServerPlayNetworking.registerGlobalReceiver(PLAY_SOUND, (server, player, handler, buf, responseSender) -> { String soundId = buf.readString(64); float volume = buf.readFloat(); server.execute(() -> handlePlay(player, soundId, volume)); }); ServerPlayNetworking.registerGlobalReceiver(STOP_SOUND, (server, player, handler, buf, responseSender) -> server.execute(() -> VoicechatAudio.stopOwned(player.getUuid()))); } private static void handlePlay(ServerPlayerEntity player, String soundId, float volume) { var config = SoundboardMod.config(); if (config.opsOnly && !player.hasPermissionLevel(2)) { player.sendMessage(Text.translatable("soundboard.denied").formatted(Formatting.RED), true); return; } long now = System.currentTimeMillis(); Long last = LAST_PLAY.get(player.getUuid()); if (last != null && now - last < config.cooldownMillis) { player.sendMessage(Text.translatable("soundboard.cooldown").formatted(Formatting.YELLOW), true); return; } SoundboardSound sound = SoundLibrary.get(soundId); if (sound == null) return; LAST_PLAY.put(player.getUuid(), now); float vol = MathHelper.clamp(volume <= 0f ? sound.volume() : volume, 0f, 4f) * config.volumeMultiplier; float range = sound.range() > 0f ? sound.range() : config.defaultRange; VoicechatAudio.play( player.getServerWorld(), player.getX(), player.getEyeY(), player.getZ(), sound, vol, range, player.getUuid()); } public static void sendSoundList(ServerPlayerEntity player) { List sounds = SoundLibrary.allInfos(); PacketByteBuf buf = PacketByteBufs.create(); buf.writeVarInt(sounds.size()); for (SoundInfo info : sounds) { buf.writeString(info.id(), 64); buf.writeString(info.displayName(), 128); } ServerPlayNetworking.send(player, SOUND_LIST, buf); } public static void broadcastSoundList(MinecraftServerAccess access) { // helper used by the reload command } // ------------------------------------------------------------------ client public static void registerClient() { ClientPlayNetworking.registerGlobalReceiver(SOUND_LIST, (client, handler, buf, responseSender) -> { int count = buf.readVarInt(); List list = new java.util.ArrayList<>(count); for (int i = 0; i < count; i++) { String id = buf.readString(64); String name = buf.readString(128); list.add(new SoundInfo(id, name)); } client.execute(() -> SoundboardClient.setSounds(list)); }); } public static void sendPlay(String soundId, float volume) { PacketByteBuf buf = PacketByteBufs.create(); buf.writeString(soundId, 64); buf.writeFloat(volume); ClientPlayNetworking.send(PLAY_SOUND, buf); } public static void sendStop() { ClientPlayNetworking.send(STOP_SOUND, PacketByteBufs.empty()); } /** Marker interface — keeps the command class from importing Minecraft types it doesn't need. */ public interface MinecraftServerAccess { } } ``` > Delete the unused `broadcastSoundList` / `MinecraftServerAccess` leftovers if you like; they're only there so the reload command can iterate players without an extra import. Actually, let's just fix that below in the command instead — remove them from this class. **Cleaner version of the tail of `SoundboardNetworking`:** drop `broadcastSoundList` and the marker interface, and have the command call `SoundboardNetworking.sendSoundList(player)` directly. ### `command/SoundboardCommand.java` ```java package com.example.soundboard.command; import com.example.soundboard.SoundLibrary; import com.example.soundboard.SoundboardMod; import com.example.soundboard.net.SoundboardNetworking; import com.example.soundboard.voicechat.VoicechatAudio; import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback; import net.minecraft.server.command.CommandManager; import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.text.Text; import net.minecraft.util.Formatting; public final class SoundboardCommand { private SoundboardCommand() { } public static void register() { CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> dispatcher.register(CommandManager.literal("soundboard") .requires(source -> source.hasPermissionLevel(2)) .then(CommandManager.literal("reload").executes(ctx -> { SoundLibrary.load(SoundboardMod.configDir()); for (ServerPlayerEntity player : ctx.getSource().getServer() .getPlayerManager().getPlayerList()) { SoundboardNetworking.sendSoundList(player); } ctx.getSource().sendFeedback(() -> Text.literal( "Reloaded " + SoundLibrary.all().size() + " soundboard sound(s)") .formatted(Formatting.GREEN), true); return 1; })) .then(CommandManager.literal("stop").executes(ctx -> { VoicechatAudio.stopEverything(); ctx.getSource().sendFeedback( () -> Text.literal("Stopped all soundboard audio"), true); return 1; })) .then(CommandManager.literal("list").executes(ctx -> { var all = SoundLibrary.all(); if (all.isEmpty()) { ctx.getSource().sendFeedback( () -> Text.literal("No sounds loaded"), false); } else { ctx.getSource().sendFeedback(() -> Text.literal( "Sounds: " + all.stream() .map(s -> s.id()) .reduce((a, b) -> a + ", " + b).orElse("")), false); } return all.size(); })) )); } } ``` ### `client/SoundboardClient.java` ```java package com.example.soundboard.client; import com.example.soundboard.SoundInfo; import com.example.soundboard.net.SoundboardNetworking; import net.fabricmc.api.ClientModInitializer; import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; import net.minecraft.client.option.KeyBinding; import net.minecraft.client.util.InputUtil; import org.lwjgl.glfw.GLFW; import java.util.List; public class SoundboardClient implements ClientModInitializer { public static KeyBinding openKey; private static volatile List sounds = List.of(); @Override public void onInitializeClient() { openKey = KeyBindingHelper.registerKeyBinding(new KeyBinding( "key.soundboard.open", InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_P, "category.soundboard")); ClientTickEvents.END_CLIENT_TICK.register(client -> { while (openKey.wasPressed()) { if (client.currentScreen == null) { client.setScreen(new SoundboardScreen()); } } }); SoundboardNetworking.registerClient(); } public static List getSounds() { return sounds; } public static void setSounds(List list) { sounds = List.copyOf(list); } } ``` ### `client/SoundboardScreen.java` ```java package com.example.soundboard.client; import com.example.soundboard.SoundInfo; import com.example.soundboard.net.SoundboardNetworking; import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.gui.widget.TextFieldWidget; import net.minecraft.text.Text; import net.minecraft.util.Formatting; import net.minecraft.util.math.MathHelper; import java.util.ArrayList; import java.util.List; import java.util.Locale; public class SoundboardScreen extends Screen { private static final int LIST_WIDTH = 220; private static final int ROW_HEIGHT = 22; private static final int LIST_TOP = 62; private final List allSounds = new ArrayList<>(); private final List visible = new ArrayList<>(); private TextFieldWidget search; private double scroll; private String filter = ""; public SoundboardScreen() { super(Text.translatable("soundboard.title")); } @Override protected void init() { allSounds.clear(); allSounds.addAll(SoundboardClient.getSounds()); search = new TextFieldWidget(this.textRenderer, this.width / 2 - 100, 34, 200, 20, Text.empty()); search.setPlaceholder(Text.translatable("soundboard.search")); search.setMaxLength(64); search.setChangedListener(value -> { filter = value.toLowerCase(Locale.ROOT); scroll = 0; refresh(); }); addDrawableChild(search); setInitialFocus(search); addDrawableChild(ButtonWidget.builder(Text.translatable("soundboard.stop"), b -> SoundboardNetworking.sendStop()) .dimensions(this.width / 2 - 50, this.height - 30, 100, 20) .build()); refresh(); } private void refresh() { visible.clear(); for (SoundInfo info : allSounds) { if (filter.isEmpty() || info.id().toLowerCase(Locale.ROOT).contains(filter) || info.displayName().toLowerCase(Locale.ROOT).contains(filter)) { visible.add(info); } } } private int listBottom() { return this.height - 42; } private int listLeft() { return this.width / 2 - LIST_WIDTH / 2; } private double maxScroll() { return Math.max(0, visible.size() * ROW_HEIGHT - (listBottom() - LIST_TOP)); } private int indexAt(double mouseX, double mouseY) { int left = listLeft(); if (mouseX < left || mouseX > left + LIST_WIDTH) return -1; if (mouseY < LIST_TOP || mouseY >= listBottom()) return -1; int index = (int) ((mouseY - LIST_TOP + scroll) / ROW_HEIGHT); return index >= 0 && index < visible.size() ? index : -1; } @Override public void render(DrawContext context, int mouseX, int mouseY, float delta) { super.render(context, mouseX, mouseY, delta); int left = listLeft(); int right = left + LIST_WIDTH; int bottom = listBottom(); context.fill(left - 1, LIST_TOP - 1, right + 1, bottom + 1, 0x80000000); if (visible.isEmpty()) { context.drawCenteredTextWithShadow(this.textRenderer, allSounds.isEmpty() ? Text.translatable("soundboard.empty") : Text.translatable("soundboard.no_results"), this.width / 2, (LIST_TOP + bottom) / 2, 0xA0A0A0); } else { context.enableScissor(left, LIST_TOP, right, bottom); for (int i = 0; i < visible.size(); i++) { int y = (int) (LIST_TOP + i * ROW_HEIGHT - scroll); if (y + ROW_HEIGHT < LIST_TOP || y > bottom) continue; boolean hovered = mouseX >= left && mouseX < right && mouseY >= y && mouseY < y + ROW_HEIGHT; context.fill(left, y, right, y + ROW_HEIGHT, hovered ? 0x60FFFFFF : 0x30000000); SoundInfo info = visible.get(i); context.drawTextWithShadow(this.textRenderer, info.displayName(), left + 6, y + 7, 0xFFFFFF); context.drawTextWithShadow(this.textRenderer, Text.literal(info.id()).formatted(Formatting.DARK_GRAY), right - 6 - this.textRenderer.getWidth(info.id()), y + 7, 0x808080); } context.disableScissor(); } // scrollbar if (maxScroll() > 0) { int trackHeight = bottom - LIST_TOP; int barHeight = Math.max(16, (int) (trackHeight * trackHeight / (visible.size() * ROW_HEIGHT))); int barY = LIST_TOP + (int) ((trackHeight - barHeight) * (scroll / maxScroll())); context.fill(right + 3, LIST_TOP, right + 7, bottom, 0x40000000); context.fill(right + 3, barY, right + 7, barY + barHeight, 0xC0FFFFFF); } context.drawCenteredTextWithShadow(this.textRenderer, this.title, this.width / 2, 16, 0xFFFFFF); } @Override public boolean mouseClicked(double mouseX, double mouseY, int button) { if (button == 0) { int index = indexAt(mouseX, mouseY); if (index >= 0) { SoundboardNetworking.sendPlay(visible.get(index).id(), 1.0f); return true; } } return super.mouseClicked(mouseX, mouseY, button); } @Override public boolean mouseScrolled(double mouseX, double mouseY, double amount) { if (indexAt(mouseX, mouseY) >= 0 || (mouseX >= listLeft() - 8 && mouseX <= listLeft() + LIST_WIDTH + 8 && mouseY >= LIST_TOP && mouseY < listBottom())) { scroll = MathHelper.clamp(scroll - amount * ROW_HEIGHT, 0, maxScroll()); return true; } return super.mouseScrolled(mouseX, mouseY, amount); } @Override public boolean shouldPause() { return false; } } ``` ### `src/main/resources/assets/soundboard/lang/en_us.json` ```json { "soundboard.title": "Soundboard", "soundboard.search": "Search…", "soundboard.stop": "Stop My Sounds", "soundboard.empty": "No sounds installed", "soundboard.no_results": "No matching sounds", "soundboard.denied": "You are not allowed to use the soundboard", "soundboard.cooldown": "Slow down!", "key.soundboard.open": "Open Soundboard", "category.soundboard": "Soundboard" } ``` --- ## 4. Using it 1. Build with `./gradlew build` and drop the jar in `mods/` alongside **Simple Voice Chat** and Fabric API. 2. Start the server once — it creates `config/soundboard/`. 3. Drop your `.wav` files in there (16-bit PCM is safest; the JDK will convert sample rates and channel counts for you). 4. `/soundboard reload` (or restart) — every connected client gets the updated list. 5. Press **P** in game to open the soundboard. Sounds play at your head position and attenuate with distance, exactly like proximity voice chat. Config lives in `config/soundboard.json`: | Option | Default | Meaning | |---|---|---| | `opsOnly` | `false` | Restrict playback to permission level 2+ | | `cooldownMillis` | `3000` | Per-player spam throttle | | `defaultRange` | `48.0` | Block radius the audio carries | | `volumeMultiplier` | `1.0` | Global gain | | `stopOnDisconnect` | `true` | Cancel a player's audio when they leave | Commands (op level 2): `/soundboard reload`, `/soundboard stop`, `/soundboard list`. --- ## 5. Notes & caveats **Simple Voice Chat API versions.** The SVC API evolves between releases. The three calls most likely to need adjustment are: ```java api.createLocationalAudioChannel(channelId, svcLevel, svcPosition) api.fromServerLevel(serverWorld) // some versions expose ServerLevel.fromServerLevel(...) api.createPosition(x, y, z) channel.setDistance(range) // some versions only accept distance at creation time ``` Check the [SVC API Javadoc](https://github.com/henkelmax/simple-voice-chat/tree/master/api/src/main/java/de/maxhenkel/voicechat/api) for your version and adjust accordingly — the streaming logic in `VoicechatAudio` is independent of those names. **Format support.** `javax.sound.sampled` gives you WAV/AIFF/AU for free. If you want MP3/OGG, add `com.googlecode.soundlibs:jlayer` or `com.googlecode.soundlibs:jorbis` + `tritonus-share` as dependencies and keep using `AudioSystem`. **Why stream in 20 ms frames?** Simple Voice Chat's network protocol encodes 960-sample Opus frames. Feeding it larger buffers makes the client's jitter buffer balloon and audio drifts out of sync; feeding it smaller ones wastes bandwidth. **Threading.** `AudioChannel.send()` is called from the `Soundboard-Audio` thread pool. SVC's channel implementations are thread-safe; if you hit issues, switch to dispatching `channel.send()` onto the server thread via `server.execute(...)` (at the cost of timer jitter). **Possible extensions.** - Per-sound volume/range via a `sounds.json` metadata file next to the WAVs. - An `EntityAudioChannel` instead of a `LocationalAudioChannel` so the audio follows the player who triggered it. - A server-side `/soundboard play [pos]` for map makers, plus a redstone-triggerable block. - Hook `EventRegistration` to mute soundboard audio for players who have voice chat deafened.