// ctrl-enter to run selection
// ctrl-. to stop
// crtl-d for ducumentation of what's under the mouse
// ctrl-shift-? for help window

s.boot;
ServerOptions.outDevices;
s.quit;
{ [SinOsc.ar(440, 0, 0.2), SinOsc.ar(442, 0, 0.2)] }.play;


//////////////////////////////// from the book
s.boot;
s.quit;

// p.4
play({SinOsc.ar(LFNoise0.kr(12, 600, 1000.0), 0.3)});

//p.5
(play({
	RLPF.ar( Dust.ar([99,100]), LFNoise1.ar(1/[3,4], 1500, 1600), 0.02)
});)

(
{ var ctl = RLPF.ar(Saw.ar(5,0.1), MouseX.kr(2, 200, 1), MouseY.kr(0.01, 1, 1));
    SinOsc.ar(ctl * 200 + 400) * 0.1;
}.play;
)


//
(  // Figure 1.1
play({ var sines=10,speed=6;
	Mix.fill(sines, {
		arg x; Pan2.ar(
			SinOsc.ar(x+1*100,
				mul: max(0,
					LFNoise1.kr(speed) +
					Line.kr(1,-1,30))),
		rand2(1.0))})/sines})
)

(  // Figure 1.3
play({
	CombN.ar(
		SinOsc.ar(
			midicps(
				LFNoise1.ar(6,5,
					LFSaw.ar([5,5],0,3,80))),
			0, 0.4),
		1,0.3,2)})
)

(  // From Sect 1.6
{Blip.ar(440, LFNoise0.kr(3,12,14), 0.3)}.play
//{Blip.ar(425, LFNoise0.kr([50,60],12,14), 0.3)}.play
)

(  // From Sect 1.7
{PMOsc.ar(440,550,7)}.play
)

(
{PMOsc.ar(440, MouseY.kr(1,550), MouseX.kr(1,15))}.play
)



s.boot;
s.quit;
({ // Figure 1.4
	var rate = Line.kr(5,40,60);
Blip.ar(
		TRand.kr( 100, 150, Impulse.kr(rate)),
		TRand.kr(1,10, Impulse.kr(rate)),
		Linen.kr(Impulse.kr(rate), 0, 0.5, 1/rate)
	)
}.play)

// 1.4 modded
(
{
	var qp1 = Impulse.kr(Line.kr(1,20,60));
	Blip.ar(
		TRand.kr(100,1000, qp1),
		3, // TRand.kr( 1, 10,   qp1),
		Linen.kr(qp1, 0, 0.5, 1/Line.kr(1,20,10))
)}.play
)

( // figure 1.5
p= {
	r = Line.kr(1,20,60);
	//r = LFTri.kr(1/10)*3+7;
	t = Impulse.kr(r);
	t = Dust.kr(r);
	e = Linen.kr(t, 0,0.5,0.1);
	f = TRand.kr(1,10,t);
	// f = e+1*4;
	Blip.ar(f*100, f, e)
}.play
)
p.free;



(
{SinOsc.ar(440.0)}.play;
)

// figure 1.6
({
	r = Impulse.kr(10);
	c = TRand.kr(100,5000,r);
	m = TRand.kr(100,5000,r);
	PMOsc.ar(c, m, 12)*0.3
}.play)

({
	var rate = 4, carrier, modRatio;
	rate = Line.kr(2,10,0.4);
	carrier = LFNoise0.kr(rate)*500 +700;
	modRatio = MouseX.kr(1,2.0);
	PMOsc.ar([carrier, carrier*8], carrier*modRatio, rate)*0.3
}.play)


( SynthDef("inp", {
	arg freq=440;
	var out = SinOsc.ar(freq)*0.3;
	Out.ar(0,out)
}).play)

Synth("inp", ["freq", 2000]);


/// fig 1.7
(
SynthDef("crotale", {
	arg midi=60, tone=3, art=1, amp=0.8, pan=0;
	var env, out, mod, freq;
	freq=midi.midicps;
	env = Env.perc(0, art);
	mod = 5+(1/IRand(2,6));
	out = PMOsc.ar(freq, mod*freq,
		pmindex: EnvGen.kr(env, timeScale: art, levelScale:tone),
		mul: EnvGen.kr(env, timeScale:art, levelScale:0.3));
	out = Pan2.ar(out, pan);
	out = out * EnvGen.kr(env, timeScale:1.3*art, levelScale:Rand(0.1,0.5),  doneAction:2);
	Out.ar(0, out);
}).add;)

Synth("crotale", ["midi", rrand(48,72).round(1), "tone", rrand(1,6)]);



// section 1.10
~hou = Buffer.read(s, "C:\\Program Files\\SuperCollider-3.13.0\\sounds\\a.aiff");
~chou = Buffer.read(s, "C:\\Program Files\\SuperCollider-3.13.0\\sounds\\a.wav");

(
{PlayBuf.ar(1, ~hou)}.play;
//{PlayBuf.ar(1, ~chou)}.play;
)

// fig 1.8
({
	var rate, trigger, frames;
	frames = ~hou.numFrames;
	rate = [1,1.25];
	trigger = Impulse.kr(rate);
	PlayBuf.ar(1, ~hou, 1, trigger, frames*Line.kr(0,1,60)) *
		EnvGen.kr(Env.linen(0.01, 0.96, 0.01),trigger) *rate;
}.play;)

(
Task({
	a = ["C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B"];
	do(50, { arg count; p = rrand(36,72);
		0.1.wait;
	});
}).play
)


// Fig 1.13

/// fig 1.13
(
SynthDef("crotale", {
	arg midi=60, tone=3, ring=1, amp=0.8, pan=0;
	var env, out, mod, freq;
	freq=midi.midicps;
	env = Env.perc(0, ring);
	mod = 5+(1/IRand(2,6));
	out = PMOsc.ar(freq, mod*freq,
		pmindex: EnvGen.kr(env, timeScale: ring, levelScale:tone),
		mul: EnvGen.kr(env, timeScale:ring, levelScale:0.3));
	out = Pan2.ar(out, pan);
	out = out * EnvGen.kr(env, timeScale:1.3*ring, levelScale:Rand(0.1,0.5),  doneAction:2);
	Out.ar(0, out);
}).add;)


(
a = ["C","C#","D","Eb","E","F","F#","G","Ab","A","Bb","B"];
r = Task({
	inf.do({arg count;
		var midi, midi2, oct, density;
		density = 0.7;
		oct = [24,36,48].choose;
		midi = [0,2,3,5,6,9,11].choose + oct;
		if (density.coin, {
			[midi+oct, a.wrapAt(midi),
				Synth("crotale", ["midi", midi, "tone", rrand(5,15),
					"ring", rrand(0.1, 3.5), // "amp", rrand(0.3,0.6),
					"pan", 1.0.rand2 ]); ]
		},{});
		0.1.wait;
	})
}).start
)


// fig 1.15
({ var fund=220;
	Mix.ar([
		SinOsc.ar(220, mul:max(0.0, LFNoise1.kr(12))),
		SinOsc.ar(440, mul:max(0.0, LFNoise1.kr(12)))*(1/2),
		SinOsc.ar(660, mul:max(0.0, LFNoise1.kr(12)))*(1/3),
		SinOsc.ar(880, mul:max(0.0, LFNoise1.kr(12)))*(1/4),
		SinOsc.ar(1110, mul:max(0.0, LFNoise1.kr(12)))*(1/5),
		SinOsc.ar(1320, mul:max(0.0, LFNoise1.kr(12)))*(1/6)
])*0.3}.play
)


// fig 1.16
Array.fill(20, {arg cnt; cnt+1*110});

({ Mix.ar(
	Array.fill(12, {arg count; var harm;
		harm = count+1*110;
		SinOsc.ar(harm, mul: max([0,0], SinOsc.kr(count+1/4))*(1/(count+1)))})
)*0.7}.play
)


// fig 1.18
({ var scale,specs,freqs,amps,rings, numRes=5,bells=20, pan, dt;
	scale = [60,62,64,67,69].midicps;
	Mix.fill(bells, {
		freqs = Array.fill(numRes, {rrand(1,15)*(scale.choose - 36)});
		amps  = Array.fill(numRes, {rrand(0.3, 0.9)});
		rings = Array.fill(numRes, {rrand(1.0, 4.0)});
		specs = [freqs, amps, rings].round(0.01);
		pan = (LFNoise1.kr(rrand(3,6))*2).softclip;
		dt = Dust.ar(1/6, 0.03);
		Pan2.ar(Klank.ar(`specs, dt), pan)
	})
}.play;
)


// fig 1.19
(
SynthDef.new("blip2", {
	arg midi=60, tone=10, art=0.125, amp=0.2, pan=1;
	var out, temper, bp, eg;
	bp = Blip.ar(midi.midicps, tone);
	eg = EnvGen.kr(Env.perc(0.01, art));
	out = Pan2.ar(bp*eg, pan);
	DetectSilence.ar(out, doneAction:2);
	amp = amp - ((midi-60)*0.02);
	Out.ar(0, out*amp)
}).add;
)
s.boot
(
~inst = [0,0,0];
~pSeq = [0,0,0];
~scaleAdd = [4,5,11,nil, 10,3,6,nil];
~notes = ["C","C#","D","Eb","E","F","F#","G","Ab","A","Bb","B"];
~durations = [0.125, 0.125, 0.125, 0.25, 0.25, 0.5, 1.0];
~rout = Task({inf.do({
	arg cnt5;
	var steps, durSeq, harmSeq, paceSeq, fill1, pace;
	steps = rrand(3,5);

	//pace = 0.5 / (2**(cnt5%3));
	//paceSeq = Array.fill(9, { ~durations.choose * 0.5 });
	if (cnt5%2==0, {
		"\n mod4".post;
		~scale = ~scale.add(~scaleAdd.wrapAt((cnt5/6).round(1) -1));
	});
	if (cnt5%3==0, {
		~scale=[0,4,7,11];
		"\n mod12".post;
		3.do({arg cnt2;
	//		fill1 = Array.fill(steps, { ~scale.choose + [48,60].choose} );
			//~pSeq.wrapPut(cnt2, fill1);

		});
	});
	fill1 = Array.fill(steps, { ~scale.choose + [48,60].choose} );
	~pSeq.wrapPut(cnt5, fill1);
	harmSeq = Array.fill(steps  , {rrand(0.5,5.0).round(0.01)});
	durSeq = Array.fill(steps-1, {rrand(0.01,0.9).round(0.01)});
	if (cnt5>2, { ~inst.wrapAt(cnt5).stop });
	~inst.wrapPut(cnt5%3, Task({  inf.do({ arg cnt3;
		Synth("blip2", [
			\midi, ~pSeq.wrapAt(cnt5).wrapAt(cnt3),
			\tone, harmSeq.wrapAt(cnt3),
			\art, durSeq.wrapAt(cnt3),
			\amp, rrand(0.2, 0.6),
			\pan, cnt5.wrap(-1,2)]);
		0.125.wait;
	})}).start;
	);
	"\n iteration: ".post;
	cnt5.post;
	" steps: ".post;
	steps.post;
	" scale: ".post;
	~scale.post;
	"\n fill1:".post;
	fill1.post;
	"\n harmseq:".post;
	harmSeq.post;
	"\n durSeq:".post;
	durSeq.post;
	"\n pSeq:".post;
	~pSeq[0].post;
	"\n      ".post;
	~pSeq[1].post;
	"\n      ".post;
	~pSeq[2].post;
	"\n".post;
	2.wait;})
}).start;
)


	});
(
	Synth("blip2", [
		\midi, 60,
		\tone, 0.2,
		\art, 0.5,
		\amp, 0.4,
	\pan, 0.0]);
)
// vary frequency
{ StandardL.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }.play(s);

{ StandardL.ar(SampleRate.ir/2, MouseX.kr(0.9,4)) * 0.3 }.play(s);
// as a frequency control
{ SinOsc.ar(StandardL.ar(40, MouseX.kr(0.9,4))*800+900)*0.4 }.play(s);

(
// z and y are the same object
var y, z;
z = [1, 2, 3];
y = z.add(4);
z.postln;
y.postln;
)

(
var y, z;
z = [1, 2, 3, 4];
y = z ++ [7, 8, 9];
z.postln;
y.postln;
)

// play
(
SynthDef.new("snar", {
	arg midi=60, tone=10, art=0.125, amp=0.2, pan=1;
	var out, temper, bp, eg;
	bp = LFNoise.ar(midi.midicps, tone);
	eg = EnvGen.kr(Env.perc(0.01, art));
	out = Pan2.ar(bp*eg, pan);
	DetectSilence.ar(out, doneAction:2);
	amp = amp - ((midi-60)*0.02);
	Out.ar(0, out*amp)
}).add;
)


// fig 1.21 -- LFO vibrato
({
	var trigger, control, scale, offset;
	scale = 200;
	offset = 600;
	trigger = Impulse.kr(10);
	control = SinOsc.ar(0.4).scope("control");
	control = control * scale + offset;
	SinOsc.ar(freq: abs(control).poll).scope("audio")
}.play)


// fig 1.22
({
	var carrier, rate, trigger, modRatio, index, control, control2, env;
	rate = 10;
	trigger = Impulse.kr(rate);

	control = LFNoise0.kr(rate);
	carrier = ((control*24) + 60).round(3.0);
	carrier.poll(trigger, "carrier");

	control2 = LFNoise0.kr(rate);
	modRatio = ((control2*1.5)+4.5).round(1.0);
	index.poll(trigger, "modRatio");

	index = 10;
	carrier = carrier.midicps;
	modRatio.poll(trigger, "modRatio");
	PMOsc.ar(carrier, carrier*modRatio, index);
}.play)