Files
tidewall/test/audio/test_sound_director.gd
claudeandClaude Opus 5.5 f3161bf46c R2: Debian package, desktop entry, launcher and application icon
- make deb (tools/deb.sh) builds tidewall_<version>-1_amd64.deb with
  dpkg-deb: launchers in /usr/games, the game in /usr/lib/tidewall, a
  validated desktop entry, hicolor icons, man pages, a DEP-5 copyright,
  the engine's licences and md5sums. No maintainer scripts. Depends on
  libc6 (>= 2.28), from the binary's GLIBC symbol versions.
- make deb-check (tools/deb_check.sh) checks it in a throwaway debian:13
  container: apt install with no recommends, desktop-file-validate,
  icons, man pages and licences, tidewall on a user's PATH, the server
  and the game headless as a user, lintian, and a purge that leaves
  nothing behind.
- The tarball gains a tidewall launcher (any directory, through a
  symlink), install-desktop-entry.sh (per-user menu entry, --remove),
  tidewall.png and ENGINE-LICENSES.txt (Godot's MIT text and bundled
  notices, which R1 lacked). make dist-check covers the launcher and the
  menu entry.
- Application icon: a hand-written SVG in palette colours, rendered to
  16-512 px by make app-icon, and set as the window icon.
  test_app_icon checks the renders, the colours and the setting.
- Fix: looping ambience played into the Dummy audio driver could be
  reported as resources in use at exit. Directors play nothing without
  real audio output (SoundBank.has_output()) and stop their voices on
  exit.

Tests: make check (648), make dist-check, make deb-check all pass.

Closes #61

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 03:12:47 -05:00

235 lines
10 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)
# Headless, the director plays nothing (SoundBank.has_output()); these tests check
# what it plays and where, so they ask it to play into the Dummy driver anyway.
director.audible = true
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")