#!/usr/bin/env python3
"""Gera os nove efeitos sonoros do Monk Tower para o fredygames.com.

Os .wav do repositorio (maciekglowka/tower-rl) nao tem autoria declarada; este script os substitui por sons sinteticos
(ondas quadrada, triangular e seno, envelopes e ruido com semente fixa), mesmos nomes de arquivo, 44,1 kHz, 16 bits, mono.
Dedicado ao dominio publico (CC0 1.0) por FredyGames. Saida identica a cada execucao.

Uso: python3 -I gen-sfx.py <pasta de saida>
"""
import math
import random
import struct
import sys
import wave

RATE = 44100


def tone(freq_fn, dur, shape="square", vol=0.5, attack=0.004, release=0.05, vibrato=(0, 0)):
    """freq_fn(t) devolve a frequencia (Hz) no instante t; envelope com ataque e queda lineares."""
    n = int(dur * RATE)
    out = []
    phase = 0.0
    for i in range(n):
        t = i / RATE
        f = freq_fn(t)
        if vibrato[0]:
            f *= 1 + vibrato[1] * math.sin(2 * math.pi * vibrato[0] * t)
        phase += f / RATE
        p = phase % 1.0
        if shape == "square":
            s = 1.0 if p < 0.5 else -1.0
        elif shape == "pulse":
            s = 1.0 if p < 0.25 else -1.0
        elif shape == "tri":
            s = 4 * abs(p - 0.5) - 1
        elif shape == "saw":
            s = 2 * p - 1
        else:
            s = math.sin(2 * math.pi * p)
        env = min(1.0, t / attack) * min(1.0, (dur - t) / release)
        out.append(s * env * vol)
    return out


def noise(dur, vol=0.5, seed=1, lowpass=0.0, decay=6.0):
    rng = random.Random(seed)
    n = int(dur * RATE)
    out = []
    y = 0.0
    for i in range(n):
        x = rng.uniform(-1, 1)
        y = y + (x - y) * (1 - lowpass) if lowpass else x
        out.append(y * vol * math.exp(-decay * i / n))
    return out


def mix(*tracks):
    n = max(len(t) for t in tracks)
    out = [0.0] * n
    for t in tracks:
        for i, v in enumerate(t):
            out[i] += v
    return out


def seq(*parts, gap=0.0):
    out = []
    for p in parts:
        out += p + [0.0] * int(gap * RATE)
    return out


def at(track, offset):
    return [0.0] * int(offset * RATE) + track


def note(n):  # semitons a partir do la 440 (n=0)
    return 440.0 * 2 ** (n / 12)


def sweep(a, b, dur):
    return lambda t: a * (b / a) ** (t / dur)


def write(path, samples):
    peak = max(1e-9, max(abs(s) for s in samples))
    scale = min(1.0, 0.9 / peak)
    with wave.open(path, "wb") as w:
        w.setnchannels(1)
        w.setsampwidth(2)
        w.setframerate(RATE)
        w.writeframes(b"".join(struct.pack("<h", int(max(-1, min(1, s * scale)) * 32767)) for s in samples))


def main(out):
    sounds = {}
    # pick: duas notas curtas subindo
    sounds["pick"] = seq(tone(lambda t: note(3), 0.07, "pulse", 0.5), tone(lambda t: note(10), 0.11, "pulse", 0.5, release=0.08))
    # use: sopro curto com tom descendo
    sounds["use"] = mix(tone(sweep(note(12), note(0), 0.22), 0.22, "tri", 0.5, release=0.1),
                        noise(0.22, 0.25, seed=2, lowpass=0.6, decay=5))
    # hit: baque grave com ruido
    sounds["hit"] = mix(tone(sweep(note(-17), note(-31), 0.2), 0.2, "square", 0.45, release=0.1),
                        noise(0.18, 0.5, seed=3, lowpass=0.3, decay=9))
    # spawn: varredura subindo com tremolo
    sounds["spawn"] = tone(sweep(note(-12), note(5), 0.45), 0.45, "saw", 0.35, attack=0.02, release=0.2, vibrato=(14, 0.04))
    # teleport: varredura que sobe e desce, oscilando
    up = tone(sweep(note(-5), note(19), 0.25), 0.25, "sine", 0.55, release=0.02, vibrato=(30, 0.03))
    down = tone(sweep(note(19), note(-7), 0.3), 0.3, "sine", 0.55, attack=0.02, release=0.15, vibrato=(30, 0.03))
    sounds["teleport"] = seq(up, down)
    # defeat: arpejo menor descendo e nota final grave
    sounds["defeat"] = seq(
        tone(lambda t: note(3), 0.16, "tri", 0.55), tone(lambda t: note(0), 0.16, "tri", 0.55),
        tone(lambda t: note(-4), 0.16, "tri", 0.55), tone(sweep(note(-9), note(-14), 0.5), 0.5, "tri", 0.6, release=0.3))
    # win: arpejo maior subindo com final longo
    sounds["win"] = seq(
        tone(lambda t: note(-9), 0.12, "pulse", 0.45), tone(lambda t: note(-5), 0.12, "pulse", 0.45),
        tone(lambda t: note(-2), 0.12, "pulse", 0.45), tone(lambda t: note(3), 0.12, "pulse", 0.45),
        mix(tone(lambda t: note(3), 0.45, "pulse", 0.4, release=0.3), tone(lambda t: note(7), 0.45, "tri", 0.4, release=0.3)))
    # upgrade: arpejo rapido com brilho
    arp = seq(*[tone(lambda t, k=k: note(k), 0.08, "pulse", 0.4) for k in (-9, -5, -2, 3, 7)])
    sounds["upgrade"] = mix(arp, at(tone(lambda t: note(19), 0.4, "sine", 0.25, release=0.3, vibrato=(9, 0.01)), 0.3))
    # ascend: tres degraus subindo
    sounds["ascend"] = seq(*[tone(lambda t, k=k: note(k), 0.08, "square", 0.4) for k in (-5, -1, 4)], gap=0.012)
    for name, samples in sounds.items():
        write(f"{out}/{name}.wav", samples)


if __name__ == "__main__":
    main(sys.argv[1])