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>
482 lines
23 KiB
GDScript
482 lines
23 KiB
GDScript
## Every Tidewall sound effect, as a recipe over tools/audio/dsp.gd. Each entry names
|
|
## its category, whether it loops, and the loudness it is levelled to. The categories
|
|
## and their targets are the mix in docs/STYLE.md: the sea always underneath, the
|
|
## tide's bell and foghorn the loudest things in a match, weapons dull thumps rather
|
|
## than sharp cracks, carpentry for building.
|
|
##
|
|
## Loudness is the loudest 400 ms window's RMS in dBFS for one-shots, and the whole
|
|
## file's RMS for loops (see tools/audio/loudness.gd).
|
|
extends RefCounted
|
|
|
|
const Dsp = preload("res://tools/audio/dsp.gd")
|
|
|
|
## Category -> target loudness in dBFS.
|
|
const TARGETS: Dictionary = {
|
|
"ui": -26.0,
|
|
"footstep": -24.0,
|
|
"player": -22.0,
|
|
"build": -19.0,
|
|
"impact": -19.0,
|
|
"weapon": -15.0,
|
|
"water": -18.0,
|
|
"tide": -12.0,
|
|
"ambience": -27.0,
|
|
"music": -25.0,
|
|
}
|
|
|
|
## Sound name -> [category, loops, recipe method].
|
|
const SOUNDS: Dictionary = {
|
|
# Footsteps, two of each so steps alternate.
|
|
"step_grass_1": ["footstep", false, "_step_grass"],
|
|
"step_grass_2": ["footstep", false, "_step_grass"],
|
|
"step_sand_1": ["footstep", false, "_step_sand"],
|
|
"step_sand_2": ["footstep", false, "_step_sand"],
|
|
"step_rock_1": ["footstep", false, "_step_rock"],
|
|
"step_rock_2": ["footstep", false, "_step_rock"],
|
|
"step_wood_1": ["footstep", false, "_step_wood"],
|
|
"step_wood_2": ["footstep", false, "_step_wood"],
|
|
"step_shallows_1": ["footstep", false, "_step_shallows"],
|
|
"step_shallows_2": ["footstep", false, "_step_shallows"],
|
|
"land": ["footstep", false, "_land"],
|
|
# Weapons: one report per weapon.
|
|
"swing_boathook": ["weapon", false, "_swing"],
|
|
"shot_fowling_piece": ["weapon", false, "_shot_fowling"],
|
|
"shot_dock_carbine": ["weapon", false, "_shot_carbine"],
|
|
"shot_signal_revolver": ["weapon", false, "_shot_revolver"],
|
|
"shot_rivet_repeater": ["weapon", false, "_shot_repeater"],
|
|
"shot_whalers_longgun": ["weapon", false, "_shot_longgun"],
|
|
"shot_line_thrower": ["weapon", false, "_shot_line"],
|
|
"shot_harpoon_gun": ["weapon", false, "_shot_harpoon"],
|
|
"keg_blast": ["weapon", false, "_keg_blast"],
|
|
"reload": ["player", false, "_reload"],
|
|
# Where shots and swings land.
|
|
"hit_wood": ["impact", false, "_hit_wood"],
|
|
"hit_stone": ["impact", false, "_hit_stone"],
|
|
"hit_iron": ["impact", false, "_hit_iron"],
|
|
"hit_player": ["impact", false, "_hit_player"],
|
|
"hit_ground": ["impact", false, "_hit_ground"],
|
|
"chop": ["impact", false, "_chop"],
|
|
# Building.
|
|
"build_driftwood": ["build", false, "_build_wood"],
|
|
"build_stone": ["build", false, "_build_stone"],
|
|
"build_salvage_iron": ["build", false, "_build_iron"],
|
|
"break_driftwood": ["build", false, "_break_wood"],
|
|
"break_stone": ["build", false, "_break_stone"],
|
|
"break_salvage_iron": ["build", false, "_break_iron"],
|
|
# Water and the tide.
|
|
"splash": ["water", false, "_splash"],
|
|
"swim": ["water", false, "_swim"],
|
|
"surge": ["tide", false, "_surge"],
|
|
"bell": ["tide", false, "_bell"],
|
|
"foghorn": ["tide", false, "_foghorn"],
|
|
"lighthouse": ["tide", false, "_lighthouse"],
|
|
# The player.
|
|
"hurt": ["player", false, "_hurt"],
|
|
"pickup": ["player", false, "_pickup"],
|
|
"chest_open": ["player", false, "_chest_open"],
|
|
"eliminated": ["player", false, "_eliminated"],
|
|
# Ambience, looped.
|
|
"amb_surf": ["ambience", true, "_amb_surf"],
|
|
"amb_wind": ["ambience", true, "_amb_wind"],
|
|
"amb_rain": ["ambience", true, "_amb_rain"],
|
|
# Menus.
|
|
"ui_hover": ["ui", false, "_ui_hover"],
|
|
"ui_click": ["ui", false, "_ui_click"],
|
|
"ui_back": ["ui", false, "_ui_back"],
|
|
"ui_confirm": ["ui", false, "_ui_confirm"],
|
|
}
|
|
|
|
|
|
## A stable seed per sound name, so each recipe's noise is its own.
|
|
static func seed_of(sound: String) -> int:
|
|
return hash(sound) & 0x7fffffff
|
|
|
|
|
|
static func render(sound: String) -> PackedFloat32Array:
|
|
var entry: Array = SOUNDS[sound]
|
|
var variant: int = 2 if sound.ends_with("_2") else 1
|
|
var recipes: Object = load("res://tools/audio/recipes.gd").new()
|
|
return recipes.call(String(entry[2]), seed_of(sound), variant)
|
|
|
|
|
|
# --- Footsteps -------------------------------------------------------------------
|
|
|
|
func _step_grass(seed_value: int, variant: int) -> PackedFloat32Array:
|
|
var swish: PackedFloat32Array = Dsp.bandpass(Dsp.noise(0.22, seed_value), [2600.0 + 400.0 * variant, 1500.0], 1.2)
|
|
swish = Dsp.shape(swish, [[0.0, 0.0], [0.015, 1.0], [0.08, 0.5], [0.22, 0.0]])
|
|
var thud: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.22, [95.0 + 8.0 * variant, 60.0]), 0.004, 0.09)
|
|
Dsp.mix_into(swish, thud, 0, 0.7)
|
|
return swish
|
|
|
|
|
|
func _step_sand(seed_value: int, variant: int) -> PackedFloat32Array:
|
|
var crunch: PackedFloat32Array = Dsp.noise(0.26, seed_value)
|
|
# Grains: sparse, uneven clicks under a soft hiss.
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = seed_value + 7
|
|
for i: int in crunch.size():
|
|
crunch[i] *= 0.25 + (1.6 if rng.randf() < 0.06 else 0.0)
|
|
crunch = Dsp.bandpass(crunch, [1700.0 + 300.0 * variant], 0.9)
|
|
return Dsp.shape(crunch, [[0.0, 0.0], [0.02, 1.0], [0.1, 0.6], [0.26, 0.0]])
|
|
|
|
|
|
func _step_rock(seed_value: int, variant: int) -> PackedFloat32Array:
|
|
var click: PackedFloat32Array = Dsp.decay(Dsp.highpass(Dsp.noise(0.18, seed_value), 1800.0), 0.001, 0.03)
|
|
var knock: PackedFloat32Array = Dsp.modes(0.18, 210.0 + 25.0 * variant, [1.0, 2.7, 5.1], [0.8, 0.4, 0.2], [0.06, 0.04, 0.02])
|
|
Dsp.mix_into(knock, click, 0, 0.8)
|
|
var grit: PackedFloat32Array = Dsp.decay(Dsp.bandpass(Dsp.noise(0.18, seed_value + 3), [3200.0], 1.5), 0.01, 0.1)
|
|
Dsp.mix_into(knock, grit, Dsp.n(0.02), 0.3)
|
|
return knock
|
|
|
|
|
|
func _step_wood(_seed_value: int, variant: int) -> PackedFloat32Array:
|
|
var board: PackedFloat32Array = Dsp.modes(0.3, 150.0 + 18.0 * variant, [1.0, 2.31, 3.9, 6.2], [1.0, 0.55, 0.3, 0.15], [0.16, 0.09, 0.05, 0.03])
|
|
var heel: PackedFloat32Array = Dsp.modes(0.2, 190.0 + 18.0 * variant, [1.0, 2.31, 3.9], [0.6, 0.3, 0.15], [0.1, 0.06, 0.04])
|
|
Dsp.mix_into(board, heel, Dsp.n(0.05), 0.7)
|
|
return board
|
|
|
|
|
|
func _step_shallows(seed_value: int, variant: int) -> PackedFloat32Array:
|
|
var slosh: PackedFloat32Array = Dsp.bandpass(Dsp.noise(0.4, seed_value), [900.0 + 150.0 * variant, 2600.0], 0.8)
|
|
slosh = Dsp.shape(slosh, [[0.0, 0.0], [0.03, 1.0], [0.12, 0.5], [0.4, 0.0]])
|
|
var bubble: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.12, [500.0 + 60.0 * variant, 1100.0]), 0.002, 0.08)
|
|
Dsp.mix_into(slosh, bubble, Dsp.n(0.06), 0.25)
|
|
return slosh
|
|
|
|
|
|
func _land(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var thump: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.4, [110.0, 45.0]), 0.003, 0.25)
|
|
var dust: PackedFloat32Array = Dsp.shape(Dsp.lowpass(Dsp.noise(0.4, seed_value), [1800.0]), [[0.0, 0.0], [0.01, 1.0], [0.35, 0.0]])
|
|
Dsp.mix_into(thump, dust, 0, 0.6)
|
|
return thump
|
|
|
|
|
|
# --- Weapons ----------------------------------------------------------------------
|
|
|
|
## A black-powder report: a low thump, a short burst of filtered noise and a tail.
|
|
## `body` is the thump's pitch, `bright` the noise's cutoff, `tail` its decay.
|
|
func _powder(seed_value: int, length: float, body: float, bright: float, tail: float, drive: float) -> PackedFloat32Array:
|
|
var out: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", length, [body * 1.8, body * 0.7]), 0.001, tail * 0.6)
|
|
var blast: PackedFloat32Array = Dsp.decay(Dsp.lowpass(Dsp.noise(length, seed_value), [bright, bright * 0.25], 2), 0.0005, tail)
|
|
Dsp.mix_into(out, blast, 0, 1.4)
|
|
var crack: PackedFloat32Array = Dsp.decay(Dsp.highpass(Dsp.noise(0.03, seed_value + 1), 1200.0), 0.0, 0.02)
|
|
Dsp.mix_into(out, crack, 0, 0.35)
|
|
return Dsp.saturate(out, drive)
|
|
|
|
|
|
func _shot_fowling(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# The scattergun: wide and boomy.
|
|
return Dsp.echo(_powder(seed_value, 0.9, 70.0, 2200.0, 0.55, 2.2), 0.19, 0.3, 2)
|
|
|
|
|
|
func _shot_carbine(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
return Dsp.echo(_powder(seed_value, 0.6, 95.0, 3400.0, 0.32, 1.8), 0.16, 0.25, 2)
|
|
|
|
|
|
func _shot_revolver(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A flare pistol's pop, and the hiss of the charge.
|
|
var out: PackedFloat32Array = _powder(seed_value, 0.5, 130.0, 2800.0, 0.2, 1.5)
|
|
var hiss: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.5, seed_value + 9), [4000.0, 2200.0], 1.0), [[0.0, 0.0], [0.04, 0.4], [0.5, 0.0]])
|
|
Dsp.mix_into(out, hiss, Dsp.n(0.02), 0.5)
|
|
return out
|
|
|
|
|
|
func _shot_repeater(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Short pop, then the rivet feed's clack.
|
|
var out: PackedFloat32Array = _powder(seed_value, 0.4, 120.0, 3000.0, 0.16, 1.6)
|
|
var clack: PackedFloat32Array = Dsp.modes(0.1, 1300.0, [1.0, 2.4, 3.7], [0.6, 0.4, 0.2], [0.03, 0.02, 0.015])
|
|
Dsp.mix_into(out, clack, Dsp.n(0.07), 0.5)
|
|
return out
|
|
|
|
|
|
func _shot_longgun(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# The heaviest report, rolling back off the cliffs.
|
|
return Dsp.echo(_powder(seed_value, 1.2, 55.0, 2600.0, 0.8, 2.4), 0.33, 0.4, 3)
|
|
|
|
|
|
func _shot_line(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A compressed-air whump and the line paying out.
|
|
var whump: PackedFloat32Array = Dsp.decay(Dsp.lowpass(Dsp.noise(0.7, seed_value), [900.0, 300.0]), 0.004, 0.2)
|
|
var body: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.7, [150.0, 70.0]), 0.002, 0.18)
|
|
Dsp.mix_into(whump, body, 0, 0.8)
|
|
var rope: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.7, seed_value + 2), [2400.0, 1200.0], 2.5), [[0.0, 0.0], [0.08, 0.0], [0.15, 0.5], [0.7, 0.0]])
|
|
Dsp.mix_into(whump, rope, 0, 0.6)
|
|
return whump
|
|
|
|
|
|
func _shot_harpoon(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A spring's twang and the harpoon's flight.
|
|
var twang: PackedFloat32Array = Dsp.decay(Dsp.osc("saw", 0.7, [180.0, 140.0], [9.0, 0.3]), 0.002, 0.35)
|
|
twang = Dsp.lowpass(twang, [2500.0, 600.0])
|
|
var thunk: PackedFloat32Array = Dsp.modes(0.3, 120.0, [1.0, 2.2], [1.0, 0.4], [0.12, 0.08])
|
|
Dsp.mix_into(twang, thunk, 0, 0.9)
|
|
var flight: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.7, seed_value), [1800.0, 700.0], 3.0), [[0.0, 0.0], [0.05, 0.6], [0.7, 0.0]])
|
|
Dsp.mix_into(twang, flight, 0, 0.5)
|
|
return twang
|
|
|
|
|
|
func _keg_blast(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var out: PackedFloat32Array = _powder(seed_value, 1.8, 40.0, 1600.0, 1.3, 2.8)
|
|
var debris: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(1.8, seed_value + 5), [2500.0, 900.0], 0.7), [[0.0, 0.0], [0.15, 0.0], [0.3, 0.35], [1.8, 0.0]])
|
|
Dsp.mix_into(out, debris, 0, 0.6)
|
|
return Dsp.echo(out, 0.4, 0.3, 2)
|
|
|
|
|
|
func _swing(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A boathook through the air.
|
|
var whoosh: PackedFloat32Array = Dsp.bandpass(Dsp.noise(0.35, seed_value), [500.0, 1600.0], 2.0)
|
|
return Dsp.shape(whoosh, [[0.0, 0.0], [0.12, 1.0], [0.2, 0.8], [0.35, 0.0]])
|
|
|
|
|
|
func _reload(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Ramrod and lock: two dull metal clicks.
|
|
var first: PackedFloat32Array = Dsp.modes(0.12, 900.0, [1.0, 2.7, 4.4], [0.7, 0.4, 0.2], [0.04, 0.03, 0.02])
|
|
var second: PackedFloat32Array = Dsp.modes(0.18, 640.0, [1.0, 2.7, 4.4], [0.9, 0.4, 0.2], [0.07, 0.04, 0.03])
|
|
return Dsp.sequence([first, second], 0.12)
|
|
|
|
|
|
# --- Impacts ----------------------------------------------------------------------
|
|
|
|
func _hit_wood(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var knock: PackedFloat32Array = Dsp.modes(0.35, 240.0, [1.0, 2.31, 3.9, 6.2], [1.0, 0.6, 0.35, 0.2], [0.18, 0.1, 0.06, 0.04])
|
|
var splinter: PackedFloat32Array = Dsp.decay(Dsp.bandpass(Dsp.noise(0.35, seed_value), [3000.0], 1.0), 0.001, 0.12)
|
|
Dsp.mix_into(knock, splinter, 0, 0.5)
|
|
return knock
|
|
|
|
|
|
func _hit_stone(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var chip: PackedFloat32Array = Dsp.decay(Dsp.highpass(Dsp.noise(0.3, seed_value), 2000.0), 0.0005, 0.08)
|
|
var body: PackedFloat32Array = Dsp.modes(0.3, 420.0, [1.0, 2.9, 5.3], [0.6, 0.35, 0.2], [0.07, 0.05, 0.03])
|
|
Dsp.mix_into(chip, body, 0, 0.8)
|
|
var rubble: PackedFloat32Array = Dsp.decay(Dsp.lowpass(Dsp.noise(0.3, seed_value + 4), [1200.0]), 0.02, 0.2)
|
|
Dsp.mix_into(chip, rubble, Dsp.n(0.03), 0.4)
|
|
return chip
|
|
|
|
|
|
func _hit_iron(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A dull clang: salvage plate, not a bell.
|
|
return Dsp.lowpass(Dsp.modes(0.8, 310.0, [1.0, 2.76, 4.07, 5.4, 6.9], [1.0, 0.6, 0.45, 0.3, 0.2], [0.6, 0.4, 0.3, 0.2, 0.15]), [3500.0])
|
|
|
|
|
|
func _hit_player(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Oilskin taking a hit: a padded thump.
|
|
var thump: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.25, [130.0, 70.0]), 0.002, 0.12)
|
|
var cloth: PackedFloat32Array = Dsp.decay(Dsp.bandpass(Dsp.noise(0.25, seed_value), [1100.0], 1.0), 0.002, 0.08)
|
|
Dsp.mix_into(thump, cloth, 0, 0.7)
|
|
return thump
|
|
|
|
|
|
func _hit_ground(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var puff: PackedFloat32Array = Dsp.decay(Dsp.lowpass(Dsp.noise(0.3, seed_value), [2400.0, 600.0]), 0.002, 0.15)
|
|
var body: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.3, [90.0, 50.0]), 0.002, 0.1)
|
|
Dsp.mix_into(puff, body, 0, 0.6)
|
|
return puff
|
|
|
|
|
|
func _chop(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A hook biting timber.
|
|
var bite: PackedFloat32Array = Dsp.modes(0.3, 330.0, [1.0, 2.31, 3.9], [1.0, 0.5, 0.3], [0.12, 0.08, 0.05])
|
|
var crack: PackedFloat32Array = Dsp.decay(Dsp.highpass(Dsp.noise(0.3, seed_value), 1500.0), 0.0005, 0.05)
|
|
Dsp.mix_into(bite, crack, 0, 0.7)
|
|
return bite
|
|
|
|
|
|
# --- Building ---------------------------------------------------------------------
|
|
|
|
func _build_wood(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Three mallet knocks, the last settling a board.
|
|
var parts: Array = []
|
|
for k: int in 3:
|
|
parts.append(Dsp.modes(0.16, 200.0 + 15.0 * k, [1.0, 2.31, 3.9, 6.2], [1.0, 0.5, 0.3, 0.15], [0.12, 0.08, 0.05, 0.03]))
|
|
return Dsp.sequence(parts, 0.07)
|
|
|
|
|
|
func _build_stone(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A block set down, and the scrape of it squared.
|
|
var set_down: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.7, [85.0, 60.0]), 0.004, 0.25)
|
|
var clunk: PackedFloat32Array = Dsp.modes(0.7, 380.0, [1.0, 2.9], [0.4, 0.2], [0.08, 0.05])
|
|
Dsp.mix_into(set_down, clunk, 0, 1.0)
|
|
var scrape: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.7, seed_value), [1400.0, 900.0], 1.5), [[0.0, 0.0], [0.2, 0.0], [0.3, 0.6], [0.65, 0.0]])
|
|
Dsp.mix_into(set_down, scrape, 0, 0.7)
|
|
return set_down
|
|
|
|
|
|
func _build_iron(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Rivets driven: four clanks, quick.
|
|
var parts: Array = []
|
|
for k: int in 4:
|
|
parts.append(Dsp.lowpass(Dsp.modes(0.12, 520.0 - 20.0 * k, [1.0, 2.76, 4.07], [1.0, 0.5, 0.3], [0.1, 0.07, 0.05]), [3000.0]))
|
|
return Dsp.sequence(parts, 0.05)
|
|
|
|
|
|
func _break_wood(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var crack: PackedFloat32Array = Dsp.decay(Dsp.bandpass(Dsp.noise(1.0, seed_value), [2200.0, 800.0], 0.8), 0.001, 0.5)
|
|
for k: int in 4:
|
|
var plank: PackedFloat32Array = Dsp.modes(0.4, 160.0 + 30.0 * k, [1.0, 2.31, 3.9], [0.8, 0.4, 0.2], [0.2, 0.1, 0.06])
|
|
Dsp.mix_into(crack, plank, Dsp.n(0.12 + 0.13 * k), 0.6)
|
|
return crack
|
|
|
|
|
|
func _break_stone(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var rumble: PackedFloat32Array = Dsp.decay(Dsp.lowpass(Dsp.brown(1.2, seed_value), [900.0, 300.0]), 0.01, 0.9)
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = seed_value + 11
|
|
for k: int in 7:
|
|
var chunk: PackedFloat32Array = Dsp.modes(0.25, rng.randf_range(250.0, 600.0), [1.0, 2.9], [0.6, 0.3], [0.06, 0.04])
|
|
Dsp.mix_into(rumble, chunk, Dsp.n(rng.randf_range(0.0, 0.8)), 0.5)
|
|
return rumble
|
|
|
|
|
|
func _break_iron(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var out: PackedFloat32Array = Dsp.lowpass(Dsp.modes(1.4, 180.0, [1.0, 2.76, 4.07, 5.4], [1.0, 0.7, 0.5, 0.3], [1.0, 0.7, 0.5, 0.3], 0.97), [2500.0])
|
|
var groan: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(1.4, seed_value), [600.0, 350.0], 6.0), [[0.0, 0.0], [0.2, 0.8], [1.4, 0.0]])
|
|
Dsp.mix_into(out, groan, 0, 0.8)
|
|
return out
|
|
|
|
|
|
# --- Water and the tide -----------------------------------------------------------
|
|
|
|
func _splash(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var body: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.9, seed_value), [700.0, 2500.0], 0.7), [[0.0, 0.0], [0.02, 1.0], [0.2, 0.5], [0.9, 0.0]])
|
|
var plunge: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.5, [160.0, 60.0]), 0.002, 0.25)
|
|
Dsp.mix_into(body, plunge, 0, 0.7)
|
|
return body
|
|
|
|
|
|
func _swim(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
return Dsp.shape(Dsp.bandpass(Dsp.noise(0.6, seed_value), [600.0, 1400.0], 1.0), [[0.0, 0.0], [0.15, 1.0], [0.6, 0.0]])
|
|
|
|
|
|
func _surge(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A wave breaking over the defences: a swell, the crash and the wash back.
|
|
var swell: PackedFloat32Array = Dsp.lowpass(Dsp.brown(3.5, seed_value), [200.0, 1600.0])
|
|
swell = Dsp.shape(swell, [[0.0, 0.0], [1.0, 0.6], [1.3, 1.0], [2.0, 0.6], [3.5, 0.0]])
|
|
var crash: PackedFloat32Array = Dsp.shape(Dsp.lowpass(Dsp.noise(3.5, seed_value + 1), [3000.0, 900.0]), [[0.0, 0.0], [1.15, 0.0], [1.3, 1.0], [3.5, 0.0]])
|
|
Dsp.mix_into(swell, crash, 0, 0.8)
|
|
return Dsp.saturate(swell, 1.5)
|
|
|
|
|
|
func _bell(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A ship's bell, struck twice: a phase has turned.
|
|
var strike: PackedFloat32Array = Dsp.modes(3.0, 523.0, [0.5, 1.0, 1.19, 1.56, 2.0, 2.51, 2.66, 3.01], [0.6, 1.0, 0.5, 0.45, 0.4, 0.25, 0.2, 0.15], [3.0, 2.4, 1.8, 1.5, 1.2, 0.9, 0.8, 0.6])
|
|
var out: PackedFloat32Array = Dsp.silence(3.8)
|
|
Dsp.mix_into(out, strike, 0, 1.0)
|
|
Dsp.mix_into(out, strike, Dsp.n(0.55), 0.85)
|
|
return out
|
|
|
|
|
|
func _foghorn(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# The tide is rising: a long, low reed note with a beating second voice.
|
|
var low: PackedFloat32Array = Dsp.osc("reed", 3.6, [98.0], [0.0, 0.0])
|
|
var beat: PackedFloat32Array = Dsp.osc("reed", 3.6, [98.6], [0.0, 0.0], 0.3)
|
|
var fifth: PackedFloat32Array = Dsp.osc("bow", 3.6, [147.0])
|
|
Dsp.mix_into(low, beat, 0, 0.8)
|
|
Dsp.mix_into(low, fifth, 0, 0.35)
|
|
low = Dsp.lowpass(low, [700.0], 2)
|
|
return Dsp.shape(low, [[0.0, 0.0], [0.35, 1.0], [2.9, 0.9], [3.6, 0.0]])
|
|
|
|
|
|
func _lighthouse(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# The last land: a slow, pure tone that swells like a turning lamp.
|
|
var tone: PackedFloat32Array = Dsp.osc("sine", 4.0, [392.0])
|
|
var upper: PackedFloat32Array = Dsp.osc("sine", 4.0, [588.0])
|
|
Dsp.mix_into(tone, upper, 0, 0.4)
|
|
var under: PackedFloat32Array = Dsp.osc("bow", 4.0, [196.0])
|
|
Dsp.mix_into(tone, Dsp.lowpass(under, [500.0]), 0, 0.5)
|
|
return Dsp.shape(tone, [[0.0, 0.0], [0.8, 0.7], [1.6, 1.0], [2.6, 0.8], [4.0, 0.0]])
|
|
|
|
|
|
# --- The player -------------------------------------------------------------------
|
|
|
|
func _hurt(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var thump: PackedFloat32Array = Dsp.decay(Dsp.osc("sine", 0.35, [85.0, 50.0]), 0.002, 0.2)
|
|
var breath: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.35, seed_value), [900.0, 600.0], 2.0), [[0.0, 0.0], [0.03, 0.5], [0.35, 0.0]])
|
|
Dsp.mix_into(thump, breath, 0, 0.7)
|
|
return thump
|
|
|
|
|
|
func _pickup(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Rope and canvas: a short rustle and a soft knock.
|
|
var rustle: PackedFloat32Array = Dsp.shape(Dsp.bandpass(Dsp.noise(0.3, seed_value), [2000.0, 3200.0], 1.2), [[0.0, 0.0], [0.04, 1.0], [0.3, 0.0]])
|
|
var knock: PackedFloat32Array = Dsp.modes(0.2, 420.0, [1.0, 2.31], [0.5, 0.2], [0.06, 0.04])
|
|
Dsp.mix_into(rustle, knock, Dsp.n(0.08), 0.8)
|
|
return rustle
|
|
|
|
|
|
func _chest_open(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A latch, then the lid's hinge creaking.
|
|
var latch: PackedFloat32Array = Dsp.modes(0.1, 1100.0, [1.0, 2.7], [0.7, 0.3], [0.04, 0.03])
|
|
var creak: PackedFloat32Array = Dsp.osc("saw", 0.6, [220.0, 310.0], [23.0, 0.6])
|
|
creak = Dsp.shape(Dsp.bandpass(creak, [900.0], 4.0), [[0.0, 0.0], [0.1, 0.8], [0.5, 0.6], [0.6, 0.0]])
|
|
var lid: PackedFloat32Array = Dsp.modes(0.3, 170.0, [1.0, 2.31, 3.9], [1.0, 0.5, 0.3], [0.18, 0.1, 0.06])
|
|
return Dsp.sequence([latch, creak, lid], 0.02)
|
|
|
|
|
|
func _eliminated(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A falling minor third on the bell's low partial: someone is out.
|
|
var first: PackedFloat32Array = Dsp.modes(1.4, 293.7, [1.0, 2.0, 2.76], [1.0, 0.3, 0.15], [1.2, 0.8, 0.5])
|
|
var second: PackedFloat32Array = Dsp.modes(1.6, 246.9, [1.0, 2.0, 2.76], [1.0, 0.3, 0.15], [1.4, 0.9, 0.6])
|
|
var out: PackedFloat32Array = Dsp.silence(2.0)
|
|
Dsp.mix_into(out, first, 0, 1.0)
|
|
Dsp.mix_into(out, second, Dsp.n(0.35), 1.0)
|
|
return out
|
|
|
|
|
|
# --- Ambience ---------------------------------------------------------------------
|
|
|
|
func _amb_surf(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# Waves arriving every few seconds over a constant low wash.
|
|
var length: float = 8.6
|
|
var wash: PackedFloat32Array = Dsp.lowpass(Dsp.brown(length, seed_value), [500.0])
|
|
var breaking: PackedFloat32Array = Dsp.lowpass(Dsp.noise(length, seed_value + 1), [1400.0])
|
|
var points: Array = [[0.0, 0.15]]
|
|
for wave: float in [0.4, 3.1, 5.6]:
|
|
points.append([wave + 0.9, 0.9])
|
|
points.append([wave + 2.2, 0.15])
|
|
points.append([length, 0.15])
|
|
breaking = Dsp.shape(breaking, points)
|
|
Dsp.mix_into(wash, breaking, 0, 0.45)
|
|
return Dsp.make_loop(wash, 0.6)
|
|
|
|
|
|
func _amb_wind(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var length: float = 7.6
|
|
var gust: PackedFloat32Array = Dsp.bandpass(Dsp.noise(length, seed_value), [380.0, 620.0], 1.6)
|
|
var whistle: PackedFloat32Array = Dsp.bandpass(Dsp.noise(length, seed_value + 1), [1100.0, 900.0], 8.0)
|
|
gust = Dsp.shape(gust, [[0.0, 0.5], [1.8, 1.0], [3.4, 0.4], [5.4, 0.9], [length, 0.5]])
|
|
Dsp.mix_into(gust, Dsp.shape(whistle, [[0.0, 0.0], [2.0, 0.6], [4.0, 0.0], [length, 0.0]]), 0, 0.5)
|
|
return Dsp.make_loop(gust, 0.6)
|
|
|
|
|
|
func _amb_rain(seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var length: float = 6.6
|
|
var hiss: PackedFloat32Array = Dsp.lowpass(Dsp.highpass(Dsp.noise(length, seed_value), 900.0), [6000.0])
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = seed_value + 3
|
|
var drop: PackedFloat32Array = Dsp.decay(Dsp.bandpass(Dsp.noise(0.05, seed_value + 4), [3500.0], 3.0), 0.0, 0.02)
|
|
for k: int in 260:
|
|
Dsp.mix_into(hiss, drop, Dsp.n(rng.randf_range(0.0, length)), rng.randf_range(0.5, 2.0), true)
|
|
return Dsp.make_loop(Dsp.scaled(hiss, 0.6), 0.6)
|
|
|
|
|
|
# --- Menus ------------------------------------------------------------------------
|
|
|
|
func _ui_hover(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
return Dsp.modes(0.08, 1250.0, [1.0, 2.31], [0.6, 0.2], [0.03, 0.02])
|
|
|
|
|
|
func _ui_click(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A peg knocked home.
|
|
return Dsp.modes(0.14, 640.0, [1.0, 2.31, 3.9], [1.0, 0.5, 0.25], [0.07, 0.05, 0.03])
|
|
|
|
|
|
func _ui_back(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
var first: PackedFloat32Array = Dsp.modes(0.1, 640.0, [1.0, 2.31], [0.8, 0.3], [0.05, 0.03])
|
|
var second: PackedFloat32Array = Dsp.modes(0.14, 480.0, [1.0, 2.31], [0.8, 0.3], [0.07, 0.04])
|
|
return Dsp.sequence([first, second], 0.03)
|
|
|
|
|
|
func _ui_confirm(_seed_value: int, _variant: int) -> PackedFloat32Array:
|
|
# A small bell, once.
|
|
return Dsp.modes(0.9, 880.0, [1.0, 2.0, 2.76, 4.1], [1.0, 0.4, 0.25, 0.1], [0.7, 0.5, 0.35, 0.2])
|