Zum Inhalt springen

Eine Live-Coding-Musik-App bauen · Teil 4 von 18 der Serie

Teil 4: Patterns sind Funktionen der Zeit

Ersetze den Rhythmus aus x und Punkten durch Patterns: Funktionen, die nach einem Abschnitt der Zeit gefragt werden und mit den Ereignissen antworten, die darin beginnen. Sechs kleine Funktionen setzen sie zu Rhythmen zusammen, die sich im Spielen wechseln lassen, ohne aus dem Takt zu fallen.

Quest-Ziele

  • Ein Pattern als Funktion von einem Abschnitt in Zyklen zu Ereignissen beschreiben
  • Die sechs Funktionen pure, stack, fast, slow, compress und sequence schreiben
  • Eine Frage mit Zahlen durch fast und compress verfolgen
  • Verhindern, dass das Rauschen der Gleitkommazahlen ein Ereignis verliert oder verdoppelt
  • Zwischen Rhythmen wechseln, während die Uhr weiterläuft

Der Rhythmus aus Teil 3 besteht aus vier Zeichenketten mit x und Punkten. Das fasst einen Takt in sechzehn Schritten und sonst nichts. Drei Anschläge in der Zeit eines Schlags passen nicht in sechzehn Schritte. Ein Rhythmus, der sich erst nach zwei Takten wiederholt, braucht längere Zeichenketten und eine Schleife, die deren Länge kennt. Jede weitere Idee wäre ein Sonderfall mehr im Callback der Uhr.

Dieser Teil ersetzt die Liste der Schritte durch die Idee, die den Rest der Serie trägt. Ein Pattern ist keine Liste, die gespeichert und abgelaufen wird. Es ist eine Funktion, die gefragt wird.

Eine Frage und eine Antwort

Die Uhr aus Teil 2 stellt schon eine Frage. Alle 25 Millisekunden ruft sie schedule(from, to) mit dem Abschnitt der Zeit auf, der gleich zu hören sein wird. Der Abschnitt wird in Zyklen gezählt: Ein Zyklus ist ein Takt mit vier Schlägen. Ein Pattern ist eine Funktion, die genau diese Frage beantwortet. Sie bekommt einen Abschnitt in Zyklen und gibt die Ereignisse zurück, die darin beginnen.

Ein Ereignis ist ein Wert mit einem Beginn und einem Ende, beide in Zyklen. Der Wert kann alles sein. Für die Drums ist es der Name eines Sounds, etwa bd. Im Code heißt ein Ereignis Hap, etwas, das passiert. Der Name stammt aus den Live-Coding-Sprachen Tidal und Strudel, an denen sich die Notation der nächsten Teile orientiert.

Lege src/pattern.ts an. Die Datei beginnt mit zwei Typen:

src/pattern.ts
/** One event of a pattern: a value that begins and ends at a time, counted in cycles. */
export interface Hap<T> {
  begin: number;
  end: number;
  value: T;
}

/**
 * A pattern is a function of time: asked for a stretch of cycles, it answers with every
 * event that begins inside it. Each event is in exactly one answer, however the time is cut
 * into stretches.
 */
export type Pattern<T> = (begin: number, end: number) => Hap<T>[];

Der letzte Satz des Kommentars ist die Abmachung, an die sich jedes Pattern halten muss: Jedes Ereignis steht in genau einer Antwort, egal wie die Zeit in Abschnitte geschnitten wird. Die Uhr gibt von ihrer Seite das passende Versprechen, denn sie fragt nach jedem Abschnitt genau einmal. Zusammen heißt das: Jedes Ereignis wird einmal gespielt, egal wann der Timer abläuft.

„Beginnt darin“ schließt den Beginn des Abschnitts ein und sein Ende aus. Frag nach 0 bis 1 und dann nach 1 bis 2, und ein Ereignis, das bei 1 beginnt, steht nur in der zweiten Antwort.

Sieh dir an, was dem Typ fehlt. Ein Pattern hat keine Länge, keine Position und keine Liste von Schritten. Es merkt sich überhaupt nichts. Wer ein Pattern hat, kann es nach Zyklus 0 oder nach Zyklus 5000 fragen, in beliebiger Reihenfolge, und die Antwort für einen Abschnitt ist immer dieselbe.

Ein Ereignis pro Zyklus

Das kleinste Pattern, das etwas hören lässt, ist pure: ein Wert pro Zyklus, so lang wie der Zyklus. Unter die Typen kommen eine Hilfsfunktion zum Runden, die ein späterer Abschnitt erklärt, das leere Pattern und pure:

src/pattern.ts
/** Rounds away the noise of floating point numbers, so that 0.30000000000000004 is 0.3. */
export const snap = (time: number): number => Math.round(time * 1e9) / 1e9;

/** A pattern without events. */
export const silence = <T>(): Pattern<T> => () => [];

/** One value per cycle, as long as the cycle. */
export function pure<T>(value: T): Pattern<T> {
  return (begin, end) => {
    const haps: Hap<T>[] = [];
    for (let cycle = Math.ceil(snap(begin)); cycle < snap(end); cycle += 1) {
      haps.push({ begin: cycle, end: cycle + 1, value });
    }
    return haps;
  };
}

pure('bd') gibt eine Funktion zurück, und diese Funktion lässt sich fragen:

  • Für 0 bis 1 antwortet sie mit einem Hap: Beginn 0, Ende 1, Wert bd.

  • Für 0,5 bis 1 antwortet sie mit nichts. Das Hap von Zyklus 0 hat vor dem Abschnitt begonnen, und das Hap von Zyklus 1 beginnt an seinem Ende, das nicht mitzählt. Im Code ist Math.ceil(0.5) gleich 1, und 1 ist nicht kleiner als 1.

  • Für 0,9 bis 1,1 antwortet sie mit dem Hap von 1 bis 2.

  • Für 2 bis 4,5 antwortet sie mit drei Haps, die bei 2, 3 und 4 beginnen.

Die Abschnitte der Uhr sind viel kürzer. Bei 120 Schlägen pro Minute dauert ein Zyklus zwei Sekunden, 25 Millisekunden sind also 0,0125 Zyklen. Meistens antwortet pure('bd') mit einer leeren Liste und einmal pro Zyklus mit einer Bassdrum, der tiefen Trommel aus Teil 3.

Die Frage und die Antwort ändern

Eine Bassdrum pro Takt ist noch kein Rhythmus. Weiter geht es nicht mit einem größeren Pattern, sondern mit kleinen Funktionen, die ein Pattern nehmen und ein neues zurückgeben. Jede von ihnen tut dieselben zwei Dinge: Sie ändert die Frage, bevor sie sie weitergibt, und sie ändert die Antwort auf dem Rückweg. Ergänze stack, fast und slow:

src/pattern.ts
/** Several patterns at the same time. */
export function stack<T>(patterns: Pattern<T>[]): Pattern<T> {
  return (begin, end) => patterns.flatMap((pattern) => pattern(begin, end));
}

/** A pattern played `factor` times as fast: ask for a longer stretch, then shrink the answer. */
export function fast<T>(factor: number, pattern: Pattern<T>): Pattern<T> {
  if (!(factor > 0) || !Number.isFinite(factor)) return silence();
  return (begin, end) =>
    pattern(begin * factor, end * factor).map((hap) => ({
      ...hap,
      begin: hap.begin / factor,
      end: hap.end / factor,
    }));
}

export const slow = <T>(factor: number, pattern: Pattern<T>): Pattern<T> => fast(1 / factor, pattern);

stack tut am wenigsten. Es stellt jedem Pattern dieselbe Frage und legt die Antworten in eine Liste: mehrere Sounds zur selben Zeit.

fast(4, pure('bd')) spielt vier Bassdrums pro Zyklus. Verfolge eine Frage hindurch:

  1. Die Uhr fragt nach 0,45 bis 0,55.

  2. fast nimmt beide Zahlen mal 4 und fragt das innere Pattern nach 1,8 bis 2,2. In der Zeit des inneren Patterns vergehen vier Zyklen, während einer zu hören ist.

  3. pure antwortet mit seinem Hap von 2 bis 3.

  4. fast teilt die Zeiten des Haps durch 4. Die Antwort ist ein Hap von 0,5 bis 0,75: eine Bassdrum auf dem dritten Schlag des Takts.

Nach dem ganzen Zyklus von 0 bis 1 gefragt, wird das innere Pattern nach 0 bis 4 gefragt und antwortet mit vier Haps. Durch 4 geteilt beginnen sie bei 0; 0,25; 0,5 und 0,75: eine Bassdrum auf jedem Schlag.

slow ist fast mit dem Kehrwert des Faktors. slow(2, pure('bd')) fragt für 0 bis 1 das innere Pattern nach 0 bis 0,5 und bekommt das Hap von 0 bis 1, aus dem ein Hap von 0 bis 2 wird. Für 1 bis 2 fragt es nach 0,5 bis 1 und bekommt nichts. Das ist eine Bassdrum alle zwei Takte. Die erste Zeile von fast fängt Faktoren ab, die keinen Sinn ergeben, etwa 0 oder eine negative Zahl: Sie ergeben Stille.

Einen Zyklus in einen Slot pressen

Tempo allein kann keine Snare, die Trommel, deren Klang vor allem Rauschen ist, auf die zweite Hälfte eines Takts setzen und die erste Hälfte leer lassen. compress(from, to, pattern) kann das: Es presst jeden Zyklus eines Patterns in einen Teil des Zyklus, den Slot, und lässt den Rest des Zyklus still. Ergänze es:

src/pattern.ts
/** Squeezes every cycle of a pattern into the part from `from` to `to` of each cycle. */
export function compress<T>(from: number, to: number, pattern: Pattern<T>): Pattern<T> {
  const width = to - from;
  if (width <= 0) return silence();
  return (begin, end) => {
    const haps: Hap<T>[] = [];
    for (let cycle = Math.floor(snap(begin)); cycle < snap(end); cycle += 1) {
      // The part of this cycle's slot that the stretch covers.
      const slotBegin = Math.max(begin, cycle + from);
      const slotEnd = Math.min(end, cycle + to);
      if (snap(slotBegin) >= snap(slotEnd)) continue;
      // The same stretch in the inner pattern's time, where the slot is the whole cycle.
      const innerBegin = cycle + (slotBegin - cycle - from) / width;
      const innerEnd = cycle + (slotEnd - cycle - from) / width;
      for (const hap of pattern(innerBegin, innerEnd)) {
        haps.push({
          ...hap,
          begin: cycle + from + (hap.begin - cycle) * width,
          end: cycle + from + (hap.end - cycle) * width,
        });
      }
    }
    return haps;
  };
}

Nimm compress(0.5, 1, pure('sd')): der Zyklus der Snare, in die zweite Hälfte jedes Zyklus gepresst. Die Breite des Slots, width, ist 0,5. Die Uhr fragt nach 0,4 bis 0,6:

  1. Die Schleife besucht nur Zyklus 0. Sein Slot reicht von 0,5 bis 1.

  2. Der Abschnitt deckt den Slot von 0,5 bis 0,6 ab. slotBegin ist die spätere von 0,4 und 0,5, slotEnd die frühere von 0,6 und 1.

  3. In der Zeit des inneren Patterns ist der Slot der ganze Zyklus, aus 0,5 bis 0,6 wird also 0 bis 0,2: (0.5 - 0 - 0.5) / 0.5 ist 0, und (0.6 - 0 - 0.5) / 0.5 ist 0,2.

  4. pure antwortet für 0 bis 0,2 mit seinem Hap von 0 bis 1.

  5. compress schiebt das Hap zurück in den Slot. Sein Beginn ist 0 + 0.5 + (0 - 0) * 0.5, also 0,5, und sein Ende 0 + 0.5 + (1 - 0) * 0.5, also 1. Die Snare spielt auf dem dritten Schlag.

Die nächste Frage der Uhr, 0,6 bis 0,8, deckt den Slot von 0,6 bis 0,8 ab, in der Zeit des inneren Patterns 0,2 bis 0,6. Dort beginnt kein Zyklus, die Antwort ist also leer, und die Snare wird kein zweites Mal gespielt. Eine Frage, die den Slot verfehlt, etwa 0,1 bis 0,3, erreicht das innere Pattern gar nicht: slotBegin wäre 0,5 und slotEnd 0,3, und die Schleife geht weiter.

Zwei Einzelheiten werden später wichtig. Die Schleife beginnt bei Math.floor, nicht bei Math.ceil wie in pure: Ein Abschnitt, der mitten in einem Zyklus beginnt, etwa 2,4 bis 2,6, kann den Slot dieses Zyklus noch erreichen. Und die Nummer des Zyklus bleibt erhalten: Zyklus 2 des inneren Patterns landet im Slot von Zyklus 2. Ein Pattern, das von Zyklus zu Zyklus anders ist, ist es auch noch, nachdem es gepresst wurde.

Eins nach dem anderen

Mit compress und stack braucht eine Abfolge zwei Zeilen. Ergänze sie am Ende der Datei:

src/pattern.ts
/** Patterns one after the other, sharing each cycle equally. */
export function sequence<T>(patterns: Pattern<T>[]): Pattern<T> {
  const count = patterns.length;
  return stack(patterns.map((pattern, index) => compress(index / count, (index + 1) / count, pattern)));
}

Jedes Pattern wird in seinen Anteil am Zyklus gepresst, und die Anteile werden übereinandergelegt. Bei zwei Patterns bekommt das erste den Slot von 0 bis 0,5 und das zweite den von 0,5 bis 1. Bei vier bekommt jedes ein Viertel.

Eine Abfolge ist ein Pattern wie jedes andere, sie kann also ein Schritt einer anderen Abfolge sein oder durch fast gehen. Das ist der Gewinn dieses Entwurfs: sechs Funktionen, jede ein paar Zeilen lang. Jede gibt ein Pattern zurück, und alle außer pure machen es aus anderen Patterns, also lassen sie sich beliebig kombinieren. Keine von ihnen speichert ein Ereignis.

Das Rauschen der Gleitkommazahlen

Die Zahlen von JavaScript können die meisten Brüche nicht genau halten: 0.1 + 0.2 ist 0.30000000000000004. Meistens schadet das nicht. Hier schon, denn die Patterns vergleichen Zeiten mit ganzen Zahlen, und eine Zahl, die um das Kleinste danebenliegt, landet auf der falschen Seite.

Eine Abfolge aus drei Schritten reicht, um es zu zeigen. Ihr mittlerer Schritt ist compress(1/3, 2/3, …). Für Zyklus 2 beginnt der Slot bei 2 + 1/3, in der Zeit des inneren Patterns genau bei 2. JavaScript kommt auf 2.0000000000000004. Math.ceil macht daraus 3, und der mittlere Schritt dieses Takts würde nie gespielt. Dasselbe Rauschen am Ende eines Abschnitts lässt ein Ereignis herein, das zum nächsten Zyklus gehört, und es würde zweimal gespielt.

snap rundet eine Zeit auf neun Nachkommastellen, bevor sie verglichen wird, und macht so aus 2.0000000000000004 eine 2. Ein Milliardstel eines Zyklus ist weit kleiner als alles, was man hören kann, und weit größer als das Rauschen. Nur die Vergleiche nutzen snap. Die Zeiten in den Haps werden so weitergegeben, wie sie ausgerechnet wurden. Auch der Weg durch compress oben war zum Lesen gerundet: Das Ergebnis von JavaScript für (0.6 - 0 - 0.5) / 0.5 ist 0.19999999999999996.

Rhythmen aus Funktionen

Ersetze in src/main.ts alles von den Importen bis einschließlich der Konstante BEAT durch das Folgende. DRUM_SOUNDS wird nicht mehr importiert, dafür die Funktionen aus ./pattern.ts:

src/main.ts
import { audio } from './audio.ts';
import { Clock } from './clock.ts';
import { Drums } from './drums.ts';
import { fast, pure, sequence, silence, slow, stack, type Pattern } from './pattern.ts';
import './style.css';

const drums = new Drums(audio().destination);

const rest = silence<string>();

/** A few beats, each put together from the same handful of functions. */
const BEATS: Record<string, Pattern<string>> = {
  'four on the floor': stack([
    fast(4, pure('bd')),
    fast(2, sequence([rest, pure('cp')])),
    fast(4, sequence([rest, pure('hh')])),
  ]),
  'boom bap': stack([
    sequence([pure('bd'), rest, sequence([rest, pure('bd')]), rest]),
    fast(2, sequence([rest, pure('sd')])),
    fast(8, pure('hh')),
  ]),
  'two bars': stack([
    slow(2, sequence([pure('bd'), pure('bd'), pure('bd'), sequence([pure('bd'), pure('bd')])])),
    fast(2, sequence([rest, pure('sd')])),
    fast(4, sequence([pure('hh'), pure('hh'), pure('oh')])),
  ]),
};

let pattern = BEATS['four on the floor'];

Jeder Rhythmus ist ein Stapel aus drei Ebenen. Lies den ersten, „four on the floor“:

  • fast(4, pure('bd')) ist die Bassdrum auf jedem Schlag.

  • sequence([rest, pure('cp')]) ist ein halber Zyklus Stille und dann ein Clap, der Sound cp. Doppelt so schnell landen die Claps bei 0,25 und 0,75: auf den Schlägen 2 und 4.

  • Die Hi-Hat hh, das kurze metallische Ticken, hat dieselbe Form, viermal so schnell. Sie landet bei 0,125; 0,375; 0,625 und 0,875, auf halbem Weg zwischen den Bassdrums.

In „boom bap“ ist die Bassdrum eine Abfolge aus vier Schritten, und der dritte Schritt ist selbst eine Abfolge. Das ergibt Bassdrums bei 0 und bei 0,625. Die Snare liegt auf den Schlägen 2 und 4, und fast(8, pure('hh')) spielt zwei Hi-Hats pro Schlag.

„two bars“ kann zwei Dinge, die die Zeichenketten aus Teil 3 nicht konnten. Seine Bassdrum ist eine Abfolge, die auf zwei Zyklen gedehnt ist: Bassdrums bei 0; 0,5; 1 und 1,5 und eine fünfte bei 1,75. Und seine Hi-Hats kommen zu dritt pro Schlag, die dritte als offene Hi-Hat, der Sound oh, der nachklingt. Zwölf Anschläge in einem Takt passen in kein Raster aus sechzehn.

Ersetze dann die Uhr, die Anweisung gleich darunter, die mit const clock beginnt:

src/main.ts
const clock = new Clock((from, to) => {
  for (const hap of pattern(from, to)) drums.play(hap.value, clock.timeAt(hap.begin));
});

Der Callback ist jetzt eine Zeile lang und weiß nichts mehr von Schritten. Er fragt das Pattern nach dem Abschnitt und spielt jedes Hap zu der Zeit der Audio-Uhr, die zu seinem Beginn gehört. Das Ende des Haps ist den Drums egal, denn ein Schlag auf eine Trommel hat seine eigene Länge. Teil 8 nutzt es für die Länge einer Note.

Wechseln, während es spielt

pattern ist eine Variable, und mehr als eine Zuweisung braucht es nicht, um die Musik zu ändern. Die Pads aus Teil 3 machen Platz für einen Button pro Rhythmus. Ersetze die Schleife, die die Pads erzeugt hat, samt ihrem Kommentar und der Zeile, die #pads gesucht hat:

src/main.ts
// A button per beat. Switching while it plays keeps the time: the new pattern is asked
// for the same cycles the old one would have been asked for.
const beats = document.querySelector<HTMLDivElement>('#beats')!;
for (const [name, beat] of Object.entries(BEATS)) {
  const button = document.createElement('button');
  button.textContent = name;
  button.classList.toggle('on', beat === pattern);
  button.addEventListener('click', () => {
    pattern = beat;
    for (const other of beats.children) other.classList.toggle('on', other === button);
  });
  beats.append(button);
}

Ein Klick startet nichts neu. Die Uhr zählt weiter, und bei ihrem nächsten Aufruf fragt sie das neue Pattern nach dem Abschnitt, nach dem sie das alte gefragt hätte. Wechselst du bei Zyklus 7,3, geht der neue Rhythmus bei 7,3 weiter, mitten in seinem Takt, auf demselben Schlag. Weil sich ein Pattern nichts merkt, gibt es nichts zu übernehmen und nichts zurückzusetzen.

Ersetze in index.html das Element main:

index.html
<main class="stage">
  <div id="beats" class="beats"></div>
  <p class="hint">Press Play, then switch between the beats.</p>
</main>

Entferne am Ende von src/style.css die zwei Regeln .pads und .pads button und setze diese an ihre Stelle:

src/style.css
.beats {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
  gap: 6px;
}

Probier es aus

Drück auf Play. „four on the floor“ beginnt: eine Bassdrum auf jedem Schlag, ein Clap auf den Schlägen 2 und 4 und eine Hi-Hat zwischen den Bassdrums. Klick auf „boom bap“, während es spielt. Der Rhythmus wechselt innerhalb einer Zehntelsekunde, und die Position in der Kopfzeile zählt weiter, als wäre nichts gewesen.

Wechsle zu „two bars“ und behalte die Position im Auge. Die zusätzliche Bassdrum auf dem vierten Schlag kommt nur in den Takten mit gerader Nummer. Wechsle in einem ungeraden Takt zu einem anderen Rhythmus und wieder zurück: Die zusätzliche Bassdrum liegt weiter in den geraden Takten, denn das Pattern wird nach dem Zyklus gefragt, den die Uhr erreicht hat, nicht nach seinem eigenen Anfang.

Beweg den Tempo-Regler. Jeder Rhythmus folgt, denn die Patterns zählen in Zyklen, und nur die Uhr weiß etwas von Sekunden.

Ändere dann den Code. Ergänze fast(3, pure('cb')) als vierte Ebene im Stapel von „four on the floor“: drei Anschläge der Cowbell, des Sounds cb, gleichmäßig über den Takt verteilt, gegen vier Bassdrums. Oder mach aus der 8 der Hi-Hats in „boom bap“ eine 16.

Drück auf Play und klick dann auf die drei Rhythmen, um im Spielen zwischen ihnen zu wechseln. Der Regler stellt das Tempo ein.
In neuem Tab öffnen

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.