Files
tidewall/test/audio/test_sound_director.gd
T
claudeandClaude Opus 5.5 2545337204 A8: Synthesized sound effects and an adaptive score
Every sound is made by scripts in tools/audio/ and committed as a WAV in
assets/audio/ with a manifest of hashes and levels:

- dsp.gd: seeded noise, wavetable oscillators, filters, envelopes and
  struck modes. recipes.gd: 50 effects (footsteps on five surfaces,
  a report per weapon, impacts, carpentry building and breaking, the
  tide's bell, foghorn, surge and lighthouse, player, ambience, menus).
- score.gd: an original eight-bar tune and chords in D Dorian, 6/8,
  rendered as four looping layers (drone, frame drum, concertina,
  fiddle).
- loudness.gd and check.gd: per-category loudness targets, a -1 dBFS
  peak ceiling and the mix order (the tide loudest). make audio and
  make audio-check.

In the client, SoundDirector turns FX records, footsteps, building,
the tide and the player's own hurts into sounds, placed on 3D voices
at the event so gunfire and footsteps come from their direction.
MusicDirector fades the score's layers with the tide on an
AudioStreamSynchronized, full in menus. MenuSounds knocks for buttons.

Closes #48

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 14:28:34 -05:00

232 lines
9.8 KiB
GDScript

extends TestCase
## A8: what the match sounds like, from the client's world. Sounds are placed where they
## happen (so they are heard from that direction), and each event picks its own sound.
const FRAME: float = 1.0 / 60.0
var tree: SceneTree
var director: SoundDirector
var game: ClientGame
var world: Simulation
func before_each() -> void:
super.before_each()
tree = Engine.get_main_loop() as SceneTree
director = SoundDirector.new()
tree.root.add_child(director)
game = ClientGame.new()
world = Simulation.new(5, SimGround.flat(0.0))
world.sea_level = -5.0
game.world = world
game.match_phase = Match.PLAY
director.update(game, 0, Vector3.ZERO, FRAME)
func after_each() -> void:
director.free()
SoundBank.clear()
super.after_each()
func _sounds() -> Array[String]:
var out: Array[String] = []
for cue: Dictionary in director.cues:
out.append(String(cue["sound"]))
return out
func _player(at: Vector3) -> SimEntity:
var player: SimEntity = world.entities.find(world.add_player())
player.position = at
player.on_ground = true
player.drop_state = Drop.NONE
player.health = 100
return player
func _fx(record: Dictionary) -> void:
game.fx.append(record)
game.fx_received += 1
func test_a_shot_is_placed_where_it_was_fired_with_that_weapons_report() -> void:
var at: Vector3 = Vector3(30.0, 2.0, -12.0)
_fx({"kind": NetFx.SHOT, "tick": 1, "player": 1, "item": ItemCatalog.code_of("whalers_longgun"), "position": at})
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), ["shot_whalers_longgun"] as Array[String])
assert_true(bool(director.cues[0]["spatial"]), "positional")
var voice: AudioStreamPlayer3D = director.voice_playing("shot_whalers_longgun")
assert_not_null(voice, "played on a 3D voice")
assert_eq(voice.global_position, at, "at the muzzle, so the engine pans it from there")
assert_true(voice.max_distance >= 400.0, "gunfire carries")
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(director.cues.size(), 0, "each FX record is heard once")
func test_each_weapon_has_its_own_report() -> void:
var seen: Dictionary = {}
for id: String in ["fowling_piece", "dock_carbine", "signal_revolver", "rivet_repeater", "whalers_longgun", "line_thrower", "harpoon_gun"]:
var sound: String = SoundDirector.shot_sound(ItemCatalog.code_of(id))
assert_eq(sound, "shot_" + id)
assert_true(SoundBank.has(sound), "%s exists" % sound)
seen[sound] = true
assert_eq(SoundDirector.shot_sound(-1), "swing_boathook", "the boathook, which has no item code")
assert_eq(SoundDirector.shot_sound(250), "shot_dock_carbine", "an unknown code still makes a sound")
func test_impacts_sound_like_what_was_hit() -> void:
var stone: StructureSet.Piece = world.structures.add(StructureSet.WALL, Materials.STONE, Vector4i(10, 0, 10, StructureSet.SLOT_WALL_X), 0, 0, 0, world.ground)
director.update(game, 0, Vector3.ZERO, FRAME)
var cases: Array = [
[Weapons.HIT_PIECE, stone.id, "hit_stone"], [Weapons.HIT_PLAYER, 3, "hit_player"],
[Weapons.HIT_PROP, 4, "hit_wood"], [Weapons.HIT_TERRAIN, 0, "hit_ground"],
]
for entry: Array in cases:
_fx({"kind": NetFx.IMPACT, "tick": 2, "player": 1, "item": ItemCatalog.code_of("dock_carbine"), "position": Vector3(1, 1, 1), "hit": entry[0], "target": entry[1]})
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), [entry[2]] as Array[String])
_fx({"kind": NetFx.HARVEST, "tick": 3, "player": 1, "item": -1, "position": Vector3.ZERO})
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), ["chop"] as Array[String])
func _walk(player: SimEntity, velocity: Vector3, seconds: float, listener: Vector3 = Vector3.ZERO) -> Array[String]:
var heard: Array[String] = []
for frame: int in int(seconds / FRAME):
player.position += velocity * FRAME
director.update(game, player.id, listener, FRAME)
heard.append_array(_sounds())
return heard
func test_footsteps_follow_the_stride_and_alternate_feet() -> void:
var player: SimEntity = _player(Vector3(5.0, 0.0, 5.0))
director.update(game, player.id, Vector3.ZERO, FRAME)
var heard: Array[String] = _walk(player, Vector3(5.0, 0.0, 0.0), 2.0)
# 10 m at a 1.6 m stride.
assert_eq(heard.size(), 6, "%s" % [heard])
assert_eq(heard[0], "step_grass_2")
assert_eq(heard[1], "step_grass_1")
for cue: Dictionary in director.cues:
assert_true(bool(cue["spatial"]))
var standing: Array[String] = _walk(player, Vector3.ZERO, 1.0)
assert_eq(standing.size(), 0, "standing still is silent")
func test_footsteps_know_the_surface() -> void:
var player: SimEntity = _player(Vector3(5.0, 2.0, 5.0))
director.update(game, player.id, Vector3.ZERO, FRAME)
var on_planks: Array[String] = _walk(player, Vector3(4.0, 0.0, 0.0), 1.0)
assert_true(on_planks.size() > 0 and on_planks[0].begins_with("step_wood"), "above the ground means on a built piece: %s" % [on_planks])
player.position.y = 0.0
world.sea_level = 0.4
director.update(game, player.id, Vector3.ZERO, FRAME)
var wading: Array[String] = _walk(player, Vector3(4.0, 0.0, 0.0), 1.0)
assert_true(wading.size() > 0 and wading[0].begins_with("step_shallows"), "%s" % [wading])
func test_footsteps_on_a_real_island_by_band() -> void:
var island_world: Simulation = Simulation.new(2)
var found: Dictionary = {}
var size: float = Tuning.WORLD_SIZE_METRES
for gz: int in 60:
for gx: int in 60:
var x: float = size * (gx + 0.5) / 60.0
var z: float = size * (gz + 0.5) / 60.0
var feet: Vector3 = Vector3(x, island_world.ground.terrain_height(x, z), z)
if feet.y <= island_world.sea_level + 0.1:
continue
found[SoundDirector.surface_at(island_world, feet)] = true
for surface: String in ["sand", "grass", "rock"]:
assert_true(found.has(surface), "the island has %s to walk on: %s" % [surface, found.keys()])
func test_far_footsteps_are_not_heard_but_near_ones_are() -> void:
var far: SimEntity = _player(Vector3(200.0, 0.0, 200.0))
var near: SimEntity = _player(Vector3(10.0, 0.0, 0.0))
director.update(game, 0, Vector3.ZERO, FRAME)
var heard: int = 0
for frame: int in 120:
far.position.x += 5.0 * FRAME
near.position.z += 5.0 * FRAME
director.update(game, 0, Vector3.ZERO, FRAME)
for cue: Dictionary in director.cues:
heard += 1
assert_true(Vector3(cue["at"]).distance_to(near.position) < 1.0, "only the near player's steps")
assert_eq(heard, 6)
func test_landing_and_splashing() -> void:
var player: SimEntity = _player(Vector3(0.0, 10.0, 0.0))
player.on_ground = false
director.update(game, player.id, Vector3.ZERO, FRAME)
_walk(player, Vector3(0.0, -12.0, 0.0), 0.5)
player.on_ground = true
assert_eq(_walk(player, Vector3.ZERO, FRAME), ["land"] as Array[String])
player.swimming = true
assert_eq(_walk(player, Vector3.ZERO, FRAME), ["splash"] as Array[String])
func test_building_and_breaking_by_material() -> void:
var piece: StructureSet.Piece = world.structures.add(StructureSet.FLOOR, Materials.SALVAGE_IRON, Vector4i(20, 0, 20, StructureSet.SLOT_FLOOR), 0, 0, 0, world.ground)
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), ["build_salvage_iron"] as Array[String])
assert_true(Vector3(director.cues[0]["at"]).distance_to(piece.boxes[0].get_center()) < 0.01, "at the piece")
world.structures.remove(piece.id, world.ground)
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), ["break_salvage_iron"] as Array[String])
func test_the_tide_rings_and_sounds_its_horn() -> void:
world.tide = Tide.new(0)
world.tick = 1
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), [] as Array[String], "nothing on the first look")
world.tick = world.tide.ticks_until_rise(1) + 2
director.update(game, 0, Vector3.ZERO, FRAME)
assert_true(_sounds().has("foghorn"), "the sea starts to rise: %s" % [_sounds()])
var heard: Dictionary = {}
while world.tide.stage_at(world.tick) != Tide.SUDDEN_DEATH:
world.tick += 20
director.update(game, 0, Vector3.ZERO, FRAME)
for sound: String in _sounds():
heard[sound] = int(heard.get(sound, 0)) + 1
assert_eq(int(heard.get("foghorn", 0)), Tide.phase_count() - 1, "a horn for each later rise: %s" % [heard])
assert_eq(int(heard.get("bell", 0)), Tide.phase_count() - 1, "a bell as each new phase holds")
assert_eq(int(heard.get("lighthouse", 0)), 1, "the lighthouse for the last land")
for cue: Dictionary in director.cues:
assert_false(bool(cue["spatial"]), "the tide is everywhere")
func test_own_hurt_and_the_feed() -> void:
var me: SimEntity = _player(Vector3.ZERO)
director.update(game, me.id, Vector3.ZERO, FRAME)
me.health = 70
director.update(game, me.id, Vector3.ZERO, FRAME)
assert_eq(_sounds(), ["hurt"] as Array[String])
game.feed.append({"victim": 9, "by": 3, "place": 12})
director.update(game, me.id, Vector3.ZERO, FRAME)
assert_eq(_sounds(), ["eliminated"] as Array[String])
func test_a_new_world_starts_quietly() -> void:
world.structures.add(StructureSet.FLOOR, Materials.STONE, Vector4i(20, 0, 20, StructureSet.SLOT_FLOOR), 0, 0, 0, world.ground)
_fx({"kind": NetFx.SHOT, "tick": 1, "player": 1, "item": 0, "position": Vector3.ZERO})
var next: Simulation = Simulation.new(6, SimGround.flat(0.0))
next.structures.add(StructureSet.FLOOR, Materials.STONE, Vector4i(20, 0, 20, StructureSet.SLOT_FLOOR), 0, 0, 0, next.ground)
game.world = next
director.update(game, 0, Vector3.ZERO, FRAME)
assert_eq(_sounds(), [] as Array[String], "what was there before the client looked isn't news")
func test_ambience_surf_near_the_water_and_wind_up_high() -> void:
director.update(game, 0, Vector3(0.0, world.sea_level + 2.0, 0.0), FRAME)
var low_surf: float = director.ambience_level("amb_surf")
var low_wind: float = director.ambience_level("amb_wind")
director.update(game, 0, Vector3(0.0, world.sea_level + 90.0, 0.0), FRAME)
assert_true(low_surf > director.ambience_level("amb_surf") * 2.0, "the surf fades with height")
assert_true(director.ambience_level("amb_wind") > low_wind * 2.0, "the wind grows with height")
assert_near(director.ambience_level("amb_rain"), 0.0, 0.001, "no rain until weather asks for it")