5.squared
squared(5)

var value; // local variable
value = 9;
value = value * 2;

(
var value;
value = 9;
value = value * 2;
)

(
~value = 9;
~value = ~value * 2;
~A; // Syntax error - unexpected classname
)

6 * 3 + 2 // 20
2 + 6 * 3 // 24!!!

// define it
(
~func = {
  var val;
  val = 5;
  val = val + 2;
};
)

// evaluate it
~func.value;

// `play` a function and fill it with one or more Unit Generators (UGens)
// in other words: functions *respond* to the `play` method
{ SinOsc.ar }.play;

// from docs
{ Blip.ar(Blip.kr(4, 5, 500, 60), 59, 0.1)!2 }.play;

// assign UGen to a global variable and call `free` to stop it.
~sine = { SinOsc.ar }.play;
~sine.free;

// stereo / multichannel are simply arrays of ugens
~sine = { [SinOsc.ar, SinOsc.ar] }.play;

// shorthand:
~sine = { SinOsc.ar.dup(2) }.play;

// even shorter: ! syntax shorthand
~sine = { SinOsc.ar!2 }.play;

// frequency, initial phase, amplitude factor, amplitude offset
SinOsc.ar(freq, phase, mul, add)

// plot it - argument is the amount of time to plot
~sine = { SinOsc.ar(300, pi, 1, 0) }.plot(0.02);

// arguments are either positional OR keyword OR mixed - useful to skip:
~sine = { SinOsc.ar(300, mul: 0.5, 0) }.play;

(
~sum = {
  var sig;
  sig = SinOsc.ar(400, mul: 0.2);
  sig = sig + SinOsc.ar(250, mul: 0.3);
  sig = sig + SinOsc.ar(1400, mul: 0.07);
}.play;
)

// or define 3 variables

(
~sum = {
  var sig1, sig2, sig3;
  sig1 = SinOsc.ar(400, mul: 0.2);
  sig2 = SinOsc.ar(250, mul: 0.3);
  sig3 = SinOsc.ar(1400, mul: 0.07);
  sig1 + sig2 + sig3
}.play;
)

(
~vib = {
  var sig, vib;
  vib = SinOsc.ar(6, mul: 20, add: 300);
  sig = SinOsc.ar(vib, mul: 0.2)!2;
}.play;
)

// less annoying way to specify a range: `range`!
(
~vib = {
  var sig, vib;
  vib = SinOsc.ar(6).range(280, 320);
  sig = SinOsc.ar(vib, mul: 0.2)!2;
}.play;
)

(
~vib = {
  var sig, mod;

  mod = LFSaw.ar(1).range(0, 500);
  sig = Pulse.ar(200 + mod, 0.5, 0.2)!2;
}.play;
)

(
x = {
  var sig;
  sig = SinOsc.ar([300, 400]); // the array "expands" outward => [ SinOsc.ar(300), SinOsc.ar(400) ]
  sig = sig * 0.2;
  sig = sig!2;
}.play;
)

// make a series of random impulses
// expand them to 8 channels of random density
// make a super simple Karplus Strong synth with a CombL
// right now we're hearing only the first two channels
// Mix mixes everything down to one channel
// to make a stereo dump we need to feed it an array formed like [ [a, b], [c, d], [e, f] ] => this will mix down to [ a + c + e, b + d + f]

(
{
  Mix.new(
    [
      CombL.ar(
        Dust.ar(
          Array.fill(8, {5.rand + 1})
          , 0.3),
        delaytime: Array.fill(8, {0.005 + 0.001.rand})
      )!2
    ]
  )
}.play;
)

x = [1, 2, 3, 4];

// 2 is added/multiplied/... to each individual item
x + 2; // [3, 4, 5, 6]
x * 2; // [2, 4, 6, 8]

// methods on arrays
[1, 2, 3, 4].squared; // [1, 4, 9, 16]
[1, 2, 3, 4].odd; // [true, false, true, false]
[1, 2, 3, 4].even; // [false, true, false, true]

[ ].collect {}

// collect
[1, 2, 3, 4].collect { arg num; num * 2; } // [1, 2, 3, 4]
// alternative for arg
[1, 2, 3, 4].collect { |num| num * 2; } // [1, 2, 3, 4]

x = [1, 2, 3, 4]
y = [1, 2, 3, 4].collect { |num| num.isPrime; } // [false, true, true, false]

// do - for side effects
// returns its RECEIVER, like Ruby's tap, capturing the result makes no sense
z = x.do { |num| num.isPrime.postln; } // prints [false, true, true, false], but RETURNS [1, 2, 3, 4]

// select - filter an array
x.select { |num| num.isPrime; } // [2, 3]

// reject - does the opposite
x.reject { |num| num.isPrime; } // [1, 4]

// any - boolean that returns true if at least one is true
[4, 5].any { |num| num.isPrime; } // true
[4, 6].any { |num| num.isPrime; } // false

// initialize with a given size
x = Array.new(5);

// initialize with an arithmetic series
x = Array.series(8, 5, 2); // 8 items, starting at 5, step 2 => [ 5, 7, 9, 11, 13, 15, 17, 19 ]
x = Array.series(8, 5, -2); // [ 5, 3, 1, -1, -3, -5, -7, -9 ]

// geometric series
x = Array.geom(8, 2, 2); // [ 2, 4, 8, 16, 32, 64, 128, 256 ]

// interpolate a range - like numpy (size, start, end)
x = Array.interpolation(8, 100, 150); // [ 100.0, 107.14285714286, 114.28571428571, 121.42857142857, 128.57142857143, 135.71428571429, 142.85714285714, 150.0 ]

// fill (size, scalar or function)
x = Array.fill(7, 4); // [4, 4, 4, 4, 4, 4, 4]
x = Array.fill(7, {"hello".scramble}) // [ hlleo, lhleo, olelh, heoll, lhole, ehlol, hello ]

10.rand; // integer in the range of 0-9

10.do({10.rand.postln}); // shorthand for [0, .... 9].do (similar to 10.times in Ruby)

// rrand - ranged rand - inclusive!
// equal "linear" probability
// accepts negative arguments
rrand(1, 100); // returns Integers
rrand(1, 100.0); // returns Floats
rrand(-50, 50);

// exprand - exponential distribution
// tend towards the lower number
// arguments must NOT cross 0
exprand(1, 100);
exprand(-2, 100); // nan
exprand(-2, -200); // is fine

Array.exprand(8, 1, 100);
Array.rand(8, 1, 100);

// ATTENTION !
Array.fill(8, rrand(1, 100)); // same random number copied 8 times - rrand is interpreted FIRST, then array is filled

Array.fill(8, {rrand(1,100)}); // function is evaluated every time

(1..100) // [1, ... 100] like a Ruby range
(1,4..100); // [1, 4, ... 100]

// function definition
(
f = {
  var sig;
  sig = SinOsc.ar(220);
  sig = sig * 8;
  sig = sig.softclip; // clip the signal back into range -1 .. 0
  sig = Pan2.ar(sig, 0, 0.2); // -1 = left, 1 = right
};
)

// function execution
// store the resulting synthesis process in a global variable
x = f.play;

x.free;

// function definition
(
f = {
  |freq=330, boost=4|
  var sig;
  sig = SinOsc.ar(freq);
  sig = sig * boost;
  sig = sig.softclip; // clip the signal back into range -1 .. 0
  sig = Pan2.ar(sig, 0, 0.2); // -1 = left, 1 = right
};
)

// function execution
// store the resulting synthesis process in a global variable
x = f.play;

// pairs of [\symbol, value]
x.set(\freq, exprand(50, 800));

// convert from MIDI to Hz
x.set(\freq, 50.midicps);

// choose from an array
x.set(\freq, (35,37..79).choose.midicps)



// similar to free, but fades out giving a "hidden" envelope that is created automatically on the synthesis function
x.release(1);

x.free;

// define initial arguments
x = f.play(args: [\freq, 250]);

60.midicps; // midi to "cycles per second"

// similar to free, but fades out giving a "hidden" envelope that is created automatically on the synthesis function
x.release(1);

(
f = {
  |freq=330, boost=4, pan=0, amp=0.1|
  var sig;
  sig = SinOsc.ar(freq);
  sig = sig * boost;
  sig = sig.softclip; // clip the signal back into range -1 .. 0
  sig = Pan2.ar(sig, pan, amp); // -1 = left, 1 = right
};
)

x = f.play(args: [\freq, (40,45..70).choose.midicps]);

// if played multiple times, only the last one (the one x is pointing to) is released
x.release(1);

// => use arrays
// generate 12 synths with randomized params
(
a = [];

12.do({
  a = a.add(
    f.play(
      fadeTime: exprand(3, 7), // NEW - attack time!
      args: [
        \freq, ((32,39..85).choose - ( [0, 2].choose )).midicps, // subtract either 0 or 2
      \boost, exprand(1,8),
      \pan, rrand(-0.8, 0.8),
      \amp, exprand(0.04, 0.1)
    ])
  );
})
)

// and release them one after the other
a.do({ |synth| synth.release(exprand(1,10)); })

s.plotTree

s.scope

(
~array = Array.exprand(5, 30, 300).round;

f = {
  |array, acc|
  if(array.isEmpty,
    acc,
    {
      var head;
      head = array.removeAt(0);
      acc = acc + head;
      f.(array, acc);
    }
  )
};

~array.postln;
f.(~array, 0).postln;
)

(
{
  [
    SinOsc.ar(100),
    SinOsc.kr(100)
  ]
}.plot(0.1);
)

(
~sound = {
  arg freq=330, boost=4, pan=0, amp=0.1, times=[0.01, 0.1];
  var sig, env;

  env = EnvGen.ar(
    Env.new(
      levels: [0, 1, 0],
      times: times,
      curve: [2, -8] // exponent
    ),
    doneAction: 2 // Done.freeSelf
  );
  sig = SinOsc.ar(freq);
  sig = sig * boost;
  sig = sig.softclip; // clip the signal back into range -1 .. 0
  sig = Pan2.ar(sig, pan, amp); // -1 = left, 1 = right
  sig = sig * env;
};

~recursion = {
  |array|
  if(array.isEmpty,
    {},
    {
      var head;
      head = array.removeAt(0);
      ~sound.play(args: head).onFree {
        ~recursion.(array);
      };
    }
  );
}

)

(
~array = 80.collect {
  |val|
  [\freq, ((32,39..85).choose - ( [0, 2].choose )).midicps,
    \boost, exprand(1,8),
    \pan, rrand(-0.8, 0.8),
    \amp, exprand(0.04, 0.1),
    \times, [exprand(0.01, 0.3), exprand(0.1, 1)]];
};
~recursion.(~array);
)

(
x = {
  var sig, env, freqenv;
  env = EnvGen.kr(
    Env.new(
      [0, 1, 0],
      [0.1, 0.3],
      [0, 0]

    )
  );
  freqenv = EnvGen.kr(
    Env.new(
      [15000, 500],
      [4],
      [-12]

    ), doneAction: 2
  );
  sig = Saw.ar(80);
  sig = LPF.ar(sig, freqenv);
  sig = sig * 0.2;
  sig = sig * env;
  sig = sig!2;
}.play;
)

(
f = {
  |gate=1|
  var sig, env;
  env = EnvGen.kr(
    Env.adsr(0.01, 0.3, 0.5, 1),
    gate
  );
  sig = SinOsc.ar(200);
  sig = sig * 0.2;
  sig = sig * env;
  sig = sig!2;
};
)

x = f.play(args: [\gate, 0]);

// start
x.set(\gate, 1);
// finish and trigger doneAction
x.set(\gate, 0);

// now can't start again -> remove doneAction

x.set(\gate, 1);

// have to free it myself now
x.free;

(
f = {
  |t_gate=1|
  var sig, env;
  env = EnvGen.kr(
    Env.perc(0.01, 0.5),
    t_gate
  );
  sig = SinOsc.ar(200);
  sig = sig * 0.2;
  sig = sig * env;
  sig = sig!2;
};
)

x = f.play(args: [\t_gate, 0]);

// since it is a `TrigControl` argument now, don't have to reset it to 0 since it automatically does that!
x.set(\t_gate, 1);

x.free;

(
x = {
  var sig;
  sig = LFSaw.ar((80,90..150)); // [80, 90, 100, .. 150]
  sig = LPF.ar(sig, 500);
  sig = sig * 0.1;
}.play;
)

// configure number of output channels
s.options.numOutputBusChannels = 8;

s.meter;
s.scope;

(
f = {
  |freq=100|
  var sig;
  sig = Pulse.ar(freq * [1, 1.01], 0.5, 0.04);

  //the SinOsc class requires an .ar method to create an audio rate instance.
  sig = sig + SinOsc.ar(freq * 1.5 * [1, 1.004], 0, 0.15);

  sig = sig + BrownNoise.ar(0.04!2);
  sig = sig * Line.ar(0,1,10);
}
)

x = f.play;

s.scope;

x = f.play(args: [\freq, 1250]);
x.set(\freq, 150);
x.set(\gate, 0, \fadeTime, 5);

(
// argument 2 is a `ugenGraphFunction`
SynthDef.new(\ocean, {
  |freq=100, gate=1, rel=3|
  var sig, env;
  sig = Pulse.ar(freq * [1, 1.01], 0.5, 0.04);

    env = EnvGen.kr(
    Env.asr(3, 1, rel, [1, -1]),
    gate,
    doneAction: 2
  );

  //the SinOsc class requires an .ar method to create an audio rate instance.
  sig = sig + SinOsc.ar(freq * 1.5 * [1, 1.004], 0, 0.15);

  sig = sig + BrownNoise.ar(0.04!2);
  sig = sig * env;

  // `bus` and signal
  Out.ar(0, sig);
}).add;
)

// don't need to call `play`!
x = Synth.new(\ocean);
x.free;

// with arguments
x = Synth.new(\ocean, [\freq, 250]);
x.set(\freq, 350);

// sending \gate and \fadeTime doesn't work, because they are generated by `Function.play`, only after adding a custom envelope
x.set(\gate, 0, \fadeTime, 5);

x.set(\gate, 0, \rel, 0.02);

s.meter;

(
// a MONO synth
SynthDef.new(\ocean, {
  |freq=100, gate=1, rel=3, out=0|
  var sig, env;
  sig = Pulse.ar(freq, 0.5, 0.04);

  env = EnvGen.kr(
    Env.asr(3, 1, rel, [1, -1]),
    gate,
    doneAction: 2
  );

  sig = sig + SinOsc.ar(freq, 0, 0.15);

  sig = sig + BrownNoise.ar(0.04);
  sig = sig * env;
  sig = sig!2;

  Out.ar(out, sig);
}).add;
)

// .new can be omitted
Synth(\ocean, [\out, 0]);

sig = sig!2;

Out.ar([0, 1], sig);

// 0 => sig, 1 => sig + sig, 2 => sig
// overlaps!

(
r =  Routine.new({
  "hello".postln;
  1.wait;
  "how are you ?".postln;
  3.wait;
  "good bye".postln;
});
)

// steps through them one by one
r.play;

// stops the routine, cannot be resumed
r.stop;

// start over
r.reset;

(
// a MONO synth
SynthDef.new(\ocean, {
  |freq=100, gate=1, atk=0.01, rel=1, out=0, pan=0|
  var sig, env;
  sig = Pulse.ar(freq, 0.5, 0.04);

  env = EnvGen.kr(
    Env.new([0, 1, 0], [atk, rel], [0, -4]),
    doneAction: 2
  );

  sig = sig + SinOsc.ar(freq, 0, 0.15);

  sig = sig + BrownNoise.ar(0.04);
  sig = sig * env;
  sig = Pan2.ar(sig, pan);

  Out.ar(out, sig);
}).add;
)

Synth(\ocean);

(
r = Routine.new({
  Synth(\ocean, [\freq, 60.midicps, \pan, rrand(-0.5, 0.5)]);
  wait(0.5);
  Synth(\ocean, [\freq, 62.midicps, \pan, rrand(-0.5, 0.5)]);
  wait(0.5);
  Synth(\ocean, [\freq, 67.midicps, \pan, rrand(-0.5, 0.5)]);
});
)

r.reset; r.play;

(
Routine.new({
  100.do {
    Synth(\ocean, [\freq, rrand(48, 72).midicps, \pan, rrand(-0.5, 0.5)]);
    wait(exprand(0.02, 0.5));
  }
}).play;
)

(
r = {
  inf.do {
    Synth(\ocean, [\freq, rrand(48, 72).midicps, \pan, rrand(-0.5, 0.5)]);
    wait(exprand(0.02, 0.5));
  }
}.fork;
)

(
r = Routine.new({
  {
    var num;
    num = rrand(48, 72);

    3.do {
      Synth(\ocean, [\freq, num.midicps, \pan, rrand(-0.5, 0.5)]);
      wait(0.15);
    };
    3.do {
      Synth(\ocean, [\freq, rrand(48, 72).midicps, \pan, rrand(-0.5, 0.5)]);
      wait(0.15);
    };
  }.loop;
}).play;
)

(
t = Task.new({
  {
    var num;
    num = rrand(48, 72);

    3.do {
      Synth(\ocean, [\freq, num.midicps, \pan, rrand(-0.5, 0.5)]);
      wait(0.15);
    };
    3.do {
      Synth(\ocean, [\freq, rrand(48, 72).midicps, \pan, rrand(-0.5, 0.5)]);
      wait(0.15);
    };
  }.loop;
});
)

t.start;
t.pause;
t.resume;

~brass = Buffer.read(s, "/Users/jrubisch/Documents/_CODE/100daysofcode/supercollider/samples/brass.wav");
~water = Buffer.read(s, "/Users/jrubisch/Documents/_CODE/100daysofcode/supercollider/samples/water.wav");

// only for debugging basically
~brass.play;

(
thisProcess.nowExecutingPath; // /Users/..../some_dir/my.scd
~path = PathName.new(thisProcess.nowExecutingPath).parentPath ++ "samples/"; // /Users/..../some_dir/samples

~brass = Buffer.read(s, ~path ++ "brass.wav");
~water = Buffer.read(s, ~path ++"water.wav");
)

~brass.plot;
~water.plot;

(
{
  var sig;
  sig = PlayBuf.ar(
    2,
    ~brass.bufnum,
    rate: 0.5,
    doneAction: 2 // for oneShot samples
  );

  sig = sig * 0.2;
}.play;
)

// created like so
Impulse.ar(100)
Dust.ar(100)

(
x = {
  |t_trig=1|
  var sig;
  sig = PlayBuf.ar(
    2,
    ~brass.bufnum,
    rate: BufRateScale.ir(~brass.bufnum) * 5.midiratio, // multiply with rate _here_
    trigger: Dust.kr(4),
    startPos: 300000,
    doneAction: 0 // to retrigger
  );

  sig = sig * 0.2;
}.play;
)

(
~path = PathName.new(thisProcess.nowExecutingPath).parentPath ++ "samples/"; // /Users/..../some_dir/samples

~brass = Buffer.read(s, ~path ++ "brass.wav");
~water = Buffer.read(s, ~path ++"water.wav");
)


(
SynthDef.new(\pb, {
  |buf=0, rate=1, t_trig=1, spos=0, loop=0, da=2, amp=0.5, out=0|
  var sig;
  sig = PlayBuf.ar(
    2,
    buf,
    rate: BufRateScale.ir(buf) * rate,
    trigger: t_trig,
    startPos: spos,
    loop: loop, 
    doneAction: da
  );

  sig = sig * amp;

  Out.ar(out, sig);
}).add;
)

Synth(\pb, [\buf, ~water]);

(
SynthDef.new(\pb1, {
  |buf=0, rate=1, t_trig=1, spos=0, loop=0, da=2, amp=0.5, out=0|
  var sig;
  sig = PlayBuf.ar(
    1,
    buf,
    rate: BufRateScale.ir(buf) * rate,
    trigger: t_trig,
    startPos: spos,
    loop: loop, 
    doneAction: da
  );

  sig = sig * amp!2;

  Out.ar(out, sig);
}).add;

SynthDef.new(\pb2, {
  |buf=0, rate=1, t_trig=1, spos=0, loop=0, da=2, amp=0.5, out=0|
  var sig;
  sig = PlayBuf.ar(
    2,
    buf,
    rate: BufRateScale.ir(buf) * rate,
    trigger: t_trig,
    startPos: spos,
    loop: loop, 
    doneAction: da
  );

  sig = sig * amp;

  Out.ar(out, sig);
}).add;
)

Synth(\pb2, [\buf, ~water]);

// random rate
(
z = 5.collect({
  Synth(\pb2, [
    \buf, ~water,
    \spos, ~water.numFrames * 0.5,
    \loop, 1,
    \rate, rrand(-0.5, 1.3)
  ]);
})
)

s.plotTree;

z.collect({ |n| n.free; });

// use iteration counter

(
z = 5.collect({
  |n|
  Synth(\pb2, [
    \buf, ~water,
    \spos, ~water.numFrames * 0.5,
    \loop, 1,
    \rate, n.midiratio
  ]);
})
)

// tenth of a semitone up
(
z = 5.collect({
  |n|
  Synth(\pb2, [
    \buf, ~water,
    \spos, ~water.numFrames * 0.5,
    \loop, 1,
    \rate, (n/10).midiratio,
    \amp, 0.15
  ]);
})
)

(
r = Routine.new({
  loop {
    // optional: bring in conditional logic to switch between mono and sstereo
    var buf;
    buf = [~water, ~brass].choose;
    if(
      buf.numChannels == 2,
      {
        Synth(\pb2, [
          \buf, buf,
          \spos, 0,
          \loop, 0,
          \da, 2,
          \rate, rrand(-12.0, 5.0).midiratio,
          \amp, 0.15
        ]);
      },
      {
        Synth(\pb1, [
          \buf, buf,
          \spos, 0,
          \loop, 0,
          \da, 2,
          \rate, rrand(-12.0, 5.0).midiratio,
          \amp, 0.15
        ]);
      }
      wait(1/3);
  }
  }).play;
)

r.stop;

(
SynthDef.new(\pb2env, {
  |buf=0, rate=1, t_trig=1, spos=0, loop=1, da=0, amp=0.5, out=0, atk=0.1, sus=0.5, rel=0.01|
  var sig, env;
  env = EnvGen.ar(
    Env.new(
      [0, 1, 1, 0],
      [atk, sus, rel],
      [0, 0, 0]
    ),
    doneAction: 2
  );
  sig = PlayBuf.ar(
    2,
    buf,
    rate: BufRateScale.ir(buf) * rate,
    trigger: t_trig,
    startPos: spos,
    loop: loop, 
    doneAction: da
  );

  sig = sig * env;
  sig = sig * amp;

  Out.ar(out, sig);
}).add;
)

)

(
Synth(\pb2env, [
  \buf, ~water,
  \spos, ~water.numFrames * 0.5
]);
)

(
r = Routine.new({
  loop {
    Synth(\pb2env, [
      \buf, ~brass,
      \spos, rrand(~water.numFrames * 0.3, ~water.numFrames * 0.6),
      \atk, 0.2,
      \sus, 0,
      \rel, 0.2
    ]);

    wait(rrand(0.05, 0.3));
  }
}).play;
)

r.stop;

(
var semi = -24;
r = Routine.new({
  loop {
    Synth(\pb2env, [
      \buf, ~brass,
      \spos, rrand(~water.numFrames * 0.3, ~water.numFrames * 0.6),
      \atk, 0.01,
      \sus, 0.2,
      \rel, 0.08,
      \rate, semi.midiratio
    ]);

    semi = semi + 1;
    if(semi > 0,
      { semi = rrand(-12, -2); }
    );

    wait([0.4, 0.2, 0.1].choose);
  }
}).play;
)

r.stop;

{BufRd.ar(2, ~brass, Line.ar(0, ~brass.numFrames - 1, ~brass.duration, doneAction: 2))}.play;

// backwards
{BufRd.ar(2, ~brass, Line.ar(~brass.numFrames - 1, 0, ~brass.duration, doneAction: 2))}.play;

// or any UGen
{BufRd.ar(2, ~brass, SinOsc.ar(1/~brass.duration).range(0, ~brass.numFrames - 1))}.play;

(
SynthDef.new(\drops, {
  |freqMin=100, freqMax=3000, gate=1, amp=0.3|
  var sig, trigEnv, env, freq, trig, reverb;

  freq = LFNoise1.kr(0.2!2).exprange(freqMin, freqMax);
  sig = SinOsc.ar(freq);

  trig = Dust.ar(1!2);
  trigEnv = EnvGen.ar(Env.perc(0.002, 0.1), trig);

  sig = sig * trigEnv;

  // add a reverb of 250m roomsize and 4 seconds reverb time
  reverb = GVerb.ar(sig, 250, 4);

  // lowpass filter it
  reverb = LPF.ar(reverb, 1200);

  // mix dry and wet
  sig = (sig + reverb) * 0.5;


  env = EnvGen.kr(Env.asr(0.01, 1, 1, -1), gate, doneAction: 2);
  sig = sig * env * amp;

  Out.ar(0, sig);
}).add;
)

x = Synth(\drops);

// reverb ends abruptly
x.set(\gate, 0);
x.free;

s.plotTree;

(
SynthDef.new(\drops, {
  |freqMin=100, freqMax=3000, gate=1, amp=0.3, out=0|
  var sig, trigEnv, env, freq, trig;

  freq = LFNoise1.kr(0.2!2).exprange(freqMin, freqMax);
  sig = SinOsc.ar(freq);

  trig = Dust.ar(1!2);
  trigEnv = EnvGen.ar(Env.perc(0.002, 0.1), trig);

  sig = sig * trigEnv;

  env = EnvGen.kr(Env.asr(0.01, 1, 1, -1), gate, doneAction: 2);
  sig = sig * env * amp;

  Out.ar(out, sig);
}).add;

SynthDef.new(\reverb, {
  |in=0, out=0|
  var sig, reverb;

  // bus, numChannels
  sig = In.ar(in, 2);
  reverb = sig.copy;

  // add a reverb of 250m roomsize and 4 seconds reverb time
  reverb = GVerb.ar(reverb, 250, 4);

  // lowpass filter it
  reverb = LPF.ar(reverb, 1200);

  // mix dry and wet
  sig = (sig + reverb) * 0.5;

  Out.ar(out, sig);
}).add;
)

// listening on bus...
r = Synth(\reverb, [\in, 48]);
// playing on bus...
d = Synth(\drops, [\out, 48]);

// reverb ends abruptly
d.set(\gate, 0);
d.free;

s.options.numOutputBusChannels; // 2  bus 0-1
s.options.numInputBusChannels; // 2 bus 2-3
s.options.numAudioBusChannels; // 1024
s.options.numPrivateAudioBusChannels; // 1024 - 2 - 2 = 1020

s.scope;

(
~path = PathName.new(thisProcess.nowExecutingPath).parentPath ++ "samples/";

~brass = Buffer.read(s, ~path ++ "brass.wav");
~water = Buffer.read(s, ~path ++ "water.wav");
)

(
SynthDef.new(\pb, {
  |buf=0, rate=1, t_trig=1, spos=0, loop=0, da=2, amp=0.5, out=0, atk=0.1, sus=0.5, rel=0.01|
  var sig, env;
  env = EnvGen.ar(
    Env.new(
      [0, 1, 1, 0],
      [atk, sus, rel],
      [0, 0, 0]
    ),
    doneAction: 2
  );
  sig = PlayBuf.ar(
    2,
    buf,
    rate: BufRateScale.ir(buf) * rate,
    trigger: t_trig,
    startPos: spos,
    loop: loop, 
    doneAction: da
  );

  sig = sig * amp * env;

  Out.ar(out, sig);
}).add;

SynthDef.new(\resonator, {
  |in=0, out=0, freq=440.0, q=10, decay=1.0, pan=0|
  var sig;

  // bus, numChannels
  sig = In.ar(in, 2);

  sig = Mix.ar(sig);

  sig = Resonz.ar(sig, freq: freq, bwr: 1/q); 

  sig = Pan2.ar(sig, pos: pan);

  Out.ar(out, sig);
}).add;
)


(
~freq = rrand(42, 72).midicps.postln;
~count = 16;
z = ~count.collect({
  |n|
  r = Routine.new({
    loop {
      Synth(\pb, [
        \buf, ~water,
        \spos, ~water.numFrames * rrand(0.2, 0.8),
        \atk, rrand(0.1, 0.7),
        \sus, exprand(0, 3),
        \out, (16 + (n * 2)),
        \rate, (-12..12).choose.midiratio
      ]);
      wait(rrand(0.15, 0.3));
    }
  }).play;

  Synth(\resonator, [
    \in, (16 + (n * 2)),
    \freq, ~freq,
    \pan, rrand(-0.8, 0.8)
  ]);
});
)

(
~path = PathName.new(thisProcess.nowExecutingPath).parentPath ++ "samples/";

~brass = Buffer.read(s, ~path ++ "brass.wav");
~water = Buffer.read(s, ~path ++ "water.wav");
)

(
SynthDef.new(\pb, {
  |buf=0, rate=1, t_trig=1, spos=0, loop=0, da=2, amp=0.5, out=0, atk=0.1, sus=0.5, rel=0.01|
  var sig, env;
  env = EnvGen.ar(
    Env.new(
      [0, 1, 1, 0],
      [atk, sus, rel],
      [0, 0, 0]
    ),
    doneAction: 2
  );
  sig = PlayBuf.ar(
    2,
    buf,
    rate: BufRateScale.ir(buf) * rate,
    trigger: t_trig,
    startPos: spos,
    loop: loop, 
    doneAction: da
  );

  sig = sig * amp * env;

  Out.ar(out, sig);
}).add;

SynthDef.new(\resonator, {
  |in=0, out=0, freq=440.0, bwr, gain, decay=1.0, pan=0|
  var sig;

  // bus, numChannels
  sig = In.ar(in, 2);

  // monofy
  sig = Mix.ar(sig);

  sig = Resonz.ar(sig, freq: freq, bwr: In.kr(bwr)); 

  sig = Pan2.ar(sig, pos: pan);

  sig = sig * In.kr(gain);

  Out.ar(out, sig);
}).add;

SynthDef.new(\mod, {
  |out_sh, out_gain|
  Out.kr(out_gain, XLine.kr(0.5, 4, 10));
  Out.kr(out_sh, Latch.kr((XLine.kr(5, 0.001, 10) + LFNoise1.kr(1).range(0.001, 0.01)), Impulse.kr(5)));
}).add;
)

(
~freq = rrand(60, 84).midicps.postln;
~count = 10;
~audioBuses = ~count.collect({Bus.audio(s, 2)});
~controlBuses = ~count.collect({Bus.control(s)});
~gainBuses = ~count.collect({Bus.control(s)});
~routines = [];
z = ~count.collect({
  |n|

  Synth(\mod, [\out_sh, ~controlBuses[n], \out_gain, ~gainBuses[n]]);

  ~routines.add(Routine.new({
    loop {
      Synth(\pb, [
        \buf, ~water,
        \spos, ~water.numFrames * rrand(0.2, 0.8),
        \atk, rrand(0.1, 0.7),
        \sus, exprand(0, 3),
        \out, ~audioBuses[n],
        \rate, (-12..12).choose.midiratio
      ]);
      wait(rrand(0.15, 0.3));
    }
  }));

  ~routines.collect { |r| r.play; };

  Synth(\resonator, [
    \in, ~audioBuses[n],
    \freq, ~freq,
    \gain, ~gainBuses[n],
    \bwr, ~controlBuses[n],
    \pan, rrand(-0.8, 0.8)
  ]);
});
)

~routines.collect { |r| r.stop; }
~routines.collect { |r| r.reset; r.play; }

~controlBuses.collect({ |b| b.free; });
~gainBuses.collect({ |b| b.free; });
~audioBuses.collect({ |b| b.free; });

s.scope;

~bus = Bus.audio(s, 2); // Bus(audio, 4, 2, localhost)  - index 4, 2 channels - starts at 4 because 0-3 are reserved by hardware
~bus2 = Bus.audio(s, 4); // Bus(audio, 6, 4, localhost)

// reset bus allocation counter
s.newBusAllocators;

// listening on bus...
r = Synth(\reverb, [\in, ~bus]);
// playing on bus...
d = Synth(\drops, [\out, ~bus]);

d.set(\gate, 0);

// NO SOUND!
d = Synth(\drops, [\out, ~bus]);
r = Synth(\reverb, [\in, ~bus]);

// FIXED with addAction
d = Synth(\drops, [\out, ~bus]);
r = Synth(\reverb, [\in, ~bus], addAction: \addToTail);

// FIXED by specifying a TARGET
// put it immediately after d
d = Synth(\drops, [\out, ~bus]);
r = Synth(\reverb, [\in, ~bus], target: d, addAction: \addAfter);

d.free;
r.free;

~grp0 = Group.new;
~grp1 = Group.new;
~grp2 = Group.new;

~grp0.free;
~grp1.free;
~grp2.free;

~grp = 10.collect({Group.new});


~srcGrp = Group.new;
~fxGrp = Group.new(~srcGrp, \addAfter);

d = Synth(\drops, [\out, ~bus], target: ~srcGrp);
p = Synth(\drops2, [\out, ~bus, \amp, 0.05], target: ~srcGrp);
r = Synth(\reverb, [\in, ~bus], target: ~fxGrp);

d.free;
p.free;

~srcGrp.set(\gate, 0);

(
SynthDef.new(\blip, {
  |freq=300, amp=0.4, pan=0, out=0|
  var sig, env;
  env = EnvGen.ar(Env.perc(0.002, 0.2), doneAction: 2);
  sig = SinOsc.ar(freq);
  sig = sig * env;
  sig = Pan2.ar(sig, pan, amp);
  Out.ar(out, sig);
}).add;
)


(
r = Routine.new({
  "hi".postln;
  1.wait;
  "hello".postln;
  2.wait;
  "bye".postln;
})
)

r.play;

// returns the value of `wait` or `yield`
r.next;

// use it to sequence frequencies
(
r = Routine.new({
  200.yield;
  300.yield;
  400.yield;
})
)

Synth(\blip, [\freq, r.next]);
r.reset();

(
r = Routine.new({
  var i = 0;
  loop {
    i.yield;
    i = i + 1;
  }
});
)

r.next;
r.reset;
r.nextN(10);

(
r = Routine.new({
  var i = 0;
  50.do {
    i.yield;
    i = i + 1;
  }
});
)
r.all; // beware of infinite loops!

p = Pseries(start: 0, step: 1, length: inf);
p.next; // doesn't work
q = p.asStream;

q.next;
q.nextN(10);


p = Pseries(start: 0, step: 1, length: 20);
q = p.asStream;
r = p.asStream;

q.all; // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
r.next; // 0

p = Pseq(list: [1, 14, 200, 97], repeats: 2).asStream;
p.nextN(10); // [ 1, 14, 200, 97, 1, 14, 200, 97, nil, nil ]

p = Prand(list: [1, 14, 200, 97], repeats: inf).asStream;
p.nextN(10); // [ 200, 1, 200, 1, 200, 14, 200, 97, 200, 97 ]

// exclusive rand - never 2 same items in a row
p = Pxrand(list: [1, 14, 200, 97], repeats: inf).asStream;
p.nextN(10); // [ 200, 1, 200, 1, 200, 14, 200, 97, 200, 97 ]

// choose a random order and repeat over
p = Pshuf(list: [1, 14, 200, 97], repeats: inf).asStream;
p.nextN(10); // [ 200, 97, 1, 14, 200, 97, 1, 14, 200, 97 ]

p = Pshuf(list: [1, 14, 200, 97], repeats: inf).asStream;
p.nextN(10);

p = Pseq([1, 2, 3, Prand([100, 200, 300], 1)], inf).asStream;
p.nextN(10); // [ 1, 2, 3, 200, 1, 2, 3, 300, 1, 2 ]

p = Pseq([1, 2, 3, Prand([100, 200, 300], inf)], inf).asStream;
// "stuck" in the internal infinite pattern
p.nextN(10); // [ 1, 2, 3, 300, 200, 200, 200, 300, 100, 100 ]

// -> a Pbinop / BinaryOpStream
p = (Pseq([1, 2, 3], inf) * Pseq([100, 200], inf)).asStream;
// 1 * 100, 2 * 200, 3 * 100, 1 * 200, 2 * 100, ...
p.nextN(10); // [ 100, 400, 300, 200, 200, 600, 100, 400, 300, 200 ]

p = Ptuple([Pbrown(1, 24, 4, inf), Pseries(0, 1, inf)]).asStream;
p.nextN(10); // [ [ 19, 0 ], [ 17, 1 ], [ 16, 2 ], [ 12, 3 ], [ 8, 4 ], [ 12, 5 ], [ 9, 6 ], [ 5, 7 ], [ 3, 8 ], [ 5, 9 ] ]

// nextFunc, resetFunc
p = Pfunc({sin(rrand(10, 20).sqrt + 4)}).asStream;
p.nextN(10);

(
p = Pbind(
  \instrument, \blip, // use the following synthdef
  \dur, 0.2,
  \freq, Pseq([200, 300, 400], inf)
);
)

x = p.play;
x.pause;
x.resume;

x.reset;

e = Event.new; // ( )

e.add(\foo -> 5); // ( 'foo': 5 )
e.add(\bar -> 12); // ( 'bar': 12, 'foo': 5 )
e.add(\more_stuff -> 101) // ( 'more_stuff': 101, 'bar': 12, 'foo': 5 )

e.at(\foo); // 5

// LITERAL syntax
e = (foo: 5, bar: 12, more_stuff: 101);
e[\foo]; // 5

e.foo; // 5 (like `Struct`)

~sw = ();
~sw.add(\bread -> "wheat");
~sw.add(\toasted -> true);
~sw.add(\mayo -> false);

// Event.sc, L165
  *makeDefaultSynthDef {
    SynthDef(\default, { arg out=0, freq=440, amp=0.1, pan=0, gate=1;
      var z;
      z = LPF.ar(
        Mix.new(VarSaw.ar(freq + [0, Rand(-0.4,0.0), Rand(0.0,0.4)], 0, 0.3, 0.3)),
        XLine.kr(Rand(4000,5000), Rand(2500,3200), 1)
      ) * Linen.kr(gate, 0.01, 0.7, 0.3, 2);
      OffsetOut.ar(out, Pan2.ar(z, pan, amp));
    }, [\ir]).add;
  }

(
~whoami = (
  name: "julian",
  play: { ("my name is " ++ \name.envirGet).postln; }
);
)

~whoami.play; // prints "my name is julian"

// even empty Events play! - default instrument

().play; // ( 'instrument': default, 'msgFunc': a Function, 'amp': 0.1, 'server': localhost, 'sustain': 0.8, 'isPlaying': true, 'freq': 261.6255653006, 'hasGate': true, 'id': [ 1142 ] )

(freq: 200).play;  // ( 'instrument': default, 'msgFunc': a Function, 'amp': 0.1, 'server': localhost, 'sustain': 0.8, 'isPlaying': true, 'freq': 200, 'hasGate': true, 'id': [ 1142 ] )

(freq: 400, amp: 0.5, sustain: 0.03).play;

(instrument: \blip, freq: 200).play;

(freq: 200, sustain: 2).play;

(
p = Pbind(
  \freq, Pseq([300, 500, 700], inf),
  \amp, Prand([0.1, 0.2], inf)
);

q = p.asStream; // -> a Routine
)

q.next(Event.new); // "placeholder" Event to store emitted Events
// -> ( 'amp': 0.2, 'freq': 300 )
// -> ( 'amp': 0.2, 'freq': 500 )
// -> ( 'amp': 0.1, 'freq': 700 )

q.nextN(10, ()); // empty event literal
// -> [ ( 'freq': 300, 'amp': 0.1 ), ( 'freq': 500, 'amp': 0.1 ), ( 'freq': 700, 'amp': 0.2 ), ( 'freq': 300, 'amp': 0.2 ), ( 'freq': 500, 'amp': 0.1 ), ( 'freq': 700, 'amp': 0.1 ), ( 'freq': 300, 'amp': 0.1 ), ( 'freq': 500, 'amp': 0.1 ), ( 'freq': 700, 'amp': 0.1 ), ( 'freq': 300, 'amp': 0.2 ) ]


x = p.play; // -> an EventStreamPlayer
x.pause;
x.resume;

// duration key
(
p = Pbind(
  \dur, Pseq([0.5, 0.2], inf), // in beats, (default tempo clock)
  \freq, Pseq([300, 500, 700], inf),
  \amp, Prand([0.1, 0.2], inf)
);
)

x = p.play;
x.stop;

(
p = Pbind(
  \instrument, \blip,
  \dur, Pseq([0.15, 0.3], inf), // in beats, (default tempo clock)
  \freq, Pseq([300, 500, 700], inf),
  \amp, Prand([0.1, 0.8], inf)
);
)

x = p.play;
x.stop;

partialEvents = (
  pitchEvent: (
    note: #{
      (~degree + ~mtranspose).degreeToKey(
        ~scale,
        ~scale.respondsTo(\stepsPerOctave).if(
          { ~scale.stepsPerOctave },
          ~stepsPerOctave
        )
      );
    },
    midinote: #{
      (((~note.value + ~gtranspose + ~root) /
        ~scale.respondsTo(\stepsPerOctave).if(
          { ~scale.stepsPerOctave },
          ~stepsPerOctave) + ~octave - 5.0) *
        (12.0 * ~scale.respondsTo(\octaveRatio).if
          ({ ~scale.octaveRatio }, ~octaveRatio).log2) + 60.0);
    },

    freq: #{
      (~midinote.value + ~ctranspose).midicps * ~harmonic;
    },
  ),
  durEvent: (),
  ampEvent: (),
  serverEvent: (),
  bufferEvent: (),
  midiEvent: (),
  //...
)

// for example, ways to express frequency:

// midinote, ctranspose, harmonic
(
p = Pbind(
  \instrument, \blip,
  \dur, 0.3,
  \midinote, Pseq([60, 72], inf),
  \ctranspose, Pseq([0, 0, 1, 1, 2, 2], inf),
  \harmonic, Pseq((1!6) ++ (2!6), inf), // [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2]
  \amp, 0.2
);
)

x = p.play;
x.stop;

// note, gtranspose, root

(
p = Pbind(
  \instrument, \blip,
  \dur, 0.3,
  \note, Pseq([0, 2, 4, 6], inf), // 0 = midinote 60
  \gtranspose, 10,
  \root, 4,
  \amp, 0.2
).trace; // postln the pattern
)

x = p.play;
x.stop;

// scale, degree, mtranspose

(
p = Pbind(
  \instrument, \blip,
  \dur, 0.3,
  \degree, Pseq([0, 2, 1, 3, 2, 4], inf), // integer index into scale
  \scale, #[0, 2, 4, 5, 7, 9, 11],
  \amp, 0.2
).trace; // postln the pattern
)

x = p.play;
x.stop;

// db for amp

(
p = Pbind(
  \instrument, \blip,
  \dur, Pseq([0.15, 0.3], inf), // in beats, (default tempo clock)
  \freq, Pseq([300, 500, 700], inf),
  \db, Prand([-30, -3], inf)
);
)

x = p.play;
x.stop;

// ADSR with gate
(
SynthDef.new(\blip, {
  |freq=300, amp=0.4, pan=0, out=0, atk=0.002, sus=0, rel=0.2, atkcrv=1, relcrv=(-10), gate=1|
  var sig, env;
  env = EnvGen.ar(
    Env.adsr,
    gate,
    doneAction: 2);
  sig = SinOsc.ar(freq);
  sig = sig * env;
  sig = Pan2.ar(sig, pan, amp);
  Out.ar(out, sig);
}).add;
)

// EventStreamPlayer handles sending of \gate 0
(
p = Pbind(
  \instrument, \blip,
  \dur, Pseq([0.15, 0.3], inf), // in beats, (default tempo clock)
  \freq, Pseq([300, 500, 700], inf),
  \db, Prand([-30, -3], inf),
  \sustain, 2
);
)

x = p.play;
x.stop;


///////// Event.sc

if (~hasGate == true)
{currentEnvironment.set(\gate, 0) }
{currentEnvironment.sendOSC([11, ~id]) };
~isPlaying = false;

(
SynthDef.new(\blip, {
  |freq=300, amp=0.4, pan=0, out=0, atk=0.002, rel=0.2|
  var sig, env;
  env = EnvGen.ar(
    Env.perc(atk, rel),
    doneAction: 2);
  sig = SinOsc.ar(freq);
  sig = sig * env;
  sig = Pan2.ar(sig, pan, amp);
  Out.ar(out, sig);
}).add;
)


(
p = Pbind(
  \instrument, \blip,
  \dur, Pseq([0.2], 10), // length 10
  \freq, Pseq([300, 500, 700], 2), // length 6
  \amp, Prand([0.02, 0.05], inf),
);
x = p.play;
)


TempoClock.default;
TempoClock.default.beats; // current time in beats from server boot
TempoClock.default.tempo; // -> 1 (beats per SECOND)


t = TempoClock.new(90/60).permanent_(true); // allow this clock to survive a main-stop

(
p = Pbind(
  \instrument, \blip,
  \dur, Pseq([0.2], inf),
  \freq, Pseq([300, 500, 700], inf),
  \amp, Prand([0.02, 0.05], inf),
);
// pass the TempoClock in here.
x = p.play(t);
)

// manually set the tempo
t.tempo_(2);
t.tempo_(1);

t = TempoClock.new(130/60).permanent_(true); 

(
~p1 = Pbind(
  \instrument, \blip,
  \dur, Pseq([0.5], inf),
  \note, Pseq([0, 7, 10, 3, 5, 7], inf),
  \amp, 0.2,
  \rel, 0.08,
  \pan, Pseq([-1, 1], inf)
);
// pass the TempoClock in here.
~q1 = ~p1.play(t);

~p2 = Pbind(
  \instrument, \blip,
  \dur, Pseq([1/3], inf),
  \note, Pseq([0, 7, 10, 3, 5, 7], inf),
  \amp, 0.1,
  \gtranspose, 19,
  \rel, 0.08,
  \pan, Pseq([1, -1], inf)
);
// pass the TempoClock in here.
~q2 = ~p2.play(t);
)

(
Window.closeAll; // class method to close all dangling windows

// invisible
w = Window.new;

// now it's visible
w.front;
w.alwaysOnTop = true;
// or
w.alwaysOnTop_(true); // allows chaining

w = Window.new("a window", bounds: Rect.new(50, 500, 300, 500))
.front
.alwaysOnTop_(true);
)

w.close;

// also change the bounds programmatically:

w.bounds_(Rect(500, 500, 300, 400));

// use the current bounds as a starting point:
w.bounds_(w.bounds.translate(Point(100, -100)));

(
SynthDef.new(\blip, {
  |freq=300, amp=0.4, pan=0, out=0, gate=1|
  var sig, env;
  env = EnvGen.ar(
    Env.asr,
    gate,
    doneAction: 2);
  sig = SinOsc.ar(freq);
  sig = sig * env;
  sig = Pan2.ar(sig, pan, amp);
  Out.ar(out, sig);
}).add;
)

x = Synth.new(\blip, [\amp, 0.1]).register; // can now call x.isPlaying

(
Window.closeAll; // class method to close all dangling windows

// from bottom left of screen
w = Window.new("a window", bounds: Rect.new(50, 500, 300, 500))
.front
.alwaysOnTop_(true);

v = View.new(w, Rect(100, 100, 100, 100))
.background_(Color.blue(0.5, 0.5)); // value, alpha
// .background_(Color.new(0.5, 0.2, 0.9)); // RGB
// .background_(Color.new255(51, 168, 216)); // RGB 8-bit

// from top left of a window
~sl = Slider.new(w, Rect(20, 20, 30, 150))
.action_({ // "listener"
  |view| // name is arbitrary, represents "this" (the View)
  view.value.postln; // 0-1

  if(
    x.isPlaying,
    { x.set(\amp, view.value/4) };
  )
});

~btn = Button.new(w, Rect(60, 20, 100, 30))
.states_([
  ["click to start", Color.white, Color.rand], // label, background
  ["click to stop", Color.black, Color.rand]
])
.action({
  |view|
  if (
    view.value == 1, // value associated with the state, starting at 0
    {
      x = Synth.new(\blip, [\amp, ~sl.value/4]).register; // initialize with slider's value/4
    },
    {
      x.set(\gate, 0);
    }
  )
});
)

x.free;


w.view.children; // -> [ a View, a Slider, a Button ]

// iterate
w.view.children.do { |a| a.visible_(false); }

(
Window.closeAll; // class method to close all dangling windows

// from bottom left of screen
w = Window.new("a window", bounds: Rect.new(50, 500, 300, 500))
.front
.alwaysOnTop_(true);

// w.view.layout_(FlowLayout.new(bounds: w.view, margin: Point(10, 50), gap: Point(5, 5)));

// syntax shortcut for Point: @
w.view.decorator_(FlowLayout.new(bounds: w.view.bounds, margin: 10@50, gap: 5@5));

~knobs = 20.collect({Knob.new(w, 50@50)})
)

~knobs[10].visible_(false);
~knobs[11].value_(0.5) // doesn't fire action
~knobs[11].valueAction_(0.5) // fires action

MIDIClient.init;
MIDIClient.sources;
MIDIClient.destinations;
MIDIClient.restart;

// To connect to a device, use the index of the sources/destinations array

MIDIIn.connect(3); // etc

// or

MIDIIn.connectAll;

MIDIFunc.trace(true); // monitor MIDI messages coming in via PostBuffer

(
b = PathName.new(PathName.new(thisProcess.nowExecutingPath).parentPath ++ "samples/").entries.collect({
  |path|
  Buffer.read(s, path.fullPath);
}); 
)

(
SynthDef.new(\playbuf, {
  |buf=0, gate=1, amp=1, pan=0, out=0|
  var sig, env;

  env = EnvGen.kr(Env.asr(0.01, 1, 0.1), gate, doneAction: 2);
  sig = PlayBuf.ar(1, buf, BufRateScale.ir(buf), doneAction: 2);
  sig = sig * env;
  sig = Pan2.ar(sig, pan, amp);

  Out.ar(out, sig);
}).add;
)

// alternative
// ~myFunc = MIDIFunc.noteOn({});

~notes = Array.fill(128, nil);

(
MIDIdef.noteOn(\on, {
  // args may depend on the MIDI message
  |val, num, chan, src|

  ~notes.put(num, Synth.new(\playbuf, [
    \buf, b.at(num - 21), // assuming b is an array of 128 buffers
    \gate, 1,
    \amp, val.linexp(0, 127, 0.02, 0.5),
    \pan, 0,
    \out, 0
  ]));
});

// listen for noteOffs and set gate to 0
MIDIdef.noteOff(\off, {
  |val, num, chan, src|
  ~notes.at(num).set(\gate, 0);
  ~notes.put(num, nil);
});
)

(
SynthDef.new(\playbuf, {
  |buf=0, gate=1, amp=1, pan=0, out=0, rev_out=0, rev_amp=0|
  var sig, env;

  env = EnvGen.kr(Env.asr(0.01, 1, 0.1), gate, doneAction: 2);
  sig = PlayBuf.ar(1, buf, BufRateScale.ir(buf), doneAction: 2);
  sig = sig * env;
  sig = Pan2.ar(sig, pan, amp);

  Out.ar(out, sig);
  Out.ar(rev_out, sig * rev_amp);
}).add;
)

(
SynthDef.new(\reverb, {
  |in, out|
  var sig = In.ar(in, 2);
  sig = GVerb.ar(sig, 250, 4, drylevel: 0);
  sig = LPF.ar(sig, 1200);
  Out.ar(out, sig);
}).add;
)

(
// refer to a MIDIdef
MIDIdef(\on).disable;
MIDIdef(\off).disable;
)

(
// refer to a MIDIdef
MIDIdef(\on).enable;
MIDIdef(\off).enable;
)


~notes = Array.fill(128, nil);
~rev_bus = Bus.audio(s, 2);

// b is an Array of size 2 (loud, quiet), containing 88 piano samples each
(
MIDIdef.noteOn(\on, {
  // args may depend on the MIDI message
  |val, num, chan, src|

  // split between 0-63 and 64-127
  var dynamic;
  dynamic = value.linlin(0, 127, 1, 0).round.asInteger;

  ~notes.put(num, Synth.new(\playbuf, [
    \buf, b.at(dynamic).at(num - 21), // assuming b is an array of 128 buffers
    \gate, 1,
    \amp, val.linexp(0, 127, 0.02, 0.5),
    \pan, 0,
    \out, 0,
    \rev_out, ~rev_bus,
    \rev_amp, ~rev_send.dbamp
  ]));
}, (21..108)); // constrain incoming note numbers

// listen for noteOffs and set gate to 0
MIDIdef.noteOff(\off, {
  |val, num, chan, src|
  ~notes.at(num).set(\gate, 0);
  ~notes.put(num, nil);
});

// use a CC to control reverb send
MIDIdef.cc(\rev, {
  |val, num, chan, src|
  ~rev_send = val.linlin(0, 127, -60, 0); // set the send for new notes
  ~notes.do({ // update all already playing notes
    |synth|
    synth.set(\rev_amp, ~rev_send.dbamp);
  });
}, 22); // controller number!
)


(
~rev = Synth.new(\reverb, [\in, ~rev_bus, \out, 0]);
~rev_send = -20;
)

(
SynthDef.new(\test, {
  |freq=#[80, 80.5], amp=0.2, out=0, pan=0| // has to be an array LITERAL (#)
  var sig, env;
  env = Env.perc.kr(2); // doneAction, gate
  sig = LFSaw.ar(freq);
  sig = sig * amp * env;
  Out.ar(0, sig);
}).add;
)

Synth(\test);

// takes care of the array business, "implicit conversion"
(
SynthDef.new(\test, {
  var sig, env;
  env = Env.perc.kr(2);
  sig = LFSaw.ar(\freq.kr([80, 80.5]));
  sig = sig * \amp.kr(0.3) * env;
  Out.ar(\out.ir(0), sig);
}).add;
)

(
SynthDef.new(\test, {
  var sig, env;
  env = Env.adsr.kr(2);
  sig = LFSaw.ar(\freq.kr(80).varlag(\freqlag.kr(1), \freqcrv.kr(-50)));
  sig = Pan2.ar(sig, \pan.kr(0));
  sig = sig * \amp.kr(0.3) * env;
  Out.ar(\out.ir(0), sig);
}).add;
)

x = Synth(\test);
x.set(\freq, rrand(40, 70).midicps);

(
// events counter
~counter = 0;

// create a blank slate on the server
ServerTree.removeAll;

// allocate new buses for FX
s.newBusAllocators;
~reverbBus = Bus.audio(s, 2); // language side object, don't need server booted

~makeNodes = {
  s.bind({ // bundles them together as a single OSC message, guarantees order of execution
    ~fxGroup = Group.new;
    ~reverb = Synth(\reverb, [\in, ~reverbBus], ~fxGroup);
  });
};

// events
~events = [
  {~sampPlayer = ~sampPat.play(quant: 1)},
  {~beepPlayer = ~beepPat.play(quant: 1)},
  // ...
  {~sampPlayer.stop; ~beepPlayer.stop;}
];

// callback to be executed after server boots
s.waitForBoot({
  s.freeAll;
  Buffer.freeAll;

  s.sync;

  // SynthDefs here...

  // wait until SynthDefs are loaded
  s.sync;

  ~bufPath = PathName.new(thisProcess.nowExecutingPath).parentPath ++ "samples/";

  b = PathName(~bufPath).entries.collect({
    |pathname|
    Buffer.read(s, pathname.fullPath);
  });

  s.sync;

  ServerTree.add(~makeNodes);
  ServerTree.run;

  s.sync;

  // Patterns
});
)

b[0].play;

b[1].play;

~events[0].value;
// ...

// evaluate repeatedly
(
~events[~counter].value;
~counter = ~counter + 1;

// make it wrap
if(~count >= ~events.size, {~count = 0;});
) 

{ SoundIn.ar(0) }.play;
{SinOsc.ar(100) * 0.5}.play;

ServerOptions.devices; 

Server.default.options.device;
// NumOutputBuses.ir;

(
s.options.device = "Fireface UCX (24007248)";
// s.options.inDevice = "Fireface UCX (24007248)";
// s.options.outDevice = "Fireface UCX (24007248)";
s.options.numInputBusChannels = 8;
s.options.numOutputBusChannels = 8;
s.reboot;
)