Fork Code: Simple performance script to launch patterns a la Ableton

name
code content
(

  s.options.memSize_(2.pow(20));
  s.options.blockSize_(64);
  s.latency = 0.1;
  s.freeAll;

  s.makeGui;

  MIDIIn.connectAll;

  s.waitForBoot{
    s.meter;


//##############################################//
////////////////// SETUP CODE ////////////////////
//##############################################//
    (

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

        ~genGrp = Group();
        ~fxGrp = Group.after(~genGrp);


        s.newBusAllocators; // Reset Bus counters
        ~reverbBus = Bus.audio(s,2);
        ~delayBus = Bus.audio(s,2);

        ~streams = (
            BD: nil,
            BD2: nil,
            SD: nil,
            SD2: nil,
            HH: nil,
            HH2: nil,
            BASS: nil,
            TOM: nil,
            TOM2: nil,
            FX: nil,
            FX2: nil,
            ATMO: nil,
            NOISE: nil
        );

        ~atmo = nil;

        ~ampBD = 0.3;
        ~ampSD = 0.3;
        ~ampHH = 0.3;
        ~ampHH2 = 0.3;
        ~ampBASS = 0.3;
        ~ampTOM = 0.3;
        ~ampFX = 0.3;
        ~ampATMO = 0.2;

        //Initialize Samples
        (
            ~makeBuffers = { |path, event|
                var dir = PathName.new(path);
                var contents = dir.entries;

                if (contents.select({ |n| n.isFile }).size > 0)
                {
                    var files, bufArray;
                    files = contents.select({ |n| n.isFile });
                    files = files.select({ |n|
                        ["aif", "aiff", "wav"].includesEqual(n.extension)
                    });

                    if (event[dir.folderName.asSymbol] != nil)
                    { "duplicate subfolder name ignored".warn; }
                    {
                        bufArray = files.collect({ |n| Buffer.read(s, n.fullPath) });
                        event[dir.folderName.asSymbol] = bufArray;
                    };
                };

                if (contents.select({ |n| n.isFolder }).size > 0)
                {
                    var folders = contents.select({ |n| n.isFolder });
                    folders.do({ |n| ~makeBuffers.(n.fullPath, event) });
                };

                event;
            };

            b = ~makeBuffers.("audio/".resolveRelative, ());
        );


        /////////////////////////////////////
        //////      E F F E C T S    ///////
        ////////////////////////////////////

        //REVERB
        (
            SynthDef(\reverb, {
                arg in = 0, out = 0, mix = 0.25;
                var sig, wet;
                sig = In.ar(in, 2);
                wet = DelayN.ar(sig, 0.03, 0.03);
                5.do({ |n|
                    var del, coef, dec;
                    del = { Rand(0.1 / (n + 2), 0.1 / (n + 1)) } ! 2;
                    coef = Rand(0.6, 0.75);
                    dec = del / (log10(coef) / 3.neg);
                    wet = AllpassN.ar(wet, 0.1, del, dec);
                });
                sig = sig + (wet * mix);
                Out.ar(out, sig);
            }).add;
        );

        //DELAY
        (
            SynthDef(\delay, {
                arg in = 0, out = 0, delayTime = 0.2, feedback = 0.5, damp = 0.5;
                var sig, echo, filteredFeedback;
                sig = In.ar(in, 2);
                echo = DelayN.ar(sig, delayTime, delayTime);
                filteredFeedback = LPF.ar(echo, 5000 * (1 - damp), 1); // Tiefpassfilter
                sig = sig + filteredFeedback * feedback;
                sig = sig ! 2;
                Out.ar(out, sig);
            }).add;
        );

        /////////////////////////////////////
        ////// I N S T R U M E N T S ///////
        ////////////////////////////////////
        s.makeBundle(s.latency, {SynthDef(\BD, {
            arg buf, amp = 0.3, rate = 1.0, pan = 0;
            var sig;
            sig = PlayBuf.ar(2, b[\drums][3], rate, loop: 0, doneAction: 2); // Stereo playback, no loop, free synth after done
            sig = sig * amp; // Apply amplitude
            Out.ar(0, Pan2.ar(sig, pan)); // Pan the signal and send to speakers
        }).add});

        s.makeBundle(s.latency, {SynthDef(\BASS, {
            arg amp = 0.4, rate = 1.0, pan = 0;
            var sig, phs;
            sig = PlayBuf.ar(2, b[\synth][4], rate, loop: 0, doneAction: 2);
            sig = sig * amp;
            sig = sig ! 2;
            Out.ar(~reverbBus, sig);
        }).add});

        s.makeBundle(s.latency, {SynthDef(\TOM, {
            arg amp = 0.3, rate = 0.9, pan = 0;
            var sig, phs;
            sig = PlayBuf.ar(1, b[\perc][2], rate, loop: 0, doneAction: 2);
            sig = Pan2.ar(sig !2, pan, amp) ;
            Out.ar(~reverbBus, sig);
        }).add});

        s.makeBundle(s.latency, {SynthDef(\HH, {
            arg amp = 0.3, rate = 1.0, pan = 0;
            var sig, phs;
            sig = PlayBuf.ar(2, b[\drums][2], rate, loop: 0, doneAction: 2);
            sig = sig * amp;
            Out.ar(~reverbBus, Pan2.ar(sig, pan));
        }).add});

        s.makeBundle(s.latency, {SynthDef(\SD, {
            arg amp = 0.3, rate = 1.0, pan = 0;
            var sig, phs;
            sig = PlayBuf.ar(2, b[\drums][5], rate, loop: 0, doneAction: 2);
            sig = sig * amp;
            Out.ar(~reverbBus, Pan2.ar(sig, pan));
        }).add});

        s.makeBundle(s.latency, {SynthDef(\FX, {
            arg amp = 0.3, rate = 0.9, pan = 0;
            var sig, phs;
            sig = PlayBuf.ar(2, b[\drums][1], rate, loop: 0, doneAction: 2);
            sig = sig * amp;
            Out.ar(~reverbBus, Pan2.ar(sig, pan));
        }).add});

        s.makeBundle(s.latency, {SynthDef(\FX2, {
            arg amp = 0.3, rate = 0.9, pan = 0;
            var sig, phs;
            sig = PlayBuf.ar(2, b[\drums][0], rate, loop: 0, doneAction: 2);
            sig = sig * amp;
            Out.ar(~reverbBus, Pan2.ar(sig, pan));
        }).add});

        // Sidechained drone SynthDef
        SynthDef(\ATMO, {
            arg buf, amp = 0.6, sc_amt = 1.0, sc_bus = 1, gate = 1, fadeIn = 3;
            var sig, control, env;
            // Play drone
            sig = PlayBuf.ar(2, b[\loops][1], BufRateScale.kr(buf), loop: 1);
            // Get amplitude of the sidechain signal (kick drum)
            control = Amplitude.kr(In.ar(sc_bus)) * sc_amt;
            // Apply volume envelope with fade-in
            env = EnvGen.kr(Env.asr(fadeIn, 1, 1), gate, doneAction: 0);
            sig = sig * env * amp; // Apply fade-in envelope and amp scaling
            Out.ar(~reverbBus, sig);
        }).add;


        //multi synth drone
        s.makeBundle(s.latency, {SynthDef.new(\multi, {
            var sig, amp, env, freq = 500;
            // 5 Sekunden Sustain, dann 5 Sekunden Fade-Out
            env = EnvGen.kr(Env.linen(0, 2, 2), doneAction: 2);
            amp = SinOsc.kr({ExpRand(0.2,12)}!8).range(0,1);
            sig = SinOsc.ar({ExpRand(freq/10, freq)}!8);
            sig = sig * amp * env;
            sig = Splay.ar(sig) * 0.1;
            Out.ar(~reverbBus, sig);
        }).add});


        s.makeBundle(s.latency, {SynthDef.new(\basspad, {
            arg freq=40, wetAmt = 0.1;
            var temp, sum, env, amp=0.3, mixed, dryAmt=1-wetAmt, wet;
            sum = 0;
            env = EnvGen.kr(Env.perc(0.01, 0.5, 0.5, -3),doneAction:2);
            10.do{
                temp = VarSaw.ar(
                    freq * {Rand(0.99,1.02)}!2,
                    {Rand(0.0, 1.0)}!2,
                    {ExpRand(0.005, 0.05)}!2
                );
                sum = sum + temp;
            };
            sum = sum * 0.05 * env * amp;
            Out.ar(~reverbBus,sum);

        }).add});


        //Whitenoise
        SynthDef(\whiteNoise, {
            arg gate = 1; // Steuerparameter für Ein/Aus
            var sig, env;
            sig = PinkNoise.ar(0.5 ! 2);
            8.do({sig = LPF.ar(sig, 10000)});
            env = EnvGen.kr(Env.perc, gate, doneAction: 2); // ADSR-Hüllkurve mit `gate`
            sig = sig * env * ~ampATMO;
            Out.ar(~reverbBus, sig);
        }).add;


        s.sync;
        ~reverb = s.makeBundle(s.latency, {Synth(\reverb, [\in, ~reverbBus.index, \out, 0, \mix, 0.3, \room, 0.3], ~fxGrp)});
        ~delay = s.makeBundle(s.latency, {Synth(\delay, [\in, ~delayBus.index, \out, 0, \delayTime, 0.3, \feedback, 0.5, \damp, 0.5], ~fxGrp)});
        s.makeBundle(s.latency, {~noiseSynth = Synth(\whiteNoise, [\gate, 0], ~genGrp)});
        ~atmo = Synth(\ATMO, [\amp, ~ampATMO, \fadeIn, 3, \gate, 0], ~genGrp);

        /////////////////////////////////////
        //////   S E Q U E N C E S   ///////
        ////////////////////////////////////

        // Kickdrum sequence 4-To-The-Floor
        ~p_BD = EventPatternProxy(Pbind(
            \instrument, \BD,
            \dur, Pseq([
                Pseq([1/2, Rest(1/2),   1/2, Rest(1/2),    1/2, Rest(1/2),    1/2, Rest(1/2)]), //bar1
                Pseq([1/2, Rest(1/2),   1/2, Rest(1/2),    1/2, Rest(1/2),    1/2, Rest(1/2)]), //bar2
                Pseq([1/2, Rest(1/2),   1/2, Rest(1/2),    1/2, Rest(1/2),    1/2, Rest(1/2)]), //bar3
                Pseq([1/2, Rest(1/2),   1/2, Rest(1/2),    1/2, 1/2,          1/2, 1/2])        //bar4
            ] , inf),
            \group, ~genGrp,
            \degree, Pseq([-20], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp, Pfunc({~ampBD}),
        ));

        ~p_BD2 = EventPatternProxy(Pbind(
            \instrument, \BD,
            \dur, Pseq([
                Pseq([1/2, Rest(1/2),   Rest(1/2), Rest(1/2),    1/2, Rest(1/2),    Rest(1/2), Rest(1/2)]), //bar1
                Pseq([1/2, Rest(1/2),   Rest(1/2), Rest(1/2),    1/2, Rest(1/2),    Rest(1/2), Rest(1/2)]), //bar2
                Pseq([1/2, Rest(1/2),   Rest(1/2), Rest(1/2),    1/2, Rest(1/2),    Rest(1/2), Rest(1/2)]), //bar3
                Pseq([1/2, Rest(1/2),   Rest(1/2), Rest(1/2),    1/2, Rest(1/2),    1/2, Rest(1/2)])        //bar4
            ] , inf),
            \group, ~genGrp,
            \degree, Pseq([-20], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp, Pfunc({~ampBD}),
        ));


        // Bassline sequence
        ~p_BASS = Pbind(
            \instrument, \BASS,
            \dur, Pseq([
                Pseq([Rest(1/2), 1/2,   Rest(1/2), Rest(1/2),   Rest(1/2), 1/2,  Rest(1/2), Rest(1/2)   ]), //bar 1
                Pseq([Rest(1/2), 1/2,   Rest(1/2), Rest(1/2),   Rest(1/2), 1/2,  Rest(1/2), Rest(1/2)   ]),  //bar 2
                Pseq([Rest(1/2), 1/2,   Rest(1/2), Rest(1/2),   Rest(1/2), 1/2,  Rest(1/2), Rest(1/2)   ]), //bar 3
                Pseq([Rest(1/2), 1/2,   Rest(1/2), Rest(1/2),   Rest(1/2), 1/2,  Rest(1/2), 1/2         ]) //bar 4
            ],
            inf),
            \group, ~genGrp,
            \degree, Pseq([-20, -10], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampBASS}),
        );

        ~p_BASS_pt2 = Pbind(
            \instrument, \BASS,
            \dur, Pseq([
                Pseq([Rest(1/2), 1/2,   Rest(1/2), 1/2,   Rest(1/2), 1/2,  Rest(1/2), 1/2   ]), //bar 1
                Pseq([Rest(1/2), 1/2,   Rest(1/2), 1/2,   Rest(1/2), 1/2,  Rest(1/2), 1/2   ]),  //bar 2
                Pseq([Rest(1/2), 1/2,   Rest(1/2), 1/2,   Rest(1/2), 1/2,  Rest(1/2), 1/2   ]), //bar 3
                Pseq([Rest(1/2), 1/2,   Rest(1/2), 1/2,         1/2, 1/2,        Rest(1/2), 1/2         ]) //bar 4
            ],
            inf),
            \group, ~genGrp,
            \degree, Pseq([-10, -10], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampBASS}),
        );

        // Bassline2 sequence
        ~p_TOM = Pbind(
            \instrument, \TOM,
            \dur, Pseq([
                Pseq([Rest(1/2), Rest(1/2),  Rest(1/2), 1/2,  Rest(1/2), Rest(1/2),   Rest(1/2), 1/2]), //bar 1
                Pseq([Rest(1/2), Rest(1/2),  Rest(1/2), 1/2,  Rest(1/2), 1/2,         Rest(1/2), 1/2]),  //bar 2
                Pseq([Rest(1/2), Rest(1/2),  Rest(1/2), 1/2,  Rest(1/2), 1/2,         Rest(1/2), 1/2]), //bar 3
                Pseq([Rest(1/2), Rest(1/2),  Rest(1/2), 1/2,  Rest(1/2), Rest(1/2),   1/2,       1/2]) //bar 4
            ],
            inf),
            \group, ~genGrp,
            \degree, Pseq([-20, -10], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp, Pfunc({~ampTOM}),
        );


        // Bassline2 sequence
        ~p_TOM2 = Pbind(
            \instrument, \TOM,
            \dur, Pseq([
                Pseq([1/2, 1/2,  Rest(1/2), 1/2,  1/2, 1/2,   Rest(1/2), 1/2]), //bar 1
                Pseq([1/2, 1/2,  Rest(1/2), 1/2,  1/2, 1/2,   Rest(1/2), 1/2]),  //bar 2
                Pseq([1/2, 1/2,  Rest(1/2), 1/2,  1/2, 1/2,   Rest(1/2), 1/2]), //bar 3
                Pseq([Rest(1/2), 1/2,  Rest(1/2), 1/2,  Rest(1/2), 1/2,   1/2,       1/2]) //bar 4
            ],
            inf),
            \group, ~genGrp,
            \degree, Pseq([-20, -10], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp, Pfunc({~ampTOM}),
        );

        // off-beat Hihat sequence
        ~p_HH = Pbind(
            \instrument, \HH,
            \dur, Pseq([
                Pseq([Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2), 1/2]), //bar 1
                Pseq([Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2), 1/2]), //bar 2
                Pseq([Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2), 1/2]), //bar 2
                Pseq([Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2), 1/2]) //bar 4
            ],
            inf),
            \group, ~genGrp,
            \degree, Pseq([-20, -10], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampHH}),
        );
        // on-beat hihat sequence
        ~p_HH2 = Pbind(
            \instrument, \HH,
            \dur, Pseq([
                Pseq([1/2, Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2)]), //bar 1
                Pseq([1/2, Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2)]), //bar 2
                Pseq([1/2, Rest(1/2), 1/2, Rest(1/2), 1/2, Rest(1/2)]), //bar 2
                Pseq([1/2, Rest(1/2), 1/2, Rest(1/2), 1/2,Rest(1/2)]) //bar 4
            ],
            inf),
            \group, ~genGrp,
            \degree, Pseq([-20, -10], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampHH2}),
        );
        // Snare sequence
        ~p_SD = Pbind(
            \instrument, \SD,
            \dur, Pseq([
                Pseq([1/2, Rest(1/2),    Rest(1/2), Rest(1/2),    1/2, Rest(1/2), Rest(1/2), Rest(1/2) ]), //bar1
                Pseq([1/2, Rest(1/2),    Rest(1/2), Rest(1/2),    1/2, Rest(1/2), Rest(1/2), Rest(1/2) ]), //bar2
                Pseq([1/2, Rest(1/2),    Rest(1/2), Rest(1/2),    1/2, Rest(1/2), Rest(1/2), Rest(1/2) ]), //bar3
                Pseq([1/2, Rest(1/2),    Rest(1/2), Rest(1/2),    1/2, Rest(1/2), 1/2, 1/2 ])        //bar4
            ] , inf),
            \group, ~genGrp,
            \degree, Pseq([-20], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampSD}),
        );

        // Snare roll
        ~p_SD2 = Pbind(
            \instrument, \SD,
            \dur, Pseq([
                Pseq([1/2, 1/2,   1/2, 1/2,    1/2, 1/2,    1/2, 1/2]), //bar1
                Pseq([1/2, 1/2,   1/2, 1/2,    1/2, 1/2,    1/2, 1/2]), //bar2
                Pseq([1/2, 1/2,   1/2, 1/2,    1/2, 1/2,    1/2, 1/2]), //bar3
                Pseq([1/2, 1/2,   1/2, 1/2,    1/2, 1/2,    1/2, 1/2])  //bar4
            ] , inf),
            \group, ~genGrp,
            \degree, Pseq([-20], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampSD}),
        );

        ~p_FX1 = Pbind(
            \instrument, \FX,
            \dur,  Pseq([1/2, Rest(1/2), Rest(1/2), Rest(1/2), Rest(1/2)],1),
            \group, ~genGrp,
            \degree, Pseq([-30], 1),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampFX}),
        );

        ~p_FX = Pbind(
            \instrument, \FX,
            \dur,  Pseq([1/2, Rest(1/2),   Rest(1/2), Rest(1/2),   Rest(1/2), Rest(1/2),   Rest(1/2), Rest(1/2)],inf),
            \group, ~genGrp,
            \degree, Pseq([-30], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampFX}),
        );

        ~p_FX2 = Pbind(
            \instrument, \FX2,
            \dur,  Pseq([Rest(1/2), Rest(1/2),   Rest(1/2), Rest(1/2),   1/2, Rest(1/2),   Rest(1/2), Rest(1/2)],inf),
            \group, ~genGrp,
            \degree, Pseq([-30], inf),
            \cut, Pwhite(20, 1500),
            \rez, Pwhite(0.1, 0.8),
            \amp,  Pfunc({~ampFX}),
        );



        /////////////////////////////////////
        //////         M I D I       ///////
        ////////////////////////////////////

        //VOLUME MAPPING
        //KICK VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 21, {
                ~ampBD = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 21).permanent_(true);
        //SNARE VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 22, {
                ~ampSD = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 22).permanent_(true);
        //Hihat 1 VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 23, {
                ~ampHH = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 23).permanent_(true);
        //Hihat 2 VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 24, {
                ~ampHH2 = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 24).permanent_(true);
        //BASS 1 VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 25, {
                ~ampBASS = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 25).permanent_(true);
        //BASS 2 VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 26, {
                ~ampTOM = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 26).permanent_(true);
        //FX VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 27, {
                ~ampFX = val.linlin(0, 127, 0.0, 1.0);
            });
        }, 27).permanent_(true);
        //ATMO VOLUME
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 28, {
                ~ampATMO = val.linlin(0, 127, 0.0, 0.2);
                if (~atmo.notNil) { // Überprüfen, ob ~atmo existiert
                    ~atmo.set(\amp, ~ampATMO);
                }
            });
        }, 28).permanent_(true);

        /// MIDI CC SETUP TO TRIGGER SEQUENCES BY KEYPRESS
        //KICK DRUM 4/4
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 44, {
                if (val == 127, {
                    "Starting BD".postln;
                    ~streams[\BD] = ~p_BD.play(t, quant: 1);
                }, {
                    "Stopping BD".postln;
                    ~streams[\BD].stop;
                });
            });
        }, 44); // Listen for CC 44 messages

        //KICK DRUM SLOW
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 36, {
                if (val == 127, {
                    "Starting BD2".postln;
                    ~streams[\BD2] = ~p_BD2.play(t, quant: 1);
                }, {
                    "Stopping BD2".postln;
                    ~streams[\BD2].stop;
                });
            });
        }, 36);

        // SNARE DRUM
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 45, {
                if (val == 127, {
                    "Starting SD".postln;
                    ~streams[\SD] = ~p_SD.play(t, quant: 4);
                }, {
                    "Stopping SD".postln;
                    ~streams[\SD].stop;
                });
            });
        }, 45);

        // SNARE DRUM ROLL
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 37, {
                if (val == 127, {
                    "Starting SD2".postln;
                    ~streams[\SD2] = ~p_SD2.play(t, quant: 2);
                }, {
                    "Stopping SD2".postln;
                    ~streams[\SD2].stop;
                });
            });
        }, 37);

        // SLOW HI-HAT
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 46, {
                if (val == 127, {
                    "Starting HH1".postln;
                    ~streams[\HH] = ~p_HH.play(t, quant: 1);
                }, {
                    "Stopping HH1".postln;
                    ~streams[\HH].stop;
                });
            });
        }, 46);

        // FAST HI-HAT
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 47, {
                if (val == 127, {
                    "Starting HH2".postln;
                    ~streams[\HH2] = ~p_HH2.play(t, quant: 1);
                }, {
                    "Stopping HH2".postln;
                    ~streams[\HH2].stop;
                });
            });
        }, 47);

        //BASS LINE 1
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 48, {
                if (val == 127, {
                    "Starting BASS".postln;
                    ~streams[\BASS] = ~p_BASS.play(t, quant: 4);
                }, {
                    "Stopping BASS".postln;
                    ~streams[\BASS].stop;
                });
            });
        }, 48);

        //BASS LINE 1 pt.2
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 40, {
                if (val == 127, {
                    "Starting BASS".postln;
                    ~streams[\BASS] = ~p_BASS_pt2.play(t, quant: 4);
                }, {
                    "Stopping BASS".postln;
                    ~streams[\BASS].stop;
                });
            });
        }, 40);

        //TOM
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 49, {
                if (val == 127, {
                    "Starting TOM".postln;
                    ~streams[\TOM] = ~p_TOM.play(t, quant: 1);
                }, {
                    "Stopping TOM".postln;
                    ~streams[\TOM].stop;
                });
            });
        }, 49);

        //TOM2
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 41, {
                if (val == 127, {
                    "Starting TOM2".postln;
                    ~streams[\TOM2] = ~p_TOM2.play(t, quant: 1);
                }, {
                    "Stopping TOM2".postln;
                    ~streams[\TOM2].stop;
                });
            });
        }, 41);

        //FX
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 50, {
                if (val == 127, {
                    "Starting FX".postln;
                    ~streams[\FX] = ~p_FX.play(t, quant: 4);
                }, {
                    "Stopping FX".postln;
                    ~streams[\FX].stop;
                });
            });
        }, 50);

        //FX2
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 42, {
                if (val == 127, {
                    "Starting FX2".postln;
                    ~streams[\FX2] = ~p_FX2.play(t, quant: 4);
                }, {
                    "Stopping FX2".postln;
                    ~streams[\FX2].stop;
                });
            });
        }, 42);

        //ATMO LOOP
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 51, {
                if (val > 0, {

                    "Starting ATMO".postln;
                    if (~atmo.isPlaying.not { // Überprüfe, ob der Synth bereits läuft
                        ~atmo.set(\gate, 1); // Starte den Synth, falls er noch nicht läuft
                        ~atmo.run;
                    },{
                        ~atmo.set(\gate, 1);
                    });
                }, {
                    "Stopping ATMO".postln;
                    ~atmo.set(\gate, 0); // Release the envelope
                });
            });
        }, 51).permanent_(true);

        //WHITE NOISE
        MIDIFunc.cc({ |val, num, chan, src|
            if (num == 43, {
                if (val == 127, {
                    "Starting Whitenoise".postln;
                    ~noiseSynth.set(\gate, 1);
                }, {
                    "Stopping Whitenoise".postln;
                    ~noiseSynth.set(\gate, 0);
                });
            });
        }, 43).permanent_(true);


        (
            //~bend = 0;
            //~group = Group();
            ~notes = Array.newClear(128, nil);
            //MIDIdef.freeAll;

            MIDIdef.noteOn(\on, {
                |val, num, chan, src|
                try {
                    ~notes.put(
                        num,
                        Synth(\basspad, [
                            \freq, num.midicps,
                            \gate, 1,
                            \amp, val.linexp(0, 127, 0.01, 1.0), // Dynamische Lautstärke
                            \out, ~reverbBus
                        ], ~genGrp)
                    );
                } { |err|
                    "Fehler beim Erstellen des monoSynth: ".postln;
                    err.reportError;
                };
            }).permanent_(true);

            MIDIdef.noteOff(\off, {
                arg val, num, chan, src;
                ~notes[num].set(\gate, 0);
                ~notes.put(num, nil);
            }).permanent_(true);
        )

    )
  }
)
//##############################################//
///////////////// END SETUP CODE ////////////////
//##############################################//

//##############################################//
///////////////// Play code /////////////////////
//##############################################//
//Pattern 1
(
~streams[\BD] = ~p_BD.play(t, quant: 4);
~streams[\BASS] = ~p_BASS.play(t, quant:4);
~streams[\BASS2] = ~p_BASS2.play(t, quant:4);
~streams[\FX] = ~p_FX1.play(t, quant:4);
)

//Pattern 2
(
~streams[\BD] = ~p_BD.play(t, quant: 4);
~streams[\BASS] = ~p_BASS.play(t, quant:4);
~streams[\BASS2] = ~p_BASS2.play(t, quant:4);
~streams[\FX] = ~p_FX1.play(t, quant:[4,3]);
~streams[\SD] = ~p_SD.play(t, quant: 4);
~streams[\HH] = ~p_HH.play(t, quant:4);
)

//Pattern 3
(
~streams[\BD] = ~p_BD.play(t, quant: 4);
~streams[\BASS] = ~p_BASS.play(t, quant:4);
~streams[\BASS2] = ~p_BASS2.play(t, quant:4);
~streams[\FX] = ~p_FX1.play(t, quant:[4,3]);
~streams[\SD] = ~p_SD.play(t, quant: 4);
~streams[\HH] = ~p_HH2.play(t, quant:4);
)

//stop individual streams
~streams[\BD].stop;
~streams[\SD].stop;
~streams[\BASS].stop;
~streams[\TOM].stop;
~streams[\FX].stop;
~streams[\HH].stop;
~streams[\HH2].stop;

//play individual instruments
~streams[\BD] = ~p_BD.play(t, quant: 4);
~streams[\BASS] = ~p_BASS.play(t, quant:4);
~streams[\TOM] = ~p_TOM.play(t, quant:4);
~streams[\FX] = ~p_FX1.play(t, quant:[4,3]);
~streams[\SD] = ~p_SD.play(t, quant: 4);
~streams[\HH] = ~p_HH.play(t, quant:4);
~streams[\HH2] = ~p_HH2.play(t, quant:4);

// Start the sidechained drone
x = Synth(\ATMO, [amp:0.2]);
x.stop;

~p_FX1.play(t, quant:4);

(
[50, 52, 64, 78].do({
	arg n;
	Synth(\pad, [freq: n.midicps]);
});
)

(
[68, 72, 76, 80, 84].do({
	arg n;
	Synth(\pad, [freq: n.midicps]);
});
)
code description
This script was my first Supercollider project to create a performance tool something similar like Ableton Live.
The script sets up a reverb and delay bus, loads samples (Kickdrum, snare, hihat, tom, bass, fx and pad) and creates sequences for each instrument, that can be triggered via Midi CC. For each channel the volume can be controlled via midi cc, too. 
The script to load the samples was taken from the book example of Eli Fieldsteel and loads all samples in folder "audio" and all sub-folders where script is stored iteratively and names the array keys according to the folders and the index defines the nth sample in this folder. So the PlayBuf have to be modified to match your need.
Additionally a synth is create that can be played via Midi keys.
At the end of the script is the Play code that can be used to test the patterns without having a midi controller at hand.
Maybe the MidiCC mapping has to be adjusted according your controller. 
There may be a lot of mistakes in the script, but at least it runs ;).
use markdown for formating
category tags comma separated, i.g. "wild, siren" (do not enter default SC class names, please)
ancestor(s) comma separated identificators, i.g. "1-C,1-1,1-4M,1-x"
Private? the code will be accessible by direct url and not visible in public activity
comment of change