---
title: "Instrukcija live music coding \/ strudel.cc lietuvių kalba"
url: https://hu.lt/live-music-coding/instrukcija-live-music-coding-strudel-cc-lietuviu-kalba/
author: "Gedas Kučinskas"
published: 2025-10-28T15:17:27+02:00
updated: 2025-10-28T15:20:53+02:00
language: lt
description: "🥁 1. BŪGNAI - Ritmo Pagrindas Pagrindiniai Būgnų Garsai Strudel naudoja samples iš bd, sd, hh, cp bibliotekų: Ritmų Kūrimas Naudokite tekstus ritminiams…"
---

# Instrukcija live music coding / strudel.cc lietuvių kalba

## 🥁 1. BŪGNAI - Ritmo Pagrindas

### Pagrindiniai Būgnų Garsai

**Strudel naudoja samples iš bd, sd, hh, cp bibliotekų:**

```javascript
// Pagrindiniai būgnai (kick drum)
sound("bd")

// Snare būgnai
sound("sd")

// Hi-hat lėkštės
sound("hh")

// Plojimas
sound("cp")
```

### Ritmų Kūrimas

**Naudokite tekstus ritminiams šablonams:**

```javascript
// Kick kiekviename take
sound("bd bd bd bd")

// Maišyti skirtingus garsus (tarpai = žingsniai)
sound("bd sd bd sd")

// Naudoti * vienu metu skambėsiančioms natoms
sound("bd*4") // 4 kick per vieną ciklą

// Naudoti / lėtesniems šablonams
sound("bd/2") // kick kas 2 ciklus
```

Mini-Notacija - Pagrindinis Įrankis

```javascript
// [] = padalinimas
sound("bd [sd sd]") // kick, tada 2 greiti snare

// ~ = pauzė/tyla
sound("bd ~ sd ~")

// <> = keičiasi kiekviename cikle
sound("bd <sd cp>") // keičiasi tarp sd ir cp

// ! = kartoti
sound("bd!3 sd") // bd bd bd sd

// , = lygiagretus/sluoksniuotas
sound("[bd sd, hh hh hh hh]") // būgnai + hi-hats kartu
```

### Įprasti Būgnų Šablonai

**House Ritmas:**

```javascript
sound("bd ~ sd ~, hh hh hh hh")
```

**Breakbeat:**

```javascript
sound("bd [~ sd] bd sd")
```

**Techno:**

```javascript
sound("bd ~ ~ ~, ~ ~ sd ~, hh*8")
```

**Trap:**

```javascript
sound("bd ~ bd ~, ~ ~ sd ~, hh*16").speed(0.5)
```

**Drum & Bass:**

```javascript
sound("bd [~ bd] ~ bd, ~ sd ~ [sd sd]")
.fast(2)
```

### Būgnų Sample Bankai

**Skirtingi būgnų rinkiniai:**

```javascript
// Skaičiai parenka variantus
sound("bd:0") // pirmas kick
sound("bd:3") // ketvirtas kick

// Skirtingi sample rinkiniai
sound("808bd") // 808 kick
sound("909bd") // 909 kick
sound("drumtraks:0") // vintage būgnų mašina

// Tyrinėti samples
sound("tabla:0 tabla:1 tabla:2 tabla:3")
```

Būgnų Garsų Formavimas

```javascript
// Gain (garsumas)
sound("bd sd").gain("1 0.7")

// Speed (greitis/aukštis)
sound("bd sd").speed("1 2") // 2 = dvigubas greitis/aukštesnis tonas

// Pan (stereo pozicija)
sound("hh hh hh hh").pan("0 0.5 1 0.5") // 0=kairė, 1=dešinė

// Room (reverb)
sound("sd").room(0.5).size(0.8)

// Cutoff (filtras)
sound("hh*8").cutoff("1000 2000 3000 4000")

// Crush (bitcrusher)
sound("bd sd").crush(4)
```

## 🎸 2. BOSAS - Žemų Dažnių Pagrindas

Pagrindinės Boso Linijos

```javascript
// Paprastas natų šablonas
note("c2 e2 f2 g2").sound("sawtooth")

// Boso sintetizatoriaus garsai
note("c1 c1 eb1 f1").sound("sawtooth")
note("c1 c1 eb1 f1").sound("triangle")
note("c1 c1 eb1 f1").sound("square")
```

Natų Sistemos

```javascript
// Raidžių notacija (c, d, e, f, g, a, b)
note("c2 d2 e2 f2")

// Skaičiai = oktavos (0-8, žemesnės = gilesnės)
note("c1") // labai žemas C
note("c4") // vidurinis C

// Diezai (#) ir bemoliai (b)
note("c#2 eb2 f2 g2")

// MIDI numeriai
n("36 38 39 41").sound("sawtooth") // tas pats kaip note
```

### Boso Šablonai ir Stiliai

**Minimalus Techno Bosas:**

```javascript
note("c1 ~ c1 ~, ~ ~ eb1 ~")
.sound("sawtooth")
.cutoff("200 400")
.resonance(10)
```

**Funkinis Bosas:**

```javascript
note("c2 ~ c3 ~ eb2 ~ c2 eb2")
.sound("triangle")
.gain("1 0 0.7 0 0.8 0 0.9 0.8")
```

**Dubstep Wobble:**

```javascript
note("c1!4")
.sound("sawtooth")
.cutoff(sine.range(200, 2000).slow(0.125))
.resonance(20)
```

**808 Sub Bosas:**

```javascript
note("c1 ~ ~ ~, ~ ~ c1 ~")
.sound("808bd")
.speed(0.5)
.lpf(100)
```

**Acid Bosas (303 stilius):**

```javascript
note("c2 d2 [eb2 f2] d2")
.sound("square")
.cutoff(saw.range(300, 3000))
.resonance(15)
.slide("<0 0.5 -0.5>")
```

**Drum & Bass Reese:**

```javascript
note("c1 ~ g1 ~")
.sound("sawtooth")
.cutoff(400)
.detune("0 5 -5") // nedidelis derinimo pokytis pločiui
```

## 🎹 3. MELODIJA - Harmoniškasis Turinys

Pagrindinės Melodijos

```javascript
// Paprasta melodija
note("c4 e4 g4 e4").sound("piano")

// Skirtingi sintetizatoriaus garsai
note("c4 d4 e4 g4").sound("sine")
note("c4 d4 e4 g4").sound("triangle")
note("c4 d4 e4 g4").sound("gtr") // gitara
note("c4 d4 e4 g4").sound("superpiano")
```

Gamtos ir Muzikos Teorija

```javascript
// Naudojant gamtas (lengviau nei įsiminti natas!)
"<0 2 4 5>".scale("C:major").sound("piano")

// Skirtingos gamtos
"0 1 2 3 4".scale("C:minor").sound("piano")
"0 1 2 3 4".scale("C:dorian").sound("piano")
"0 1 2 3 4".scale("C:phrygian").sound("piano")
"0 1 2 3 4".scale("C:pentatonic").sound("piano")

// Akordų progresijos
"<[0,2,4] [5,7,9] [3,5,7] [5,7,9]>"
.scale("C:major")
.sound("piano")
```

### Melodijos Stiliai

**Ambient Pad:**

```javascript
"[0,2,4,7]".scale("C:minor")
.sound("sine")
.slow(4)
.room(0.9)
.size(0.9)
.gain(0.6)
```

**Arpedžai:**

```javascript
"0 2 4 7 4 2".scale("C:major")
.sound("triangle")
.fast(2)
.delay(0.5)
.delaytime(0.125)
```

**Lead Sintezatorius:**

```javascript
"<0 3 5 7>".scale("C:minor")
.sound("square")
.cutoff(2000)
.resonance(10)
.room(0.3)
```

**Skambinimas:**

```javascript
"0 2 4 5 4 2".scale("G:major")
.sound("gtr")
.decay(0.1)
.release(0.1)
```

## 🎛️ 4. EFEKTAI - Poliravimas ir Erdvė

### Laiko Pagrįsti Efektai

**Delay (Aidas):**

```javascript
sound("cp").delay(0.5) // delay kiekis
.delaytime(0.25) // delay laikas (ketvirtinė nata)
.delayfeedback(0.6) // pakartojimų skaičius
Reverb (Erdvė):
```

```javascript
sound("sd")
.room(0.7) // reverb kiekis
.size(0.8) // kambario dydis
```

### Filtro Efektai

**Lowpass Filtras:**

```javascript
sound("hh*8").lpf(2000) // pašalina dažnius virš 2000Hz
```

**Highpass Filtras:**

```javascript
sound("bd").hpf(100) // pašalina dažnius žemiau 100Hz
```

**Bandpass Filtras:**

```javascript
sound("~ sd").bpf(1000) // palieka tik dažnius apie 1000Hz
```

**Rezonansinis Filtras:**

```javascript
note("c1").sound("sawtooth")
.cutoff(500)
.resonance(20) // pabrėžia cutoff dažnį
```

Iškraipymo Efektai

```javascript
// Distortion (iškraipymas)
sound("bd sd").distort(0.5) // 0-1

// Crush (bitcrusher)
sound("hh*8").crush(4) // bitų gylio sumažinimas

// Shape (bangos formavimas)
sound("bd").shape(0.6)
```

### Moduliacijos Efektai

**Vibrato (aukščio moduliacija):**

```javascript
note("c4").sound("sine")
.vibrato(4) // greitis
.vibratoDepth(0.5) // kiekis
Tremolo (garsumo moduliacija):
```

```javascript
note("c4").sound("sine")
.tremolo(8)
.tremolodepth(0.8)
```

**Phaser:**

```javascript
sound("hh*8")
.phaser(4)
.phaserdepth(1)
```

### Dinaminiai Efektai

**Gain (Garsumas):**

```javascript
sound("bd sd").gain("1 0.7")
Pan (Stereo):
```

```javascript
sound("hh*8").pan(sine.slow(2)) // auto-pan kairė/dešinė
```

**Kompresija:**

```javascript
sound("bd sd").compress(0.8)
```

Efektų Moduliacija su LFO

```javascript
// Sinusinė banga moduliacijai
sound("hh*8").cutoff(sine.range(500, 5000).slow(4))

// Pjūklo banga moduliacijai
note("c1").sound("sawtooth").cutoff(saw.range(200, 2000))

// Kosinusas (pasislinkęs sinusas)
sound("bd").gain(cosine.range(0.5, 1))

// Perlin triukšmas (lygus atsitiktinis)
sound("sd").pan(perlin.range(0, 1))
```

### 🔊 VISI EFEKTAI - PILNAS PAAIŠKINIMAS

Dabar paaiškinsiu kiekvieną efektą paprastai, kad suprastų net nemuzikas.

### FILTRAI - Tono Formavimas

Filtrai kaip boso/aukštųjų dažnių rankenėlės ant stereo sistemos.

### lpf - Lowpass Filtras (Patamsina/Užtramdo)

Paprastas paaiškinimas: Pašalina aukštus garsus, palieka žemus dundesį

```javascript
// Normalus hi-hat (šviesus, traškus)
sound("hh*8")

// Tamsus hi-hat (užtramtytas, tarsi po vandeniu)
sound("hh*8").lpf(1000)

// Labai užtramtytas (tarsi per pagalvę)
sound("hh*8").lpf(300)
```

**Kada naudoti:**

### Sumažinti lėkščių aštrumą

### Sukurti "po vandeniu" arba "toli" efektą

### Pašalinti šviesumą iš bet kokio garso

Padaryti bosą "riebesnį" pašalinant aukštą traškėjimą

Realaus pasaulio analogija: Uždėti antklodę ant garsiakalbio

### hpf - Highpass Filtras (Plonina/Šviesina)

Paprastas paaiškinimas: Pašalina žemus dundesius, palieka aukštus garsus

```javascript
// Normalus kick būgnas (gilus dundėjimas)
sound("bd")

// Plonas kick būgnas (tik spragtelėjimas, be dundėjimo)
sound("bd").hpf(200)

// Super plonas (beveik išnykęs)
sound("bd").hpf(500)
```

**Kada naudoti:**

### Pašalinti dundėjimą/drumstumą iš garsų

Padaryti dalykus skambant "skardiniai" (kaip telefono garsiakalbis)

### Palikti erdvės boso instrumentams

Sukurti "radijo balso" efektą

Realaus pasaulio analogija: Klausymas per mažą telefono garsiakalbį

### cutoff + resonance - Slenkantis Filtras (Wah-Wah Efektas)

Paprastas paaiškinimas: Kaip lpf, bet galite priversti jį "dainuoti" sustiprindami vieną dažnį

```javascript
// Statinė wah pozicija
note("c2").sound("sawtooth").cutoff(800).resonance(10)

// Judanti wah (wobble bosas)
note("c1").sound("sawtooth")
.cutoff(sine.range(200, 2000).fast(4))
.resonance(20)

// Klasikinis acid garsas (TB-303)
note("c2 d2 eb2 f2").sound("square")
.cutoff(1000).resonance(15)
```

**Kada naudoti:**

### Sukurti "wah-wah" gitaros pedalo efektą

### Padaryti "wobble" bosą (dubstep)

### Animuotus, judančius garsus

70-ųjų funk garsus

### IŠKRAIPYMAS - Grubumas

### distort - Švelnusis Iškraipymas (Šiluma/Grubumas)

Paprastas paaiškinimas: Daro dalykus neaiškius ir garsesnius, kaip perdarytas garsiakalbis

```javascript
// Švarus kick
sound("bd")

// Šiek tiek neaiškus kick
sound("bd").distort(0.3)

// Labai iškraipytas kick (metalas/rokas)
sound("bd").distort(0.8)
```

**Kada naudoti:**

### Pridėti "šilumą" arba "analoginį" jausmą

### Padaryti būgnus galingesnius

### Sukurti agresyvius/grubius garsus

Gitarinio stiprintuvo efektai

### crush - Bitcrusher (Vaizdo Žaidimas/Lo-Fi Efektas)

Paprastas paaiškinimas: Daro dalykus skambant kaip seni vaizdo žaidimai ar pigi elektronika

```javascript
// Normalus būgnas
sound("bd sd")

// Vaizdo žaidimo būgnas
sound("bd sd").crush(4)

// Ekstremalus 8-bitų garsas
sound("bd sd").crush(2)
```

**Kada naudoti:**

### Retro vaizdo žaidimų garsai (NES, Game Boy)

### "Lo-fi" hip-hop estetika

### Sugadintos elektronikos efektas

Vintage kompiuterio garsai

### LAIKO EFEKTAI - Erdvė ir Aidai

### delay + delaytime + delayfeedback - Aidas

Paprastas paaiškinimas: Sukuria pasikartojantiaidus, kaip šaukimas kanjone

```javascript
// Vienas aidas
sound("cp").delay(0.5).delaytime(0.25).delayfeedback(0.3)

// Keli aidai
sound("cp").delay(0.6).delaytime(0.25).delayfeedback(0.7)

// Begalinis aidas (dub/reggae stilius)
sound("cp").delay(0.7).delaytime(0.375).delayfeedback(0.9)
```

**Trys rankenėlės paaiškinti:**

### delay: Koks garsus aidas (0=be aido, 1=labai garsus aidas)

delaytime: Kokiu atstumu aidai atskirti (0.25 = ketvirtadalis takto)

delayfeedback: Kiek kartų kartojasi (0.3=keli pakartojimais, 0.9=daug pakartojimų)

**Kada naudoti:**

### Sukurti ritminius aidus

### Pridėti gylį ir erdvę

### Dub reggae efektai

Padaryti vieniškus garsus didesniais

Realaus pasaulio analogija: Šaukimas kanjone ir girdint aidus

### room + size - Reverb (Kambario Garsas)

Paprastas paaiškinimas: Daro taip, kad skamba, jog grojate kambaryje/salėje/katedroje

```javascript
// Sausas (be kambario)
sound("sd").room(0)

// Maža vonios kambarys
sound("sd").room(0.4).size(0.3)

// Koncertų salė
sound("sd").room(0.7).size(0.8)

// Katedra/milžiniška erdvė
sound("sd").room(0.9).size(0.95)
```

**Dvi rankenėlės:**

### room: Kiek reverb (0=nieko, 1=skenduoja reverb)

size: Kokio dydžio kambarys (0.2=spintelė, 0.9=katedra)

**Kada naudoti:**

### Padaryti dalykus skambant "profesionaliai"

### Pridėti gylį ir matmenį

### Sukurti ambient/atmosferinius garsus

Padaryti garsus mažiau "sausus" ir natūralesnius

### STEREO - Kairės ir Dešinės Garsiakalbio Valdymas

### pan - Stereo Pozicija

Paprastas paaiškinimas: Perkelia garsą tarp kairės ir dešinės garsiakalbių

```javascript
// Toli kairėje garsiakalbis
sound("bd").pan(0)

// Centre (abu garsiakalbiai)
sound("bd").pan(0.5)

// Toli dešinėje garsiakalbis
sound("bd").pan(1)

// Judėjimas pirmyn atgal (auto-pan)
sound("hh*8").pan(sine.slow(2))

// Skirtingi būgnai skirtingose vietose
sound("bd sd cp hh").pan("0.5 0.2 0.8 0.3")
```

**Kada naudoti:**

### Paskleisti garsus per stereo lauką

### Sukurti plotį jūsų mikse

### Įdomūs kairės-dešinės judesiai

Atskirti panašius garsus

### GARSUMAS - Kaip Garsūs Dalykai

### gain - Garsumo Valdymas

Paprastas paaiškinimas: Daro dalykus garsesnius ar tyliau

```javascript
// Normalus garsumas
sound("bd").gain(1)

// Tyliai
sound("hh*8").gain(0.3)

// Garsiai
sound("bd").gain(2)

// Ritmo kūrimas su garsumu (akcentai)
sound("bd bd bd bd").gain("1 0.5 0.7 0.5")
```

**Skaičiai:**

### 0 = tyla

### 0.5 = pusė garsumo

### 1 = normalus garsumas

2 = dvigubai garsiau

### AUKŠTIS - Kaip Aukštai ar Žemai Skamba

### speed - Atkūrimo Greitis (Keičia Aukštį)

Paprastas paaiškinimas: Privertė samples groti greičiau/lėčiau, keičiant aukštį kaip pagreitintą/sulėtintą įrašą

```javascript
// Normalus
sound("bd").speed(1)

// Aukštesnis aukštis (voveraitė)
sound("bd").speed(2)

// Žemesnis aukštis (sulėtintas)
sound("bd").speed(0.5)

// Atgal
sound("bd").speed(-1)

// Skirtingi aukščiai
sound("bd bd bd bd").speed("1 1.5 2 0.75")
```

**Kada naudoti:**

### Pakeisti būgnų samples aukštį

### Sukurti voveraitės/lėto judesio efektus

### Groti samples atgal

Padaryti vieną sample į daug aukščių

### note - Muzikinės Natos (Sintezatoriams)

Paprastas paaiškinimas: Pasako sintezatoriams, kokią muzikos natą groti

```javascript
// Groti vidurinį C
note("c4").sound("sine")

// Groti melodiją (c, d, e, f)
note("c4 d4 e4 f4").sound("sine")

// Žemos natos (bosas)
note("c1 c1 eb1 f1").sound("sawtooth")

// Aukštos natos
note("c6 e6 g6").sound("sine")
```

**Natų pavadinimas:**

### Raidės: c, d, e, f, g, a, b (muzikinės natos)

Skaičiai: 1-8 (oktava - kaip žema/aukšta)

### 1-2 = bosas (dundėjimas)

### 3-4 = vidurys (melodija)

5-7 = aukštas (diskant)

Diežai (#) ir bemoliai (b): c# = tarp c ir d

### 📐 VOKAS - Garso Forma Laikui Bėgant

Galvokite apie tai kaip apie "gyvenimo istoriją" kiekvieno garso - kaip jis prasideda, išsilaiko ir baigiasi.

### attack - Išryškinimo Laikas

Paprastas paaiškinimas: Kiek laiko trunka garsui pasiekti pilną garsumą

```javascript
// Momentinis (spragtelėjimas, būgno smūgis)
note("c4").sound("sine").attack(0)

// Lėtas išryškinimas (švelnus)
note("c4").sound("sine").attack(1)

// Labai lėtas (ambient swell)
note("c4").sound("sine").attack(4)
```

**Kada naudoti:**

0 sekundžių = būgnai, spragtelėjimai, perkusija (momentinis)

### 0.01-0.1 = fortepijonas, gitara (greitas)

### 0.5-2 = padai, styginiai (švelnūs)

2-8 = ambient išsiplėtimai (labai lėtas)

### release - Išblukimo Laikas

Paprastas paaiškinimas: Kiek laiko trunka išblukti po garso pabaigos

```javascript
// Greitas nutraukimas (staccato)
note("c4 e4 g4").sound("sine").release(0.05)

// Natūralus išblukimas
note("c4 e4 g4").sound("sine").release(0.3)

// Ilga uodega (panašus į reverb)
note("c4").sound("sine").release(4)
```

**Kada naudoti:**

### 0.01-0.1 = trumpas, stiprus (būgnai)

### 0.2-0.5 = natūralus (dauguma instrumentų)

1-8 = išlaikytas, ambient

### decay + sustain - Vidurinis Garso Dalis

Paprastas paaiškinimas: Po atakos garsas gali nukristi į žemesnį lygį (decay) ir išsilaikyti ten (sustain)

```javascript
// Skambinamas garsas (be sustain)
note("c4 e4 g4").sound("sine")
.attack(0).decay(0.3).sustain(0).release(0.1)

// Išlaikytas garsas (vargonai)
note("c4").sound("sine")
.attack(0.1).decay(0.1).sustain(1).release(0.5)

// Varpas garsas (lėtas decay)
note("c5").sound("sine")
.attack(0).decay(3).sustain(0).release(0.1)
```

### 🎨 SPECIALŪS EFEKTAI

### tremolo - Garsumo Svyravimas

Paprastas paaiškinimas: Garsumas kyla ir krenta ritmiškai

```javascript
// Lėtas svyravimas
note("c4").sound("sine").tremolo(2).tremolodepth(0.5)

// Greitas svyravimas
sound("hh*4").tremolo(8).tremolodepth(0.8)

// Sraigtasparnio efektas
note("c4").sound("sine").tremolo(16).tremolodepth(1)
```

**Kada naudoti:**

### Vintage stiprintuvo efektas

### Ritminis pulsavimas

### Sraigtasparnio garsai

Pridėti judėjimą statiniams garsams

### vowel - Priversti Sintezatorius "Kalbėti"

Paprastas paaiškinimas: Privertė sintezatorius skambėti, tarsi jie dainuotų balses (a, e, i, o, u)

```javascript
// Sakyti "a"
note("c2").sound("sawtooth").vowel("a")

// Kalbantis sintezatorius (a-e-i-o-u)
note("c2!4").sound("sawtooth").vowel("<a e i o u>")

// Greitas kalbėjimas
note("c2*8").sound("square").vowel("a e i o a e i o")
```

\`\`\`

### \*\*Kada naudoti:\*\*

### - Sukurti "kalbančio" sintezatoriaus garsus

### - Pridėti charakterį bosui

### - Vokalinės raiškos

- Funky, išraiškingų garsų

---

## 🎛️ GREITA INFORMACIJA

### ### Šviesumas/Tonas

- \`lpf(1000)\` - tamsesnis, užtramtytas (žemesnis = tamsesnis)

- \`hpf(200)\` - plonesnis, šviesesnis (aukštesnis = plonesnis)

- \`cutoff(800).resonance(10)\` - wah-wah efektas

### ### Grubumas/Tekstūra

### - \`distort(0.5)\` - neaiškus, šiltas (0-1)

- \`crush(4)\` - vaizdo žaidimo garsas (1-16, žemesnis = labiau sutraiškytas)

### ### Erdvė/Gylis

### - \`delay(0.5)\` - aido efektas (0-1)

- \`room(0.5).size(0.7)\` - kambario dydis (0-1 abu)

### ### Pozicija

- \`pan(0.5)\` - stereo pozicija (0=kairė, 0.5=centras, 1=dešinė)

### ### Garsumas

- \`gain(1)\` - garsumas (0=tyliai, 1=normalus, 2=garsiai)

### ### Aukštis

- \`speed(1)\` - atkūrimo greitis (0.5=lėtas/žemas, 2=greitas/aukštas)

- \`note("c4")\` - muzikinė nata (c1=žemas bosas, c4=vidurys, c6=aukštas)

### ### Garso Forma

### - \`attack(0.1)\` - išryškinimo laikas sekundėmis

- \`release(0.3)\` - išblukimo laikas sekundėmis

---

## 🎼 MELODIJOS, AKORDAI IR PROGRESIJOS

### Natų Supratimas

### \*\*Muzikinė abėcėlė:\*\*

### \`\`\`

### C - D - E - F - G - A - B - (atgal į C)

Tai yra! Tik 7 raidės, kurios kartojasi. Po B grįžtate į C.

Oktavos (Kaip Aukštai ar Žemai)

```javascript
// Labai žemai (sub bosas)
note("c1 d1 e1")

// Žemai (bosas)
note("c2 d2 e2")

// Viduryje (melodijos diapazonas)
note("c3 d3 e3")
note("c4 d4 e4")  // c4 = "vidurinis C" fortepijone

// Aukštai (melodija)
note("c5 d5 e5")

// Labai aukštai (šviesūs lyderiai)
note("c6 d6 e6")
```

Taisyklė: Didesnis skaičius = aukštesnis aukštis

### Diežai (#) ir Bemoliai (b)

Paprastas paaiškinimas: "Juodi klavišai" fortepijone (natos tarp)

```javascript
// Natūralios natos (balti klavišai)
note("c d e f g a b")

// Diežai - pustoniu AUKŠTYN
note("c# d# f# g# a#")

// Bemoliai - pustoniu ŽEMYN
note("db eb gb ab bb")

// Jie yra tas pats garsas!
note("c#") // tas pats kaip note("db")
note("f#") // tas pats kaip note("gb")
```

### 🎹 AKORDŲ GROJIMAS

Kas yra Akordas?

### Paprastas paaiškinimas: 3+ natų grojimas vienu metu

**Strudel naudokite laužtinius skliaustus \[\] su kableliais:**

```javascript
// Viena nata
note("c4").sound("piano")

// Akordas (3 natos kartu)
note("[c4, e4, g4]").sound("piano")
```

### Pagrindiniai Akordų Tipai

**Durinis Akordas (Linksmas):**

```javascript
// C Durinis akordas: C + E + G
note("[c4, e4, g4]").sound("piano")

// D Durinis: D + F# + A
note("[d4, f#4, a4]").sound("piano")

// G Durinis: G + B + D
note("[g4, b4, d4]").sound("piano")
```

**Molinis Akordas (Liūdnas):**

```javascript
// C Molinis akordas: C + Eb + G
note("[c4, eb4, g4]").sound("piano")

// A Molinis: A + C + E
note("[a3, c4, e4]").sound("piano")

// D Molinis: D + F + A
note("[d4, f4, a4]").sound("piano")
```

### Akordai Naudojant Gamtos Laipsnius (DAUG LENGVIAU!)

**Vietoj natų įsiminėjimo naudokite skaičius:**

```javascript
// Durinis akordas: 0, 2, 4 (pagrindas, 3-asis, 5-asis gamtos)
"[0, 2, 4]".scale("C:major").sound("piano")
// Tai automatiškai duoda jums C, E, G (C Durinis akordas)

// Tas pats šablonas, skirtinga raktas
"[0, 2, 4]".scale("G:major").sound("piano")
// Duoda jums G, B, D (G Durinis akordas)

// Molinis akordas: tie patys skaičiai, skirtinga gamta
"[0, 2, 4]".scale("A:minor").sound("piano")
// Duoda jums A, C, E (A Molinis akordas)
```

### 🎵 AKORDŲ PROGRESIJOS

Akordų progresijos yra VISOS populiarios muzikos pagrindas.

### "Pop Tobulybė" Progresija (I - V - vi - IV)

Naudojama: 1000+ hitų dainų (Let It Be, Don't Stop Believin', Someone Like You, ir kt.)

```javascript
// Romos skaitmenys į gamtos laipsnius:
// I = 0, V = 4, vi = 5, IV = 3

"<[0,2,4] [4,6,8] [5,7,9] [3,5,7]>"
  .scale("C:major")
  .sound("piano")
  .slow(4)  // kiekvienas akordas trunka 1 ciklą

// Skirtingame rakte
"<[0,2,4] [4,6,8] [5,7,9] [3,5,7]>"
  .scale("G:major")
  .sound("piano")
  .slow(4)
```

Kaip tai skamba: Kiekviena pop baladė kada nors

### "Liūdna Daina" Progresija (i - VI - III - VII)

Naudojama: Emocionalios dainos, baladės

```javascript
"<[0,2,4] [5,7,9] [2,4,6] [6,8,10]>"
  .scale("A:minor")
  .sound("piano")
  .slow(4)

"50-ųjų Doo-Wop" (I - vi - IV - V)
```

Naudojama: Stand By Me, Earth Angel, Blue Moon

```javascript
"<[0,2,4] [5,7,9] [3,5,7] [4,6,8]>"
  .scale("C:major")
  .sound("piano")
  .slow(4)

"Canon" Progresija (I - V - vi - iii - IV - I - IV - V)
```

Naudojama: Pachelbel's Canon, daug pop dainų

```javascript
"<[0,2,4] [4,6,8] [5,7,9] [2,4,6] [3,5,7] [0,2,4] [3,5,7] [4,6,8]>"
  .scale("D:major")
  .sound("piano")
  .slow(8)

"Du Akordai Vamp" (i - VII)
```

Naudojama: Techno, house, minimali muzika

```javascript
"<[0,2,4] [6,8,10]>".scale("E:minor")
  .sound("sawtooth")
  .lpf(800)
  .slow(2)
```

### 🎸 ARPEDŽAI

Paprastas paaiškinimas: Akordo natų grojimas po vieną (vietoj visų kartu)

Pagrindinis Arpedžas

```javascript
// Akordas (visi vienu metu)
note("[c4, e4, g4]").sound("piano")

// Arpedžas (po vieną)
note("c4 e4 g4").sound("piano")

// Aukštyn ir žemyn
note("c4 e4 g4 e4").sound("piano")

// Pilna oktava
note("c4 e4 g4 c5 g4 e4").sound("piano")
```

### Arpedžo Šablonai

**Klasikinis Aukštyn Šablonas:**

```javascript
// Durinio akordo arpedžas
"0 2 4 7".scale("C:major").sound("piano").fast(2)

// Molinio akordo arpedžas
"0 2 4 7".scale("A:minor").sound("piano").fast(2)
```

**Aukštyn ir Žemyn (Lygus):**

```javascript
"0 2 4 7 4 2".scale("C:major").sound("piano").fast(2)
Kaitaliojantis (Šokinėjantis):
```

```javascript
"0 4 2 4 0 4 2 4".scale("G:major").sound("piano").fast(2)
```

### 🎚️ VALDYMO KOMANDOS

### stack() - Sluoksniuoti Kelis Šablonus

Paprastas paaiškinimas: Groti kelis šablonus vienu metu (kaip sluoksniai Photoshop)

```javascript
// Groti būgnus IR bosą kartu
stack(
  sound("bd sd bd sd"),           // būgnai
  note("c1 ~ eb1 ~").sound("sawtooth")  // bosas
)

// Pilnas išdėstymas
stack(
  sound("bd ~ bd ~"),                    // kick
  sound("~ sd ~ sd"),                    // snare
  sound("hh*8").gain(0.3),               // hi-hats
  note("c1 eb1 f1 g1").sound("sawtooth") // bosas
)
```

**Kada naudoti:**

### Kurti pilnas dainas

### Sluoksniuoti skirtingus instrumentus

### Atskirti šablono logiką

Išlaikyti kodą tvarkingą

### orbit() - Atskiri Efektų Kanalai

Paprastas paaiškinimas: Siųsti garsus į skirtingus efektų autobusus (kaip atskiri maišymo kanalai)

```javascript
// Visi tame pačiame kanale (efektai maišosi kartu)
stack(
  sound("bd sd").room(0.5),
  sound("hh*8").room(0.5)
)

// Atskiri kanalai (nepriklausomi efektai)
stack(
  sound("bd sd").orbit(0),              // sausi būgnai
  sound("hh*8").room(0.8).orbit(1),     // reverb hi-hats
  note("c4 e4").sound("sine").delay(0.6).orbit(2)  // delay melodija
)
```

### 12 prieinamų orbitų: 0-11

**Kada naudoti:**

### Išlaikyti būgnus sausus, kai melodija šlapia

### Atskiras apdorojimas kiekvienam elementui

### Geresnis maišymo valdymas

Išvengti efekto "purvo"

### .fast() - Pagreitinti Šabloną

Paprastas paaiškinimas: Priversti šabloną groti greičiau (2x, 4x, ir kt.)

```javascript
// Normalus greitis
sound("bd sd cp hh")

// 2x greičiau (groja du kartus tuo pačiu laiku)
sound("bd sd cp hh").fast(2)

// 4x greičiau
sound("bd sd cp hh").fast(4)

// Naudoti dvigubam laikui hi-hats
sound("hh cp hh cp").fast(2)

.slow() - Sulėtinti Šabloną
```

Paprastas paaiškinimas: Priversti šabloną groti lėčiau (pusė greičio, ketvirtadalis greičio, ir kt.)

```javascript
// Normalus greitis
sound("bd sd bd sd")

// Pusė greičio (užtrunka 2 ciklus)
sound("bd sd bd sd").slow(2)

// Ketvirtadalis greičio (užtrunka 4 ciklus)
sound("bd sd bd sd").slow(4)

// Naudoti padams
note("[c3,e3,g3,b3]").sound("sine").slow(4)

.every() - Taikyti Efektą Kas N Ciklų
```

Paprastas paaiškinimas: Daryti kažką ypatingo kas kelias kartus

```javascript
// Kas 4 ciklus, padaryti jį greitesnį
sound("bd sd bd sd").every(4, x => x.fast(2))

// Kas 2 ciklus, pridėti reverb
sound("cp ~ cp ~").every(2, x => x.room(0.8))

// Kas 3 ciklus, apversti
sound("bd sd cp hh").every(3, x => x.rev())

.sometimes() - 50% Atsitiktinė Tikimybė
```

Paprastas paaiškinimas: Kartais daryti kažką (atsitiktinė galimybė)

```javascript
// 50% tikimybė kiekviename cikle
sound("bd sd bd sd").sometimes(x => x.room(0.8))

// Keli kartais
sound("cp cp cp cp")
  .sometimes(x => x.fast(2))
  .sometimes(x => x.gain(1.5))

.rev() - Apversti Šabloną
```

Paprastas paaiškinimas: Groti šabloną atgal

```javascript
// Normalus: bd sd cp hh
sound("bd sd cp hh")

// Apverstas: hh cp sd bd
sound("bd sd cp hh").rev()

// Šaunu su melodijomis
note("c4 d4 e4 f4 g4").sound("piano").rev()
```

### rand - Atsitiktinis Skaičius (0-1)

Paprastas paaiškinimas: Atsitiktinė vertė tarp 0 ir 1, skirtinga kiekvieną kartą

```javascript
// Atsitiktinis panoramavimas
sound("cp cp cp cp").pan(rand)

// Atsitiktinis garsumas
sound("hh*8").gain(rand.range(0.3, 0.8))

// Atsitiktinis cutoff
note("c1").sound("sawtooth").cutoff(rand.range(200, 2000))
```

### <> - Kaitalioti/Cikluoti Per Variantus

Paprastas paaiškinimas: Kiekviename cikle perjungti į kitą variantą

```javascript
// Ciklas 1: bd, Ciklas 2: sd, Ciklas 3: bd, Ciklas 4: sd
sound("bd <sd cp>")

// Kaitalioti hi-hats
sound("hh*8").speed("<1 1.5 2>")

// Akordų progresijos
note("<[c4,e4,g4] [d4,f4,a4] [e4,g4,b4]>").sound("sine")
```

### sine / saw / square / tri - LFO Bangų Formos

Paprastas paaiškinimas: Automatinės judančios vertės (kaip rankenėlės besisukančios pačios)

```javascript
// Sinusinė banga (lygi aukštyn/žemyn)
sound("hh*8").cutoff(sine.range(500, 3000))

// Pjūklo banga (rampė aukštyn, nukrenta, kartojasi)
sound("bd").gain(saw.range(0.5, 1))

// Kvadratinė banga (įjungta/išjungta kaitaliojasi)
sound("hh*8").gain(square.range(0.3, 1))

// Trikampė banga (tiesinė aukštyn/žemyn)
note("c1").sound("sawtooth").cutoff(tri.range(200, 2000))

cps() - Ciklai Per Sekundę (Tempas)
```

Paprastas paaiškinimas: Kaip greitai ciklai groja (tempo valdymas)

```javascript
// Lėtai (0.5 ciklai per sekundę = 60 BPM)
sound("bd sd bd sd").cps(0.5)

// Vidutiniškai (1 ciklas per sekundę = 120 BPM)
sound("bd sd bd sd").cps(1)

// Greitai (2 ciklai per sekundę = 240 BPM)
sound("bd sd bd sd").cps(2)
```

**BPM konvertavimas į CPS:**

### 60 BPM = 0.5 cps

### 90 BPM = 0.75 cps

### 120 BPM = 1 cps

### 140 BPM = 1.17 cps

### 160 BPM = 1.33 cps

180 BPM = 1.5 cps

### 🎼 PILNŲ DAINŲ RAŠYMAS - STRUKTŪRA

### .when() - Groti Tik Per Konkrečius Ciklus

Paprastas paaiškinimas: "Groti šį šabloną TIK kai sąlyga yra teisinga"

```javascript
// Tik groti per 0-7 ciklus (pirmi 8 ciklai = intro)
sound("bd sd bd sd").when($ => $ < 8)

// Tik groti per 8-15 ciklus (posmas)
sound("bd ~ sd ~").when($ => $ >= 8 && $ < 16)

// Tik groti per 16-31 ciklus (priedainis)
sound("bd*2 sd bd*2 sd").when($ => $ >= 16 && $ < 32)
```

Pavyzdys: Paprasta Dainos Struktūra

```javascript
// Apibrėžkite liniją laiko
```

### const intro = $ => $ < 8 // 0-7 ciklai

### const posmas1 = $ => $ >= 8 && $ < 24 // 8-23 ciklai

const priedainis1 = $ => $ >= 24 && $ < 40 // 24-39 ciklai

### const posmas2 = $ => $ >= 40 && $ < 56 // 40-55 ciklai

const priedainis2 = $ => $ >= 56 && $ < 72 // 56-71 ciklai

const outro = $ => $ >= 72 // 72+ ciklai

### stack(

### // INTRO - minimalus

sound("bd ~ ~ ~").when(intro),

sound("~ ~ ~ hh").when(intro).gain(0.3),

### // POSMAS - grovas

sound("bd ~ sd ~").when($ => posmas1($) || posmas2($)),

sound("hh ~ hh ~").when($ => posmas1($) || posmas2($)).gain(0.4),

### // PRIEDAINIS - pilna energija

sound("bd ~ bd sd").when($ => priedainis1($) || priedainis2($)),

sound("hh\*8").when($ => priedainis1($) || priedainis2($)).gain(0.5),

### // BOSAS

### note("<c2 g2 a2 f2>")

### .sound("sawtooth")

### .lpf(300)

### .when($ => posmas1($) || posmas2($))

.slow(4),

### note("<c1 g1 a1 f1>")

### .sound("sawtooth")

### .lpf(800)

### .when($ => priedainis1($) || priedainis2($))

.slow(4),

### // AKORDAI - tik priedainyje

### "<\[0,2,4\] \[4,6,8\] \[5,7,9\] \[3,5,7\]>"

### .scale("C:major")

### .sound("sine")

### .gain(0.5)

### .room(0.6)

### .when($ => priedainis1($) || priedainis2($))

.slow(4),

### // MELODIJA - tik priedainyje

### note("c5 d5 e5 g5 e5 d5 c5 ~")

### .sound("square")

### .room(0.4)

### .delay(0.4)

### .when($ => priedainis1($) || priedainis2($))

.slow(2),

### // OUTRO - išblukimas

sound("bd ~ ~ ~").when(outro).slow(2),

sound("~ ~ hh ~").when(outro).gain(0.2)

).cps(1) // 120 BPM

### 🎨 HUMANIZACIJA - Padarykite Skambant Gyvai

Kompiuterinė muzika dažnai skamba "kieta" ir "tobula" - tai būtent tai, kas verčia ją skambėti netikrai. Tikri muzikantai turi netobulumų, ir tai yra tai, kas daro muziką jaučiasi GYVĄ.

### Pagrindinė Paslaptis: ATSITIKTINUMAS IR NETOBULUMAS

Humanizacijos raktas yra pridėti subtilų variaciją į viską.

### Laiko Humanizacija

degradeBy() - Atsitiktinai Pašalinti Natas

```javascript
// Robotiniai hi-hats (kiekvienas smūgis yra tikslus)
sound("hh*8").gain(0.4)

// Žmogiški hi-hats (kai kurie smūgiai praleisti atsitiktinai)
sound("hh*8").gain(0.4).degradeBy(0.2)  // 20% smūgių pašalinti
sometimes() - Kartais Variacijos
```

```javascript
// Kartais smogti stipriau (akcentai)
sound("hh*8")
  .gain(0.4)
  .sometimes(x => x.gain(0.7))

// Retai pridėti vaiduoklio natą
sound("bd ~ sd ~")
  .rarely(x => x.fast(2))
```

### Garsumo Humanizacija (Garsumo Variacijos)

Atsitiktinis Garsumas Per Smūgį

```javascript
// Robotinis (visi smūgiai to paties garsumo)
sound("hh*8").gain(0.4)

// Žmogiškas (atsitiktinis greitis)
sound("hh*8").gain(rand.range(0.3, 0.5))

// Platesnis diapazonas (daugiau dinamikos)
sound("bd sd bd sd").gain(rand.range(0.7, 1.2))
```

Perlin Triukšmas (Lygūs Atsitiktiniai Pakeitimai)

```javascript
// Laipsniškai garsumo pakeitimai (kvėpavimas, dinamika)
sound("hh*8").gain(perlin.range(0.3, 0.5))

// Puikiai veikia padams
note("[c3,e3,g3]").sound("sine")
  .gain(perlin.range(0.4, 0.6))
  .slow(4)
```

### Aukščio Humanizacija

Atsitiktinės Aukščio Variacijos

```javascript
// Tobulai derintas (robotinis)
note("c4 e4 g4").sound("piano")

// Šiek tiek išėjęs iš derinimo (žmogiškas/analoginis)
note("c4 e4 g4").sound("piano")
  .add(rand.range(-0.05, 0.05))  // ±5 centai
```

Analoginis Dryfas (Vintage Sintezatoriai)

```javascript
// Sintezatorius lėtai išeina iš derinimo
note("c1 c1 eb1 f1").sound("sawtooth")
  .add(perlin.range(-0.1, 0.1))  // lygus aukščio dryfas

// Keli osciliatoriai šiek tiek išėję iš derinimo
stack(
  note("c2").sound("sawtooth").add(0),
  note("c2").sound("sawtooth").add(0.05),
  note("c2").sound("sawtooth").add(-0.05)
).gain(0.4)  // momentinė analoginė šiluma!
```

### Sample Variacija (Apvalus Robinas)

Sample Pasirinkimas su n()

```javascript
// Tas pats kick kiekvieną kartą (nuobodu)
sound("bd*4")

// Skirtingi kick samples (įvairovė!)
sound("bd*4").n("0 1 2 3")

// Atsitiktinis kick pasirinkimas
sound("bd*4").n(choose([0, 1, 2, 3, 5]))

// Hi-hats su varija
sound("hh*8").n(rand.range(0, 7))
```

### Filtravimas Organiniam Jausmui

Lėti Filtro Šveitai

```javascript
// Statinis filtras (nuobodu)
sound("hh*8").lpf(2000)

// Kvėpuojantis filtras (gyvas!)
sound("hh*8").lpf(sine.range(1500, 3000).slow(4))

// Atsitiktinis filtro judėjimas
sound("hh*8").lpf(perlin.range(1000, 4000))
```

### Sodrumas ir Šiluma

Subtilus Sodrumas

```javascript
// Švarus (skaitmeninis)
sound("bd sd bd sd")

// Šiltas (analoginis)
sound("bd sd bd sd").distort(0.2)

// Traškus (juosta)
sound("bd sd bd sd").distort(0.3).shape(0.2)

// Vintage (lo-fi)
sound("bd sd bd sd").crush(6)
```

### Stereo Plotis (Mažiau Tobulas = Daugiau Tikras)

Atsitiktinis Panoramavimas

```javascript
// Centruotas (nuobodu)
sound("hh*8").pan(0.5)

// Judantis aplink (gyvas)
sound("hh*8").pan(rand)

// Lygus judėjimas
sound("hh*8").pan(perlin)
```

💡 PRO PATARIMAI

### Pradėkite subtiliai - per daug = netvarkinga, ne žmogiška

Naudokite perlin lygiems pakeitimams (filtrai, garsumas, pan)

### Naudokite rand per smūgio variaciją (greitis, aukštis)

### degradeBy(0.2-0.3) ant hi-hats = momentinis grovas

Derinkite 3-4 humanizacijos technikas geriausiai rezultatams

### Nedidelis sodrumas (distort 0.1-0.3) = analoginė šiluma

### Apvalus robinas samples (n()) = išvengti kulkosvaidžio

### Laiko variacija (±20ms) = didžiausias poveikis

### Nehumanizuokite kick per daug - turi būti tvirtas

Daugiau variacijos ant cimbalom/hats nei ant būgnų

### 📋 GREITA INFORMACIJA - HUMANIZACIJA

**Būgnams:**

```javascript
.gain(rand.range(0.8, 1.0))          // greičio variacija
.n(choose([0,1,2,3]))                // sample apvalus-robinas
.degradeBy(0.2)                       // vaiduoklio natos
.late(rand.range(-0.02, 0.02))       // laiko variacija
.distort(0.2)                         // analoginė šiluma
```

**Bosui:**

```javascript
.add(perlin.range(-0.05, 0.05))      // aukščio dryfas
.lpf(perlin.range(200, 500))         // filtro judėjimas
.distort(0.3)                         // sodrumas
.gain(rand.range(0.9, 1.0))          // dinamika
```

**Akordams/Padams:**

```javascript
.add(rand.range(-0.03, 0.03))        // išėjimas iš derinimo
.gain(perlin.range(0.4, 0.6))        // kvėpavimas
.room(perlin.range(0.5, 0.8))        // erdvės variacija
.pan(perlin)                          // lėtas panoramavimas
```
