Lecture_Series_02.ck

// Machine.add("utilities.ck");

me.dir() + "/audio/" => string path;

// utility functions
fun int random_from(int arr[]){
    return arr[Math.random2(0, arr.cap()-1)];
}

fun int[] randomArray_from(int arr[], int length){
    // return new array of capacity length chosing elements from arr
    int generated_arr[0];
    for(0 => int i; i<length; i++){
        generated_arr << random_from(arr); // append element
    }
    return generated_arr;
}

fun int[] range(int start, int end){
    // includes start and end
    int arr[0];
    for(start => int i; i<=end; i++) arr << i;
    return arr;
}

fun string repr(int arr[]){
    /*
    this returns a string representation of an int array,
    useful for debug printing.
    */
    "[" + Std.itoa(arr[0]) => string s;
    for (1 => int i; i < arr.cap(); i++){
        "," + Std.itoa(arr[i]) +=> s;
    }
    return s + "]";
}

fun int inArray(int token, int arr[]){
    /*
    tests membership of an array
    */ 
    for(0 => int i; i<arr.cap(); i++){
        if (arr[i]==token) return 1;
    }
    return 0;
}

fun int[][] stepify(string sequence_data[]){
    /*
    this function converts a string array to an int array,
    it accepts fuzzy formatting:
    "1..1..1..1.." becomes [1,0,0,1,0,0,1,0,0,1,0,0]
    "1..1.   .1..1.." also becomes [1,0,0,1,0,0,1,0,0,1,0,0]
    */

    sequence_data.cap() => int parts;
    32 => int steps;  // hard code for now
    <<< parts, steps >>>;
    
    int data_store[parts][steps];
    for(0 => int i; i<sequence_data.cap(); i++){

        sequence_data[i] => string seq_string;
        int part_data[0];
        int trigger;
        //<<< seq_string >>>;
        for(0 => int j; j < seq_string.length(); j++){
            seq_string.substring(j,1) => string token; // crazy

            if (token == " ") continue;
            if (token == ".") 0 => trigger;
            else if (token == "1") 1 => trigger;

            part_data << trigger;
        }
        //<<< repr_int_array(part_data)>>>;
        part_data @=> data_store[i];
    }
    return data_store;
}

fun string[] split(string arr, string token){
    // you trim arr before feeding it to this function
    string return_array[0];
    string collect;
    string ch;
    for(0 => int i; i<arr.length(); i++){
        arr.substring(i, 1) => ch;
        if (ch == token){
            return_array << collect.substring(0);
            "" => collect;
        } 
        else { ch +=> collect; }
    }
    return return_array << collect;
}

fun void connect(
    Pan2 pans[], string names[], 
    SndBuf buffers[], Gain master){

    for (0 =>int i; i<names.cap(); i++){
        path + names[i] => buffers[i].read;
        buffers[i].samples() => buffers[i].pos;
        buffers[i] => pans[i] => master;
    }
}

fun void buff_control(string ctrl_msg, SndBuf sb[], int idx){
        split(ctrl_msg, " ") @=> string sysexp[];
        Std.atof(sysexp[0]) => float fg => sb[idx].gain;
        Std.atoi(sysexp[1]) => int ip => sb[idx].pos;
        Std.atof(sysexp[2]) => float fr => sb[idx].rate;
        // <<< fg, ip, fr >>>;
}

Gain bd_master => dac;
Gain perc_master => dac;
Gain hat_master => dac;

// BD
[   "1... 1... 1... 1..."
] @=> string bd_patterns[];

[   "kick_01.wav", 
    "kick_02.wav", 
    "kick_03.wav", 
    "kick_04.wav"
] @=> string bd_names[];

bd_names.cap() => int num_wavs;
Pan2 bd_pans[num_wavs];
SndBuf bd_buffers[num_wavs];
connect(bd_pans, bd_names, bd_buffers, bd_master);
stepify(bd_patterns) @=> int bd_triggers[][];

// PERC
[   "...1 ...1 .1.. 1.1.", 
    "1... .1.. .... ....",
    ".1.. ..1. 1... .1..",
    "...1 1... ...1 ...1"
] @=> string perc_patterns[];

[   "click_01.wav",
    "click_02.wav", 
    "click_02.wav",
    "click_03.wav"
] @=> string perc_names[];

perc_names.cap() => int num_pwavs;
Pan2 perc_pans[num_pwavs];
SndBuf perc_buffers[num_pwavs];
connect(perc_pans, perc_names, perc_buffers, perc_master);
stepify(perc_patterns) @=> int perc_triggers[][];


// shuffle setup
int shuffle;
float tick_duration;
1.0 => float global_rate;
144 * global_rate => float long_tick;
long_tick * .74 => float short_tick;
0 => int beat;
0 => int tick;

bd_triggers[0].cap() => int steps;



while(beat<4){
    <<< "beat:", beat >>>;
    
    for(0 => int i; i<steps; i++){
        i % 2 => shuffle;
        bd_triggers[0][i] => int stab_trigger;

        if (stab_trigger){
            buff_control("0.11 2360 0.58", bd_buffers, 0);
            buff_control("0.8 2883 0.88", bd_buffers, 1);
            buff_control("0.13 560 0.02", bd_buffers, 2);
            buff_control("0.01 137 0.77", bd_buffers, 3);
            // buff_control("0.0 0 1.0", bd_buffers, 4);
        }

        // each part of perc is one iteration of j
        for(0 => int j; j<perc_triggers.cap(); j++){
            perc_triggers[j][i] => int perc_trigger;

            if (perc_trigger){
                if (j==0) buff_control("0.11 7 6.77", perc_buffers, 0);
                if (j==1) buff_control("0.11 267 1.17", perc_buffers, 1);
                if (j==2) buff_control("0.41 57 1.27", perc_buffers, 2);
                if (j==3) buff_control("0.1 17 2.77", perc_buffers, 3);
            }



        }



        // TIME 

        if (shuffle==0) long_tick => tick_duration;
        else short_tick => tick_duration;

        tick_duration::ms => now;
        tick++;

    }
    beat++;
}