Zum Inhalt springen

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

Teil 7: Auswahl, Polymeter und wechselnde Tempi

Mach die Mini-Notation fertig: eine Auswahl zwischen mehreren Abfolgen, die in jedem Zyklus neu getroffen wird, Ebenen verschiedener Länge, die sich gegeneinander verschieben, und Tempi, die von Zyklus zu Zyklus wechseln. Am Ende steht eine Übersicht aller Zeichen.

Quest-Ziele

  • Einen Zeitabschnitt an den Zyklusgrenzen teilen und in jedem Zyklus ein anderes Pattern fragen
  • Pro Zyklus eine von mehreren Abfolgen per Zufall auswählen
  • Ebenen verschiedener Länge als Polymeter nebeneinander laufen lassen
  • Das Tempo eines Schritts von Zyklus zu Zyklus wechseln
  • Jedes Zeichen der Notation in einer Liste nachschlagen

Die Notation aus Teil 6 kann Schritte wiederholen, dehnen und ausdünnen. Drei Dinge fehlen noch: zwischen ganzen Alternativen entscheiden, Ebenen verschiedener Länge nebeneinander laufen lassen und ein Tempo von einem Zyklus zum nächsten wechseln. Dieser Teil ergänzt sie, und damit ist die Sprache vollständig. Neuen Code gibt es wenig: zwei kleine Funktionen über den Patterns aus Teil 4, dazu ein paar Zeilen im Parser und im Compiler.

In jedem Zyklus ein anderes Pattern

Zwei der drei brauchen dasselbe: mehrere Patterns, von denen pro Zyklus eines spielt. Ein Pattern wird nach einem Abschnitt von Zyklen gefragt und antwortet mit den Ereignissen, die darin beginnen, und der Abschnitt kann beliebig sein. Die Uhr fragt nach kleinen Stücken, und ab und zu reicht ein Stück über die Grenze zwischen zwei Zyklen. fast fragt nach Abschnitten, die mehrere Zyklen lang sind. Bevor also ein Pattern pro Zyklus ausgesucht werden kann, muss der Abschnitt an den Zyklusgrenzen geteilt werden. Ergänze in src/pattern.ts am Ende der Datei eine Hilfsfunktion:

src/pattern.ts
/** Calls `visit` for every cycle a stretch touches, with the part of the stretch inside it. */
function eachCycle(begin: number, end: number, visit: (cycle: number, from: number, to: number) => void) {
  for (let cycle = Math.floor(snap(begin)); cycle < snap(end); cycle += 1) {
    const from = Math.max(begin, cycle);
    const to = Math.min(end, cycle + 1);
    if (snap(from) < snap(to)) visit(cycle, from, to);
  }
}

Für den Abschnitt von 0,9 bis 2,1 ruft sie visit dreimal auf: für Zyklus 0 mit 0,9 bis 1, für Zyklus 1 mit 1 bis 2 und für Zyklus 2 mit 2 bis 2,1. Die Vergleiche laufen über snap aus Teil 4. So fällt ein Stück weg, das es nur als Rundungsrauschen der Gleitkommazahlen gibt. Ergänze unter der Hilfsfunktion die zwei Funktionen, die sie benutzen:

src/pattern.ts
/** One of several patterns per cycle, taking turns: the same pattern at a speed per cycle. */
export function takeTurns<T>(patterns: Pattern<T>[]): Pattern<T> {
  if (patterns.length === 1) return patterns[0];
  return (begin, end) => {
    const haps: Hap<T>[] = [];
    eachCycle(begin, end, (cycle, from, to) => {
      haps.push(...patterns[cycle % patterns.length](from, to));
    });
    return haps;
  };
}

/** One of several patterns per cycle, picked by chance. */
export function choose<T>(patterns: Pattern<T>[], seed: number): Pattern<T> {
  return (begin, end) => {
    const haps: Hap<T>[] = [];
    eachCycle(begin, end, (cycle, from, to) => {
      const pick = Math.floor(random(cycle + 0.5, seed) * patterns.length);
      haps.push(...patterns[pick](from, to));
    });
    return haps;
  };
}

takeTurns wählt nach der Nummer des Zyklus. Bei zwei Patterns spielt das erste in den Zyklen 0, 2 und 4, das zweite in den Zyklen 1, 3 und 5.

choose würfelt mit random aus Teil 6, das für dieselbe Zeit und denselben Seed immer dieselbe Zahl liefert. Als Zeit bekommt es hier nicht den Anfang des Abschnitts, sondern einen festen Punkt des Zyklus, seine Mitte: cycle + 0.5. Die ist für jedes Stück des Zyklus dieselbe. Die Wahl gilt also, egal wie der Zyklus in Abschnitte zerlegt wird, und sie fällt wieder gleich aus, wenn der Zyklus ein zweites Mal gefragt wird.

Beide geben dem gewählten Pattern nur das Stück des Abschnitts, das in seinem Zyklus liegt. Jedes Ereignis kommt weiterhin genau einmal zurück.

Neue Zeichen

Die Notation braucht vier neue Zeichen: {, }, | und %. Ersetze in src/mini.ts die SYMBOLS des Tokenizers:

src/mini.ts
const SYMBOLS = '[]<>(){},|~*/@_!?%';

Der Baum bekommt zwei neue Arten von Knoten, choice und polymeter, und fast und slow halten eine Liste von Faktoren statt eines einzelnen. Ersetze den Typ Node:

src/mini.ts
export type Node =
  | { type: 'atom'; value: Atom }
  | { type: 'rest' }
  | { type: 'sequence'; steps: Step[] }
  | { type: 'stack'; layers: Node[] }
  | { type: 'alternate'; steps: Step[] }
  | { type: 'choice'; options: Node[]; seed: number }
  | { type: 'polymeter'; layers: Node[]; steps: number | undefined }
  | { type: 'fast'; node: Node; factors: number[] }
  | { type: 'slow'; node: Node; factors: number[] }
  | { type: 'sometimes'; node: Node; amount: number; seed: number }
  | { type: 'euclid'; node: Node; pulses: number; steps: number; rotation: number };

Der Compiler wird choose und takeTurns aufrufen. Ersetze den Import am Anfang der Datei:

src/mini.ts
import {
  choose,
  euclid,
  fast,
  pure,
  sequence,
  silence,
  slow,
  sometimes,
  stack,
  takeTurns,
  type Pattern,
} from './pattern.ts';

Auswahl: a | b

bd*2 | bd*4 spielt einen ganzen Zyklus lang eine seiner zwei Seiten und entscheidet im nächsten neu. Das ist etwas anderes als ?, das einzelne Ereignisse weglässt: | wählt zwischen ganzen Abfolgen, und es dürfen mehr als zwei sein, wie in bd sd | bd bd sd | bd(3,8).

In der Grammatik steht | dort, wo , steht: zwischen Abfolgen. Die Regel für Ebenen liest also beide, und das Trennzeichen entscheidet, was aus der Gruppe wird. Ersetze parseLayers():

src/mini.ts
/** layers = sequence ("," sequence)* | sequence ("|" sequence)* */
private parseLayers(): Node {
  const layers = [this.parseSequence()];
  let separator: string | undefined;
  while (this.isSymbol(',') || this.isSymbol('|')) {
    const token = this.next();
    if (separator && separator !== token.text) {
      throw new MiniError('"," and "|" can\'t be mixed in one group', token.start);
    }
    separator = token.text;
    layers.push(this.parseSequence());
  }
  if (layers.length === 1) return layers[0];
  if (separator === ',') return { type: 'stack', layers };
  const seed = this.seed;
  this.seed += 1;
  return { type: 'choice', options: layers, seed };
}

Eine Gruppe besteht entweder aus Ebenen oder ist eine Auswahl. bd, sd | cp ließe sich auf zwei Arten lesen, also ist es ein Fehler, gemeldet am zweiten Trennzeichen. Eckige Klammern sagen, welche Lesart gemeint ist: bd, [sd | cp].

Jede Auswahl nimmt sich einen Seed von dem Zähler, den ? schon benutzt. Zwei Auswahlen in einem Pattern würfeln dann mit verschiedenen Würfeln und wählen nicht immer gleich. Ändere den Kommentar über dem Zähler in der Klasse Parser entsprechend:

src/mini.ts
/** Counts up, so that every "?" and "|" in a pattern rolls dice of its own. */
private seed = 0;

Eine Abfolge muss enden, wenn sie auf ein | trifft, und ebenso an der } des nächsten Abschnitts. Ersetze atSequenceEnd():

src/mini.ts
private atSequenceEnd(): boolean {
  const token = this.peek();
  return token.type === 'end' || (token.type === 'symbol' && ']>},|)'.includes(token.text));
}

Ergänze in compile() nach 'alternate' einen Fall:

src/mini.ts
case 'choice':
  return choose(node.options.map(compile), node.seed);

„Pro Zyklus“ meint einen Zyklus in der eigenen Zeit der Auswahl. In ~ [sd | cp] füllt die Gruppe die zweite Hälfte jedes Zyklus, und gewählt wird einmal pro Zyklus. In [sd | cp]*2 läuft die Gruppe zweimal pro Zyklus, und jeder Durchlauf wählt für sich.

Polymeter: {a b c}%4

In eckigen Klammern teilen sich Ebenen den Zyklus. In [bd hh sd hh, cb ~ ~] füllen die vier Schritte der ersten Ebene und die drei Schritte der zweiten beide einen Zyklus, die Schritte der zweiten Ebene sind also länger. Geschweifte Klammern drehen das um. In {bd hh sd hh, cb ~ ~} ist jeder Schritt jeder Ebene gleich lang, und dafür sind die Ebenen verschieden lang. Die erste Ebene gibt das Maß vor: Sie hat vier Schritte, also füllen vier Schritte einen Zyklus. Die zweite Ebene hat drei. Sie ist nach drei Vierteln des Zyklus zu Ende und fängt genau dort wieder an. Das ist ein Polymeter: mehrere Metren, hier eines aus vier und eines aus drei Schritten, die gleichzeitig laufen. Ein Metrum ist die Zahl der Schritte, nach der eine Figur von vorn beginnt.

Mit einem x für einen Anschlag und einem Punkt für einen Schritt ohne Anschlag sehen drei Zyklen mit je vier Schritten so aus. Die Striche zeigen nur, wo ein Zyklus endet:

  • x...|x...|x... ist die bd der ersten Ebene, am Anfang jedes Zyklus.

  • x..x|..x.|.x.. ist die cb der zweiten Ebene, auf jedem dritten Schritt.

Die Cowbell landet in jedem Zyklus auf einem anderen Schritt: Sie verschiebt sich gegen den Takt. Nach zwölf Schritten, also drei Zyklen, beginnen beide Ebenen wieder gemeinsam, und die Figur wiederholt sich.

Eine Zahl nach % gibt das Maß anstelle der ersten Ebene vor. {hh hh oh}%8 spielt acht Schritte pro Zyklus aus einer Ebene mit drei. Die offene Hi-Hat fällt im ersten Zyklus auf die Schritte 3 und 6, im zweiten auf 1, 4 und 7 und im dritten auf 2, 5 und 8.

Die geschweiften Klammern sind eine neue Art von Schritt. Ersetze parseStep():

src/mini.ts
/** step = word | "~" | "[" layers "]" | "<" layers ">" | "{" layers "}" ("%" n)? */
private parseStep(): Node {
  const token = this.next();
  if (token.type === 'word') {
    const number = Number(token.text);
    return { type: 'atom', value: Number.isFinite(number) ? number : token.text };
  }
  if (token.text === '~') return { type: 'rest' };
  if (token.text === '[') {
    const inner = this.parseLayers();
    this.expect(']');
    return inner;
  }
  if (token.text === '<') {
    const inner = this.parseLayers();
    this.expect('>');
    return alternate(inner);
  }
  if (token.text === '{') {
    const inner = this.parseLayers();
    this.expect('}');
    let steps: number | undefined;
    if (this.isSymbol('%')) {
      this.next();
      steps = this.parseNumber();
    }
    return { type: 'polymeter', layers: inner.type === 'stack' ? inner.layers : [inner], steps };
  }
  throw new MiniError(
    token.type === 'end' ? 'The pattern ends too early' : `Unexpected "${token.text}"`,
    token.start,
  );
}

In den geschweiften Klammern gilt dieselbe Regel wie in den eckigen: parseLayers(). Kommt ein Stack zurück, sind seine Ebenen die Ebenen des Polymeters. Alles andere ist eine einzelne Ebene. Ergänze in compile() den Fall nach 'choice':

src/mini.ts
case 'polymeter': {
  // Every layer runs at the same speed: `steps` of its steps per cycle.
  const counts = node.layers.map((layer) => stepsOf(layer).reduce((sum, step) => sum + step.repeat, 0));
  const steps = node.steps ?? counts[0] ?? 1;
  return stack(
    node.layers.map((layer, index) =>
      counts[index] ? fast(steps / counts[index], compileSteps(stepsOf(layer))) : silence(),
    ),
  );
}

Eine neue Pattern-Funktion braucht es dafür nicht. Jede Ebene wird als Abfolge kompiliert, die einen Zyklus füllt, und fast gibt ihr das Tempo: Eine Ebene aus drei Schritten, die vier Schritte pro Zyklus spielen soll, läuft 4/3-mal so schnell. Ein Schritt, der mit ! wiederholt wird, zählt so oft, wie er gespielt wird.

Wechselnde Tempi: hh*<2 4>

hh*2 spielt zwei Hi-Hats pro Zyklus, hh*4 vier. hh*<2 4> wechselt ab: zwei in einem Zyklus, vier im nächsten. Die spitzen Klammern bedeuten dasselbe wie um Schritte, eines pro Zyklus, nur stehen hier Zahlen darin. Ergänze im Parser unter parseNumber() eine Methode:

src/mini.ts
/** factor = n | "<" n+ ">": one speed, or one per cycle, taking turns */
private parseFactors(): number[] {
  if (!this.isSymbol('<')) return [this.parseNumber()];
  const open = this.next();
  const factors: number[] = [];
  while (!this.isSymbol('>')) {
    if (this.peek().type === 'end') throw new MiniError('Missing ">"', open.start);
    factors.push(this.parseNumber());
  }
  this.next();
  if (factors.length === 0) throw new MiniError('"<>" needs a number', open.start);
  return factors;
}

Eine einzelne Zahl kommt als Liste mit einem Eintrag zurück. Ersetze in parseModifiers() die Fälle für * und /:

src/mini.ts
case '*':
  this.next();
  step.node = { type: 'fast', node: step.node, factors: this.parseFactors() };
  break;
case '/':
  this.next();
  step.node = { type: 'slow', node: step.node, factors: this.parseFactors() };
  break;

Der Kommentar über parseModifiers() nennt die Regel. Ändere ihn zu:

src/mini.ts
/** modifier = "*" factor | "/" factor | "@" n | "!" n? | "?" n? | "(" n "," n ("," n)? ")" */

Ersetze in compile() die Fälle 'fast' und 'slow':

src/mini.ts
case 'fast': {
  const inner = compile(node.node);
  return takeTurns(node.factors.map((factor) => fast(factor, inner)));
}
case 'slow': {
  const inner = compile(node.node);
  return takeTurns(node.factors.map((factor) => slow(factor, inner)));
}

Der Schritt wird einmal kompiliert, und takeTurns bekommt ihn in jedem der Tempi. Bei einem einzelnen Faktor gibt takeTurns dieses eine Pattern zurück, hh*4 funktioniert also wie bisher.

Das Eingabefeld der Seite soll mit einem Pattern beginnen, das die neue Notation benutzt. Ersetze in index.html das <input>. In HTML werden die spitzen Klammern des Patterns als &lt; und &gt; geschrieben:

index.html
<input id="pattern" value="bd*&lt;2 4&gt;, ~ [sd | cp], {hh hh oh}%8" spellcheck="false" autocomplete="off" />

Die ganze Notation

Die Sprache ist vollständig. Hier steht jedes Zeichen aus den Teilen 5 bis 7, jeweils mit einem Pattern zum Eintippen:

  • bd sd: Schritte, durch Leerzeichen getrennt, teilen sich den Zyklus gleichmäßig. Ein Schritt ist ein Wort, etwa der Name eines Sounds, oder eine Zahl. Beispiel: bd sd hh sd

  • ~: eine Pause, ein Schritt ohne Sound. Beispiel: bd ~ sd ~

  • [a b]: eine Gruppe, eine Abfolge auf dem Platz eines Schritts. Beispiel: bd [sd sd]

  • a, b: Ebenen, Abfolgen, die gleichzeitig spielen und jeweils den Zyklus oder die Gruppe füllen. Beispiel: bd sd, hh hh hh

  • <a b>: pro Zyklus einer der Schritte, abwechselnd. Beispiel: bd <sd cp>

  • a*n: schneller, der Schritt spielt n-mal auf seinem Platz. Beispiel: hh*4

  • a/n: langsamer, der Schritt dauert n-mal so lang. Beispiel: bd/2, eine Bassdrum in jedem zweiten Zyklus

  • a@n: ein Gewicht, der Schritt bekommt n-mal so viel Platz wie ein einfacher Schritt. Beispiel: bd@3 sd

  • a _: macht den Schritt davor um einen Schritt länger. Beispiel: bd _ _ sd, dasselbe wie bd@3 sd

  • a! und a!n: spielt den Schritt noch einmal oder insgesamt n-mal. Beispiel: bd!3 sd, dasselbe wie bd bd bd sd

  • a? und a?n: lässt jedes Ereignis mit der Wahrscheinlichkeit ein halb oder n weg. Beispiel: hh*8?0.2

  • a(3,8): ein euklidischer Rhythmus, 3 Anschläge so gleichmäßig wie möglich auf 8 Schritte verteilt. Eine dritte Zahl dreht ihn um so viele Schritte weiter. Beispiel: bd(3,8), bd(3,8,2)

  • a | b: pro Zyklus eine der Abfolgen, per Zufall gewählt. Lässt sich in derselben Gruppe nicht mit , mischen. Beispiel: bd*2 | bd*4

  • {a b c, d e}: ein Polymeter, Ebenen, deren Schritte alle gleich lang sind, so viele pro Zyklus, wie die erste Ebene hat. Beispiel: {bd hh sd hh, cb ~ ~}

  • {a b c}%n: ein Polymeter mit n Schritten pro Zyklus. Beispiel: {hh hh oh}%8

  • a*<2 4> und a/<2 4>: ein Tempo pro Zyklus, abwechselnd. Beispiel: hh*<2 4>

Modifikatoren stehen hinter ihrem Schritt und können aufeinander folgen: [bd sd]*2, hh*8?0.2, bd(3,8)?.

Probier es aus

Drück Play. Die Demo beginnt mit bd*<2 4>, ~ [sd | cp], {hh hh oh}%8. Die Bassdrum spielt in einem Takt zweimal und im nächsten viermal. In der Mitte jedes Takts kommt entweder eine Snare oder ein Clap. Die Würfel dieses Patterns fallen nach jedem Play gleich: in den ersten vier Takten die Snare, der erste Clap in Takt 5. Die offene Hi-Hat liegt in jedem Takt auf einem anderen Schritt und ist nach drei Takten einmal herum.

  • Tipp {bd hh sd hh, cb ~ ~} ein und verfolge die Cowbell: Fällt sie auf den ersten Schritt eines Takts, ist sie drei Takte später wieder dort.

  • Ändere {hh hh oh}%8 zu {hh hh oh}%6. Die Verschiebung ist weg, denn sechs Schritte sind genau zwei Runden der drei.

  • Tipp hh*<4 8 16> ein: Die Hi-Hat verdoppelt ihr Tempo zweimal und fängt dann von vorn an.

  • Tipp bd sd | bd bd sd | bd(3,8) ein: Jeder Takt ist einer der drei, und nichts verrät dir, welcher als Nächster kommt.

  • Tipp bd, sd | cp ein. Die Meldung unter dem Eingabefeld zeigt auf das |, und das letzte gültige Pattern spielt weiter.

Die Drums haben jetzt eine Sprache, aber sie sind das einzige Instrument. Der nächste Teil baut einen Synth, und dieselbe Notation spielt darauf Noten.

Die App am Ende von Teil 7. Drück Play und ändere dann das Pattern im Eingabefeld. Sounds: bd sd hh oh cp rim lt mt ht cb cy.
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.