Files
routine/tools/gen_sounds.py
T

942 lines
27 KiB
Python

#!/usr/bin/env python3
"""Synthesize the check-off sounds into shared/sounds/*.wav (22.05 kHz mono 16-bit, <= 1 s; the star's
and the calm set's are 2 s, and the calm ones are written at under half the level).
Standard library only and deterministic. Each name matches an animation's "sound" in
tools/gen_animations.py; the streak animations' sounds live beside them in
tools/streak_anims/*_sounds.py (2 s; the calm streak ones written quiet like the calm set's).
Run: python3 tools/gen_sounds.py everything into shared/sounds
python3 tools/gen_sounds.py --level 3 --out DIR only streak level 3's (or calm), into DIR/sounds
"""
import math
import os
import random
from sound_kit import (CALM_DUR, OUT, SR, TAU, add_bell, add_noise, add_pluck, add_tone, buf, # noqa: F401
cbuf, ease_off, env, pad, soft_bell, write)
# ── the twenty ────────────────────────────────────────────────────────────────
def plip():
b = buf(0.7)
for k, f in enumerate((523, 659, 784, 1047)):
add_tone(b, k * 0.09, 0.3, f, f * 1.03, 0.35, d=0.08, shape="tri")
return b
def whoosh():
b = buf(1.0)
add_noise(b, 0.0, 1.0, 0.7, a=0.35, d=0.25, lp0=0.03, lp1=0.6)
add_tone(b, 0.0, 0.9, 90, 400, 0.15, a=0.3, d=0.3, shape="saw")
return b
def chime():
b = buf(1.0)
for k, f in enumerate((1318, 1760, 2093)):
add_bell(b, k * 0.07, f, 0.22, 0.35)
return b
def boing():
b = buf(0.8)
add_tone(b, 0, 0.75, 140, 520, 0.6, d=0.3, vib=(14, 0.18))
return b
def sproing():
b = buf(0.9)
add_tone(b, 0, 0.85, 900, 180, 0.45, d=0.35, shape="tri", vib=(22, 0.25))
add_noise(b, 0, 0.05, 0.3, d=0.02, lp0=0.8)
return b
def pop():
b = buf(0.5)
add_tone(b, 0, 0.12, 900, 120, 0.7, a=0.001, d=0.03)
add_noise(b, 0, 0.3, 0.6, a=0.001, d=0.04, lp0=0.9, lp1=0.2, seed=8)
return b
def fizzbang():
b = buf(1.0)
add_noise(b, 0, 0.45, 0.25, a=0.3, d=0.1, lp0=0.4, lp1=0.9, seed=4)
add_tone(b, 0, 0.45, 300, 1600, 0.15, a=0.3, d=0.2, shape="saw")
add_noise(b, 0.45, 0.55, 0.9, a=0.001, d=0.12, lp0=0.6, lp1=0.05, seed=5)
add_tone(b, 0.45, 0.4, 110, 50, 0.6, a=0.001, d=0.1)
return b
def tweet():
b = buf(0.8)
for k in range(3):
add_tone(b, 0.05 + k * 0.2, 0.12, 2400, 3600, 0.35, a=0.005, d=0.05, vib=(60, 0.05))
add_tone(b, 0.17 + k * 0.2, 0.06, 3600, 2800, 0.25, a=0.002, d=0.03)
return b
def kalimba():
b = buf(1.0)
for k, f in enumerate((587, 880, 740, 1175)):
add_tone(b, k * 0.13, 0.6, f, amp=0.35, a=0.002, d=0.12)
add_tone(b, k * 0.13, 0.2, f * 5.9, amp=0.06, a=0.001, d=0.02)
return b
def rattle():
b = buf(0.9)
rng = random.Random(9)
for k in range(16):
add_noise(b, k * 0.045 + rng.uniform(0, 0.02), 0.04, 0.5 * (1 - k / 18), a=0.001, d=0.008,
lp0=rng.uniform(0.3, 0.9), seed=k)
return b
def wobble():
b = buf(0.9)
add_tone(b, 0, 0.85, 220, 300, 0.45, a=0.02, d=0.4, shape="tri", vib=(7, 0.22))
return b
def zap():
b = buf(0.6)
add_tone(b, 0, 0.35, 2400, 90, 0.45, a=0.001, d=0.12, shape="square")
add_noise(b, 0, 0.2, 0.3, a=0.001, d=0.05, lp0=0.95, seed=2)
return b
def slide():
b = buf(1.0)
add_tone(b, 0, 0.95, 400, 1800, 0.45, a=0.03, d=0.6, vib=(6, 0.02))
add_noise(b, 0, 0.95, 0.05, a=0.03, d=0.6, lp0=0.3)
return b
def thump():
b = buf(1.0)
for k, s in enumerate((0.0, 0.18, 0.5, 0.68)):
add_tone(b, s, 0.2, 120 if k % 2 == 0 else 95, 50, 0.8, a=0.002, d=0.06)
return b
def splash():
b = buf(1.0)
add_tone(b, 0, 0.15, 500, 1400, 0.3, a=0.005, d=0.06)
add_noise(b, 0.7, 0.3, 0.7, a=0.002, d=0.08, lp0=0.8, lp1=0.2, seed=11)
add_tone(b, 0.7, 0.2, 700, 300, 0.2, a=0.002, d=0.05)
return b
def rise():
b = buf(1.0)
for k, f in enumerate((262, 330, 392, 523, 659)):
add_tone(b, k * 0.12, 0.5, f, amp=0.25, a=0.01, d=0.25, shape="tri")
return b
def drip():
b = buf(0.9)
for k, s in enumerate((0.0, 0.25, 0.5)):
add_tone(b, s, 0.1, 900 - k * 120, 2200 - k * 200, 0.45, a=0.001, d=0.035)
return b
def bloop():
b = buf(0.7)
add_tone(b, 0, 0.3, 160, 700, 0.6, a=0.005, d=0.1)
add_tone(b, 0.3, 0.3, 200, 900, 0.45, a=0.005, d=0.08)
return b
def flutter():
b = buf(1.0)
for k in range(12):
add_noise(b, k * 0.075, 0.05, 0.35, a=0.01, d=0.015, lp0=0.15 + 0.03 * (k % 3), seed=20 + k)
add_tone(b, 0.1, 0.8, 1400, 1700, 0.08, a=0.1, d=0.5, vib=(13, 0.08))
return b
def boo():
b = buf(1.0)
add_tone(b, 0, 0.95, 300, 160, 0.35, a=0.15, d=0.5, shape="tri", vib=(5, 0.06))
add_tone(b, 0, 0.95, 452, 241, 0.15, a=0.15, d=0.5, vib=(5, 0.06))
add_noise(b, 0, 0.95, 0.08, a=0.15, d=0.5, lp0=0.1)
return b
# ── set 1 and set 2 ──
def ribbit():
b = buf(0.7)
for k in range(2):
add_tone(b, k * 0.22, 0.16, 180, 140, 0.5, a=0.005, d=0.08, shape="square", vib=(30, 0.3))
return b
def squelch():
b = buf(1.0)
add_noise(b, 0, 0.9, 0.35, a=0.1, d=0.4, lp0=0.05, lp1=0.2, seed=40)
add_tone(b, 0, 0.9, 120, 90, 0.25, a=0.1, d=0.4, vib=(9, 0.3))
return b
def mew():
b = buf(0.8)
add_tone(b, 0, 0.6, 700, 900, 0.4, a=0.04, d=0.25, shape="tri", vib=(6, 0.04))
add_tone(b, 0.25, 0.35, 950, 600, 0.3, a=0.01, d=0.15, shape="tri")
return b
def fwump():
b = buf(0.7)
add_tone(b, 0, 0.15, 300, 900, 0.2, a=0.01, d=0.06)
add_noise(b, 0.12, 0.3, 0.8, a=0.002, d=0.07, lp0=0.4, lp1=0.05, seed=41)
add_tone(b, 0.12, 0.25, 140, 70, 0.5, a=0.002, d=0.06)
return b
def swish():
b = buf(1.0)
add_noise(b, 0, 0.3, 0.5, a=0.1, d=0.08, lp0=0.1, lp1=0.7, seed=42)
add_tone(b, 0.25, 0.5, 600, 1500, 0.2, a=0.05, d=0.2, vib=(4, 0.3))
add_noise(b, 0.75, 0.25, 0.4, a=0.05, d=0.08, lp0=0.6, lp1=0.1, seed=43)
return b
def breeze():
b = buf(1.0)
add_noise(b, 0, 1.0, 0.5, a=0.3, d=0.5, lp0=0.04, lp1=0.12, seed=44)
for k, f in enumerate((660, 880, 990)):
add_tone(b, 0.2 + k * 0.2, 0.4, f, amp=0.12, a=0.02, d=0.15, shape="tri")
return b
def tinkle():
b = buf(1.0)
for k, f in enumerate((2637, 3136, 2349, 3520, 2794, 4186)):
add_bell(b, k * 0.11, f, 0.12, 0.2)
return b
def patter():
b = buf(1.0)
rng = random.Random(45)
for k in range(22):
st = rng.uniform(0.15, 0.95)
add_tone(b, st, 0.05, rng.uniform(1500, 2600), rng.uniform(800, 1200), 0.18, a=0.001, d=0.012)
add_noise(b, 0, 0.2, 0.15, a=0.05, d=0.1, lp0=0.1, seed=46)
return b
def lullaby():
b = buf(1.0)
for k, f in enumerate((784, 659, 784, 1047)):
add_tone(b, k * 0.2, 0.5, f, amp=0.25, a=0.03, d=0.2, vib=(5, 0.01))
add_tone(b, k * 0.2, 0.4, f * 2, amp=0.05, a=0.03, d=0.1)
return b
def creak():
b = buf(1.0)
add_tone(b, 0, 0.6, 90, 160, 0.35, a=0.02, d=0.4, shape="saw", vib=(23, 0.15))
for k, f in enumerate((392, 494, 587, 784)):
add_tone(b, 0.55 + k * 0.08, 0.3, f, amp=0.15, a=0.005, d=0.08, shape="tri")
return b
def pomp():
b = buf(0.7)
for k, (f0, f1) in enumerate(((120, 260), (180, 380), (240, 520))):
add_tone(b, k * 0.15, 0.15, f0, f1, 0.45, a=0.003, d=0.06)
return b
def rumble():
b = buf(1.0)
add_noise(b, 0, 1.0, 0.9, a=0.05, d=0.45, lp0=0.015, lp1=0.04, seed=47)
add_tone(b, 0, 1.0, 55, 40, 0.5, a=0.05, d=0.4)
for k in range(4):
add_noise(b, 0.3 + k * 0.13, 0.08, 0.35, a=0.001, d=0.03, lp0=0.4, seed=48 + k)
return b
def spout():
b = buf(1.0)
add_tone(b, 0, 0.4, 70, 110, 0.4, a=0.08, d=0.2, vib=(3, 0.1))
add_noise(b, 0.35, 0.65, 0.6, a=0.03, d=0.3, lp0=0.7, lp1=0.2, seed=52)
return b
def warble():
b = buf(1.0)
add_tone(b, 0, 0.95, 500, 1100, 0.35, a=0.1, d=0.6, vib=(9, 0.12))
add_tone(b, 0, 0.95, 1000, 2200, 0.1, a=0.1, d=0.6, vib=(9, 0.12))
return b
def clack():
b = buf(0.9)
for k in range(6):
add_noise(b, k * 0.13, 0.03, 0.6, a=0.0005, d=0.006, lp0=0.95, seed=53 + k)
add_tone(b, k * 0.13, 0.04, 2200 if k % 2 else 1800, amp=0.3, a=0.0005, d=0.008)
return b
def tune():
b = buf(1.0)
for k, f in enumerate((523, 659, 587, 784, 698, 880)):
add_tone(b, k * 0.13, 0.25, f, amp=0.3, a=0.005, d=0.09, shape="square")
return b
def whirr():
b = buf(1.0)
for k in range(16):
add_noise(b, k * 0.055, 0.05, 0.3 + 0.01 * k, a=0.005, d=0.02, lp0=0.2 + k * 0.03, seed=60 + k)
add_tone(b, 0, 0.9, 300, 700, 0.1, a=0.1, d=0.5, shape="saw")
return b
def blub():
b = buf(0.9)
for k, s0 in enumerate((0.0, 0.18, 0.4, 0.55)):
add_tone(b, s0, 0.09, 400 + k * 90, 1200 + k * 200, 0.4, a=0.002, d=0.03)
add_noise(b, 0.75, 0.1, 0.3, a=0.001, d=0.02, lp0=0.9, seed=77)
return b
def thunk():
b = buf(0.8)
add_noise(b, 0, 0.3, 0.25, a=0.05, d=0.06, lp0=0.2, lp1=0.6, seed=78)
add_tone(b, 0.3, 0.3, 180, 90, 0.8, a=0.001, d=0.05)
add_tone(b, 0.32, 0.45, 330, 330, 0.2, a=0.001, d=0.12, vib=(18, 0.08))
return b
def clatter():
b = buf(1.0)
rng = random.Random(79)
for k in range(10):
st = 0.05 + k * 0.08 + rng.uniform(-0.02, 0.02)
add_noise(b, st, 0.03, 0.5 * (1 - k / 14), a=0.0005, d=0.01, lp0=0.8, seed=80 + k)
add_tone(b, st, 0.05, rng.uniform(900, 1400), amp=0.2, a=0.0005, d=0.015)
return b
def trickle():
b = buf(1.0)
add_noise(b, 0, 1.0, 0.25, a=0.2, d=0.6, lp0=0.5, lp1=0.3, seed=90)
for k, f in enumerate((1200, 1000, 800)):
add_bell(b, 0.1 + k * 0.3, f, 0.1, 0.15)
return b
def sparkle():
b = buf(1.0)
rng = random.Random(91)
for k in range(9):
add_bell(b, k * 0.09, rng.choice((2093, 2637, 3136, 4186)), 0.1, 0.12)
return b
def click():
b = buf(0.6)
add_noise(b, 0, 0.02, 0.8, a=0.0005, d=0.004, lp0=0.95, seed=92)
add_noise(b, 0.12, 0.02, 0.9, a=0.0005, d=0.004, lp0=0.95, seed=93)
add_tone(b, 0.15, 0.4, 660, 990, 0.25, a=0.005, d=0.12, shape="tri")
return b
def fanfare():
b = buf(1.0)
for k, (st, f, dur) in enumerate(((0, 523, 0.12), (0.13, 523, 0.12), (0.26, 523, 0.12), (0.4, 784, 0.55))):
add_tone(b, st, dur, f, amp=0.3, a=0.01, d=0.3, shape="saw")
add_tone(b, st, dur, f * 1.5, amp=0.1, a=0.01, d=0.3, shape="saw")
return b
def regal():
b = buf(1.0)
for k, f in enumerate((392, 523, 659)):
add_tone(b, k * 0.06, 0.9, f, amp=0.2, a=0.02, d=0.4, shape="tri")
add_bell(b, 0.4, 1568, 0.15, 0.3)
return b
def shimmer():
b = buf(1.0)
for k, f in enumerate((523, 587, 659, 698, 784, 880, 988, 1047)):
add_tone(b, k * 0.09, 0.3, f, amp=0.18, a=0.01, d=0.15, vib=(12, 0.01))
return b
def howl():
b = buf(1.0)
add_noise(b, 0, 1.0, 0.6, a=0.2, d=0.5, lp0=0.05, lp1=0.25, seed=94)
add_tone(b, 0, 1.0, 300, 500, 0.1, a=0.2, d=0.5, vib=(2, 0.2))
return b
def buzz():
b = buf(1.0)
add_tone(b, 0, 0.95, 220, 260, 0.3, a=0.03, d=0.6, shape="saw", vib=(7, 0.1))
return b
def squeak():
b = buf(0.8)
for k in range(3):
add_tone(b, k * 0.22, 0.08, 3000, 4200, 0.3, a=0.002, d=0.03)
return b
def cheep():
b = buf(1.0)
for k, st in enumerate((0.0, 0.08, 0.16)):
add_noise(b, st, 0.02, 0.4, a=0.0005, d=0.005, lp0=0.9, seed=95 + k)
for k in range(2):
add_tone(b, 0.5 + k * 0.2, 0.1, 2600, 3400, 0.35, a=0.003, d=0.04)
return b
def twinkle():
"""The star's own sound: a 2-second rising sparkle that blooms into a chord."""
b = buf(2.0)
notes_ = (523, 659, 784, 1047, 1319, 1568, 2093)
for k, f in enumerate(notes_):
add_bell(b, k * 0.11, f, 0.18, 0.3)
for f in (523, 659, 784, 1047):
add_tone(b, 0.9, 1.1, f, amp=0.12, a=0.05, d=0.5, vib=(5, 0.006))
rng = random.Random(99)
for k in range(10):
add_bell(b, 1.1 + k * 0.08, rng.choice((2637, 3136, 3520, 4186)), 0.07, 0.15)
return b
# ── set 0, second batch ──
def popple():
b = buf(1.0)
rng = random.Random(301)
for k in range(7):
st = k * 0.09 + rng.uniform(0, 0.03)
add_noise(b, st, 0.05, 0.6, a=0.0005, d=0.012, lp0=0.7, seed=310 + k)
add_tone(b, st, 0.06, rng.uniform(500, 800), 200, 0.3, a=0.0005, d=0.02)
return b
def zipzip():
b = buf(1.0)
add_tone(b, 0, 0.35, 300, 1400, 0.35, a=0.005, d=0.2, shape="tri")
add_tone(b, 0.45, 0.15, 1400, 1500, 0.2, a=0.005, d=0.08, vib=(30, 0.05))
add_tone(b, 0.62, 0.35, 1400, 300, 0.35, a=0.005, d=0.2, shape="tri")
return b
def wubwub():
b = buf(1.0)
for k in range(3):
add_tone(b, k * 0.3, 0.28, 150, 260, 0.45, a=0.06, d=0.12, vib=(5, 0.1))
return b
def streak():
b = buf(1.0)
add_tone(b, 0, 0.9, 3000, 700, 0.15, a=0.02, d=0.4)
add_noise(b, 0, 0.9, 0.4, a=0.02, d=0.35, lp0=0.8, lp1=0.15, seed=320)
for k, f in enumerate((1568, 2093)):
add_bell(b, 0.05 + k * 0.08, f, 0.12, 0.2)
return b
def flap():
b = buf(1.0)
for k in range(7):
add_noise(b, 0.2 + k * 0.1, 0.06, 0.45, a=0.005, d=0.02, lp0=0.25 + 0.05 * (k % 2), seed=330 + k)
add_tone(b, 0, 0.25, 200, 600, 0.2, a=0.01, d=0.1)
return b
def ding():
b = buf(1.0)
add_bell(b, 0, 1760, 0.4, 0.45)
add_bell(b, 0.12, 2637, 0.18, 0.3)
return b
def beepboop():
b = buf(1.0)
for k, f in enumerate((880, 660, 990, 520, 1175)):
add_tone(b, k * 0.14, 0.11, f, amp=0.28, a=0.002, d=0.08, shape="square")
return b
def chop():
b = buf(1.0)
for k in range(14):
add_noise(b, k * 0.068, 0.05, 0.5, a=0.002, d=0.018, lp0=0.12, seed=340 + k)
add_tone(b, k * 0.068, 0.05, 90, 70, 0.3, a=0.002, d=0.02)
return b
def lapping():
b = buf(1.0)
for k in range(3):
add_noise(b, k * 0.3, 0.35, 0.45, a=0.1, d=0.1, lp0=0.05, lp1=0.25, seed=350 + k)
add_tone(b, 0.1, 0.7, 520, 560, 0.08, a=0.1, d=0.4, vib=(3, 0.03))
return b
def twirl():
b = buf(1.0)
for k, f in enumerate((660, 784, 988, 1175, 988, 1175, 1319)):
add_tone(b, k * 0.08, 0.25, f, amp=0.22, a=0.005, d=0.08, shape="tri", vib=(14, 0.02))
return b
def toot():
b = buf(1.0)
add_noise(b, 0, 0.25, 0.4, a=0.05, d=0.08, lp0=0.3, seed=360)
add_tone(b, 0.3, 0.6, 440, 470, 0.4, a=0.02, d=0.35, shape="saw", vib=(6, 0.03))
add_tone(b, 0.3, 0.6, 660, 700, 0.15, a=0.02, d=0.35, shape="saw", vib=(6, 0.03))
return b
def orbit():
b = buf(1.0)
add_tone(b, 0, 0.95, 330, 340, 0.3, a=0.1, d=0.6, vib=(4, 0.15))
add_tone(b, 0, 0.95, 495, 505, 0.12, a=0.1, d=0.6, vib=(4, 0.15))
return b
def bonk():
b = buf(0.9)
for k, st in enumerate((0.15, 0.4, 0.66)):
add_tone(b, st, 0.18, 500 + k * 60, 180, 0.55 + k * 0.1, a=0.001, d=0.05)
add_noise(b, st, 0.03, 0.4, a=0.0005, d=0.01, lp0=0.6, seed=370 + k)
add_bell(b, 0.7, 2349, 0.12, 0.15)
return b
def punch():
b = buf(0.8)
add_tone(b, 0, 0.25, 200, 900, 0.2, a=0.005, d=0.1, shape="tri", vib=(25, 0.2))
add_noise(b, 0.25, 0.25, 0.9, a=0.001, d=0.05, lp0=0.5, lp1=0.08, seed=380)
add_tone(b, 0.25, 0.25, 130, 60, 0.7, a=0.001, d=0.06)
return b
def plod():
b = buf(1.0)
for k in range(4):
add_tone(b, 0.1 + k * 0.22, 0.12, 160 if k % 2 else 130, 90, 0.5, a=0.004, d=0.04, shape="tri")
return b
def hoot():
b = buf(1.0)
for k, (st, d) in enumerate(((0.0, 0.25), (0.4, 0.45))):
add_tone(b, st, d, 400, 360, 0.45, a=0.04, d=0.2, vib=(5, 0.02))
add_noise(b, st, d, 0.06, a=0.04, d=0.2, lp0=0.08, seed=390 + k)
return b
def plop():
b = buf(0.9)
for k, st in enumerate((0.1, 0.35, 0.6)):
add_tone(b, st, 0.12, 250 + k * 60, 900 + k * 100, 0.5, a=0.002, d=0.04)
add_noise(b, st, 0.06, 0.2, a=0.001, d=0.02, lp0=0.3, seed=400 + k)
return b
def crackle():
b = buf(1.0)
rng = random.Random(410)
for k in range(40):
st = rng.uniform(0, 0.95)
add_noise(b, st, 0.01, rng.uniform(0.2, 0.6), a=0.0003, d=0.003, lp0=0.95, seed=411 + k)
add_noise(b, 0, 1.0, 0.08, a=0.1, d=0.6, lp0=0.6, seed=460)
return b
def dangle():
b = buf(1.0)
add_tone(b, 0, 0.35, 1400, 300, 0.3, a=0.005, d=0.2, shape="tri")
add_tone(b, 0.35, 0.3, 300, 420, 0.3, a=0.005, d=0.12, vib=(16, 0.12))
add_tone(b, 0.7, 0.3, 300, 1300, 0.3, a=0.005, d=0.15, shape="tri")
return b
def floaty():
b = buf(1.0)
add_noise(b, 0, 0.12, 0.5, a=0.002, d=0.04, lp0=0.5, seed=470)
for k, f in enumerate((784, 740, 659, 587, 523)):
add_tone(b, 0.15 + k * 0.16, 0.35, f, amp=0.2, a=0.02, d=0.15, vib=(5, 0.02))
return b
SOUNDS = [plip, whoosh, chime, boing, sproing, pop, fizzbang, tweet, kalimba, rattle,
wobble, zap, slide, thump, splash, rise, drip, bloop, flutter, boo,
ribbit, squelch, mew, fwump, swish, breeze, tinkle, patter, lullaby, creak,
pomp, rumble, spout, warble, clack, tune, whirr, blub, thunk, clatter,
trickle, sparkle, click, fanfare, regal, shimmer, howl, buzz, squeak, cheep,
twinkle,
popple, zipzip, wubwub, streak, flap, ding, beepboop, chop, lapping, twirl,
toot, orbit, bonk, punch, plod, hoot, plop, crackle, dangle, floaty]
# ── the calm set (added 2026-11-07): 2 s each, soft attacks, no bangs, written quieter ──
def hush():
b = cbuf()
add_noise(b, 0, 2.0, 0.5, a=0.9, d=0.7, lp0=0.03, lp1=0.06, seed=1001)
return b
def paddle():
b = cbuf()
for k, st in enumerate((0.1, 1.0)):
add_noise(b, st, 0.7, 0.4, a=0.15, d=0.2, lp0=0.08, lp1=0.03, seed=1010 + k)
add_tone(b, st + 0.1, 0.6, 180, 150, 0.08, a=0.1, d=0.25)
return b
def unspool():
b = cbuf()
for k, f in enumerate((392, 349, 330, 294, 262)):
add_tone(b, 0.05 + k * 0.35, 0.8, f, amp=0.18, a=0.03, d=0.25, shape="tri")
return b
def glow():
b = cbuf()
pad(b, 0, 2.0, 220, 0.2, a=0.7, d=0.9)
pad(b, 0.3, 1.7, 330, 0.12, a=0.6, d=0.8)
return b
def rustle():
b = cbuf()
for k in range(5):
add_noise(b, k * 0.35, 0.6, 0.25, a=0.2, d=0.2, lp0=0.25, lp1=0.12, seed=1030 + k)
return b
def babble():
b = cbuf()
add_noise(b, 0, 2.0, 0.3, a=0.4, d=1.0, lp0=0.1, seed=1040)
rng = random.Random(1041)
for k in range(10):
st = rng.uniform(0.1, 1.7)
f = rng.uniform(500, 900)
add_tone(b, st, 0.08, f, f * 1.4, 0.06, a=0.01, d=0.03)
return b
def purr():
b = cbuf()
for k in range(int(2.0 * 25)):
add_noise(b, k / 25, 0.03, 0.25 * (0.6 + 0.4 * math.sin(k * 0.25)), a=0.01, d=0.015, lp0=0.04, seed=1050 + k)
add_tone(b, 0, 2.0, 55, amp=0.12, a=0.5, d=1.0)
return b
def nibble():
b = cbuf()
for k in range(9):
add_noise(b, 0.6 + k * 0.11 + (0.3 if k > 4 else 0), 0.02, 0.2, a=0.001, d=0.006, lp0=0.4, seed=1060 + k)
add_noise(b, 0, 0.5, 0.12, a=0.1, d=0.15, lp0=0.2, seed=1070)
return b
def coo():
b = cbuf()
for st, f0, f1, dur in ((0.1, 330, 300, 0.5), (0.75, 300, 280, 0.35), (1.15, 330, 290, 0.7)):
add_tone(b, st, dur, f0, f1, 0.2, a=0.08, d=0.3, vib=(6, 0.01))
return b
def warmth():
b = cbuf()
for k, f in enumerate((262, 330, 392)):
pad(b, k * 0.15, 2.0 - k * 0.15, f, 0.12, a=0.6, d=0.9)
return b
def waft():
b = cbuf()
add_noise(b, 0, 2.0, 0.25, a=0.8, d=0.6, lp0=0.15, lp1=0.05, seed=1080)
pad(b, 0.4, 1.6, 880, 0.04, a=0.5, d=0.5)
return b
def steep():
b = cbuf()
add_noise(b, 0, 0.8, 0.2, a=0.2, d=0.3, lp0=0.2, lp1=0.08, seed=1090)
soft_bell(b, 0.7, 523, 0.12, 0.6)
return b
def flicker():
b = cbuf()
pad(b, 0, 2.0, 196, 0.12, a=0.6, d=1.0)
rng = random.Random(1100)
for k in range(8):
add_noise(b, rng.uniform(0.2, 1.8), 0.015, 0.12, a=0.001, d=0.005, lp0=0.3, seed=1101 + k)
return b
def drift():
b = cbuf()
add_tone(b, 0.0, 0.9, 587, 523, 0.15, a=0.15, d=0.4, shape="tri")
add_tone(b, 0.8, 1.2, 523, 440, 0.15, a=0.2, d=0.5, shape="tri")
return b
def sprinkle():
b = cbuf()
rng = random.Random(1110)
for k in range(14):
st = 0.3 + k * 0.1 + rng.uniform(-0.03, 0.03)
f = rng.uniform(1200, 1900)
add_tone(b, st, 0.1, f, f * 0.8, 0.05, a=0.002, d=0.03)
add_noise(b, 0.3, 1.5, 0.1, a=0.3, d=0.6, lp0=0.3, seed=1111)
return b
def crickets():
b = cbuf()
for k in range(6):
st = 0.1 + k * 0.32
for m in range(3):
add_tone(b, st + m * 0.04, 0.03, 4200, amp=0.04, a=0.005, d=0.01)
pad(b, 0, 2.0, 247, 0.06, a=0.7, d=1.0)
return b
def airy():
b = cbuf()
add_noise(b, 0, 2.0, 0.2, a=0.6, d=0.7, lp0=0.4, lp1=0.2, seed=1120)
soft_bell(b, 0.5, 1047, 0.06, 0.6)
return b
def still():
b = cbuf()
pad(b, 0, 2.0, 220, 0.18, a=0.5, d=1.2)
pad(b, 0.6, 1.4, 330, 0.08, a=0.4, d=0.8)
return b
def sway():
b = cbuf()
pad(b, 0, 2.0, 174, 0.18, a=0.6, d=1.0, vib=(0.8, 0.02))
pad(b, 0, 2.0, 261, 0.08, a=0.8, d=1.0, vib=(0.6, 0.02))
return b
def tingle():
b = cbuf()
for k, f in enumerate((784, 659, 880, 587)):
soft_bell(b, 0.1 + k * 0.38, f, 0.1, 0.5)
return b
def airflow():
b = cbuf()
add_noise(b, 0, 2.0, 0.35, a=1.0, d=0.6, lp0=0.02, lp1=0.08, seed=1130)
return b
def drone():
b = cbuf()
for f in (110, 110.6, 165, 165.9):
pad(b, 0, 2.0, f, 0.1, a=0.7, d=1.0)
return b
def surf():
b = cbuf()
add_noise(b, 0, 2.0, 0.4, a=0.8, d=0.5, lp0=0.04, lp1=0.15, seed=1140)
add_noise(b, 0.9, 1.1, 0.15, a=0.1, d=0.5, lp0=0.4, lp1=0.1, seed=1141)
return b
def foghorn():
b = cbuf()
pad(b, 0.05, 1.9, 98, 0.25, a=0.5, d=0.8, shape="tri")
pad(b, 0.05, 1.9, 147, 0.08, a=0.6, d=0.7)
return b
def flit():
b = cbuf()
for k in range(12):
add_noise(b, 0.2 + k * 0.13, 0.06, 0.12, a=0.01, d=0.03, lp0=0.12, seed=1150 + k)
return b
def inhale():
b = cbuf()
add_noise(b, 0, 1.0, 0.3, a=0.8, d=0.1, lp0=0.05, lp1=0.15, seed=1160)
add_noise(b, 1.0, 1.0, 0.3, a=0.05, d=0.4, lp0=0.12, lp1=0.04, seed=1161)
return b
def sand():
b = cbuf()
for k in range(5):
add_noise(b, k * 0.38, 0.33, 0.25, a=0.08, d=0.15, lp0=0.5, lp1=0.3, seed=1170 + k)
return b
def stack():
b = cbuf()
for k, st in enumerate((0.2, 0.6, 1.0, 1.4)):
add_tone(b, st, 0.2, 220 + k * 30, 200 + k * 30, 0.2, a=0.003, d=0.05, shape="tri")
add_noise(b, st, 0.05, 0.08, a=0.001, d=0.02, lp0=0.15, seed=1180 + k)
return b
def dew():
b = cbuf()
add_tone(b, 0.3, 0.3, 700, 1100, 0.12, a=0.005, d=0.08)
pad(b, 0.3, 1.7, 349, 0.1, a=0.4, d=0.8)
return b
def yawn():
b = cbuf()
add_tone(b, 0.1, 1.8, 330, 165, 0.2, a=0.4, d=0.8, shape="tri", vib=(4, 0.01))
return b
def glide():
b = cbuf()
add_tone(b, 0, 2.0, 262, 294, 0.15, a=0.5, d=1.0, vib=(1.5, 0.01))
add_noise(b, 0, 2.0, 0.1, a=0.6, d=0.8, lp0=0.06, seed=1190)
return b
def celesta():
b = cbuf()
for k, f in enumerate((1047, 1319, 1568, 1319, 1760)):
soft_bell(b, 0.1 + k * 0.32, f, 0.07, 0.4)
return b
def ooze():
b = cbuf()
add_tone(b, 0, 1.9, 196, 147, 0.18, a=0.4, d=0.9)
add_tone(b, 1.5, 0.4, 300, 200, 0.05, a=0.02, d=0.1)
return b
def stitch():
b = cbuf()
for k in range(8):
add_noise(b, 0.15 + k * 0.22, 0.04, 0.12, a=0.002, d=0.012, lp0=0.35, seed=1200 + k)
add_tone(b, 0.15 + k * 0.22, 0.05, 900, amp=0.02, a=0.002, d=0.015)
return b
def page():
b = cbuf()
add_noise(b, 0.4, 0.9, 0.3, a=0.35, d=0.2, lp0=0.15, lp1=0.5, seed=1210)
return b
def embers():
b = cbuf()
add_noise(b, 0, 2.0, 0.2, a=0.5, d=1.0, lp0=0.04, seed=1220)
rng = random.Random(1221)
for k in range(10):
add_noise(b, rng.uniform(0.1, 1.9), 0.01, rng.uniform(0.08, 0.18), a=0.0005, d=0.004, lp0=0.6, seed=1222 + k)
return b
def hum():
b = cbuf()
for f, a in ((262, 0.2), (264.5, 0.2), (705, 0.06), (708, 0.06)):
add_tone(b, 0.05, 1.95, f, amp=a, a=0.3, d=1.2)
return b
def nestle():
b = cbuf()
for k in range(4):
add_noise(b, 0.1 + k * 0.25, 0.2, 0.15, a=0.03, d=0.08, lp0=0.3, seed=1240 + k)
pad(b, 0.8, 1.2, 294, 0.1, a=0.3, d=0.6)
return b
def seep():
b = cbuf()
add_tone(b, 0.15, 0.1, 900, 600, 0.06, a=0.005, d=0.04)
pad(b, 0.25, 1.75, 165, 0.18, a=0.6, d=1.0, vib=(0.7, 0.02))
return b
def rocker():
b = cbuf()
for k, st in enumerate((0.0, 0.7, 1.35)):
add_tone(b, st, 0.5, 140, 120, 0.12 * (1 - k * 0.25), a=0.12, d=0.2, shape="tri", vib=(9, 0.04))
return b
CALM_SOUNDS = [hush, paddle, unspool, glow, rustle, babble, purr, nibble, coo, warmth,
waft, steep, flicker, drift, sprinkle, crickets, airy, still, sway, tingle,
airflow, drone, surf, foghorn, flit, inhale, sand, stack, dew, yawn,
glide, celesta, ooze, stitch, page, embers, hum, nestle, seep, rocker]
def streak_sounds(strict=True, only=None):
"""{key: [fn]} from tools/streak_anims/*_sounds.py (key = level number or "calm")."""
import streak_anims
return {k: list(m.SOUNDS) for k, m in streak_anims.load("_sounds", strict, only).items()}
def write_streak(key, fns, out):
for fn in fns:
if key == "calm": # as quiet as the calm set's
write(fn.__name__, ease_off(fn()), 0.3, out)
else:
write(fn.__name__, ease_off(fn(), 0.15), 0.7, out)
def main():
import argparse
ap = argparse.ArgumentParser(description="Synthesize the check-off sounds")
ap.add_argument("--level", help="only this streak level's sounds (0-7, or calm)")
ap.add_argument("--out", help="write into OUT/sounds/ instead of shared/sounds (always use it with --level)")
a = ap.parse_args()
only = None if a.level is None else ("calm" if a.level == "calm" else int(a.level))
if only is not None and not a.out:
raise SystemExit("--level writes only some sounds: give --out DIR (a scratch folder)")
streak = streak_sounds(strict=only is None, only=only)
names = [fn.__name__ for fn in SOUNDS + CALM_SOUNDS] + [fn.__name__ for k in streak for fn in streak[k]]
dup = sorted({n for n in names if names.count(n) > 1})
if dup:
raise SystemExit("not unique: %s" % dup)
out = os.path.join(a.out, "sounds") if a.out else OUT
os.makedirs(out, exist_ok=True)
if only is not None:
write_streak(only, streak.get(only, []), out)
print(f"wrote {len(streak.get(only, []))} streak sounds ({a.level}) to {out}")
return
for fn in SOUNDS:
write(fn.__name__, fn(), out=out)
for fn in CALM_SOUNDS: # quieter: they're for early mornings and late nights
write(fn.__name__, ease_off(fn()), 0.3, out)
for k in streak:
write_streak(k, streak[k], out)
print(f"wrote {len(SOUNDS)} sounds + {len(CALM_SOUNDS)} calm ones + "
f"{sum(len(v) for v in streak.values())} streak ones to {out}")
if __name__ == "__main__":
main()