Compare commits

..

No commits in common. 'a952d38e891f2b0e452a3f83686482705524de7c' and 'cfec0aee7a53ab86434282210663629f273098fa' have entirely different histories.

  1. 286
      auto-techno.py
  2. 74
      deleteme.tidal
  3. 284
      test.tidal

286
auto-techno.py

@ -1,8 +1,4 @@ @@ -1,8 +1,4 @@
#!/usr/bin/env python3
scriptName = "Auto-Techno Generator"
version = 0.1
author = "Chris Beckstrom"
author_email = "chris@chrisbeckstrom.com"
# a deterministic techno generator for tidalcycles
# input an integer value as a seed
# and it spits out some techno ready to play
@ -21,7 +17,7 @@ lowestBpm = 92 @@ -21,7 +17,7 @@ lowestBpm = 92
highestBpm = 135
# force everything to happen within 1 bar
oneBar = 0
oneBar = 1
# stack name
# this doesn't matter, can be any string
@ -31,8 +27,7 @@ stackName = "techno" @@ -31,8 +27,7 @@ stackName = "techno"
####### PERCUSSION ##############################
# for euclidean rhythms, define the choices for the 2nd number
# eg "[t(3,NN)]"
#dividers = [4,8,16]
dividers = [16]
dividers = [4,8,16]
# how many percussive/rhythmic elements to generate?
percCount = 5
percMidiChanStart = 0
@ -43,8 +38,7 @@ percMidiChanStart = 0 @@ -43,8 +38,7 @@ percMidiChanStart = 0
# set some notes for percussion tracks
percNotes = [0,1,2,3]
# perc track names
# a percussion track will be generated for each item in this list
percNames = ["kick", "hh", "sd", "cp", "ohh","ride","cymbal"]
percNames = ["kick", "hh", "sd", "cp", "five"]
# for use generating sequences of 0's and 1's
#
#
@ -60,8 +54,8 @@ percNames = ["kick", "hh", "sd", "cp", "ohh","ride","cymbal"] @@ -60,8 +54,8 @@ percNames = ["kick", "hh", "sd", "cp", "ohh","ride","cymbal"]
noteRange = [12,24,36]
# define the shortest and longest sequence you want
# eg if shortest is 7, there will be no melodic sequences shorter than 7
shortestMelodic = 3
longestMelodic = 10
shortestMelodic = 4
longestMelodic = 16
# for melodic lines, what divisions do you want to choose from?
# eg 4 = quarter notes, 8 = eighth notes
@ -82,57 +76,24 @@ import random @@ -82,57 +76,24 @@ import random
import math
import re
import time
import decimal
from decimal import Decimal
##################################################
# this is the 1st argument given via command line
# this is used to calculate everything
rawinput = sys.argv[1]
# let's assume it's a hex value
# convert to decimal
#input = int(hex,int(89))
################ SEED HEX #####################
# make sure the seed is a hex value
# why? it doesn't really matter technically
# I just think it would be cool
# plus, hex values for long numbers are shorter
# and easier to read/type
# and might be good track names
# TODO - this is in progress
# if the input is a hex value, we'll know because it starts with 0x
if (rawinput.startswith("0x")):
# the input is a hex number
#print("string starts with 0x")
seed = rawinput.upper()
else:
# the input is NOT a hex number
# convert to a hex number
seed = hex(int(rawinput)).upper()
# by now the seed should start with 0X
# let's change that X to lowercase
seed = seed.replace("X","x")
#print("seed: "+seed)
decimalSeed = int(seed,16)
# seeds should be 6 digits or longer
input = sys.argv[1]
### FRONTMATTER ###
print("-- raw input: " + str(rawinput))
print("-- hex seed: "+seed)
print("-- decimal seed: "+str(decimalSeed))
print("-- seed: " + str(input))
print("-- generated at "+str(time.time()))
print("-- "+scriptName+" v"+str(version))
print("")
########### THIS CHANGES EVERYTHING! #############
# set the random seed based on user input
random.seed(decimalSeed)
random.seed(input)
##################################################
indent = " "
@ -143,7 +104,6 @@ bpm = "setcps ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)" @@ -143,7 +104,6 @@ bpm = "setcps ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)"
####################### FUNCTIONS ###################
def generateBinary(busyness):
"""
busy-ness (sic)
@ -199,8 +159,7 @@ def genOnOff(limit,busyness,struct): @@ -199,8 +159,7 @@ def genOnOff(limit,busyness,struct):
# ['12', '34', '56', '78', '9']
#zeroesOnes = re.findall('.{1,2}', zeroesOnes)
if (struct == 1):
#zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
zeroesOnes = "[{"+str(zeroesOnes)+"}%16]"
zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
return(zeroesOnes)
else:
return(zeroesOnes)
@ -235,8 +194,7 @@ def euclid(divider): @@ -235,8 +194,7 @@ def euclid(divider):
secondEuclid = "<"+str(random.choice(dividers))+" "+str(random.choice(dividers))+">"
# [t(<3 8>,16)]
#return ("struct \"[t("+str(firstEuclid)+","+str(secondEuclid)+")]\"")
return ("[t("+str(firstEuclid)+","+str(secondEuclid)+")]")
return ("struct \"[t("+str(firstEuclid)+","+str(secondEuclid)+")]\"")
def genNotes(melodicOneBar):
"""
@ -254,7 +212,7 @@ def genNotes(melodicOneBar): @@ -254,7 +212,7 @@ def genNotes(melodicOneBar):
melody = ""
for i in range(melodyLength):
melody = str(random.randrange(0,random.choice(noteRange))) + " " + str(melody)
return ("n "+"\"[{"+melody+"}%"+str(random.choice(melodicDivisions))+"]\"")
return ("n "+"\"{"+melody+"}%"+str(random.choice(melodicDivisions))+"\"")
def offset():
amounts = ["1/4","1/8","1/16","1/16","1/16"]
@ -265,13 +223,6 @@ def every(): @@ -265,13 +223,6 @@ def every():
bars = random.randint(2,16)
return (indent+indent+"$ every "+str(bars)+" ")
def within():
firstnum = random.choice([0,0.25,0.5,0.75])
secondnum = random.choice([0.25,0.5,0.75,1])
return (indent+indent+"within ("+str(firstnum)+","+str(secondnum)+" ")
def scramble():
divisions = [4,8,16]
return ("scramble "+str(random.choice(divisions)))
@ -288,7 +239,7 @@ def stut(): @@ -288,7 +239,7 @@ def stut():
"""
# choose how many repeats
repeats = random.choice([1,1,1,1,1,1,2,2,2,3,3,3,4,4,4,4,4,5])
time = random.choice([0.125,0.125,0.125,0.0625,0.0625])
time = random.choice(["1/4","1/8","1/16","1/16","1/16"])
return("stut "+str(repeats)+" 1 \""+str(time)+"\"")
def bite():
@ -302,7 +253,7 @@ def bite(): @@ -302,7 +253,7 @@ def bite():
# generate like 1*4 8*4 2*2 1*2 9*1
repeatChoices = [1,2,4]
# how long should it be?
length = int(random.randint(4,8))
length = int(random.randint(4,16))
bit = ""
for i in range(length):
bit = str(random.randint(0,int(number)))+"*"+str(random.choice(repeatChoices))+" "+bit
@ -316,9 +267,6 @@ def offset(): @@ -316,9 +267,6 @@ def offset():
offsetChoices = [0.125,0.125,0.125,0.125,0.1875,0.1875,0.1875]
return ("("+str(random.choice(offsetChoices))+" ~>)")
def degrade():
degradeAmt = (decimal.Decimal(random.random())).quantize(Decimal('.01'))
return "degradeBy "+str(degradeAmt)
def fills():
"""
@ -332,41 +280,22 @@ def fills(): @@ -332,41 +280,22 @@ def fills():
fills = ""
for i in range(1,10):
# roll the dice
whenmods = ["8 7","16 15","16 14","32 31","64 62","64 63","32 30"]
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()+")"
def sometimesBeQuiet():
"""
Generate a gain pattern so that sometimes a track
is silent, and other times it isn't
"""
#def genOnOff(limit,busyness,struct):
# decide whether to do this at all
if (random.randint(0,10) > 5):
# for now, 8 bar phrases
# (# gain "[0 1 0 0 1]/8")
# how many cycles to make?
quietCycles = random.choice([2,3,4])
quietBinary = genOnOff(quietCycles,2,0)
# split 001001 into 0 0 1 0 0 1
quietBinary = list(quietBinary)
finalQuietBinary = ""
for i in quietBinary:
finalQuietBinary = i + " " + finalQuietBinary
print(indent+indent+"$ degradeBy \"<"+str(finalQuietBinary).rstrip()+">/8\"")
########################### LISTS ##########################
# a collection of typical-ish kick drum patterns
bdPats=["[t*4]","[tttt*2]","[tttt*2?]","t(3,8)","[t~~~~~<~t~~>~~~t~~<~t>~~]"]
hhPats=["[t*16]","[tt*2]*4","[~t]*4","[t*16]"]
sdPats=["[~t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
cpPats=["[~t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
cyPats=["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"]
bdPats= ["[t*4]","[t t t t*2]","[t t t t*2?]","t(3,8)","[t~~~ ~~<~t~~>~ ~~t~ ~<~t>~~]"]
hhPats= ["[t*16]","[t t*2]*4", "[~t]*4","[t*16]"]
sdPats= ["[~ t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
cpPats= ["[~ t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
cyPats = ["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"]
# a collection of misc rhythms
rhythmLibrary = ["[1*4]","[1*8]","[1*9]","[01]*2","[0101]","[1*16]","[1*16?]","[111111[1001][01]]/2","[{100}%16]","[{101011010101}%16]","[{10100}%16]","[{10001}%16]","[{10101}%16]","[{1001010}%16]","[{1011010}%16]","[{10101000100}%16]","[{10101001010}%16]","[{10010010010}%16]","[{1010101001010}%16]","[{1001001001010}%16]","[11*2]*4","[100000<0100>000100<01>00]","[1[10000001]]","[1111*2]","[[0001][01]]*2","[0010000100000001]","[[0001][01]]*2","[[01]1[1001][01]]","[[01]1[1001][0001]]","[11000010]*2","[[0001]000]","[[0001]]*4"]
############### It's assemble time!! ###################
@ -374,11 +303,9 @@ print("do") @@ -374,11 +303,9 @@ print("do")
#print("")
# create "let" statements
print(indent+"let fourToTheFloor = 0")
print(indent+" -- control density per track")
for i in percNames:
#print("let "+i+"M = \"["+genOnOff(4,5,0)+"]\"")
print(indent+" "+i+"M = \"[1111]\"")
print(indent+"let "+i+"M = \"[1111]\"")
#print("")
@ -387,7 +314,7 @@ for i in percNames: @@ -387,7 +314,7 @@ for i in percNames:
print(indent+"p \""+stackName+"\" ")
# stack stuff like bite, scramble, etc. will go here
print(indent+indent+"-- fills")
# roll the dice up to N times
for i in range(1,8):
if (random.randint(0,10) > 4):
@ -396,8 +323,7 @@ for i in range(1,8): @@ -396,8 +323,7 @@ for i in range(1,8):
# how many "fun" things to add?
# a list of things to do to patterns to make them more interesting
# these happen BEFORE struct, note, etc.
#interestingThings = [stut(),bite(),"rev",scramble(),offset()]
interestingThings = [stut(),"rev",scramble(),offset(),degrade()]
interestingThings = [stut(),bite(),"rev",scramble(),offset()]
def funThings():
wholeEnchilada = ""
# add between 1 and 4 "fun" things
@ -409,18 +335,25 @@ def funThings(): @@ -409,18 +335,25 @@ def funThings():
# for each iteration, choose an interestingThing
# indent + "every N" + ( rev )
wholeEnchilada = str(every()+"("+str(random.choice(interestingThings))+")\n"+wholeEnchilada).rstrip()
# using "every"
#return (every()+"("+bite()+")")
return wholeEnchilada
# uncomment this for some wildness
#funThings()
# the top of the 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+indent+"-- four to the floor")
print(indent+indent+"degradeBy fourToTheFloor $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
print(indent+indent+"(#gain 0) $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
#print(",struct \"[t*4]\" $ n 0 # midichan 0")
# generate rhythm tracks
# set the starting midi channel
percMidiChan = 0
########################################################
@ -429,98 +362,74 @@ percMidiChan = 0 @@ -429,98 +362,74 @@ percMidiChan = 0
## will be created
for i in percNames:
# print the name of the track (from the percNames list)
print(indent+indent+"-------------- "+i+" ---------------")
print(indent+indent+"-- "+percNames[percMidiChan]+" -----------------")
# MASK: make this so once the entire thing is generated, it's easy to
# alter how dense the pattern is, by altering "let nnM = "[1111]
print(indent+indent+"mask "+i+"M")
# sometimes be quiet
if (i != "kick"):
sometimesBeQuiet()
# 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+indent+"degradeBy 0 ")
print(indent+indent+"mask "+i+"M")
#### VARIATIONS #####
#### FUN STUFF #####
# insert some funStuff, maybe
if (random.randint(0,10) > 3):
if (random.randint(0,10) > 8):
print(funThings())
#### OFFSET ###
# offset the pattern by a certain amount
# this can make things much funkier
#### OFFSET ####
if (random.randint(0,10) > 6):
print(indent+indent+"$ "+offset())
##### THE RHYTHMS #####
# how many bars to create?
rhythmLengthChoices = [1,1,1,1,1,1,2,2]
rhythmLength = random.choice(rhythmLengthChoices)
# for the number of bars, do this:
fullRhythm = ""
for i in range(rhythmLength):
# choose between random, type-specific (bd,hh,etc),
# rhythm library, or euclidean rhythms
rChoice = random.choice([0,1,1,1,2,3])
rhythm = "" # placeholder for the rhythm
if (rChoice == 0):
# if choice = 0, choose hardcoded rhythms
# if this is the first iteration, ie "kick"
# choose from some hard-coded kick rhythms
# 2nd? same for hh
# 3rd? same for sd
if (i == 0):
rhythm = str(random.choice(bdPats))
elif (i == 1):
rhythm = str(random.choice(hhPats))
elif (i == 2):
rhythm = str(random.choice(sdPats))
elif (i == 3):
rhythm = str(random.choice(cpPats))
elif (i == 4):
rhythm = str(random.choice(cyPats))
else:
# print("LIBRARY")
rhythm = str(random.choice(rhythmLibrary))
#rhythm = "struct \""+rhythm+"\""
elif (rChoice == 1):
# GENERATE A SERIES OF 0's and 1's
# choose how long the rhythm will be
# if (oneBar == 1):
# percLength = 16
# else:
# percLength = int(random.randrange(4,8))
percLength = int(random.randrange(4,10))
#percSequence = genOnOff(percLength)
#print(","+str(genOnOff(10)))
#print(str(percSequence))
# how busy will it be?a
# choose a random value between 0 and 9
busyness = random.randrange(0,7)
generateBinary(busyness)
rhythm = str(genOnOff(percLength,busyness,1))
elif (rChoice == 2):
# GENERATE EUCLIDEAN RHYTHMS
rhythm = str(euclid(random.choice(dividers)))
#print(indent+indent+euclid(random.choice(dividers)))
#
##### THE RHYTHMS #####
# choose between random, hardcoded, or euclidean rhythms
rChoice = random.choice([0,1,2])
rhythm = ""
if (rChoice == 0):
# if choice = 0, choose hardcoded rhythms
# if this is the first iteration, ie "kick"
# choose from some hard-coded kick rhythms
# 2nd? same for hh
# 3rd? same for sd
if (i == 0):
rhythm = str(random.choice(bdPats))
elif (i == 1):
rhythm = str(random.choice(hhPats))
elif (i == 2):
rhythm = str(random.choice(sdPats))
elif (i == 3):
rhythm = str(random.choice(cpPats))
elif (i == 4):
rhythm = str(random.choice(cyPats))
else:
# print("LIBRARY")
rhythm = str(random.choice(rhythmLibrary))
#rhythm = "struct \""+rhythm+"\""
fullRhythm = str(rhythm) + " " + fullRhythm
# remove the trailing space
fullRhythm = fullRhythm.rstrip()
rhythm = "t*4"
rhythm = "struct \""+rhythm+"\""
elif (rChoice == 1):
# GENERATE A SERIES OF 0's and 1's
# choose how long the rhythm will be
if (oneBar == 1):
percLength = 16
else:
percLength = int(random.randrange(4,16))
#percSequence = genOnOff(percLength)
#print(","+str(genOnOff(10)))
#print(str(percSequence))
# how busy will it be?a
# choose a random value between 0 and 9
busyness = random.randrange(0,7)
generateBinary(busyness)
rhythm = str(genOnOff(percLength,busyness,1))
elif (rChoice == 2):
# GENERATE EUCLIDEAN RHYTHMS
rhythm = str(euclid(random.choice(dividers)))
#print(indent+indent+euclid(random.choice(dividers)))
#
else:
rhythm = "struct [t*4]"
# add "struct" to the beginning
# and enclose in < >
print(indent+indent+"$ struct \"<"+fullRhythm+">\"")
print(indent+indent+"$ "+rhythm)
print (indent+indent+"$ n "+str(random.choice(percNotes))+" # midichan "+str(percMidiChan)+",")
percMidiChan = percMidiChan + 1
@ -533,15 +442,12 @@ for i in range(melodyCount): @@ -533,15 +442,12 @@ for i in range(melodyCount):
#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+indent+"$ struct \""+genOnOff(16,(busyness),1)+"\"")
print(indent+indent+"$ "+genOnOff(16,(busyness),1))
print(indent+indent+"$ "+genNotes(1))
else:
# how many 16th notes?
thisLength = random.randint(3,16)
#genOnOff(8,(busyness))
print(indent+indent+"$ struct \""+genOnOff(thisLength,(busyness),1)+"\"")
print(indent+indent+"$ "+genNotes(0))
print(indent+indent+"# midichan "+str(melodicMidiChan)+" + n (-42)")
genOnOff(32,(busyness))
print(indent+indent+"$ "+genNotes(1))
print(indent+indent+"# midichan "+str(melodicMidiChan)+" + n (-36)")
melodicMidiChan = melodicMidiChan + 1
print(indent+indent+"] # sunvox")

74
deleteme.tidal

@ -1,74 +0,0 @@ @@ -1,74 +0,0 @@
-- raw input: 268982558670766555
-- hex seed: 0x3BB9E364458C1DB
-- decimal seed: 268982558670766555
-- generated at 1633539511.09
-- Auto-Techno Generator v0.1
do
let fourToTheFloor = 0
-- control density per track
kickM = "[1111]"
hhM = "[1111]"
sdM = "[1111]"
cpM = "[1111]"
ohhM = "[1111]"
rideM = "[1111]"
cymbalM = "[1111]"
p "techno"
-- fills
$ whenmod 32 30 (rev)
$ whenmod 32 31 (stut 2 1 "0.125")
$ whenmod 32 30 (scramble 16)
$ whenmod 16 15 (rev)
$ whenmod 64 62 (rev)
$ stack [
-- four to the floor
degradeBy fourToTheFloor $ struct "[t*4]" $ n "0" # midichan 0,
-------------- kick ---------------
mask kickM
$ every 6 ((0.125 ~>))
$ (0.125 ~>)
$ struct "<[{0101011}%16]>"
$ n 1 # midichan 0,
-------------- hh ---------------
mask hhM
$ every 16 (scramble 8)
$ every 15 ((0.125 ~>))
$ struct "<[1*16]>"
$ n 3 # midichan 1,
-------------- sd ---------------
mask sdM
$ every 15 (stut 5 1 "0.0625")
$ (0.125 ~>)
$ struct "<[t(15,16)]>"
$ n 2 # midichan 2,
-------------- cp ---------------
mask cpM
$ degradeBy "[0 0 1]/8"
$ struct "<[{0000100}%16]>"
$ n 3 # midichan 3,
-------------- ohh ---------------
mask ohhM
$ struct "<[tt*2]*4 [[0001]]*4>"
$ n 0 # midichan 4,
-------------- ride ---------------
mask rideM
$ every 10 (scramble 8)
$ every 5 (rev)
$ every 13 (scramble 8)
$ (0.1875 ~>)
$ struct "<[t(4,16)]>"
$ n 0 # midichan 5,
-------------- cymbal ---------------
mask cymbalM
$ every 8 (rev)
$ every 7 (rev)
$ every 12 (stut 5 1 "0.0625")
$ struct "<[{10011000}%16]>"
$ n 3 # midichan 6,
-----------------------
degradeBy 0
$ struct "[{0010100000000000}%16]"
$ n "[{18 6 8 7 19 35 8 24 11 7 7 8 3 23 8 33 }%16]"
# midichan 7 + n (-42)
] # sunvox

284
test.tidal

@ -13,11 +13,7 @@ some seeds I've liked: @@ -13,11 +13,7 @@ some seeds I've liked:
1035561506162950173 -- groovy
231920015948102138 -- funky
7138151558308434562 -- funky
2154183685935315319 -- vaguely arabic
1880041842519425526
1014891741240181557 -- pretty funky
850750894594826640 -- great if the kick is t(3,8) instead of t(3,4)
2195224328517994763 -- funnnnkkky
-- seed: -2138151558308434562
setcps = (18/60/4)
@ -648,19 +644,18 @@ $ whenmod 8 7 (rev) @@ -648,19 +644,18 @@ $ whenmod 8 7 (rev)
-- seed: -863274151192537696
-- generated at 1633468522.75jjjjjjjjjjjjjjjjjjjjjjjG
-- generated at 1633468522.75
do
let kickM = "[0000]"
let hhM = "[0000]"
let sdM = "[0000]"
let cpM = "[0000]"
let fiveM = "[0000]"
let sixM = "[0000]"
let basslineM = "[0000]"
let eightM = "[0000]"
let nineM = "[0000]"
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")
@ -862,260 +857,3 @@ $ stack [ @@ -862,260 +857,3 @@ $ stack [
$ n "{8 19 11 33 8 8 10 18 2 8 3 2 17 8 8 1 }%8"
# midichan 7 + n (-36)
] # sunvox
hush
do
let masky = "[0]"
p "techno"
$ whenmod 8 7 (fast 2)
$ stack [
mask masky
$ s "bd*16"
]
-- seed: -844672810981675420
-- generated at 1633469145.73
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 32 31 (scramble 4)
$ whenmod 32 31 (scramble 4)
$ whenmod 16 14 (bite 4 "{3*4 2*1 0*1 0*1 1*2 3*2 2*4 2*1 3*4 2*1 4*1 0*1 0*2 4*4 4*2 3*1 }%4")
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ (0.125 ~>)
$ struct "t*4"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ every 9 (stut 2 1 "1/4")
$ every 4 (bite 4 "{4*2 4*2 2*2 4*4 1*1 2*1 2*4 0*4 3*2 0*4 3*1 0*1 3*2 1*2 }%4")
$ struct "t*4"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ (0.1875 ~>)
$ struct "{0011010110101101}%16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ struct "[t(7,8)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ (0.125 ~>)
$ struct "{0000000000000001}%16"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ struct "t*4"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ (0.125 ~>)
$ struct "t*4"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ struct "t*4"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ struct "[t(4,8)]"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0111101111101011}%16"
$ n "{17 2 23 15 29 35 8 20 5 19 2 9 34 2 1 5 }%8"
# midichan 7 + n (-36)
] # sunvox
-- seed: 2235447325725207626
-- generated at 1633469239.66
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 15 (scramble 16)
$ whenmod 4 3 (stut 4 1 "1/16")
$ whenmod 32 31 (rev)
$ whenmod 16 14 (stut 3 1 "1/4")
$ whenmod 16 15 (scramble 16)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ (0.125 ~>)
$ struct "[t(2,16)]"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ struct "[t(2,4)]"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ struct "[t(9,16)]"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ struct "[t(2,4)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ (0.125 ~>)
$ struct "[t(2,4)]"
$ n 0 # midichan 4,
-- six -----------------
mask sixM
$ every 9 (scramble 8)
$ struct "{1100101000001100}%16"
$ n 0 # midichan 5,
-- bassline -----------------
mask basslineM
$ struct "[t(11,16)]"
$ n 0 # midichan 6,
-- eight -----------------
mask eightM
$ every 4 ((0.1875 ~>))
$ every 4 ((0.1875 ~>))
$ every 13 ((0.1875 ~>))
$ (0.1875 ~>)
$ struct "[t(3,4)]"
$ n 0 # midichan 7,
-- nine -----------------
mask nineM
$ every 2 (scramble 8)
$ struct "t*4"
$ n 0 # midichan 8,
-----------------------
degradeBy 0
$ struct "{0010100101000001}%16"
$ n "{9 4 9 4 18 18 8 13 11 8 0 5 5 12 1 21 }%16"
# midichan 7 + n (-36)
] # sunvox
-- seed: 590111300892224819
-- generated at 1633469475.43
do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[100]"
let fiveM = "[1111]"
p "techno"
$ whenmod 32 31 (rev)
$ whenmod 16 14 (stut 4 1 "1/16")
$ whenmod 8 7 (scramble 16)
$ stack [
-- four to the floor
(#gain 1) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ (0.1875 ~>)
$ struct "[t(3,4)]"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ struct "[t(3,4)]"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ struct "{0000000010000000}%16"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ struct "[t(10,16)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ struct "[t(7,8)]"
$ n 0 # midichan 4,
-----------------------
degradeBy 0
$ struct "{0100101101100010}%16"
$ n "{15 3 21 25 5 7 3 2 15 7 13 3 0 3 13 10 }%16"
# midichan 7 + n (-36)
] # sunvox
utouto
-- seed: 493703295080029503
-- generated at 1633469804.11
do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
p "techno"
$ whenmod 8 7 (rev)
$ whenmod 4 3 (stut 4 1 0.125)
$ whenmod 32 31 (scramble 16)
$ stack [
-- four to the floor
(#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
-- kick -----------------
mask kickM
$ (0.125 ~>)
$ struct "t*4"
$ n 0 # midichan 0,
-- hh -----------------
mask hhM
$ struct "{1000011101010000}%16"
$ n 0 # midichan 1,
-- sd -----------------
mask sdM
$ (0.1875 ~>)
$ struct "t*4"
$ n 0 # midichan 2,
-- cp -----------------
mask cpM
$ every 13 (scramble 4)
$ struct "[t(7,8)]"
$ n 0 # midichan 3,
-- five -----------------
mask fiveM
$ (0.1875 ~>)
$ struct "t*4"
$ n 0 # midichan 4,
-----------------------
degradeBy 0
$ struct "{1111100110011111}%16"
$ n "{11 7 5 10 15 7 0 24 5 14 11 11 0 20 22 24 }%16"
# midichan 7 + n (-36)
] # sunvox
hush
hush

Loading…
Cancel
Save