Browse Source

more tweaks; added a choice of 4 midi notes (to later add more than 1 sound source, so the system can choose between different drum sounds for more variation)

master
spoonietunes 8 months ago
parent
commit
cfec0aee7a
  1. 120
      auto-techno.py
  2. 813
      test.tidal

120
auto-techno.py

@ -35,10 +35,10 @@ percMidiChanStart = 0 @@ -35,10 +35,10 @@ percMidiChanStart = 0
# perc note
# set a static note for percussion tracks
percNote = 0
# set some notes for percussion tracks
percNotes = [0,1,2,3]
# perc track names
percNames = ["kick", "hh", "sd", "cp", "?", "?", "bassline", "?", "?"]
percNames = ["kick", "hh", "sd", "cp", "five"]
# for use generating sequences of 0's and 1's
#
#
@ -75,6 +75,7 @@ import sys @@ -75,6 +75,7 @@ import sys
import random
import math
import re
import time
##################################################
@ -83,7 +84,11 @@ import re @@ -83,7 +84,11 @@ import re
# seeds should be 6 digits or longer
input = sys.argv[1]
### FRONTMATTER ###
print("-- seed: " + str(input))
print("-- generated at "+str(time.time()))
print("")
########### THIS CHANGES EVERYTHING! #############
@ -91,11 +96,11 @@ print("-- seed: " + str(input)) @@ -91,11 +96,11 @@ print("-- seed: " + str(input))
random.seed(input)
##################################################
indent = " "
indent = " "
# generate a bpm between lowest and highest
# looks like: cps = (BPM/60/4)
bpm = "cps = ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)"
print(bpm+"\n")
bpm = "setcps ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)"
#print(bpm)
####################### FUNCTIONS ###################
@ -130,7 +135,7 @@ def generateBinary(busyness): @@ -130,7 +135,7 @@ def generateBinary(busyness):
binary = [0,0,1,1,1,1,1,1,1,1,1]
return binary
def genOnOff(limit,busyness):
def genOnOff(limit,busyness,struct):
"generate a series of 0's and 1's"
zeroesOnes = ""
@ -153,8 +158,14 @@ def genOnOff(limit,busyness): @@ -153,8 +158,14 @@ def genOnOff(limit,busyness):
# >>> re.findall('.{1,2}', '123456789')
# ['12', '34', '56', '78', '9']
#zeroesOnes = re.findall('.{1,2}', zeroesOnes)
zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
return(zeroesOnes)
if (struct == 1):
zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
return(zeroesOnes)
else:
return(zeroesOnes)
def euclid(divider):
"generate a euclidean rhythm for tidalcycles"
@ -210,7 +221,7 @@ def offset(): @@ -210,7 +221,7 @@ def offset():
def every():
# TODO add a switch to choose divisible by 2/4/8 or not
bars = random.randint(2,16)
return ("$ every "+str(bars)+" ")
return (indent+indent+"$ every "+str(bars)+" ")
def scramble():
divisions = [4,8,16]
@ -227,7 +238,7 @@ def stut(): @@ -227,7 +238,7 @@ def stut():
stut REPEATS VOLUME TIME
"""
# choose how many repeats
repeats = random.choice([1,1,1,1,1,1,2,2,2,3,3,3,4,4,4,4,4,45])
repeats = random.choice([1,1,1,1,1,1,2,2,2,3,3,3,4,4,4,4,4,5])
time = random.choice(["1/4","1/8","1/16","1/16","1/16"])
return("stut "+str(repeats)+" 1 \""+str(time)+"\"")
@ -252,6 +263,26 @@ def bite(): @@ -252,6 +263,26 @@ def bite():
# we don't need to prepend with $ or ,
return ("bite "+number+ " \"{"+bit+"}%"+number+"\"")
def offset():
offsetChoices = [0.125,0.125,0.125,0.125,0.1875,0.1875,0.1875]
return ("("+str(random.choice(offsetChoices))+" ~>)")
def fills():
"""
Generate some things that would be cool at the end of phrases,
eg whenmod 8 7 (do something)
But nothing too intense
"""
# like whenmod 8 7
fillChoices = [stut(),"rev",scramble()]
# how many filles do we want?
fills = ""
for i in range(1,10):
# roll the dice
whenmods = ["8 7","4 3","16 15","16 14","32 31"]
fills = str(random.choice(fillChoices))+" "+fills
return "whenmod "+str(random.choice(whenmods))+" ("+fills.rstrip()+")"
########################### LISTS ##########################
@ -267,12 +298,27 @@ cyPats = ["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"] @@ -267,12 +298,27 @@ cyPats = ["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"]
############### It's assemble time!! ###################
print("do")
#print("")
# create "let" statements
for i in percNames:
#print("let "+i+"M = \"["+genOnOff(4,5,0)+"]\"")
print(indent+"let "+i+"M = \"[1111]\"")
#print("")
# actually assemble the stack!
print("p \""+stackName+"\" ")
print(indent+"p \""+stackName+"\" ")
# stack stuff like bite, scramble, etc. will go here
print("$ whenmod 8 7 (scramble 4)") #
# roll the dice up to N times
for i in range(1,8):
if (random.randint(0,10) > 4):
print(indent+indent+"$ "+fills())
# how many "fun" things to add?
# a list of things to do to patterns to make them more interesting
@ -288,7 +334,7 @@ def funThings(): @@ -288,7 +334,7 @@ def funThings():
# for each iteration, choose an interestingThing
# indent + "every N" + ( rev )
wholeEnchilada = indent+str(every()+"("+str(random.choice(interestingThings))+")\n"+wholeEnchilada).rstrip()
wholeEnchilada = str(every()+"("+str(random.choice(interestingThings))+")\n"+wholeEnchilada).rstrip()
# using "every"
#return (every()+"("+bite()+")")
@ -298,12 +344,12 @@ def funThings(): @@ -298,12 +344,12 @@ def funThings():
#funThings()
# the top of the stack
print("$ stack [")
print(indent+indent+"$ stack [")
# this is an empty track to make dealing with commas easier
# just 4 to the floor in case you want it
print(indent+"-- four to the floor")
print(indent+"(#gain 0) $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
print(indent+indent+"-- four to the floor")
print(indent+indent+"(#gain 0) $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
#print(",struct \"[t*4]\" $ n 0 # midichan 0")
@ -314,20 +360,28 @@ percMidiChan = 0 @@ -314,20 +360,28 @@ percMidiChan = 0
## this is where each "track" is generated
## percCount = how many rhythmic (non-melodic) tracks
## will be created
for i in range(percCount):
for i in percNames:
print(indent+"-- "+percNames[percMidiChan]+" -----------------")
print(indent+indent+"-- "+percNames[percMidiChan]+" -----------------")
# this is here so there is the same thing at the start of
# each new track (so we know "whenmod" for instance always
# starts with $ and not ,)
print(indent+"degradeBy 0 ")
#print(indent+indent+"degradeBy 0 ")
print(indent+indent+"mask "+i+"M")
#### FUN STUFF #####
# insert some funStuff, maybe
if (random.randint(0,10) > 2):
if (random.randint(0,10) > 8):
print(funThings())
#### OFFSET ####
if (random.randint(0,10) > 6):
print(indent+indent+"$ "+offset())
##### THE RHYTHMS #####
# choose between random, hardcoded, or euclidean rhythms
rChoice = random.choice([0,1,2])
rhythm = ""
@ -348,7 +402,7 @@ for i in range(percCount): @@ -348,7 +402,7 @@ for i in range(percCount):
elif (i == 4):
rhythm = str(random.choice(cyPats))
else:
rhythm = "t*16"
rhythm = "t*4"
rhythm = "struct \""+rhythm+"\""
elif (rChoice == 1):
@ -365,35 +419,35 @@ for i in range(percCount): @@ -365,35 +419,35 @@ for i in range(percCount):
# choose a random value between 0 and 9
busyness = random.randrange(0,7)
generateBinary(busyness)
rhythm = str(genOnOff(percLength,busyness))
rhythm = str(genOnOff(percLength,busyness,1))
elif (rChoice == 2):
# GENERATE EUCLIDEAN RHYTHMS
rhythm = str(euclid(random.choice(dividers)))
#print(indent+euclid(random.choice(dividers)))
#print(indent+indent+euclid(random.choice(dividers)))
#
else:
rhythm = "struct [t*4]"
print(indent+"$ "+rhythm)
print (indent+"$ n "+str(percNote)+" # midichan "+str(percMidiChan)+",")
print(indent+indent+"$ "+rhythm)
print (indent+indent+"$ n "+str(random.choice(percNotes))+" # midichan "+str(percMidiChan)+",")
percMidiChan = percMidiChan + 1
# generate melodic tracks
melodicMidiChan = melodyMidiChanStart
#melodyMidiChanStart = 7
for i in range(melodyCount):
print(indent+"-----------------------")
print(indent+"degradeBy 0 ")
print(indent+indent+"-----------------------")
print(indent+indent+"degradeBy 0 ")
#print(", ")
busyness = random.choice([0,1,2,3,4,5,6,6,6,6,7,7,7,7,8,8,8,9,9])
if (oneBar == 1):
print(indent+"$ "+genOnOff(16,(busyness)))
print(indent+"$ "+genNotes(1))
print(indent+indent+"$ "+genOnOff(16,(busyness),1))
print(indent+indent+"$ "+genNotes(1))
else:
genOnOff(32,(busyness))
print(indent+"$ "+genNotes(1))
print(indent+"# midichan "+str(melodicMidiChan)+" + n (-36)")
print(indent+indent+"$ "+genNotes(1))
print(indent+indent+"# midichan "+str(melodicMidiChan)+" + n (-36)")
melodicMidiChan = melodicMidiChan + 1
print("] # sunvox")
print(indent+indent+"] # sunvox")

813
test.tidal

@ -9,14 +9,21 @@ some seeds I've liked: @@ -9,14 +9,21 @@ some seeds I've liked:
644793890351458335
803051260356546356
1061676950143263647
1726268759940563490
1035561506162950173 -- groovy
2138151558308434562 -- funky
231920015948102138 -- funky
7138151558308434562 -- funky
-- seed: -2138151558308434562
do
let cps = (90/60/4)
setcps = (18/60/4)
bpm (100/60/4)
setcps (130/60/4)
hush
p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
@ -52,3 +59,801 @@ $ stack [ @@ -52,3 +59,801 @@ $ stack [
$ n "{28 15 3 6 21 21 22 16 2 34 9 6 0 35 23 28 }%16"
# midichan 7 + n (-36)
] # sunvox
hush
-- seed: -1128205447549990176
cps = (98/60/4)
p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
$ every 5 (stut 3 1 "1/4")
$ every 2 (rev)
$ every 2 (rev)
$ struct "[t t t t*2]"
$ n 0 # midichan 0,
] # sunvox
d1 $ s "bd"
hush
-- seed: 319200159481021387
setcps (94/60/4)
p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
degradeBy 0
$ every 8 (rev)
$ every 9 (rev)
$ every 5 (stut 2 1 "1/4")
$ struct "{0000000011100100}%16"
$ n 0 # midichan 0,
-- hh -----------------
degradeBy 0
$ struct "[t(3,4)]"
$ n 0 # midichan 1,
-- sd -----------------
degradeBy 0
$ every 12 (rev)
$ every 13 (rev)
$ struct "{0000101001001011}%16"
$ n 0 # midichan 2,
-- cp -----------------
degradeBy 0
$ every 13 (stut 2 1 "1/4")
$ struct "{0101101100111111}%16"
$ n 0 # midichan 3,
-- ? -----------------
degradeBy 0
$ every 13 (scramble 16)
$ every 14 (("1/8" ~>))
$ every 9 (bite 4 "{1*1 4*1 4*4 3*1 0*1 1*2 4*4 4*1 3*1 3*4 3*4 1*1 }%4")
$ struct "[<t~~~>~~~]"
$ n 0 # midichan 4,
-----------------------
degradeBy 0
$ struct "{1100101001010010}%16"
$ n "{0 7 3 2 3 1 20 11 6 17 5 6 20 16 20 6 }%16"
# midichan 7 + n (-36)
] # sunvox
hush
-- seed: -1054995728480467182
cps = (123/60/4)
p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
degradeBy 0
$ (0.125 ~>)
$ struct "[t~~~ ~~<~t~~>~ ~~t~ ~<~t>~~]"
$ n 0 # midichan 0,
-- hh -----------------
degradeBy 0
$ struct "[t*16]"
$ n 0 # midichan 1,
-- sd -----------------
degradeBy 0
$ (0.1875 ~>)
$ struct "[[~~~t][~t]]*2"
$ n 0 # midichan 2,
-- cp -----------------
degradeBy 0
$ struct "[t(3,8)]"
$ n 0 # midichan 3,
-- ? -----------------
degradeBy 0
$ struct "[t*8]"
$ n 0 # midichan 4,
-----------------------
degradeBy 0
$ struct "{0111111111101100}%16"
$ n "{33 14 2 25 10 23 4 11 11 1 25 7 10 6 8 33 }%16"
# midichan 7 + n (-36)
] # sunvox
hush
do
setcps (120)
let something = "hello"
d1 $ s "bd"
-- seed: 2104142091522455394
-- generated at 1633463772.53
hush
-- seed: 197507295067074279
-- generated at 1633463837.81
-- seed: 485348289655373702
-- generated at 1633463949.6
-- seed: -1703565451078464692
-- generated at 1633464313.44
do
p "techno"
$ whenmod 2 1 (bite 4 "0 0 0 4")
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
degradeBy 0
$ every 8 (scramble 16)
$ every 10 ((0.1875 ~>))
$ every 14 (rev)
$ struct "[t*4]"
$ n 0 # midichan 0,
-- hh -----------------
degradeBy 0
$ struct "[t(4,8)]"
$ n 0 # midichan 1,
-- sd -----------------
degradeBy 0
$ struct "[t(4,8)]"
$ n 0 # midichan 2,
-- cp -----------------
degradeBy 0
$ struct "{0010000000000000}%16"
$ n 0 # midichan 3,
-- ? -----------------
degradeBy 0
$ struct "{0000100010000000}%16"
$ n 0 # midichan 4,
-----------------------
degradeBy 0
$ struct "{1111101101111110}%16"
$ n "{20 20 1 0 10 8 5 8 25 0 9 23 21 30 8 9 }%8"
# midichan 7 + n (-36)
] # sunvox
-- seed: 563969774834715115
-- generated at 1633465467.85
-- seed: 456859454801594881
-- generated at 1633467293.87
hush
do
let hello = "[t*8]"
p "techno" $ stack [
struct hello $ s "bd"
]
-- seed: 315014084723179620
-- generated at 1633467476.05
hush
-- seed: 412835948404765370
-- generated at 1633467827.68
do
let kickM = "[1]"
let hhM = "[0111]"
let sdM = "[1100]"
let cpM = "[1110]"
let fiveM = "[1011]"
let sixM = "[1100]"
let basslineM = "[1011]"
let eightM = "[1000]"
let nineM = "[1000]"
p "techno"
$ whenmod 32 31 (bite 4 "{2*2 2*1 1*4 3*4 2*4 2*1 1*1 3*2 }%4")
$ whenmod 16 15 (stut 3 1 "1/16")
$ whenmod 8 7 (scramble 16)
$ whenmod 16 15 (stut 1 1 "1/16")
$ whenmod 32 31 (scramble 16)
$ whenmod 16 15 (scramble 4)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask "[0]"
$ (0.1875 ~>)
$ struct "{1011000100100100}%16"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ (0.1875 ~>)
$ struct "t*16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ every 12 (rev)
$ every 2 (bite 4 "{2*1 0*2 4*2 1*1 }%4")
$ every 7 (rev)
$ (0.125 ~>)
$ struct "t*16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ (0.1875 ~>)
$ struct "[t(2,4)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ struct "{1010010001001000}%16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ struct "t*16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "t*16"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ (0.1875 ~>)
$ struct "[t(11,16)]"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ (0.125 ~>)
$ struct "{0010001011101101}%16"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{1110100111101110}%16"
$ n "{8 18 18 34 8 34 0 17 13 3 4 7 4 17 1 0 }%16"
# midichan 7 + n (-36)
] # sunvox
-- seed: -944805744933000927
-- generated at 1633468178.51
-- seed: -639917386321814739
-- generated at 1633468248.95
do
let kickM = "[0001]"
let hhM = "[0001]"
let sdM = "[1110]"
let cpM = "[0010]"
let fiveM = "[0111]"
let sixM = "[0011]"
let basslineM = "[0011]"
let eightM = "[1110]"
let nineM = "[1001]"
p "techno"
$ whenmod 16 15 (scramble 8)
$ whenmod 16 15 (bite 4 "{1*2 1*4 1*2 2*4 0*2 4*2 0*1 2*1 2*2 3*4 3*2 1*4 }%4")
$ whenmod 8 7 (stut 4 1 "1/16")
$ whenmod 4 3 (scramble 8)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ struct "t*16"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ (0.1875 ~>)
$ struct "[t(7,8)]"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ (0.125 ~>)
$ struct "{1011011100011100}%16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ (0.125 ~>)
$ struct "[t(15,16)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ struct "t*16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ every 13 (stut 2 1 "1/16")
$ every 5 (rev)
$ every 9 ((0.1875 ~>))
$ (0.1875 ~>)
$ struct "{0111100111000101}%16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ (0.125 ~>)
$ struct "t*16"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ every 10 (stut 2 1 "1/16")
$ every 15 ((0.1875 ~>))
$ struct "t*16"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ struct "[t(3,4)]"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0001100111101001}%16"
$ n "{4 21 12 15 2 16 5 22 8 20 4 8 1 23 14 27 }%8"
# midichan 7 + n (-36)
] # sunvox
-- seed: -1022362753540599887
-- generated at 1633468290.41
do
let kickM = "[1101]"
let hhM = "[1001]"
let sdM = "[1110]"
let cpM = "[0111]"
let fiveM = "[1010]"
let sixM = "[1100]"
let basslineM = "[1110]"
let eightM = "[1100]"
let nineM = "[1000]"
Traceback (most recent call last):
File "/home/chris/tidal-auto-techno/auto-techno.py", line 313, in <module>
print(+"p \""+stackName+"\" ")
TypeError: bad operand type for unary +: 'str'
-- seed: -1667571548371307357
-- generated at 1633468363.94
hush
-- seed: -1728339397765061981
-- generated at 1633468433.83
do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 16 14 (scramble 4)
$ whenmod 16 15 (bite 4 "{2*1 4*4 1*1 1*4 3*2 0*2 4*2 2*1 }%4")
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ (0.1875 ~>)
$ struct "[t(4,8)]"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ every 14 (rev)
$ every 15 (bite 4 "{0*4 2*4 4*2 2*4 2*2 1*1 4*2 0*2 1*2 4*4 3*1 2*1 2*1 0*1 0*2 0*4 }%4")
$ every 6 (stut 1 1 "1/16")
$ (0.1875 ~>)
$ struct "{0001000000000000}%16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ (0.125 ~>)
$ struct "t*16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ (0.1875 ~>)
$ struct "[t(5,16)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ struct "{0101010100000101}%16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ struct "{1101001011110010}%16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "[t(2,4)]"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ every 14 (scramble 8)
$ struct "[t(7,8)]"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ struct "{0010000000000000}%16"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0110110101100110}%16"
$ n "{19 0 15 19 15 19 14 34 23 0 5 10 13 23 17 16 }%16"
# midichan 7 + n (-36)
] # sunvox
-- seed: -925754403333800332
-- generated at 1633468492.63
do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 8 7 (scramble 16)
$ whenmod 16 15 (rev)
$ whenmod 16 15 (stut 3 1 "1/16")
$ whenmod 16 15 (bite 4 "{4*1 3*4 0*4 4*1 3*1 1*1 2*2 0*4 3*4 }%4")
$ whenmod 32 31 (scramble 8)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ struct "[t(3,4)]"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ every 13 (stut 1 1 "1/8")
$ every 5 (bite 8 "{2*4 7*4 6*2 5*2 2*4 2*2 8*1 2*1 0*1 6*1 1*2 5*1 0*2 6*2 7*2 6*2 }%8")
$ struct "[t(2,4)]"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ (0.125 ~>)
$ struct "[t(6,8)]"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ struct "t*16"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ (0.1875 ~>)
$ struct "[t(4,8)]"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ struct "t*16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "[t(9,16)]"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ (0.1875 ~>)
$ struct "[t(2,16)]"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ (0.125 ~>)
$ struct "t*16"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0011101101100110}%16"
$ n "{8 34 9 4 9 0 10 15 30 7 29 18 18 20 19 27 }%8"
# midichan 7 + n (-36)
] # sunvox
-- seed: -296151779328239296
-- generated at 1633468506.28
do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 8 7 (scramble 8)
$ whenmod 32 31 (scramble 4)
$ whenmod 4 3 (scramble 8)
$ whenmod 8 7 (bite 8 "{0*2 6*1 8*2 2*1 8*2 7*1 6*1 2*1 3*4 }%8")
$ whenmod 16 15 (stut 2 1 "1/16")
$ whenmod 8 7 (rev)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ (0.1875 ~>)
$ struct "t*16"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ every 9 (bite 8 "{1*4 3*4 3*1 5*2 5*1 3*4 8*2 3*2 7*2 4*4 6*4 6*2 7*2 0*2 0*4 }%8")
$ (0.1875 ~>)
$ struct "{1111001000001110}%16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ struct "[t(12,16)]"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ (0.125 ~>)
$ struct "[t(15,16)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ (0.125 ~>)
$ struct "t*16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ (0.125 ~>)
$ struct "[t(2,8)]"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "[t(7,16)]"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ struct "t*16"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ struct "t*16"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0101010011101010}%16"
$ n "{0 8 0 6 10 8 6 9 4 18 6 4 1 6 35 30 }%8"
# midichan 7 + n (-36)
] # sunvox
-- seed: -863274151192537696
-- generated at 1633468522.75
do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 4 3 (scramble 4)
$ whenmod 16 14 (bite 8 "{7*4 1*2 7*4 8*2 4*2 5*2 2*4 0*2 7*1 8*4 4*4 1*1 7*2 5*1 2*2 }%8")
$ whenmod 32 31 (stut 3 1 "1/16")
$ whenmod 16 15 (stut 1 1 "1/16")
$ whenmod 8 7 (rev)
$ whenmod 32 31 (stut 1 1 "1/16")
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ struct "t*16"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ struct "{0001100001001011}%16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ (0.125 ~>)
$ struct "{0000000010000000}%16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ (0.1875 ~>)
$ struct "[t(3,4)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ struct "[t(14,16)]"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ every 4 (scramble 8)
$ every 12 (rev)
$ struct "{1011110000111001}%16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ (0.125 ~>)
$ struct "[t(2,4)]"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ struct "[t(7,8)]"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ struct "{0010000000000100}%16"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0111001111011110}%16"
$ n "{1 5 26 24 6 4 35 21 5 8 30 11 6 1 15 5 }%16"
# midichan 7 + n (-36)
] # sunvox
-- seed: -1900899368135846569
-- generated at 1633468554.75
do
let kickM = "[0]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 16 15 (stut 1 1 "1/16")
$ whenmod 8 7 (scramble 16)
$ whenmod 4 3 (scramble 8)
$ whenmod 4 3 (scramble 8)
$ whenmod 32 31 (rev)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ every 9 (stut 3 1 "1/8")
$ struct "{1000101110111001}%16"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ struct "{0000000000000000}%16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ every 8 (bite 4 "{2*1 4*2 0*1 3*2 3*4 0*4 0*4 }%4")
$ every 4 (bite 4 "{2*1 4*2 0*1 3*2 3*4 0*4 0*4 }%4")
$ (0.125 ~>)
$ struct "[t(3,4)]"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ every 5 ((0.125 ~>))
$ every 16 ((0.125 ~>))
$ struct "{0000010000000101}%16"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ struct "{0000000000000100}%16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ every 5 (scramble 4)
$ struct "t*4"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "[t(5,8)]"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ struct "t*4"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ struct "t*4"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0111111111111111}%16"
$ n "{5 9 6 7 6 22 22 22 13 2 3 7 10 16 24 8 }%16"
# midichan 7 + n (-36)
] # sunvox
-- seed: 221325860405508199
-- generated at 1633468703.57
do
let kickM = "[0]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 4 3 (bite 8 "{8*2 4*4 1*2 3*4 5*4 5*4 4*2 5*1 6*1 7*4 }%8")
$ whenmod 16 14 (bite 8 "{2*2 3*2 0*1 5*2 }%8")
$ whenmod 8 7 (stut 4 1 "1/16")
$ whenmod 16 14 (scramble 8)
$ whenmod 4 3 (bite 4 "{1*2 1*1 1*1 1*4 3*2 3*2 1*2 4*4 3*2 3*4 2*4 }%4")
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ struct "[t(14,16)]"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ every 3 (scramble 4)
$ struct "{1000100000001010}%16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ every 12 (bite 4 "{2*4 1*1 3*1 3*2 0*2 4*2 }%4")
$ every 10 (scramble 4)
$ struct "{0000101000000010}%16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ struct "[t(3,4)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ (0.1875 ~>)
$ struct "{0000000000000100}%16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ struct "{0000000001000110}%16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "{0101011011010001}%16"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ struct "{0011111011101100}%16"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ every 11 (stut 1 1 "1/16")
$ (0.125 ~>)
$ struct "{0110010001110101}%16"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0011101011110111}%16"
$ n "{8 19 11 33 8 8 10 18 2 8 3 2 17 8 8 1 }%8"
# midichan 7 + n (-36)
] # sunvox

Loading…
Cancel
Save