Instrukcija live music coding / strudel.cc lietuvių kalba

// 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 „)

// 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(„„)
.sound(„sawtooth”)
.lpf(300)
.when($ => posmas1($) || posmas2($))
.slow(4),

note(„„)
.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