Play the game's own cursor, select and back sounds in the launcher.

The launcher's sound effects were chimes made from sine tones. They are now the game's interface sounds, the ones its menus make for the cursor, a choice and going back: SE_Sys_Cursor00, SE_Sys_Do00 and SE_Sys_Cancel00, the files the in-game menu plays. The launcher decodes them from the player's built game or dump into data/cache/sounds (gamefiles.extract_sounds, a BWAV reader for PCM16 and DSP-ADPCM), beside the font it already reads that way, so no sound ships. The chimes stand in until the game has been read. The cursor's sound is a little under the others, as in the game's menu, and is left out for a quarter of a second after a choice, since one sound plays at a time and the pointer landing on a row of the next screen would cut the choice's sound short. Sounds stay off until the player picks a loudness.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
epicmeme546
2026-11-10 00:21:31 -05:00
parent 41eb0e635b
commit 158ba315d5
6 changed files with 269 additions and 37 deletions

View File

@@ -305,18 +305,29 @@ class App:
return self.fcache[(family, max(7, int(px * smallest)), weight)]
def fonts_from_game(self, game_dir='', dump=''):
"""Decode the game's fonts in the background and redraw with them."""
if self.game_fonts:
"""Decode the game's fonts and its interface sounds in the background, redraw with the fonts and take up
the sounds."""
fonts, sounds = not self.game_fonts, not self.sounds.game
if not fonts and not sounds:
return
def work():
got = heard = {}
try:
got = gamefiles.extract_fonts(self.layout, game_dir, dump)
if fonts:
got = gamefiles.extract_fonts(self.layout, game_dir, dump)
except Exception as e:
self.ctx.log(f'fonts: {e}')
got = {}
try:
if sounds:
heard = gamefiles.extract_sounds(self.layout, game_dir, dump)
self.ctx.log(f'sounds: {len(heard)} of {len(gamefiles.SOUNDS)} interface sounds from the game')
except Exception as e:
self.ctx.log(f'sounds: {e}')
if got:
self.root.after(0, self.reload_fonts)
if heard:
self.root.after(0, self.sounds.load_game)
import threading
threading.Thread(target=work, daemon=True).start()
@@ -940,7 +951,7 @@ class App:
desc=('A gliding cursor, sliding screens and drifting sparks.',)),
Row('enum', 'Sounds', get=lambda: dict(SOUND_LEVELS).get(self.settings.get('sounds'), 'Off'),
left=lambda: sounds(-1), right=lambda: sounds(1),
desc=('Short chimes when you move and choose. Off by default.',)),
desc=('The game\'s cursor, select and back sounds. Off by default.',)),
Row('divider'),
Row('action', 'Back', on=lambda: self.show('home', self.home_row('Customize Launcher')), height=40,
desc=('Back to the main menu.',)),

View File

@@ -1,30 +1,38 @@
"""The launcher's sound effects: short chimes made here from sine tones, so no sound file ships and none comes from
the game.
"""The launcher's sound effects: the game's own interface sounds, the ones its menus make for the cursor, a choice
and going back, read from the player's game (launcher/gamefiles.py extract_sounds decodes them into
data/cache/sounds, as runtime/menu_sound.c plays them in the in-game menu). No sound file ships: until the player's
game has been read, and for a sound it does not hold, short chimes made here from sine tones stand in.
They are off until the player picks a loudness in Customize Launcher (the Sounds row). Each effect is a few plucked
notes (a tone with two overtones, a quick attack and an exponential decay) written as a 16-bit mono WAV in memory.
Windows plays it with PlaySound from that memory; elsewhere the WAV goes to a file in the cache folder and the first
of pw-play, paplay and aplay found plays it. One effect sounds at a time: a new one cuts the last, which suits a
cursor moving quickly down a list.
They are off until the player picks a loudness in Customize Launcher (the Sounds row). An effect is a 16-bit WAV in
memory: the game's sound scaled to the loudness (the cursor's a little under the others, as in the game's menu), or a
few plucked notes (a tone with two overtones, a quick attack and an exponential decay). Windows plays it with
PlaySound from that memory; elsewhere the WAV goes to a file in the cache folder and the first of pw-play, paplay
and aplay found plays it. One effect sounds at a time: a new one cuts the last, so the cursor's sound is left out
for a quarter of a second after a choice, which the pointer landing on a row of the next screen would otherwise cut.
move the cursor went to another row
toggle a switch or a choice changed
select a row was chosen (another screen, a folder dialog)
back back to the screen before
start Play
done an install, update or rebuild finished
error something could not be done
move the cursor went to another row the game's cursor sound
toggle a switch or a choice changed the cursor sound
select a row was chosen (another screen) the game's decide sound
back back to the screen before the game's cancel sound
start Play the decide sound
done an install, update or rebuild finished the decide sound
error something could not be done the cancel sound
"""
import ctypes
import os
import shutil
import struct
import subprocess
import time
import numpy as np
RATE = 44100
LEVELS = {'off': 0.0, 'low': 0.18, 'medium': 0.4, 'high': 0.75} # the Sounds choice: the loudest sample's share of full scale
# Which of the game's sounds (gamefiles.SOUNDS) each effect plays, and how loud beside the others.
GAME_SOUND = {'move': ('move', 0.6), 'toggle': ('move', 0.6), 'select': ('select', 1.0), 'start': ('select', 1.0),
'done': ('select', 1.0), 'back': ('back', 1.0), 'error': ('back', 1.0)}
QUIET_AFTER = 0.25 # seconds after a choice in which the cursor's sound is left out
# Notes as (start in seconds, frequency in Hz, length in seconds, loudness 0..1).
C5, D5, E5, G5, A5, C6, D6, E6, G6, C7 = 523.25, 587.33, 659.25, 783.99, 880.0, 1046.5, 1174.66, 1318.51, 1567.98, 2093.0
@@ -62,13 +70,28 @@ def synth(name):
return out / peak if peak > 0 else out
def wav_bytes(samples, level):
"""A 16-bit mono WAV of samples (-1..1) at level (0..1 of full scale)."""
def wav_bytes(samples, level, rate=RATE, channels=1):
"""A 16-bit WAV of samples (-1..1; frames by channels when there are two) at level (0..1 of full scale)."""
pcm = (np.clip(samples * level, -1, 1) * 32767).astype('<i2').tobytes()
return (b'RIFF' + struct.pack('<I', 36 + len(pcm)) + b'WAVEfmt ' + struct.pack('<IHHIIHH', 16, 1, 1, RATE, RATE * 2, 2, 16)
return (b'RIFF' + struct.pack('<I', 36 + len(pcm)) + b'WAVEfmt '
+ struct.pack('<IHHIIHH', 16, 1, channels, rate, rate * 2 * channels, 2 * channels, 16)
+ b'data' + struct.pack('<I', len(pcm)) + pcm)
def read_wav(data):
"""A 16-bit PCM WAV as written by gamefiles.pcm_to_wav: (rate, channels, samples in -1..1 with its loudest at 1),
or None when it is another kind of file."""
if len(data) < 44 or data[:4] != b'RIFF' or data[8:16] != b'WAVEfmt ' or data[36:40] != b'data':
return None
kind, channels, rate, _bytes, _align, bits = struct.unpack_from('<HHIIHH', data, 20)
size = min(struct.unpack_from('<I', data, 40)[0], len(data) - 44)
if kind != 1 or bits != 16 or channels not in (1, 2) or size < 2 * channels:
return None
a = np.frombuffer(data, dtype='<i2', count=size // 2, offset=44).astype(np.float32)
peak = float(np.abs(a).max())
return rate, channels, a / peak if peak > 0 else a
class Sounds:
"""Plays the effects at the level of the Sounds choice. Every failure is silent: a PC without a sound device, or
without a player program, just has a quiet launcher."""
@@ -77,6 +100,8 @@ class Sounds:
self.cache = cache_dir
self.log = log or (lambda line: None)
self.level = None # set_level below: 'off' unless the player chose a loudness
self.game = {} # the game's sounds decoded from the player's files: name -> (rate, channels, samples)
self.last_choice = 0.0 # when a sound other than the cursor's last started
self.wavs = {} # name -> WAV bytes at the current level (Windows plays from this memory: it must stay)
self.files = {} # name -> the WAV file elsewhere
self.player = None # elsewhere: the program that plays a WAV file
@@ -92,6 +117,22 @@ class Sounds:
else:
self.player = next((p for p in ('pw-play', 'paplay', 'aplay') if shutil.which(p)), None)
self.set_level(level)
self.load_game()
def load_game(self):
"""Takes up the game's sounds decoded into <cache>/sounds (again after gamefiles.extract_sounds wrote them)."""
game = {}
for name in {g for g, _gain in GAME_SOUND.values()}:
try:
got = read_wav((self.cache / 'sounds' / f'{name}.wav').read_bytes())
except OSError:
got = None
if got:
game[name] = got
if set(game) != set(self.game):
self.stop()
self.game, self.wavs, self.files = game, {}, {}
return bool(game)
def set_level(self, level):
level = level if level in LEVELS else 'off'
@@ -103,7 +144,12 @@ class Sounds:
def wav(self, name):
if name not in self.wavs:
self.wavs[name] = wav_bytes(synth(name), LEVELS[self.level])
source, gain = GAME_SOUND[name]
if source in self.game:
rate, channels, samples = self.game[source]
self.wavs[name] = wav_bytes(samples, LEVELS[self.level] * gain, rate, channels)
else:
self.wavs[name] = wav_bytes(synth(name), LEVELS[self.level])
return self.wavs[name]
def stop(self):
@@ -117,6 +163,12 @@ class Sounds:
def play(self, name):
if LEVELS.get(self.level, 0) <= 0 or self.failed or name not in EFFECTS:
return
now = time.monotonic()
if GAME_SOUND[name][0] == 'move':
if now - self.last_choice < QUIET_AFTER:
return
else:
self.last_choice = now
try:
if self.winmm:
# SND_ASYNC | SND_NODEFAULT | SND_MEMORY: PlaySound reads the bytes while it plays, and self.wavs