Eine Live-Coding-Musik-App bauen · Teil 6 von 18 der Serie
Teil 6: Tempo, Länge und Zufall
Sieben Ergänzungen der Mini-Notation: * und / für das Tempo, @ und _ für die Länge, ! für Wiederholungen, ? für Zufall und (3,8) für euklidische Rhythmen. Schritte bekommen ein Gewicht, Zufallszahlen werden eine Funktion der Zeit, und ein Algorithmus verteilt Treffer gleichmäßig über einen Takt.
Eine Live-Coding-Musik-App bauenTeil 6 von 18
Auf dieser Seite
Quest-Ziele
- Einen Schritt mit * und / schneller und langsamer machen
- Schritten ein Gewicht und eine Wiederholung geben und eine Abfolge den Zyklus nach Gewicht teilen lassen
- Zufallszahlen erzeugen, die für denselben Moment immer dieselben sind
- Treffer mit dem Algorithmus von Bjorklund gleichmäßig über Schritte verteilen
- Tokenizer, Parser und Compiler um Modifikatoren erweitern
Die Sprache aus Teil 5 kann sagen, welche Sounds aufeinander folgen und welche zusammen spielen. Sechzehn Hi-Hats brauchen immer noch sechzehn Wörter, jeder Schritt ist so lang wie seine Nachbarn, und nichts ist dem Zufall überlassen. Dieser Teil ergänzt sieben Zeichen. Die meisten stehen direkt hinter einem Schritt und ändern ihn:
hh*4: viermal so schnell. Vier Hi-Hats, die kurzen metallischen Ticks des Drumcomputers, in der Zeit eines Schritts.[bd sd]/2: halb so schnell. Die Gruppe braucht zwei Zyklen, die Bassdrumbdfüllt also den ersten und die Snaresdden zweiten. Ein Zyklus ist ein Takt mit vier Schlägen.bd@3 sd: ein Gewicht. Die Bassdrum ist dreimal so lang wie ein Schritt ohne Gewicht: Sie hat drei Viertel des Zyklus und die Snare das letzte Viertel.bd _ _ sd: dasselbe, ausgeschrieben. Jedes_macht den Schritt davor um einen Schritt länger.bd!3 sd: eine Wiederholung, dasselbe wiebd bd bd sd. Ein!ohne Zahl spielt den Schritt einmal mehr.sd?: Zufall. Der Schritt fällt in der Hälfte der Fälle aus.sd?0.2lässt ihn in 20 Prozent der Fälle aus.bd(3,8): ein euklidischer Rhythmus. Drei Treffer, so gleichmäßig wie möglich über acht Schritte verteilt.
Das Tempo gibt es schon: fast und slow aus Teil 4. Länge und Wiederholungen brauchen eine Abfolge, deren Schritte nicht alle gleich groß sind. Zufall und der euklidische Rhythmus brauchen zwei neue Funktionen für Patterns. Danach lernen Tokenizer, Parser und Compiler aus Teil 5 die Zeichen.
Eine Abfolge mit Gewichten
Bisher hat sequence jedem Pattern denselben Anteil am Zyklus gegeben. Jetzt bringt jedes ein Gewicht mit, und sein Anteil ist sein Gewicht geteilt durch die Summe aller Gewichte. Ersetze in src/pattern.ts die Funktion sequence:
/** Patterns one after the other, each with a share of the cycle according to its weight. */
export function sequence<T>(steps: Array<{ pattern: Pattern<T>; weight: number }>): Pattern<T> {
const total = steps.reduce((sum, step) => sum + step.weight, 0);
if (total <= 0) return silence();
let before = 0;
return stack(
steps.map(({ pattern, weight }) => {
const from = before / total;
before += weight;
return compress(from, before / total, pattern);
}),
);
}before zählt die Gewichte zusammen, die schon vergeben sind. Für bd@3 sd sind die Gewichte 3 und 1, und die Summe ist 4. Die Bassdrum wird in den Slot von 0/4 bis 3/4 gepresst, die Snare in den Slot von 3/4 bis 4/4. Mit einem Gewicht von 1 überall ist das Ergebnis dasselbe wie vorher.
Ein Drum-Sound hat seine eigene Länge, für die Drums verschiebt ein längerer Schritt also nur die Schritte, die nach ihm kommen. Ab Teil 8 klingt eine Note so lang wie ihr Schritt.
Die Funktion nimmt jetzt Objekte, jedes mit einem pattern und einem weight. Ihr bisher einziger Aufrufer ist der Compiler in src/mini.ts, der ihr noch bloße Patterns übergibt. TypeScript meldet diesen Aufruf als Fehler, bis der Compiler weiter unten geändert ist.
Zufall, nach dem man wieder fragen kann
Der naheliegende Weg, einen Anschlag ab und zu auszulassen, ist Math.random(). Er passt nicht. Ein Pattern ist eine Funktion der Zeit, und Teil 4 hat sich auf eine Eigenschaft davon verlassen: Dieselbe Frage bekommt dieselbe Antwort. Mit Math.random() würde ein Pattern jedes Mal anders antworten, wenn es nach demselben Abschnitt gefragt wird. Stop und Play brächten nie dieselben Takte zurück. Und niemand außer der Uhr könnte ein Pattern je fragen, was es spielt, denn eine zweite Frage bekäme eine zweite Antwort.
Ein Pattern braucht eine Zahl, die zufällig aussieht und von nichts als der Zeit abhängt. Das leistet ein Hash: eine Funktion, die ihre Eingabe so gründlich durcheinanderbringt, dass das Ergebnis wie Zufall aussieht, während dieselbe Eingabe immer dasselbe Ergebnis liefert. Ergänze am Ende von src/pattern.ts:
/**
* A number from 0 to 1 that looks random, but is always the same for the same time and
* seed. A pattern has to give the same answer whenever it is asked for the same stretch.
*/
export function random(time: number, seed = 0): number {
let x = (Math.floor(snap(time) * 1e5) ^ Math.imul(seed + 1, 0x9e3779b1)) >>> 0;
x = Math.imul(x ^ (x >>> 16), 0x21f0aaad);
x = Math.imul(x ^ (x >>> 15), 0x735a2d97);
x ^= x >>> 15;
return (x >>> 0) / 4294967296;
}
/** Drops each event with a chance of `amount`. */
export function sometimes<T>(amount: number, seed: number, pattern: Pattern<T>): Pattern<T> {
return (begin, end) => pattern(begin, end).filter((hap) => random(hap.begin, seed) >= amount);
}random arbeitet in drei Zügen. Die erste Zeile macht aus der Zeit eine ganze Zahl, gezählt in Hunderttausendsteln eines Zyklus, und mischt den Seed hinein: eine zweite Eingabe, die für dieselben Zeiten eine andere Reihe von Zahlen ergibt. Die nächsten drei Zeilen bringen die Bits durcheinander: Die Zahl wird mit einer verschobenen Kopie ihrer selbst verknüpft und mit einer großen Konstante multipliziert, und das zweimal, und dann noch einmal mit einer verschobenen Kopie verknüpft. Math.imul multipliziert so, wie es 32-Bit-Ganzzahlen tun, und genau das braucht ein solches Durchmischen. Die letzte Zeile teilt durch 2 hoch 32, die Anzahl der Werte, die 32 Bits halten können, das Ergebnis liegt also zwischen 0 und 1.
Die Konstanten haben nichts mit Musik zu tun. Sie sind von der Art, die Hashfunktionen für ganze Zahlen nutzen, und so gewählt, dass benachbarte Eingaben Ergebnisse liefern, die nichts miteinander zu tun haben. random(0) ist 0,135, random(0.125) ist 0,988 und random(0.25) ist 0,069, auf drei Stellen gerundet, heute und an jedem anderen Tag.
sometimes fragt sein Pattern und behält die Ereignisse, deren Zahl mindestens amount ist. Die Zahl kommt vom Beginn des Ereignisses, jedes Ereignis hat also seine eigene, und sie ist dieselbe, wann immer nach dem Ereignis gefragt wird.
Gebraucht wird der Seed in einem Fall. In sd? sd? ist jede Snare in ihrem Schritt ein eigenes Pattern, und in einem Schritt beginnt die Zeit mit dem Zyklus: Beide Snares beginnen im selben Moment ihrer eigenen Zeit. Ohne Seed bekämen sie dieselbe Zahl und würden immer zusammen ausfallen. Mit verschiedenen Seeds würfelt jede für sich.
Euklidische Rhythmen
Viele Rhythmen lösen eine Aufgabe: ein paar Treffer so gleichmäßig wie möglich über eine Anzahl von Schritten verteilen. Vier Treffer über sechzehn Schritte sind jeder vierte Schritt. Drei Treffer über acht Schritte können nicht gleichmäßig sein, denn acht ist nicht durch drei teilbar. Die gleichmäßigste Antwort hat Lücken von drei, drei und zwei Schritten. Mit einem x für einen Treffer und einem Punkt für eine Lücke geschrieben ist sie x..x..x., ein Rhythmus, der als Tresillo bekannt ist. In der Notation ist das bd(3,8).
Der Algorithmus von Bjorklund findet diese Rhythmen, indem er Paare bildet. Für drei Treffer über acht Schritte:
Beginne mit einer Gruppe pro Treffer und einer Gruppe pro Lücke:
x x xund. . . . .Gib jedem Treffer eine Lücke. Das ergibt
x. x. x., und zwei Lücken bleiben übrig:. .Bilde wieder Paare. Zwei der Gruppen nehmen je eine Lücke und werden zu
x.. x... Diesmal bleibt eine Gruppe übrig:x.Nur eine Gruppe ist übrig, also endet das Paaren. Alles hintereinander:
x..x..x.
Für fünf Treffer über acht Schritte ergeben dieselben Züge x. x. x. mit x x als Rest, dann x.x x.x mit x. als Rest und hintereinander x.xx.xx., also bd(5,8).
Ergänze den Algorithmus unter sometimes:
/** Spreads `pulses` hits over `steps` steps as evenly as whole steps allow. */
export function bjorklund(pulses: number, steps: number, rotation = 0): boolean[] {
steps = Math.max(0, Math.floor(steps));
pulses = Math.max(0, Math.min(steps, Math.floor(pulses)));
if (steps === 0) return [];
// Start with a group per hit and a group per gap, then keep pairing them up.
let groups: boolean[][] = Array.from({ length: pulses }, () => [true]);
let rest: boolean[][] = Array.from({ length: steps - pulses }, () => [false]);
while (rest.length > 1 && groups.length > 0) {
const pairs = Math.min(groups.length, rest.length);
const paired = groups.slice(0, pairs).map((group, index) => [...group, ...rest[index]]);
const leftGroups = groups.slice(pairs);
const leftRest = rest.slice(pairs);
groups = paired;
rest = leftGroups.length > 0 ? leftGroups : leftRest;
}
const rhythm = [...groups.flat(), ...rest.flat()];
const shift = ((Math.floor(rotation) % steps) + steps) % steps;
return [...rhythm.slice(shift), ...rhythm.slice(0, shift)];
}groups sind die Gruppen, die wachsen, rest ist, was übrig bleibt. Jede Runde der Schleife hängt an so viele Gruppen wie möglich je eine übrige Gruppe an. Was keinen Partner gefunden hat, ist der neue rest: die Gruppen, die nichts bekommen haben, oder, wenn jede Gruppe etwas bekommen hat, der Rest des alten rest. Die Schleife endet, wenn höchstens eine Gruppe übrig ist.
Die ersten zwei Zeilen halten die Zahlen vernünftig: ganze Zahlen und nicht mehr Treffer als Schritte. Die letzten zwei Zeilen drehen den Rhythmus. bd(3,8,2) beginnt zwei Schritte weiter hinten in ihm, was .x..x.x. ergibt, und so, wie shift ausgerechnet wird, dreht eine negative Zahl in die andere Richtung.
Die Funktion für Patterns ist kurz. Ergänze sie am Ende der Datei:
/** A euclidean rhythm: the pattern on the hits, silence in the gaps. */
export function euclid<T>(pulses: number, steps: number, rotation: number, pattern: Pattern<T>): Pattern<T> {
const rhythm = bjorklund(pulses, steps, rotation);
if (rhythm.length === 0) return silence();
return sequence(rhythm.map((hit) => ({ pattern: hit ? pattern : silence<T>(), weight: 1 })));
}Aus dem Rhythmus wird eine Abfolge von Schritten mit demselben Gewicht, mit dem Pattern auf den Treffern und Stille in den Lücken. bd(3,8) sind acht Schritte von je einem Achtel eines Zyklus, mit Bassdrums bei 0; 0,375 und 0,75.
Neue Symbole, neue Knoten
Der Rest des Teils spielt in src/mini.ts und geht die drei Stufen der Reihe nach durch. Die Datei braucht drei weitere Funktionen aus ./pattern.ts. Ersetze ihren Import:
import { euclid, fast, pure, sequence, silence, slow, sometimes, stack, type Pattern } from './pattern.ts';Der Tokenizer muss nur die neuen Symbole kennen: die zwei runden Klammern sowie *, /, @, _, ! und ?. Ersetze SYMBOLS:
const SYMBOLS = '[]<>(),~*/@_!?';Der Baum bekommt vier neue Arten von Knoten, und die Schritte einer Abfolge werden mehr als bloße Knoten. Ersetze den Typ Node und ergänze darunter Step:
export type Node =
| { type: 'atom'; value: Atom }
| { type: 'rest' }
| { type: 'sequence'; steps: Step[] }
| { type: 'stack'; layers: Node[] }
| { type: 'alternate'; steps: Step[] }
| { type: 'fast'; node: Node; factor: number }
| { type: 'slow'; node: Node; factor: number }
| { type: 'sometimes'; node: Node; amount: number; seed: number }
| { type: 'euclid'; node: Node; pulses: number; steps: number; rotation: number };
/** A step of a sequence: how much of the time it takes, and how often it is played. */
interface Step {
node: Node;
weight: number;
repeat: number;
}fast, slow, sometimes und euclid umschließen je einen Knoten und tragen die Zahlen, die hinter ihm standen. Gewicht und Wiederholung sind keine Knoten. Sie ändern nichts am Schritt selbst. Sie sagen der Abfolge um ihn herum, wie viel Platz der Schritt bekommt und wie oft er vorkommt, also stehen sie in einem Step neben dem Knoten. Die Schritte von sequence und alternate haben jetzt diesen Typ.
Schritte und ihre Modifikatoren
Die Grammatik wächst um eine Regel und ändert eine andere. In der Kurzform aus Teil 5, mit n für eine Zahl und einem bloßen ? für „darf fehlen“:
sequence = (step modifier* | "_" | "!")*: Eine Abfolge besteht aus Schritten, denen jeweils beliebig viele Modifikatoren folgen. Dazwischen darf ein_oder ein!für sich stehen.modifier = "*" n | "/" n | "@" n | "!" n? | "?" n? | "(" n "," n ("," n)? ")": Ein Modifikator ist ein Stern, ein Schrägstrich oder ein At-Zeichen mit einer Zahl, oder ein Ausrufezeichen oder ein Fragezeichen, das eine Zahl haben darf, oder zwei oder drei Zahlen in runden Klammern.
Der Parser braucht einen Zähler für die Seeds. Ergänze in der Klasse Parser ein Feld unter at:
/** Counts up, so that every "?" in a pattern rolls dice of its own. */
private seed = 0;Ergänze unter isSymbol() ein weiteres Werkzeug:
/** True when nothing, not even a space, is between the last token and the next one. */
private attached(): boolean {
const last = this.tokens[this.at - 1];
return last !== undefined && this.peek().start === last.end;
}Hier zahlen sich die Positionen der Tokens zum zweiten Mal aus. Der Tokenizer hat die Leerzeichen weggeworfen, aber zwei Tokens berühren sich genau dann, wenn das eine dort beginnt, wo das andere endet.
Ersetze parseSequence() und atSequenceEnd():
/** sequence = (step modifier* | "_" | "!")*, up to whatever closes it */
private parseSequence(): Node {
const steps: Step[] = [];
while (!this.atSequenceEnd()) {
const token = this.peek();
const last = steps[steps.length - 1];
if (token.type === 'symbol' && (token.text === '_' || token.text === '!')) {
if (!last) throw new MiniError(`"${token.text}" needs a step before it`, token.start);
this.next();
// "a _" makes the step before it longer, "a !" plays it once more.
if (token.text === '_') last.weight += 1;
else last.repeat += 1;
continue;
}
const step: Step = { node: this.parseStep(), weight: 1, repeat: 1 };
this.parseModifiers(step);
steps.push(step);
}
return { type: 'sequence', steps };
}
private atSequenceEnd(): boolean {
const token = this.peek();
return token.type === 'end' || (token.type === 'symbol' && ']>,)'.includes(token.text));
}Jeder Schritt beginnt mit einem Gewicht von 1 und einer Wiederholung von 1, und parseModifiers() kann beides ändern. Bevor die Schleife einen Schritt liest, sucht sie nach einem _ oder einem !, das dort steht, wo ein Schritt stünde. Ein solches Zeichen ist kein Schritt: Es ändert den letzten, um eine Einheit Gewicht oder um eine Wiederholung mehr. Am Anfang einer Abfolge gibt es keinen letzten Schritt, und der Fehler sagt das. Ein ! kommt nur nach einem _ bis hierher, wie in bd _ !. Eines, das auf einen Schritt folgt, mit oder ohne Leerzeichen, hat schon parseModifiers() genommen, das dasselbe damit tut.
atSequenceEnd() kennt ein Token mehr, das eine Abfolge schließt, das ).
Die Modifikatoren stecken voller Zahlen, also bekommt der Parser eine Methode, die eine verlangt. Ergänze sie unter atSequenceEnd():
private parseNumber(): number {
const token = this.next();
const number = Number(token.text);
if (token.type !== 'word' || !Number.isFinite(number)) {
throw new MiniError(
token.type === 'end' ? 'A number is missing at the end' : `Expected a number, found "${token.text}"`,
token.start,
);
}
return number;
}Und darunter, über parseStep(), die Modifikatoren selbst:
/** modifier = "*" n | "/" n | "@" n | "!" n? | "?" n? | "(" n "," n ("," n)? ")" */
private parseModifiers(step: Step) {
for (;;) {
const token = this.peek();
if (token.type !== 'symbol') return;
switch (token.text) {
case '*':
this.next();
step.node = { type: 'fast', node: step.node, factor: this.parseNumber() };
break;
case '/':
this.next();
step.node = { type: 'slow', node: step.node, factor: this.parseNumber() };
break;
case '@':
this.next();
step.weight = this.parseNumber();
break;
case '!':
this.next();
// "a!3" plays it three times, "a!" once more.
if (this.peek().type === 'word' && this.attached()) step.repeat = Math.max(1, Math.floor(this.parseNumber()));
else step.repeat += 1;
break;
case '?': {
this.next();
const amount = this.peek().type === 'word' && this.attached() ? this.parseNumber() : 0.5;
step.node = { type: 'sometimes', node: step.node, amount, seed: this.seed };
this.seed += 1;
break;
}
case '(': {
this.next();
const pulses = this.parseNumber();
this.expect(',');
const steps = this.parseNumber();
let rotation = 0;
if (this.isSymbol(',')) {
this.next();
rotation = this.parseNumber();
}
this.expect(')');
step.node = { type: 'euclid', node: step.node, pulses, steps, rotation };
break;
}
default:
return;
}
}
}Die Methode läuft in einer Schleife, weil ein Schritt mehrere Modifikatoren haben kann, und sie hält beim ersten Token an, das keiner ist. Was jeder tut:
*und/umschließen den Knoten des Schritts mit einemfast- oder einemslow-Knoten.@setzt das Gewicht des Schritts.!setzt die Wiederholung auf die Zahl dahinter oder zählt eins dazu, wenn keine Zahl da ist.?umschließt den Knoten mit einemsometimes-Knoten. Sein Anteil ist die Zahl dahinter oder 0,5, und sein Seed ist der Zähler des Parsers, der danach weiterzählt.(liest zwei Zahlen mit einem Komma dazwischen, eine dritte, wenn noch ein Komma folgt, und verlangt das).
! und ? können ohne Zahl stehen, und das macht das nächste Token mehrdeutig: In sd? 3 könnte die 3 der Anteil sein oder der nächste Schritt. attached() entscheidet. Eine Zahl gehört nur dann zum Zeichen, wenn nichts zwischen ihnen steht, nicht einmal ein Leerzeichen. Die anderen Modifikatoren brauchen ihre Zahl immer, bd* ist also ein Fehler: A number is missing at the end.
parseStep() bleibt, wie es ist. alternate() unter der Klasse muss Schritte statt Knoten weitergeben. Ersetze es und ergänze stepsOf():
/** `<a b, c d>` alternates in each of its layers. */
function alternate(node: Node): Node {
if (node.type === 'stack') return { type: 'stack', layers: node.layers.map(alternate) };
return { type: 'alternate', steps: stepsOf(node) };
}
function stepsOf(node: Node): Step[] {
return node.type === 'sequence' ? node.steps : [{ node, weight: 1, repeat: 1 }];
}Der Compiler
Der Compiler bekommt einen Fall pro neuem Knoten, und compileSteps() lernt Gewichte und Wiederholungen kennen. Ersetze compile() und compileSteps():
function compile(node: Node): Pattern<Atom> {
switch (node.type) {
case 'atom':
return pure(node.value);
case 'rest':
return silence();
case 'sequence':
return compileSteps(node.steps);
case 'stack':
return stack(node.layers.map(compile));
case 'alternate': {
// All steps in a row, slowed down so that a step of weight 1 fills a cycle.
const length = node.steps.reduce((sum, step) => sum + step.weight * step.repeat, 0);
return slow(length || 1, compileSteps(node.steps));
}
case 'fast':
return fast(node.factor, compile(node.node));
case 'slow':
return slow(node.factor, compile(node.node));
case 'sometimes':
return sometimes(node.amount, node.seed, compile(node.node));
case 'euclid':
return euclid(node.pulses, node.steps, node.rotation, compile(node.node));
}
}
function compileSteps(steps: Step[]): Pattern<Atom> {
const parts: Array<{ pattern: Pattern<Atom>; weight: number }> = [];
for (const step of steps) {
const pattern = compile(step.node);
for (let i = 0; i < step.repeat; i += 1) parts.push({ pattern, weight: step.weight });
}
if (parts.length === 0) return silence();
if (parts.length === 1) return parts[0].pattern;
return sequence(parts);
}Die vier neuen Fälle sind je ein Aufruf, wie in Teil 5. compileSteps() kompiliert jeden Schritt einmal und legt ihn so oft in die Liste, wie seine Wiederholung sagt, jedes Mal mit seinem Gewicht. Aus bd!3 sd werden vier Teile mit Gewicht 1, aus bd@3 sd zwei Teile mit den Gewichten 3 und 1. Diese Liste ist das, was das neue sequence nimmt, und der Typfehler vom Anfang des Teils ist weg.
Der Fall alternate hat seine Schritte bisher um ihre Anzahl verlangsamt. Jetzt verlangsamt er sie um ihre Länge, die Summe aus Gewicht mal Wiederholung, sodass ein Schritt mit Gewicht 1 weiterhin einen Zyklus füllt. <bd sd!2> hat die Länge 3 und spielt die Bassdrum einen Zyklus lang und die Snare zwei. In <bd@3 sd> dauert der Schritt der Bassdrum drei Zyklen, sie wird also einmal in drei Takten angeschlagen, und die Snare hat den vierten.
Die Seite ändert sich nur an einer Stelle. Ersetze in index.html das Eingabefeld, sodass es mit einem Pattern beginnt, das die neuen Zeichen nutzt. src/main.ts und src/style.css bleiben, wie sie sind:
<input id="pattern" value="bd(3,8), ~ sd ~ sd?, hh*4 [hh oh]@2 hh!2" spellcheck="false" autocomplete="off" />Probier es aus
Drück auf Play. Das Pattern hat drei Ebenen. Die Bassdrum spielt den Tresillo, x..x..x.. Die Snare liegt in jedem Takt auf Schlag 2 und nur in manchen auf Schlag 4: nicht in Takt 1, dann in den Takten 2, 3 und 4, nicht in Takt 5. Drück auf Stop und wieder auf Play, und es sind dieselben Takte. Die dritte Ebene schneidet den Takt in fünf Teile statt in vier: vier schnelle Hi-Hats im ersten Teil, dann eine Hi-Hat, eine offene Hi-Hat und zwei weitere Hi-Hats, eine pro Teil.
Tipp dann:
bd(5,8)stattbd(3,8): Aus der Bassdrum wirdx.xx.xx..bd(3,8,2)spielt den ersten Rhythmus ab seinem dritten Schritt:.x..x.x.hh*8?als einziges Pattern: acht Hi-Hats mit Löchern. Die Löcher sind von Takt zu Takt andere, aber jeder Takt hat immer dieselben: Drück auf Stop und Play, und Takt 1 hat die Löcher, die er vorher hatte.hh*16?0.3lässt weniger von mehr aus.bd _ _ sdund dannbd@3 sd: kein Unterschied zu hören.[bd sd]/2, hh*4: die Bassdrum in einem Takt, die Snare im nächsten.bd*: Die Markierung steht unter dem Ende des Texts, mitA number is missing at the end, und das letzte gute Pattern spielt weiter.
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.