spawnpoint-studio 0.1.0__py3-none-any.whl

spawnpoint/rules.py

@@ -0,0 +1,310 @@
+"""Declarative rules -> generated GDScript (`rules.gd`).
+
+A rule is {"on": <event>, "if": <expr>?, "do": [<action>...]}. Every reference is checked against
+the graph and the component manifest, so the generated script is valid by construction.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+from .diagnostics import Diagnostics, did_you_mean, join_path
+from .expr import ExprError, Scope, _attr_chain, entity_literal, gd_string, normalize, translate
+from .graph import Rule
+from .manifest import Manifest
+
+GAMESTATE_EVENTS: dict[str, list[str]] = {
+    "score_changed": ["score"],
+    "lives_changed": ["lives"],
+    "var_changed": ["name", "value"],
+    "second_passed": ["seconds"],
+    "game_won": [],
+    "game_lost": [],
+}
+
+# name -> (min args, max args, description)
+BUILTINS: dict[str, tuple[int, int, str]] = {
+    "add_score": (1, 1, "add_score(n)"),
+    "set_var": (2, 2, 'set_var("name", value)'),
+    "add_var": (2, 2, 'add_var("name", delta)'),
+    "win": (0, 0, "win()"),
+    "lose": (0, 0, "lose()"),
+    "restart": (0, 0, "restart()"),
+    "spawn": (1, 1, 'spawn("Entity") at the emitting entity'),
+    "spawn_at": (3, 3, 'spawn_at("Entity", tile_x, tile_y)'),
+    "destroy": (1, 1, 'destroy(self) | destroy("Entity") | destroy(event.arg)'),
+    "shake": (1, 1, "shake(0..1)"),
+    "freeze": (1, 1, "freeze(seconds)"),
+    "sound": (1, 1, 'sound("name")'),
+    "message": (1, 1, 'message("text")'),
+}
+
+HEADER = """\
+# Generated by Spawn Point from the game graph (spawnpoint.json).
+# Do not edit by hand: change the graph's "rules" and rebuild.
+extends Node"""
+
+
+@dataclass
+class Event:
+    kind: str  # "entity" | "gamestate" | "ready"
+    label: str
+    args: list[str]
+    entity: str | None = None
+    component: str | None = None
+    signal: str | None = None
+
+
+@dataclass
+class RulesResult:
+    source: str
+    calls_win: bool
+
+
+def resolve_event(on: str, entities: dict[str, list[str]], manifest: Manifest) -> Event:
+    parts = on.strip().split(".")
+    if parts == ["Game", "ready"]:
+        return Event("ready", on, [])
+    if parts[0] == "GameState":
+        if len(parts) != 2 or parts[1] not in GAMESTATE_EVENTS:
+            raise ExprError(f"unknown GameState event '{on}'",
+                            did_you_mean(parts[-1], GAMESTATE_EVENTS))
+        return Event("gamestate", on, GAMESTATE_EVENTS[parts[1]], signal=parts[1])
+    ent = parts[0]
+    if ent not in entities:
+        raise ExprError(f"unknown entity '{ent}' in event '{on}'",
+                        did_you_mean(ent, [*entities, "GameState", "Game"]))
+    comps = entities[ent]
+    if len(parts) == 3:
+        comp_name, sig = parts[1], parts[2]
+        if comp_name not in comps:
+            raise ExprError(f"{ent} has no component '{comp_name}'", did_you_mean(comp_name, comps))
+        comp = manifest.get(comp_name)
+        if comp is None or sig not in comp.signals:
+            raise ExprError(f"{comp_name} has no signal '{sig}'", did_you_mean(sig, comp.signals if comp else []))
+    elif len(parts) == 2:
+        sig = parts[1]
+        owners = [c for c in comps if (m := manifest.get(c)) and sig in m.signals]
+        if not owners:
+            available = [f"{ent}.{s}" for c in comps if (m := manifest.get(c)) for s in m.signals]
+            raise ExprError(f"no component of {ent} emits '{sig}'",
+                            did_you_mean(f"{ent}.{sig}", available) if available else f"{ent} has no signals")
+        if len(owners) > 1:
+            raise ExprError(f"'{on}' is ambiguous", "Use one of: " + ", ".join(f"{ent}.{o}.{sig}" for o in owners))
+        comp_name = owners[0]
+    else:
+        raise ExprError(f"cannot parse event '{on}'", "Use Entity.signal, Entity.Component.signal, GameState.<event> or Game.ready")
+    sig_def = manifest.get(comp_name).signals[sig]
+    return Event("entity", on, [a.name for a in sig_def.args], ent, comp_name, sig)
+
+
+class _Actions:
+    """Translates action calls of one rule into GDScript statements."""
+
+    def __init__(self, scope: Scope, entities: dict[str, list[str]], manifest: Manifest):
+        self.scope = scope
+        self.entities = entities
+        self.manifest = manifest
+        self.calls_win = False
+
+    def expr(self, node: ast.AST) -> str:
+        return translate(ast.unparse(node), self.scope)
+
+    def translate(self, src: str) -> str:
+        try:
+            node = ast.parse(normalize(src).strip(), mode="eval").body
+        except SyntaxError as e:
+            raise ExprError(f"syntax error in action '{src}': {e.msg}") from e
+        if not isinstance(node, ast.Call):
+            raise ExprError(f"action '{src}' must be a call like win() or Door.open()")
+        if node.keywords:
+            raise ExprError("keyword arguments are not supported in actions")
+        if isinstance(node.func, ast.Name):
+            return self.builtin(node.func.id, node.args)
+        chain = _attr_chain(node.func)
+        if chain is None:
+            raise ExprError(f"cannot call '{ast.unparse(node.func)}'")
+        return self.method_call(chain, node.args, src)
+
+    def builtin(self, name: str, args: list[ast.expr]) -> str:
+        if name not in BUILTINS:
+            raise ExprError(f"unknown action '{name}()'", did_you_mean(name, BUILTINS))
+        lo, hi, usage = BUILTINS[name]
+        if not lo <= len(args) <= hi:
+            raise ExprError(f"wrong number of arguments for {name}()", f"Usage: {usage}")
+        e = self.expr
+        match name:
+            case "add_score":
+                return f"GameState.add_score(int({e(args[0])}))"
+            case "set_var" | "add_var":
+                key = _string_literal(args[0], f"{name}() needs the variable name in quotes")
+                return f"GameState.{name}({gd_string(key)}, {e(args[1])})"
+            case "win":
+                self.calls_win = True
+                return "GameState.win()"
+            case "lose":
+                return "GameState.lose()"
+            case "restart":
+                return "GameState.restart.call_deferred()"
+            case "spawn":
+                ent = entity_literal(args[0], self.entities)
+                if self.scope.self_entity is None:
+                    raise ExprError("spawn() places the entity at the emitting entity, but this event has none",
+                                    f'Use spawn_at("{ent}", tile_x, tile_y)')
+                self.scope.used.add("source")
+                return f'World.spawn.call_deferred({gd_string(ent)}, source.global_position)'
+            case "spawn_at":
+                ent = entity_literal(args[0], self.entities)
+                return f"World.spawn_at_tile.call_deferred({gd_string(ent)}, int({e(args[1])}), int({e(args[2])}))"
+            case "destroy":
+                a = args[0]
+                if isinstance(a, ast.Name) and a.id == "self":
+                    return f"World.destroy({e(a)})"
+                if isinstance(a, ast.Attribute):
+                    return f"World.destroy({e(a)})"
+                ent = entity_literal(a, self.entities)
+                return f'World.destroy_all(&"{ent}")'
+            case "shake":
+                return f"FX.shake({e(args[0])})"
+            case "freeze":
+                return f"FX.hitstop({e(args[0])})"
+            case "sound":
+                snd = _string_literal(args[0], 'sound() needs a sound name in quotes, e.g. sound("coin")')
+                return f"Sfx.play({gd_string(snd)})"
+            case "message":
+                return f"GameState.message(str({e(args[0])}))"
+        raise AssertionError(name)
+
+    def method_call(self, chain: list[str], args: list[ast.expr], src: str) -> str:
+        head = chain[0]
+        if head == "event":
+            if len(chain) < 3:
+                raise ExprError(f"cannot call '{'.'.join(chain)}'", "Use event.<arg>.<Component>.<method>()")
+            target_code = self.expr(ast.parse(f"event.{chain[1]}", mode="eval").body)
+            rest = chain[2:]
+            ent_type = None
+        elif head == "self":
+            if self.scope.self_entity is None:
+                raise ExprError("'self' is not available for this event (no emitting entity)")
+            self.scope.used.add("source")
+            target_code = "source"
+            rest = chain[1:]
+            ent_type = self.scope.self_entity
+        elif head in self.entities:
+            target_code = None
+            rest = chain[1:]
+            ent_type = head
+        else:
+            raise ExprError(f"unknown call target '{head}' in '{src}'",
+                            did_you_mean(head, [*self.entities, "self", "event"]))
+
+        if len(rest) == 2:
+            comp_name, method = rest
+        elif len(rest) == 1:
+            method = rest[0]
+            comp_name = self._component_for(method, ent_type)
+        else:
+            raise ExprError(f"cannot call '{'.'.join(chain)}'", "Use Entity.method() or Entity.Component.method()")
+
+        comp = self.manifest.get(comp_name)
+        if comp is None:
+            raise ExprError(f"unknown component '{comp_name}'", did_you_mean(comp_name, self.manifest.components))
+        if ent_type is not None and comp_name not in self.entities[ent_type]:
+            raise ExprError(f"{ent_type} has no component '{comp_name}'", did_you_mean(comp_name, self.entities[ent_type]))
+        m = comp.methods.get(method)
+        if m is None:
+            raise ExprError(f"{comp_name} has no method '{method}'", did_you_mean(method, comp.methods))
+        if not m.min_args <= len(args) <= len(m.args):
+            sig = ", ".join(a.name for a in m.args)
+            raise ExprError(f"{comp_name}.{method}() takes {m.min_args}-{len(m.args)} argument(s), got {len(args)}",
+                            f"Signature: {method}({sig})")
+        arg_code = "[" + ", ".join(self.expr(a) for a in args) + "]"
+        if target_code is None:
+            return f'World.call_all(&"{ent_type}", &"{comp_name}", &"{method}", {arg_code})'
+        return f'World.call_on({target_code}, &"{comp_name}", &"{method}", {arg_code})'
+
+    def _component_for(self, method: str, ent_type: str | None) -> str:
+        candidates = self.entities[ent_type] if ent_type else list(self.manifest.components)
+        owners = [c for c in candidates if (m := self.manifest.get(c)) and method in m.methods]
+        if not owners:
+            available = sorted({mm for c in candidates if (m := self.manifest.get(c)) for mm in m.methods})
+            where = ent_type or "any component"
+            raise ExprError(f"{where} has no method '{method}'", did_you_mean(method, available))
+        if len(owners) > 1:
+            raise ExprError(f"method '{method}' is ambiguous", "Name the component: " + ", ".join(f"{o}.{method}()" for o in owners))
+        return owners[0]
+
+
+def _string_literal(node: ast.AST, message: str) -> str:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    raise ExprError(message)
+
+
+def compile_rules(rules: list[Rule], entities: dict[str, list[str]], manifest: Manifest,
+                  diags: Diagnostics) -> RulesResult:
+    binds: list[str] = []
+    ready_calls: list[str] = []
+    funcs: list[str] = []
+    calls_win = False
+    for i, rule in enumerate(rules):
+        path = join_path("rules", i)
+        try:
+            ev = resolve_event(rule.on, entities, manifest)
+        except ExprError as e:
+            diags.error("E_RULE_EVENT", path + ".on", str(e), e.hint)
+            continue
+        arg_names = {a: f"a_{a}" for a in ev.args}
+        scope = Scope(manifest, entities, arg_names, ev.entity if ev.kind == "entity" else None)
+        ok = True
+        cond = None
+        if rule.if_:
+            try:
+                cond = translate(rule.if_, scope)
+            except ExprError as e:
+                diags.error("E_RULE_IF", path + ".if", str(e), e.hint)
+                ok = False
+        actions = _Actions(scope, entities, manifest)
+        body: list[str] = []
+        if not rule.actions:
+            diags.error("E_RULE_DO", path + ".do", "rule has no actions")
+            ok = False
+        for j, act in enumerate(rule.actions):
+            try:
+                body.append(actions.translate(act))
+            except ExprError as e:
+                diags.error("E_RULE_DO", join_path(path, "do", j), str(e), e.hint)
+                ok = False
+        if not ok:
+            continue
+        calls_win |= actions.calls_win
+
+        fname = f"_rule_{i}"
+        params = [(gd if gd in scope.used else "_" + gd) for gd in arg_names.values()]
+        if ev.kind == "entity":
+            params.append("source" if "source" in scope.used else "_source")
+            binds.append(f'World.bind_signal(&"{ev.entity}", &"{ev.component}", &"{ev.signal}", {fname})')
+        elif ev.kind == "gamestate":
+            binds.append(f"GameState.{ev.signal}.connect({fname})")
+        else:
+            ready_calls.append(f"{fname}()")
+
+        comment = f"# Rule {i}: on {rule.on}" + (f" if {rule.if_}" if rule.if_ else "")
+        lines = [comment, f"func {fname}({', '.join(params)}) -> void:"]
+        if cond:
+            lines += [f"\tif not {cond}:", "\t\treturn"]
+        lines += [f"\t{stmt}" for stmt in body]
+        funcs.append("\n".join(lines))
+
+    ready = ["func _ready() -> void:"]
+    ready += [f"\t{b}" for b in binds]
+    if ready_calls:
+        ready.append("\t_on_game_ready.call_deferred()")
+    if len(ready) == 1:
+        ready.append("\tpass")
+    chunks = [HEADER, "\n".join(ready)]
+    if ready_calls:
+        chunks.append("\n".join(["func _on_game_ready() -> void:", *[f"\t{c}" for c in ready_calls]]))
+    chunks += funcs
+    return RulesResult("\n\n\n".join(chunks) + "\n", calls_win)

spawnpoint/sfx.py

@@ -0,0 +1,352 @@
+"""Procedural retro sound effects (a port of DrPetter's sfxr synth and its preset generators).
+
+Every game gets jump / land / hurt / shoot / coin / explosion / powerup / dash / blip sounds,
+deterministic for a given seed, so the first build already has audio feedback.
+"""
+
+from __future__ import annotations
+
+import io
+import math
+import random
+import struct
+import wave
+from dataclasses import dataclass, replace
+from pathlib import Path
+
+SAMPLE_RATE = 44100
+SQUARE, SAW, SINE, NOISE = 0, 1, 2, 3
+
+
+@dataclass
+class SfxParams:
+    wave_type: int = SQUARE
+    base_freq: float = 0.3
+    freq_limit: float = 0.0
+    freq_ramp: float = 0.0
+    freq_dramp: float = 0.0
+    duty: float = 0.0
+    duty_ramp: float = 0.0
+    vib_strength: float = 0.0
+    vib_speed: float = 0.0
+    env_attack: float = 0.0
+    env_sustain: float = 0.3
+    env_decay: float = 0.4
+    env_punch: float = 0.0
+    lpf_resonance: float = 0.0
+    lpf_freq: float = 1.0
+    lpf_ramp: float = 0.0
+    hpf_freq: float = 0.0
+    hpf_ramp: float = 0.0
+    pha_offset: float = 0.0
+    pha_ramp: float = 0.0
+    repeat_speed: float = 0.0
+    arp_speed: float = 0.0
+    arp_mod: float = 0.0
+    volume: float = 0.6
+
+
+# --- preset generators (after sfxr's "generator" buttons) -------------------------------------
+
+
+def _pickup(r: random.Random) -> SfxParams:
+    p = SfxParams(base_freq=0.4 + r.random() * 0.5, env_sustain=r.random() * 0.1,
+                  env_decay=0.1 + r.random() * 0.4, env_punch=0.3 + r.random() * 0.3)
+    p.arp_speed = 0.5 + r.random() * 0.2
+    p.arp_mod = 0.2 + r.random() * 0.4
+    return p
+
+
+def _laser(r: random.Random) -> SfxParams:
+    p = SfxParams(wave_type=r.choice([SQUARE, SAW, SINE]))
+    p.base_freq = 0.5 + r.random() * 0.5
+    p.freq_limit = max(0.2, p.base_freq - 0.2 - r.random() * 0.6)
+    p.freq_ramp = -0.15 - r.random() * 0.2
+    if r.random() < 0.5:
+        p.duty, p.duty_ramp = r.random() * 0.5, r.random() * 0.2
+    else:
+        p.duty, p.duty_ramp = 0.4 + r.random() * 0.5, -r.random() * 0.7
+    p.env_sustain = 0.1 + r.random() * 0.2
+    p.env_decay = r.random() * 0.4
+    if r.random() < 0.5:
+        p.env_punch = r.random() * 0.3
+    if r.random() < 0.33:
+        p.pha_offset, p.pha_ramp = r.random() * 0.2, -r.random() * 0.2
+    p.hpf_freq = r.random() * 0.3 if r.random() < 0.5 else 0.0
+    p.volume = 0.45
+    return p
+
+
+def _explosion(r: random.Random) -> SfxParams:
+    p = SfxParams(wave_type=NOISE)
+    if r.random() < 0.5:
+        p.base_freq, p.freq_ramp = 0.1 + r.random() * 0.4, -0.1 + r.random() * 0.4
+    else:
+        p.base_freq, p.freq_ramp = 0.2 + r.random() * 0.7, -0.2 - r.random() * 0.2
+    p.base_freq *= p.base_freq
+    if r.random() < 0.2:
+        p.freq_ramp = 0.0
+    if r.random() < 0.33:
+        p.repeat_speed = 0.3 + r.random() * 0.5
+    p.env_sustain = 0.1 + r.random() * 0.3
+    p.env_decay = 0.2 + r.random() * 0.4
+    if r.random() < 0.5:
+        p.pha_offset, p.pha_ramp = -0.3 + r.random() * 0.9, -r.random() * 0.3
+    p.env_punch = 0.2 + r.random() * 0.6
+    if r.random() < 0.5:
+        p.vib_strength, p.vib_speed = r.random() * 0.7, r.random() * 0.6
+    return p
+
+
+def _powerup(r: random.Random) -> SfxParams:
+    p = SfxParams()
+    if r.random() < 0.5:
+        p.wave_type = SAW
+    else:
+        p.duty = r.random() * 0.6
+    if r.random() < 0.5:
+        p.base_freq, p.freq_ramp, p.repeat_speed = 0.2 + r.random() * 0.3, 0.1 + r.random() * 0.4, 0.4 + r.random() * 0.4
+    else:
+        p.base_freq, p.freq_ramp = 0.2 + r.random() * 0.3, 0.05 + r.random() * 0.2
+        if r.random() < 0.5:
+            p.vib_strength, p.vib_speed = r.random() * 0.7, r.random() * 0.6
+    p.env_sustain = r.random() * 0.4
+    p.env_decay = 0.1 + r.random() * 0.4
+    return p
+
+
+def _hurt(r: random.Random) -> SfxParams:
+    p = SfxParams(wave_type=r.choice([SQUARE, SAW, NOISE]))
+    if p.wave_type == SQUARE:
+        p.duty = r.random() * 0.6
+    p.base_freq = 0.2 + r.random() * 0.6
+    p.freq_ramp = -0.3 - r.random() * 0.4
+    p.env_sustain = r.random() * 0.1
+    p.env_decay = 0.1 + r.random() * 0.2
+    if r.random() < 0.5:
+        p.hpf_freq = r.random() * 0.3
+    return p
+
+
+def _jump(r: random.Random) -> SfxParams:
+    p = SfxParams(wave_type=SQUARE, duty=r.random() * 0.6)
+    p.base_freq = 0.3 + r.random() * 0.3
+    p.freq_ramp = 0.1 + r.random() * 0.2
+    p.env_sustain = 0.1 + r.random() * 0.3
+    p.env_decay = 0.1 + r.random() * 0.2
+    if r.random() < 0.5:
+        p.hpf_freq = r.random() * 0.3
+    if r.random() < 0.5:
+        p.lpf_freq = 1.0 - r.random() * 0.6
+    p.volume = 0.45
+    return p
+
+
+def _blip(r: random.Random) -> SfxParams:
+    p = SfxParams(wave_type=r.choice([SQUARE, SAW]))
+    if p.wave_type == SQUARE:
+        p.duty = r.random() * 0.6
+    p.base_freq = 0.2 + r.random() * 0.4
+    p.env_sustain = 0.1 + r.random() * 0.1
+    p.env_decay = r.random() * 0.2
+    p.hpf_freq = 0.1
+    return p
+
+
+def _land(r: random.Random) -> SfxParams:
+    # A soft, low thud.
+    return SfxParams(wave_type=NOISE, base_freq=0.08 + r.random() * 0.04, freq_ramp=-0.1,
+                     env_sustain=0.02, env_decay=0.12 + r.random() * 0.05, env_punch=0.4,
+                     lpf_freq=0.35, volume=0.5)
+
+
+def _dash(r: random.Random) -> SfxParams:
+    # A breathy whoosh.
+    return SfxParams(wave_type=NOISE, base_freq=0.35 + r.random() * 0.1, freq_ramp=-0.25,
+                     env_attack=0.05, env_sustain=0.08, env_decay=0.18, lpf_freq=0.5, lpf_ramp=-0.2,
+                     hpf_freq=0.15, volume=0.45)
+
+
+PRESETS = {
+    "jump": _jump,
+    "land": _land,
+    "hurt": _hurt,
+    "shoot": _laser,
+    "coin": _pickup,
+    "explosion": _explosion,
+    "powerup": _powerup,
+    "dash": _dash,
+    "blip": _blip,
+}
+
+
+def preset(name: str, seed: int = 0) -> SfxParams:
+    # Stable per-preset seed so changing one preset never changes the others.
+    r = random.Random(f"{name}:{seed}")
+    return PRESETS[name](r)
+
+
+# --- synthesis --------------------------------------------------------------------------------
+
+
+def synthesize(p: SfxParams, seed: int = 0, max_seconds: float = 2.0) -> list[float]:
+    rnd = random.Random(seed)
+    out: list[float] = []
+
+    def reset(restart: bool) -> None:
+        nonlocal fperiod, fmaxperiod, fslide, fdslide, period, square_duty, square_slide
+        nonlocal arp_mod, arp_time, arp_limit
+        fperiod = 100.0 / (p.base_freq * p.base_freq + 0.001)
+        period = int(fperiod)
+        fmaxperiod = 100.0 / (p.freq_limit * p.freq_limit + 0.001)
+        fslide = 1.0 - p.freq_ramp**3 * 0.01
+        fdslide = -(p.freq_dramp**3) * 0.000001
+        square_duty = 0.5 - p.duty * 0.5
+        square_slide = -p.duty_ramp * 0.00005
+        arp_mod = 1.0 - p.arp_mod**2 * 0.9 if p.arp_mod >= 0 else 1.0 + p.arp_mod**2 * 10.0
+        arp_time = 0
+        arp_limit = int((1.0 - p.arp_speed) ** 2 * 20000 + 32)
+        if p.arp_speed == 1.0:
+            arp_limit = 0
+
+    fperiod = fmaxperiod = fslide = fdslide = square_duty = square_slide = arp_mod = 0.0
+    period = arp_time = arp_limit = 0
+    reset(False)
+
+    phase = 0
+    fltp = fltdp = fltphp = 0.0
+    fltw = p.lpf_freq**3 * 0.1
+    fltw_d = 1.0 + p.lpf_ramp * 0.0001
+    fltdmp = min(5.0 / (1.0 + p.lpf_resonance**2 * 20.0) * (0.01 + fltw), 0.8)
+    flthp = p.hpf_freq**2 * 0.1
+    flthp_d = 1.0 + p.hpf_ramp * 0.0003
+    vib_phase = 0.0
+    vib_speed = p.vib_speed**2 * 0.01
+    vib_amp = p.vib_strength * 0.5
+    env_vol = 0.0
+    env_stage = 0
+    env_time = 0
+    env_length = [max(1, int(p.env_attack**2 * 100000)), max(1, int(p.env_sustain**2 * 100000)),
+                  max(1, int(p.env_decay**2 * 100000))]
+    fphase = p.pha_offset**2 * 1020.0 * (1 if p.pha_offset >= 0 else -1)
+    fdphase = p.pha_ramp**2 * (1 if p.pha_ramp >= 0 else -1)
+    iphase = abs(int(fphase))
+    ipp = 0
+    phaser = [0.0] * 1024
+    noise = [rnd.uniform(-1, 1) for _ in range(32)]
+    rep_time = 0
+    rep_limit = int((1.0 - p.repeat_speed) ** 2 * 20000 + 32)
+    if p.repeat_speed == 0.0:
+        rep_limit = 0
+
+    for _ in range(int(SAMPLE_RATE * max_seconds)):
+        rep_time += 1
+        if rep_limit and rep_time >= rep_limit:
+            rep_time = 0
+            reset(True)
+        arp_time += 1
+        if arp_limit and arp_time >= arp_limit:
+            arp_limit = 0
+            fperiod *= arp_mod
+        fslide += fdslide
+        fperiod *= fslide
+        if fperiod > fmaxperiod:
+            fperiod = fmaxperiod
+            if p.freq_limit > 0.0:
+                break
+        rfperiod = fperiod
+        if vib_amp > 0.0:
+            vib_phase += vib_speed
+            rfperiod = fperiod * (1.0 + math.sin(vib_phase) * vib_amp)
+        period = max(int(rfperiod), 8)
+        square_duty = min(max(square_duty + square_slide, 0.0), 0.5)
+
+        env_time += 1
+        if env_time > env_length[env_stage]:
+            env_time = 0
+            env_stage += 1
+            if env_stage == 3:
+                break
+        if env_stage == 0:
+            env_vol = env_time / env_length[0]
+        elif env_stage == 1:
+            env_vol = 1.0 + (1.0 - env_time / env_length[1]) * 2.0 * p.env_punch
+        else:
+            env_vol = 1.0 - env_time / env_length[2]
+
+        fphase += fdphase
+        iphase = min(abs(int(fphase)), 1023)
+        if flthp_d != 1.0:
+            flthp = min(max(flthp * flthp_d, 0.00001), 0.1)
+
+        ssample = 0.0
+        for _s in range(8):  # 8x supersampling
+            phase += 1
+            if phase >= period:
+                phase %= period
+                if p.wave_type == NOISE:
+                    noise = [rnd.uniform(-1, 1) for _ in range(32)]
+            fp = phase / period
+            if p.wave_type == SQUARE:
+                sample = 0.5 if fp < square_duty else -0.5
+            elif p.wave_type == SAW:
+                sample = 1.0 - fp * 2.0
+            elif p.wave_type == SINE:
+                sample = math.sin(fp * 2.0 * math.pi)
+            else:
+                sample = noise[phase * 32 // period]
+            pp = fltp
+            fltw = min(max(fltw * fltw_d, 0.0), 0.1)
+            if p.lpf_freq != 1.0:
+                fltdp += (sample - fltp) * fltw
+                fltdp -= fltdp * fltdmp
+            else:
+                fltp = sample
+                fltdp = 0.0
+            fltp += fltdp
+            fltphp += fltp - pp
+            fltphp -= fltphp * flthp
+            sample = fltphp
+            phaser[ipp & 1023] = sample
+            sample += phaser[(ipp - iphase + 1024) & 1023]
+            ipp = (ipp + 1) & 1023
+            ssample += sample * env_vol
+        out.append(ssample / 8.0)
+
+    # Normalize to the requested loudness and fade the last few ms to avoid clicks.
+    peak = max((abs(s) for s in out), default=0.0)
+    if peak > 0:
+        k = p.volume / peak
+        out = [s * k for s in out]
+    fade = min(len(out), int(SAMPLE_RATE * 0.005))
+    for i in range(fade):
+        out[-1 - i] *= i / fade
+    return out
+
+
+def to_wav_bytes(samples: list[float]) -> bytes:
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(SAMPLE_RATE)
+        w.writeframes(b"".join(struct.pack("<h", int(max(-1.0, min(1.0, s)) * 32767)) for s in samples))
+    return buf.getvalue()
+
+
+def write_all(out_dir: Path, seed: int = 0, names: list[str] | None = None) -> list[Path]:
+    """Writes <name>.wav for each preset. Skips files whose params did not change."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written = []
+    for name in names or list(PRESETS):
+        params = preset(name, seed)
+        stamp = out_dir / f".{name}.params"
+        target = out_dir / f"{name}.wav"
+        key = repr(replace(params))
+        if target.exists() and stamp.exists() and stamp.read_text() == key:
+            written.append(target)
+            continue
+        target.write_bytes(to_wav_bytes(synthesize(params, seed)))
+        stamp.write_text(key)
+        written.append(target)
+    return written