startup.sb

let briff = fn(root)
{
  #print("VALLEYNOTES:", valid_notes);
  let beat = bjork(rand(9) + 2, 16);
  #let beat = rand_array(16, 0, 1);
  for ( let i = 0; i < 16; ++i) {
    if (beat[i] == 1) {
      beat[i] = root;
    }
  }
  return beat;
}

set mixer:delay:sync 1;
set mixer:delay:wetmx 1;
set mixer:delay:fb 65;
set mixer:reverb:wetmx 100;
set mixer:reverb:reverbtime 2000;

let riff = fn(root)
{
  #print("VALLEYNOTES:", valid_notes);
  let beat = bjork(rand(9) + 2, 16);
  #let beat = rand_array(16, 0, 1);
  for ( let i = 0; i < 16; ++i) {
    if (beat[i] == 1) {
      beat[i] = root;
    }
  }
  return beat;
}

let key_riff = fn(root)
{
  let valid_notes = notes_in_key(root);
  #print("VALLEYNOTES:", valid_notes);
  let beat = bjork(rand(9) + 2, 16);
  #let beat = rand_array(16, 0, 1);
  for ( let i = 0; i < 16; ++i) {
    if (beat[i] == 1) {
      beat[i] = valid_notes[rand(len(valid_notes))];
    }
  }
  return beat;
}

let chord_riff = fn(notes)
{
  #print("VALLEYNOTES:", valid_notes);
  let beat = bjork(rand(9) + 2, 16);
  #let beat = rand_array(16, 0, 1);
  for ( let i = 0; i < 16; ++i) {
    if (beat[i] == 1) {
      beat[i] = notes[rand(len(notes))];
    }
  }
  return beat;
}

let map = fn(arrray, fooonction)
{
  let mapduh = [];
  for (let i = 0; i < len(arrray); ++i)
  {
    if (arrray[i] ) {
      mapduh = push(mapduh, fooonction(arrray[i]));
    } else {
      mapduh = push(mapduh, ~);
    }
  }
  return mapduh;
}

let rand_beat = gen()
{
  setup() {
    let shiko = [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0];
    let son = [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0];
    let rumba = [1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0];
    let soukous = [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0];
    let gahu = [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0];
    let bossa = [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0];
    let bruijun1 =  [1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0];
    let bruijun2 =  [1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0];
    let bruijun3 =  [1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0];
    let bruijun4 =  [1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0];
    let bruijun5 =  [1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0];
    let bruijun6 =  [1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0];
    let bruijun7 =  [1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0];
    let bruijun8 =  [1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0];
    let bruijun9 =  [1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0];
    let bruijun10 =  [1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0];
    let bruijun11 =  [1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0];
    let bruijun12 =  [1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0];
    let bruijun13 =  [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0];
    let bruijun14 =  [1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0];
    let bruijun15 =  [1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0];
    let bruijun16 =  [1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0];

    let rhythms_int = [ shiko, son, rumba, soukous, gahu, bossa, bjork(3, 16), bjork(5, 16), bruijun1, bruijun2, bruijun3, bruijun4, bruijun5, bruijun6, bruijun7, bruijun8, bruijun9, bruijun10, bruijun11, bruijun12, bruijun13, bruijun14, bruijun15, bruijun16];

  }

  run() {
    let idx = rand(len(rhythms_int));
    return rhythms_int[idx];
  }
}

let count = 0;

let countr = gen()
{
  setup() {}
  run()
  {
    ++count;
    unsolo();
    xclear();
  }
}
let xfade_gen = gen()
{
  setup()
  {
    let poz = [1, -1, 1, 1, -1, 1, -1];
    let px = 0;
  }
  run()
  {
    if (count % 2 == 0) {
      set mixer:xfader:xpos poz[px] at=8*pp;
      if (count % 16 < 14 ) {
        set mixer:xfader:xpos 0 at=16*pp;
      }
      px = incr(px, 0, len(poz));
    }
  }
}


p0 # countr ;
#p1 # xfade_gen ;

# i.e. 3840 / 16 == 240 midi Pulses Per 16th
let pp = 240;

let up = fn(array_val, halfstep)
{
  return map(array_val, fn(v) { if (v > 0) { return v + halfstep; } else { return v;}  });
}

let down = fn(array_val, halfstep)
{
  return map(array_val, fn(v) { if (v > 0) { return v - halfstep; } else { return v;}  });
}

let combinorCh = fn(rhythm, chord)
{
  let return_melody= [];
  for (let i=0; i < len(rhythm); ++i)
  {
    if (type(rhythm[i]) == "ARRAY") {
      return_melody = push(return_melody, combinorCh(rhythm[i], melody));
    }
    else {
      if (rhythm[i] > 0) {
        if (type(chord) == "ARRAY" && len(chord) > 1 && type(chord[0]) == "ARRAY") {
          return_melody = push(return_melody, chord[rand(len(chord))]);
        } else {
          return_melody = push(return_melody, chord);
        }
      } else {
        return_melody = push(return_melody, 0);
      }
    }
  }
  return return_melody;
}


let combinor = fn(rhythm, melody)
{
  let return_melody= [];
  let mel_idx = 0;
  for (let i=0; i < len(rhythm); ++i)
  {
    if (type(rhythm[i]) == "ARRAY") {
      return_melody = push(return_melody, combinor(rhythm[i], melody));
    }
    else {
      if (rhythm[i] > 0) {
        return_melody = push(return_melody, melody[mel_idx]);
        if (rand(10) > 7) {
          mel_idx = incr(mel_idx, 0, len(melody));
        }
      } else {
        return_melody = push(return_melody, 0);
      }
    }
  }
  return return_melody;
}
let rcombinor = fn(rhythm, melody)
{
  let return_melody= [];
  for (let i=0; i < len(rhythm); ++i)
  {
    if (type(rhythm[i]) == "ARRAY") {
      return_melody = push(return_melody, rcombinor(rhythm[i], melody));
    }
    else {
      if (rhythm[i] > 0) {
        return_melody = push(return_melody, melody[rand(len(melody))]);
      } else {
        return_melody = push(return_melody, 0);
      }
    }
  }
  return return_melody;
}

let phasefn = fn(soundgen1, soundgen2, pat_array, sg2_px, carry, bars_to_phase_over, note_dur)
{
  let pp = 3840 / len(pat_array);
  let qpp = (3840* bars_to_phase_over) / (len(pat_array) * bars_to_phase_over + 1);

  # normal time
  for (let i = 0; i < len(pat_array); ++i) {
    #print("sg:", soundgen1, "I:", pat_array[i], " dru:" ,note_dur, " pp:", pp);
    note_on_at(soundgen1, pat_array[i], i * pp, dur=note_dur);
  }

  # phased time
  for (let i = 0; i < len(pat_array); ++i ) {
    let time_at = i * qpp + carry;
    note_on_at(soundgen2, pat_array[sg2_px], time_at, dur=note_dur);
    sg2_px = incr(sg2_px, 0, len(pat_array));
  }
  let last_idx = (len(pat_array) * qpp) + carry;
  if (last_idx < 3840) {
    note_on_at(soundgen2, pat_array[sg2_px], last_idx, dur=note_dur);
    sg2_px = incr(sg2_px, 0, len(pat_array));
    let diff = 3840 - last_idx;
    carry = qpp - diff;
  } else {
    carry = last_idx - 3840;
  }
  return [sg2_px, carry];
}

let map_to_array = fn(the_map, len_array)
{
  let the_array = [];

  for (let i = 0; i < len_array; ++i) {
    if (type(the_map[i]) == "NUMBER") {
      push(the_array, the_map[i]);
    } else {
      push(the_array, 0);
    }
  }
  return the_array;
}

let is_val_in_list = fn(the_list, the_val)
{
  for (let i = 0; i < len(the_list); ++i) {
    if (the_list[i] == the_val) {
      return true;
    }
  }
  return false;
}

let expand = fn(in_array)
{
  if (len(in_array) == 0 || len(in_array) > 15) {
    return in_array;
  }

  let rhythm = bjork(len(in_array), 16);
  return combinor(rhythm, in_array);
}

let list_to_array = fn(the_list, len_array)
{
  let the_array = [];
  for (let i = 0; i < len_array; ++i) {
    if (is_val_in_list(the_list, i)){
      the_array = push(the_array, 1);
    } else {
      the_array = push(the_array, 0);
    }
  }
  return the_array;
}

let double = fn(list)
{
  let return_valz = list_to_array([], 16);
  if (len(list) == 16) {
    for (let i = 0; i < 16; ++i) {
      if (list[i] > 0) {
        return_valz[i/2] = list[i];
        return_valz[8 + i/2] = list[i];
      }
    }
  }
  return return_valz;
}

let play_pattern = fn(sg, pat)
{
  let lenny = len(pat);
  let pp = 3840 / lenny;

  for (let i = 0; i < lenny; ++i) {
    if (type(pat[i]) == "ARRAY" || (type(pat[i]) == "NUMBER" && pat[i] > 0)) {
      note_on_at(sg, pat[i], pp * i);
    }
  }
}

let gen_beat2 = fn()
{
  let ran1 = rand(8);
  let ran2 = rand(8);
  let ran3 = 16 - (ran1 + ran2);
  let beat = bjork(rand(ran1), ran1) + bjork(rand(ran2), ran2) + bjork(rand(ran3), ran3);
  beat[0] = 1;
  return beat;
}

let gen_beat = fn()
{
  let beat = bjork(rand(5)+2, 16);
  if (rand(100) > 70) {
    beat = rand_beat();
  }

  for (let i = 4; i < 16; ++i) {
    if (beat[i] == 1 && rand(100) > 60) {
      beat[i] = bjork(rand(3)+3, 8);
    }
  }

  for (let i = 8; i < 16; ++i) {
    if (beat[i] == 1 && rand(100) > 80) {
      beat[i] = bjork(rand(4)+2, 8);
    }
  }

  return beat;
}

let stepper = fn(sg, pat, read_idx, play_idx, d, v)
{
  if (type(pat[read_idx]) == "ARRAY") {
    note_on_at(sg, pat[read_idx][0], play_idx * pp);
  } else {
    if (pat[read_idx] > 0) {
      # let v = 100 + rand(27);
      # if (play_idx % 4 == 0) {
        #   v = 127;
        # }
      let offset = 60;
      if (play_idx % 2 == 0) {
        offset = 0;
      }
      note_on_at(sg, pat[read_idx], play_idx * pp + offset, dur = d, vel = v);
      return true;
    }
    return false;
  }
}
let dstepper = fn(sg, sg2, pat, read_idx, play_idx, d)
{
  if (type(pat[read_idx]) == "ARRAY") {
    note_on_at(sg, pat[read_idx][0], play_idx * pp);
  } else {
    if (pat[read_idx] > 0) {
      let v = 100 + rand(27);
      if (play_idx % 2 == 0) {
        v = 127;
      }
      note_on_at(sg, pat[read_idx], play_idx * pp, dur = d, vel = v);
    } else {
      note_on_at(sg2, pat[rand(len(pat))], play_idx * pp, dur = d, vel = v);
    }
  }
}
let cstepper = fn(sg, pat, read_idx, play_idx)
{
  if (type(pat[read_idx]) == "ARRAY") {
    note_on_at(sg, notes_in_chord(pat[read_idx][0], 1, 1), play_idx * pp);
  } else {
    if (pat[read_idx] > 0) {
      note_on_at(sg, notes_in_chord(pat[read_idx], 1, 1), play_idx * pp);
    }
  }
}

let is_valid_string_mask = fn(input_mask) {
  let val_items = ["0", "1", "2", "3", "4", "5", "6", "7",
      "8", "9", "a", "b", "c", "d", "e", "f"];

  let lcmask = lowercase(input_mask);
  for (let i = 0; i < len(lcmask); ++i) {
    if (!is_val_in_list(val_items, lcmask[i])) {
      return false;
    }
  }
  return true;
}

let string_to_hex = fn(char) {
  if (char == "0") {
    return [0, 0, 0, 0];
  }
  if (char == "1") {
    return [0, 0, 0, 1];
  }
  if (char == "2") {
    return [0, 0, 1, 0];
  }
  if (char == "3") {
    return [0, 0, 1, 1];
  }
  if (char == "4") {
    return [0, 1, 0, 0];
  }
  if (char == "5") {
    return [0, 1, 0, 1];
  }
  if (char == "6") {
    return [0, 1, 1, 0];
  }
  if (char == "7") {
    return [0, 1, 1, 1];
  }
  if (char == "8") {
    return [1, 0, 0, 0];
  }
  if (char == "9") {
    return [1, 0, 0, 1];
  }
  if (char == "a") {
    return [1, 0, 1, 0];
  }
  if (char == "b") {
    return [1, 0, 1, 1];
  }
  if (char == "c") {
    return [1, 1, 0, 0];
  }
  if (char == "d") {
    return [1, 1, 0, 1];
  }
  if (char == "e") {
    return [1, 1, 1, 0];
  }
  if (char == "f") {
    return [1, 1, 1, 1];
  }
  return [0, 0, 0, 0];
}


let string_to_mask = fn(string_mask) {
  let ret_mask = [];
  if (!is_valid_string_mask(string_mask)) {
    return ret_mask;
  }

  let lcmask = lowercase(string_mask);
  for (let i = 0; i < len(string_mask); ++i) {
    let hx = string_to_hex(string_mask[i]);
    for (let j = 0; j < 4; ++j) {
      push(ret_mask, hx[j]);
    }
  }
}

let mask = fn(original_pattern, mask_pattern)
{
  let return_pattern = [];

  let maskr = mask_pattern;
  if (type(mask_pattern) == "STRING") {
    maskr = string_to_mask(mask_pattern);
  }

  for (let i = 0; i < min(len(original_pattern), len(maskr)); ++i) {
    if (maskr[i] > 0) {
      push(return_pattern, 0);
    } else {
      push(return_pattern, original_pattern[i]);
    }
  }

  return return_pattern;
}

let ormask = fn(first_pattern, second_pattern)
{
  let return_pattern = [];

  for (let i = 0; i < min(len(first_pattern), len(second_pattern)); ++i) {
    if (first_pattern[i] > 0 || second_pattern[i] > 0)  {
      push(return_pattern, 1);
    } else {
      push(return_pattern, 0);
    }
  }

  return return_pattern;
}

let perky = fn(beat_pattern, sample_array)
{
  if (len(beat_pattern) == 0 || len(sample_array) == 0) {
    return;
  }

  for (let i = 0; i < len(beat_pattern); ++i) {
    let v = rand(90) + 17;
    if (type(beat_pattern[i]) == "ARRAY") {
      let larr = beat_pattern[i];
      let ppp = pp / len(larr);
      for (let j = 0; j < len(larr); ++j) {
        if (larr[j] > 0) {
          note_on_at(sample_array[rand(len(sample_array))], 1, i * pp + j * ppp, vel = v);
        }
      }
    } else {
      if (beat_pattern[i] > 0) {
        note_on_at(sample_array[rand(len(sample_array))], 1, i * pp, vel = v);
      }
    }
  }
}

let cbeat = fn(cp) {
  cmbeat(cp, 1);
}
let cmbeat = fn(cp, midi_num)
{
  let probz = {4:90, 6:10, 12:90, 13:5, 15:10};
  let parray = map_to_array(probz, 16);
  for (let i = 0; i < 16; ++i) {
    if (parray[i] > 0 && parray[i] > rand(100)) {
      let v = 127;
      if (i > 12) {
        v = 72;
      }
      let offset = 0;
      if (i > 0) {
        offset = rand(45);
      }
      note_on_at(cp, midi_num, i * pp - offset, vel = v);
    }
  }
}

let dbeat = fn(bd)
{
  dmbeat(bd, 1);
}
let dmbeat = fn(bd, midi_num)
{
  let prob = rand(100);
  if (prob < 20) {
    return;
  }

  let parray = "";
  if (prob < 80) {
    let probz = {0:90, 4:30, 6:90, 8:30, 11:50, 12:20, 14:50, 15:10};
    parray = map_to_array(probz, 16);
  } else {
    parray = combinor(rand_beat(), [90]);
  }
  for (let i = 0; i < 16; ++i) {
    if (parray[i] > 0 && parray[i] > rand(100)) {
      let v = 100 + rand(28);
      if (i == 0 || i == 8) {
        v = 128;
      }
      if (i > 12) {
        v = 72;
      }
      let offset = 0;
      if (i > 0) {
        offset = rand(45);
      }
      note_on_at(bd, midi_num, i * pp + offset, vel = v, dur = 100 + rand(2000));
    }
  }
}

let hhbeat = fn(hh)
{
  hhmbeat(hh, 1);
}
let hhmbeat = fn(hh, midi_num)
{
  let sw = rand(20);
  if (rand(100) < 95) {
    for (let i = 0; i < 16; ++i) {
      if (rand(100) < 95) {
        let offset = 0;
        let v = 60 + rand(27);
        if (i % 2 == 1) {
          offset = sw;
        }
        note_on_at(hh, midi_num, i * pp + offset, vel = v);
      }
    }
  }
}


let moog_midi_assign = fn()
{
  midi_map(1, "mo:eg1_attack");
  midi_map(2, "mo:eg1_decay");
  midi_map(3, "mo:eg1_release");
  midi_map(4, "mo:l1rate");
  midi_map(5, "mo:fc");
  midi_map(6, "mo:fq");
}

let dx_midi_assign = fn()
{
  midi_map(1, "dx:algo");
  midi_map(2, "dx:vol");
  midi_map(3, "dx:porta");
  midi_map(4, "dx:op4fb");
  midi_map(5, "dx:op1out");
  midi_map(6, "dx:op2out");
  midi_map(7, "dx:op3out");
  midi_map(8, "dx:op4out");
}

let dx_midi_op1 = fn()
{
  midi_map(1, "dx:o1wav");
  midi_map(2, "dx:o1rat");
  midi_map(3, "dx:o1det");
  #  midi_map(4, "dx:o1sus");
  midi_map(5, "dx:e1att");
  midi_map(6, "dx:e1dec");
  midi_map(7, "dx:e1sus");
  midi_map(8, "dx:e1rel");
}

let dx_midi_op2 = fn()
{
  midi_map(1, "dx:o2wav");
  midi_map(2, "dx:o2rat");
  midi_map(3, "dx:o2det");
  #  midi_map(4, "dx:o2sus");
  midi_map(5, "dx:e2att");
  midi_map(6, "dx:e2dec");
  midi_map(7, "dx:e2sus");
  midi_map(8, "dx:e2rel");
}

let dx_midi_op3 = fn()
{
  midi_map(1, "dx:o3wav");
  midi_map(2, "dx:o3rat");
  midi_map(3, "dx:o3det");
  #  midi_map(4, "dx:o1sus");
  midi_map(5, "dx:e3att");
  midi_map(6, "dx:e3dec");
  midi_map(7, "dx:e3sus");
  midi_map(8, "dx:e3rel");
}

let dx_midi_op4 = fn()
{
  midi_map(1, "dx:o4wav");
  midi_map(2, "dx:o4rat");
  midi_map(3, "dx:o4det");
  #  midi_map(4, "dx:o1sus");
  midi_map(5, "dx:e4att");
  midi_map(6, "dx:e4dec");
  midi_map(7, "dx:e4sus");
  midi_map(8, "dx:e4rel");
}

let play_sub = fn(instrument, start_idx, sub_range, arr)
{
  let local_inc = sub_range / len(arr);
  for (let i = 0; i < len(arr); ++i) {
    let plx = start_idx + i * local_inc;

    if (type(arr[i]) == "ARRAY") {
      if (rand(10) < 9) {
        play_sub(instrument, plx, local_inc, arr[i]);
      }
    }
    let drift = 0;
    if (i % 2 == 1) {
      drift = rand(20);
    }
    let v = 100 + rand(27);
    if (plx % 960 == 0) {
      v = 127;
    }
    if (type(arr[i]) == "NUMBER" && arr[i] > 0) {
      note_on_at(instrument, arr[i], plx + drift, dur = 200 + rand(300), vel = v);
    }
  }


}

let player = fn(instrument, beat)
{
  play_sub(instrument, 0, 3840, beat);
}

let bassgen = fn()
{
  let onehit = [1, 0, 0, 0];
  let onehit2 = [0, 1, 0, 0];
  let onehit3 = [0, 0, 1, 0];

  let twohit = [1, 0, 0, 1];
  let twohit2 = [1, 0, 1, 0];

  let rhm = [];
  if (rand(100) < 70) {
    rhm = twohit;
  } else {
    rhm = onehit;
  }
  for (let i = 0; i < 3; ++i) {
    let rnd = rand(100);
    if (rnd < 50) {
      if (rnd < 20) {
        rhm = rhm + onehit;
      } else {
        if (rnd < 35) {
          rhm = rhm + onehit2;
        } else {
          rhm = rhm + onehit3;
        }
      }
    } else {
      if (rnd < 80) {
        rhm = rhm + twohit;
      } else {
        rhm = rhm + twohit2;
      }
    }
  }
  return rhm;
}

let golden_ratio = 1.61803398875;

let golden_step = fn(last)
{
  return (last + golden_ratio) % 1.0;
}

let golden_seq = fn(num_beats)
{
  let circ_timez = [];
  let cur = rand(1);
  for (let i = 0; i < num_beats; ++i) {
    push(circ_timez, cur);
    cur = golden_step(cur);
  }
  return sort(circ_timez);
}

let garmelody = fn(num_steps, notez, loop_len)
{
  let beat = golden_seq(num_steps);
  let melody = rand_array(loop_len, 0, 0);

  for (let i = 0; i < len(beat); ++i) {
    let note = notez[rand(len(notez))];
    let time_val = floor(beat[i]*loop_len);
    melody[time_val] = note;
  }

  return melody;
}


let gamelody = fn(num_steps, root_key, chord_type)
{
  let melody = rand_array(num_steps, 0, 0);
  let notez = take_random_n(notes_in_key(root_key, chord_type), 4);

  for (let i = 0; i < len(melody); ++i) {
    if (rand(100)> 30) {
      let note = notez[rand(len(notez))];
      if (i == 0 || i == len(melody) -1) {
        note = root_key;
      }
      melody[i] = note;
    }
  }

  return melody;
}


let gcmelody = fn(num_steps, notez, loop_len)
{
  let melody = [];
  if (num_steps > 16) {
    return melody;
  }

  let rn = rand(num_steps) + 2;
  let rn2 = num_steps - rn;

  if (rn < 8) {
    melody = bjork(rn, 8) + bjork(rn2, 8);
  } else {
    melody = bjork(num_steps, 16);
  }

  for (let i = 0; i < len(melody); ++i) {
    if (melody[i] == 1) {
      let note = notez[rand(len(notez))];
      if (i == 0 || i == len(melody) -1) {
        note = notez[0];
      }
      melody[i] = note;
    }
  }

  return melody;
}

kit();

let take_n = fn(an_array, num_to_take) {
  let numz = [];
  if (num_to_take > len(an_array)) {
    return numz;
  }
  for (let i = 0; i < num_to_take; ++i) {
    push(numz, an_array[rand(len(an_array))]);
  }
  return numz;
}

let mashup = fn(sndgenz)
{

  xclear();
  if (type(sndgenz) != "ARRAY") {
    print("WHOA", type(sngenz));
    return;
  }
  if (len(sndgenz) == 0) {
    return;
  }
  for (let i = 0; i < len(sndgenz); ++i) {
    xassign(i % 2, sndgenz[i]);
  }

  let poz = [-1, 1];
  let px = 0;
  for (let i = 0; i < 16; ++i) {
    if (i % 4 == 0) {
      set mixer:xfader:xpos poz[px] at=i*pp;
      px = incr(px, 0, len(poz));
    }
  }
  # if (count % 4 == 3) {
    #   solo(sndgenz[rand(len(sndgenz))], at = 14*pp) ;
    # }
}

let mashupToo = fn(pat, soundgz)
{
  for (let i = 0; i < 16; ++i) {
    if (pat[i] < len(soundgz)) {
      note_on_at(soundgz[pat[i]], 1, i * pp);
    }
  }
}

let StepDatPattern = fn(pat, base_key, range_of_melody)
{
  let nots = notes_in_key(base_key, 1);
  let cur_val = 0;
  for (let i = 0; i < len(pat); ++i) {
    if (pat[i] == 1)  {
      pat[i] = nots[cur_val % range_of_melody % len(nots)];
      if (rand(100) > 90) {
        pat[i] = 0;
      }
      if (rand(100) > 95) {
        if (i > 0) {
          pat[i - 1] = pat[i];
          pat[i] = 0;
        }
      }
      cur_val = cur_val + rand(range_of_melody);
      if (rand(100) > 70) {
        cur_val = cur_val - rand(4);
        if (cur_val < 0) {
          cur_val = base_key;
        }
      }
    }
  }
  return pat;
}

let GenMellerdy = fn(length_of_melody, base_key, range_of_melody)
{
  let third_of_melody = length_of_melody / 3;
  let len_section_one = floor(third_of_melody + rand(third_of_melody));
  let len_section_two = floor((length_of_melody - len_section_one) / 2);
  let len_section_three = (length_of_melody - len_section_one) - len_section_two;

  let steps_section_one = 3 + rand(2);
  let section_one = bjork(steps_section_one, len_section_one);

  section_one = StepDatPattern(section_one, base_key, range_of_melody);

  let section_two_one = bjork(1 + rand(2), len_section_two);
  section_two_one = StepDatPattern(section_two_one, base_key, range_of_melody);
  let section_two_two = bjork(1 + rand(3), len_section_three);
  section_two_two = StepDatPattern(section_two_two, base_key, range_of_melody);

  return section_one + section_two_one + section_two_two;

}

let numzFromBits = fn(bits)
{
  if (len(bits) % 4 != 0) {
    print("Bits need to be in chunks of 4");
    return;
  }

  let returnNumz = [];
  let curNum = 0;
  for (let i = 0; i < len(bits); i = i + 4) {
    let num = 0;
    if (bits[i] > 0) {
      num = num + 8;
    }
    if (bits[i+1] > 0) {
      num = num + 4;
    }
    if (bits[i +2] > 0) {
      num = num + 2;
    }
    if (bits[i + 3] > 0) {
      num = num + 1;
    }
    push(returnNumz, num);
  }
  return returnNumz;
}

let gen2stepbeat = fn()
{
  let beat = rand_array(16, 0, 0);
  if (count % 2 == 0 && rand(100) > 10) {
    beat[0] = 1;
  }
  beat[8] = 1;

  for (let i = 4; i < 16; i = i + 4) {
    let stepz = gen2stepsequence();
    for (let j = 0; j < len(stepz); j++) {
      beat[i + stepz[j]] = 1);
    }
  }
  beat[9] = 0;
  return beat;
}


let gen2stepsequence = fn()
{
  let num_steps = rand(2) + 1;
  let idxz = [];
  let have_all = false;
  for (let i = 0; i < num_steps; !have_all  ) {
    let next_idx = rand(3) + 1;
    if (!is_val_in_list(idxz, next_idx)) {
      push(idxz, next_idx);
      i++;
    }
    if (len(idxz) == num_steps) {
      have_all = true;
    }
  }
  return idxz;
}

let print_notes = fn(notes)
{
  print("Notes:", notes);
  let ans = "";
  for (let i = 0; i < len(notes); i++) {
    let num = notes[i] % 12;
    if (num == 0) {
      ans = ans + "C ";
    }
    if (num == 1) {
      ans = ans + "C# ";
    }
    if (num == 2) {
      ans = ans + "D ";
    }
    if (num == 3) {
      ans = ans + "D# ";
    }
    if (num == 4) {
      ans = ans + "E ";
    }
    if (num == 5) {
      ans = ans + "F ";
    }
    if (num == 6) {
      ans = ans + "F# ";
    }
    if (num == 7) {
      ans = ans + "G ";
    }
    if (num == 8) {
      ans = ans + "G# ";
    }
    if (num == 9) {
      ans = ans + "A ";
    }
    if (num == 10) {
      ans = ans + "A# ";
    }
    if (num == 11) {
      ans = ans + "B ";
    }
  }
  return ans;
}