2b:null 2c:["$","title",null,{"children":"PLAYA | Ricardo Matias | Observable"}] 31:T757,md`Let's expand to the foundation of Western Music, keys and scales. There are two classes, aptly named ${docs('Core#Key', 'Key')} and ${docs('Core#Scale', 'Scale')}.
The difference between them is that a Scale defines a relationship between notes via ${docs('Types.Interval', 'intervals')} and a Key, makes use of it and expands the relationship to other scales.
Enough abstract talk, here are two examples: * new Scale('A', Scale.Minor) => ${new Playa.Scale('A', Playa.Scale.Minor).string.join(' ')} * new Key('C2', Key.Dorian) => ${new Playa.Scale('C2', Playa.Key.Dorian).string.join(' ')} * new Scale('F', Scale.Ionian, [4, 1]) => ${new Playa.Scale('F', Playa.Scale.Ionian, [4, 1]).string.join(' ')} *side note*: [4, 1] [* octave, number of octaves *]: this is another way to define octaves They look pretty similar, but what you can do with them differs. If you're interested in trying out different scales, perhaps generating some isolated note sequences Scale is a good choice. On the other hand, if you want to try a combination of scales, Key will be a better fit. Slight detour, everytime you see some note representation may it be midi, frequency or string, it's been done via some common accessors to the base harmonic classes Chord, Scale or Key, which inherit from ${docs('Core.HarmonyBase', 'HarmonyBase')}. Here are them: * key.string: ${key.string.join(' ')} * chord.notes: ${chord.notes} * scale.midi: ${scale.midi.join(' ')} * chord.freq: ${chord.freq.map(f => f.toFixed(0)+'hz').join(' ')} `32:[] 2f:{"id":"fa7da79da0054098","slug":"playa","title":"PLAYA","thumbnail":"9674ff899c851e2dc6d2fde86fc7e32374f717ae96e5a4f11f8c4ec0832d935c","access_level":"public","create_time":"$D2020-10-30T15:04:55.174Z","update_time":"$D2024-04-08T09:49:34.093Z","view_time":null,"first_public_time":"$D2020-11-06T15:48:08.708Z","fork":false,"stars":21,"starred":false,"owner":{"type":"team","id":"f82069c93b3055fb","login":"ricardomatias","name":"Ricardo Matias","avatar_url":"https://avatars-next.observableusercontent.com/00a9d9648ed3b34f8eb40a201ff9aa78caba4ea9492c2c16cd0bea2c7c7dce73","tier":"starter_2024"},"version":2108,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"a4c1fb679d50b600","login":"ricardomatias","name":"Ricardo Matias","avatar_url":"https://avatars-next.observableusercontent.com/00a9d9648ed3b34f8eb40a201ff9aa78caba4ea9492c2c16cd0bea2c7c7dce73","tier":null}],"members":[{"type":"individual","id":"a4c1fb679d50b600","login":"ricardomatias","name":"Ricardo Matias","avatar_url":"https://avatars-next.observableusercontent.com/00a9d9648ed3b34f8eb40a201ff9aa78caba4ea9492c2c16cd0bea2c7c7dce73","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":5,"collection":null,"type":"notebook","body":{"title":"PLAYA","cells":[{"id":0,"value":"md`# PLAYA`\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":5,"value":"html`

`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2058,"value":"md`[${githubIcon} Github Repository](https://github.com/ricardomatias/playa)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2025,"value":"viewof sayPlaya = button('click me')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":7,"value":"md`*PLAYA* is a framework for musical composition. It allows creating custom music algorithms, musical phrases, percussion rhythms, harmonic sequences and more.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":89,"value":"md`In this guide I'll introduce you to the library and show what can be done with it. Make sure to check the ${link('https://ricardomatias.net/playa/', 'documentation')} (<- this is a documentation link, you'll see more like this), which has more information on how to use it.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":220,"value":"md`You can use the library in the following manner:\n* const Playa = require('playa');\n* import Playa from 'playa';\n* import { Note, Chord, Scale } from 'playa';\n\n_In this guide I'll assume point of view of the last option via destructuring._\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":95,"value":"md`### *It starts with* ${note.note}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":15,"value":"md`This how you would define the ${docs('Core#Note', 'Note')}: A -> new Note('${note.note}').

\nThat's perfectly fine, but you probably want to be able to hear that A, so a more useful way would be to assign an octave like new Note('A3'). Now you can figure out other things such as:\n* .midi: ${note.midi}\n* .freq: ${note.freq.toFixed(2)} hz\n* .next: ${note.next.n}\n* .prev: ${note.prev.n}\n* .isNatural: ${note.isNatural}\n\nYou can also start with midi and go the other way around new Note(${note.midi})\n\n* .n: ${note.n}\n* .note: ${note.note}\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":99,"value":"note = {\n let note;\n yield note = new Playa.Note(0);\n \n while (true) {\n await Promises.delay(3000);\n if (note.midi >= 126) {\n yield note = new Playa.Note(0);\n } else {\n yield note = note.next;\n }\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":162,"value":"md`### *Growing the relation* ${chord.notes.map(n => n.note).join(' ')}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":214,"value":"md`Single notes are, well, single. One of the ways to change that is to make use of ${docs('Core#Chord', 'Chord')}. You can create a ${chord.name} chord with:\n* a symbol: new Chord('${chord.root.note}', '${chord.symbol}')
\n* or intervals: new Chord('${chord.root.note}', '${chord.intervals}')\n* or from name: Chord.fromName('${chord.root.note}${chord.symbol}')\n* or via scale: Chord.fromIntervals('${chord.root.note}', '${chord.intervals}', ['${chord.structure[0]}']).
*Don't pay attention to the specific intervals used, I'll explain later why this way of creating is useful.*\n\nHere is a list of the supported ${docs('Constants.ChordSymbol', 'chord symbols')}:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":18,"value":"ChordSymbols = Playa.ChordSymbol","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":260,"value":"md`You can select a different symbol below via it's ${docs('Constants.ChordName', 'name')} and see how the chord changes:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":262,"value":"viewof chordSymbol = select({\n value: Playa.ChordName.Minor,\n options: Object.values(Playa.ChordName)\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":273,"value":"md`also here are the respective ${docs('Constants.ChordIntervals', 'intervals')}:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":245,"value":"ChordIntervals = Playa.ChordIntervals","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":290,"value":"md`As shown before chords can be created via Chord.fromIntervals which combines two things, *intervals* and a *chord structure*. The combination is powerful and allows figuring specific chords from a set of intervals, f.ex:\n* a sixth chord in *F minor* key => ${Playa.Chord.fromIntervals('F', Playa.Scale.Minor, Playa.Chord.Structures.Sixth).string.join(' ')}\n
Chord.fromIntervals('F', Scale.Minor, Chord.Structures.Sixth\n\n* or suspended chord in *Bb major* key ==> ${Playa.Chord.fromIntervals('Bb', Playa.Scale.Major, Playa.Chord.Structures.Sus).string.join(' ')}
\nChord.fromIntervals('Bb', Scale.Major, Chord.Structures.Sus)\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":370,"value":"md`Here are the default *chord structures*:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":380,"value":"ChordStructures = Playa.ChordStructure","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":385,"value":"md`You can use custom chord structures, as long as they fit in the given *intervals*, f.ex:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":388,"value":"md`

Chord.fromIntervals('D', '1P 2m 3M 4A 5P 6m 7m', ['1 2 6 7'])
 => ${Playa.Chord.fromIntervals('D', '1P 2m 3M 4A 5P 6m 7m', ['1 2 6 7']).string.join(' ')}

`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":397,"value":"md`Inverting chords is also possible, albeit without [slash chord](https://en.wikipedia.org/wiki/Slash_chord) nomenclature.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":405,"value":"md`Chord.fromName('Am7').invert() => ${Playa.Chord.fromName('Am7').invert().string.join(' ')}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":163,"value":"chord = new Playa.Chord(note.n, Playa.ChordSymbol[chordSymbol])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":423,"value":"md`### *Making it whole*

${scale.notes.map(n => n.note).join(' ')}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":440,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":527,"value":"md`Back to it. One requirement to use Key is that you can only make use of intervals belonging to the seven Modes.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":552,"value":"Modes = Playa.Key.Modes","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":555,"value":"md`For the sake of convenience you can refer to the *Ionian* mode by *Major* and *Aeolian* by *Minor* since they are the same set of intervals. 
To access the intervals of any Scale you can do it via:
\n  Key.Phrygian => ${Playa.Key.Phrygian}\n
\nLet's talk about modulation. There are two ways to modulate in *PLAYA*, you can modulate within the same key which means that you're transitioning from one mode to another, f.ex:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":445,"value":"key = new Playa.Key('C', Playa.Key.Major)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":632,"value":"md`

\n  const key = Key('C', Key.Ionian); => ${new Playa.Key('C', Playa.Key.Ionian).string.join(' ')}\n  key.IV;\n  // or\n  key.modulateMode({ direction: Key.ModulateUp, interval: 4 });\n  key.string; => ${key.IV.string.join(' ')}\n  key.modePositionRoman; => ${key.modePositionRoman}\n

\n\nyou can also just modulate randomly to another mode by calling ${docs('Core#Key#modulateMode', 'modulateMode')} without any arguments:

\n  key.modulateMode() => ${key.modulateMode().string.join(' ')} // everytime this cell runs the key will be different

\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":647,"value":"{\n  const keyMod = new Playa.Key('C', Playa.Key.Major);\n  \n  yield md`or you can ${docs('Core#Key#modulate', 'modulate')} to another key:

\n  const key = new Key('C', Key.Major);\n  key.modulateUp() => ${keyMod.modulateUp().string.join(' ')} //default interval is '5P'\n  key.root.note => ${keyMod.root.note}\n  key.intervals => ${keyMod.intervals}\n  key.name => ${keyMod.name}\n

\n`\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":498,"value":"scale = new Playa.Scale(note.note, Playa.Scale.Major)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":521,"value":"md`### *There was a time* ${transport.bbs}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":721,"value":"md`The last core building block to talk about is ${docs('Core#Time', 'Time')}. There are several time formats that can be used and converted with Time, for example here is a quarter note:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":742,"value":"qt = new Playa.Time('4n');","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":740,"value":"md`\n* qt.ticks - ${qt.ticks}\n* qt.notevalue - ${qt.notevalue}\n* qt.transport - ${qt.bbs}\n* qt.toSeconds(120) - ${qt.toSeconds(120)} // 120 bpm\n\nthe most prominent of the formats would be **ticks**, since it's an absolute number non-bpm dependent which is measured as the [PPQ](https://en.wikipedia.org/wiki/Pulses_per_quarter_note) (pulse per quarter) value.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":791,"value":"md`*PLAYA* adopts the default *PPQ* of 480, meaning that a quarter note (4n) = ${Playa.Ticks['4n']} ticks. This value is also used in Ableton Live and Max/MSP.\nThis is important to keep in mind, because the context where you use *PLAYA* might have a different *PPQ* value, such as *Tone.js* which uses ${Tone.Transport.PPQ} PPQ.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":794,"value":"md`You can also use different [time signatures](https://en.wikipedia.org/wiki/Time_signature), which is essential for *transport* time conversions:

\n  new Time('2:0:0', [3, 4]).ticks => ${new Playa.Time('2:0:0', [3, 4]).ticks}\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":807,"value":"md`for us humans though, it's much easier to think of ${docs('Types.Notevalue', 'Note Values')}, here's a two-way map of *ticks* to *note values*:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":811,"value":"Playa.Ticks","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":818,"value":"md`which can be easily accessed as Ticks['4n'] or Ticks[480].`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":700,"value":"transport = {\n  let transport;\n  yield transport = new Playa.Time('0:0:0');\n  const delay = new Playa.Time('4n').toSeconds(60) * 1000;\n  \n  while (true) {\n    await Promises.delay(delay);\n    const newTick = transport + new Playa.Time('4n');\n    if (newTick >= new Playa.Time('16:0:0').t) {\n      yield transport = new Playa.Time('0:0:0');\n    } else {\n      yield transport = new Playa.Time(newTick);\n    }\n  }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1530,"value":"md`### *Play me something..* ${composing.note}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":929,"value":"md`Let's move towards creating some musical phrases. We've seen how we can choose notes, now it's time to figure out how and when to play them.
\nThere's a Rhythm namespace which provides two ways of creating rhythms.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":944,"value":"md`One way is with ${docs('Tools.Rhythm.free', 'Rhythm.free')} which creates rhythms by fitting the given *note values* with the given rhythm length. The *note values* will be picked randomly (but according to a probability distribution, which is *decreasing* by default, meaning the first has a higher chance than the next) in order to fit the desired length.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":931,"value":"free = Playa.Rhythm.free('2:0:0', ['4n', '2n'])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":926,"value":"md`The result is an ${docs('Types.Event', 'Event')} collection.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1015,"value":"md`Another way is with ${docs('Tools.Rhythm.turn', 'Rhythm.Turn')}, which makes use of a grid like structure like this:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1018,"value":"grid = Playa.Rhythm.createGrid('1:0:0', 4)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1025,"value":"md`to create a rhythm which has the number of events equal to the given **turns**.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1028,"value":"turn = Playa.Rhythm.turn('1:0:0', 4)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1054,"value":"md`now onto our first musical phrase. We'll start with ${docs('Composition.createMotif', 'createMotif')}, which given a collection of **notes** and **rhythm events**, creates a musical motif.

\nHere is with the rhythm we've created before using Rhythm.free:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1046,"value":"motifFree = Playa.createMotif(key.notes, free)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1067,"value":"{\n  const [h, part] = scheduleEvents(motifFree, '2:0:0', synth)\n  \n  invalidation.then(() => {\n    part.dispose();\n  })\n  \n  yield h;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1166,"value":"md`and here with the rhythm created by Rhythm.turn:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1151,"value":"motifTurn = Playa.createMotif(key.notes, turn)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1154,"value":"{\n  const [h, part] = scheduleEvents(motifTurn, '1:0:0', synth)\n  \n  invalidation.then(() => {\n    part.dispose();\n  })\n  \n  yield h;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1548,"value":"md`these aren't the most exciting musical phrases, but they are the building blocks of what we need to compose.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1534,"value":"composing = {\n  let comp;\n  let idx = 0;\n  yield comp = motifFree[idx];\n  \n  while (true) {\n    await Promises.delay(new Playa.Time(comp.dur).toSeconds(100) * 1000);\n    yield comp = motifFree[idx++ % motifFree.length];\n  }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":830,"value":"md`### *Clap on the one ${clap}*`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1465,"value":"md`to create percussion rhythms, we can make use of [Euclidean Rhythms](https://en.wikipedia.org/wiki/Euclidean_rhythm) by using directly ${docs('Tools.Euclidean.create', 'Euclidean.create')}:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1473,"value":"euclid = Playa.Euclidean.create(12, 7)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1485,"value":"{\n  const [h, loop] = schedulePercussion({patterns: [euclid], subdivision: \"8n\"})\n  \n  invalidation.then(() => {\n    loop.dispose();\n  })\n  \n  yield h;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1511,"value":"md`*note: don't play this and the createPercussion example at the same time.. seriously.*`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1494,"value":"md`or more easily by using ${docs('Composition.createPercussion', 'createPercussion')}, which creates multiple euclidean patterns:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1241,"value":"drums = Playa.createPercussion(16, [5, 2, 8, 1, 2, 3], [], [0, 4, 0, 8, 2, 3]);","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1479,"value":"{\n  const [h, loop] = schedulePercussion(drums)\n  \n  invalidation.then(() => {\n    loop.dispose();\n  })\n  \n  yield h;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1516,"value":"clap = {\n  let clap;\n  let idx = 0;\n  yield clap = euclid[idx];\n  \n  while (true) {\n    await Promises.delay(1000);\n    yield clap = euclid[idx++ % 12];\n  }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1567,"value":"md`### *Movements*`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1570,"value":"md`In order to compose musical phrases that are harmonically coeherent (or to put simply, that \"fit\" nicely together), we need to establish a shared context. In this case, we make sure that throughout a composition there is a Key, which can be used to generate chords, motifs, etc.
\nCue in ${docs('Types.Movement', 'Movements')}, these define a **timeline** for the harmonic movements in our compositions. They are made of harmonic events called **turns**.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1583,"value":"md`Here's how we can create one via ${docs('Composition.createMovement', 'createMovement')}:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1586,"value":"movement = Playa.createMovement(new Playa.Key('D', Playa.Key.Mixolydian), movementLength, 4)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2099,"value":"movement","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1803,"value":"movementLength = '8:0:0'","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1590,"value":"md`the **timeline** property is what we'll focus on. The events just gives us a more detailed description of the movement's events.` ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1594,"value":"md`now that we have a movement's **timeline**, we can use ${docs('Composition.createMelodies', 'createMelodies')} to generate motifs that follow these key changes:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1598,"value":"melodies = Playa.createMelodies(movement.timeline, {\n  restProb: 0.3,\n  octaves: [ [4, 1], [3,1] ],\n  dejaVuChance: 0.6,\n  rhythmValues: ['8n', '4n']\n});","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1604,"value":"{\n  const [h, p] = scheduleEvents(melodies, movementLength, arpSynth)\n  \n  invalidation.then(() => p.dispose())\n  \n  yield h\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1610,"value":"md`we can also create chords via ${docs('Composition.createChordProgression', 'createChordProgression')}:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1619,"value":"chordProgression = Playa.createChordProgression(movement.timeline, {\n  octaves: [ [3, 1] ],\n  structures: [ Playa.Chord.Structures.Triad ],\n  rhythmValues: ['2n',  '4n'],\n  inversionProb: 0.3,\n  restProb: 0.2\n});","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1623,"value":"{\n  const [h, p] = scheduleChordEvents(chordProgression, movementLength)\n  \n  invalidation.then(() => p.dispose())\n  \n  yield h\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1923,"value":"md`both createMelodies and createChordProgression are meant to be used with **movements**. But there are other ways of creating phrases which are not tied to them, such as ${docs('Composition.createArp', 'createArp')}, a flexible [arpeggio](https://en.wikipedia.org/wiki/Arpeggio) generator:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1929,"value":"arp = Playa.createArp(new Playa.Scale('G4', Playa.ScaleIntervals.Altered), [1, 6, 3, 5, 3, 2], ['4n', '8n', '4nd', '8n', '4n', '2n'])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1936,"value":"{\n  const [h, p] = scheduleEvents(arp, new Playa.Time(arp[arp.length - 1].next).bbs, arpSynth)\n  \n  invalidation.then(() => p.dispose())\n  \n  yield h\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1949,"value":"md`nevertheless, we can easily make it follow a **movement** as shown below:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1876,"value":"bassMovement = {\n  let turnDuration = 0;\n  let rhythm;\n  \n  return movement.timeline.map((turn) => {\n    // Here we try to keep the same rhythm throughout the whole movement\n    // if the duration of each turn is the same, the rhythm will never change\n    if (!rhythm || turn.dur !== turnDuration) {\n      rhythm = Playa.Rhythm.free(turn.dur, ['4n', '8n', '4nt'], ['8n']);\n    }\n    \n    turnDuration = turn.dur;\n    \n    // create the arpeggio in the turn's key\n    const arp = Playa.createArp(new Playa.Key(turn.key.root, turn.key.scale, [2, 1]), [ 1, 5 ], rhythm);\n    \n    // Here we do 2 things:\n    // * map each arpeggio to the correct starting time\n    // * add some rests to the arpeggio\n    return arp.map((evt) => {\n      const mapdEvt = Playa.mapStartToEvent(evt, turn.time);\n      \n      if (Playa.Random.float() < 0.3) mapdEvt.isRest = true;\n      \n      return mapdEvt;\n     });\n  }).flat();\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1882,"value":"{\n  const [h, p] = scheduleEvents(bassMovement, movementLength, bassSynth)\n  \n  invalidation.then(() => p.dispose())\n  \n  yield h\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2081,"value":"{\n  const data = {\n    movement,\n    bass: bassMovement,\n    chordProgression,\n    melodies\n  };\n  \n  yield html`Save the movement's note events to JSON:
${downloadButton(data)}`\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1994,"value":"md`### * On Randomness*`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1999,"value":"md`Throughout the code base, there's a dedicated singleton class called ${docs('Tools.Random', 'Random')} which is used for random number generation. Internally it uses [Simplex Noise](https://en.wikipedia.org/wiki/Simplex_noise) and a **seed** value which allows obtaining the same result for every run.\n
\nTake a look at [this](https://github.com/ricardomatias/playa/blob/master/test/tools/choose.spec.ts) test file for the ${docs('Tools.choose', 'choose')} tool, it uses Random.setSeed to set the value of the **seed** before each test case is run, therefore obtaining the same result.
\nYou can use this kind of pattern to generate new results by changing *only* the seed value. If you keep track of the **seed** values, you can reproduce previous results.\n\n  \n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1983,"value":"md`## *The End*`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1985,"value":"md`This is end of the guide. There is more in *PLAYA* than what is presented here, but the essentials have been covered. Explore the ${link('https://ricardomatias.net/playa/', 'documentation')} to find what other tools *PLAYA* has to offer. Happy creating!`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1072,"value":"md`## Audio`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1456,"value":"transportButtons(() => Tone.Transport.start('+0.1'), () => Tone.Transport.stop())","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1499,"value":"viewof bpm = slider({ \n  min: 60, \n  max: 180, \n  step: 1,\n  value: 106,\n  description: 'BPM'\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1506,"value":"{\n  bpm;\n  Tone.Transport.bpm.value = bpm;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1074,"value":"{\n  Tone.Transport.loop = false;\n  \n  while(true) {\n    await Promises.delay(1000);\n    yield Tone.now();\n  }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1290,"value":"updateTimeout = new Playa.Time('16n').toSeconds(Tone.Transport.bpm.value) * 1000","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1199,"value":"transportPosition = {\n  while(true) {\n    await Promises.delay(updateTimeout)\n    yield Tone.Transport.position;\n  }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1171,"value":"function transportButtons(playCallback, stopCallback, bar) {\n  const l = (cb) => ({\n    onclick: event => {\n      event.currentTarget.dispatchEvent(new CustomEvent(\"input\", {bubbles: true}));\n      cb();\n    }\n  })\n  const playButton = Object.assign(html`