anticipate.tidal

-- scale function
let major = scale "major"

-- Begin / end
-- cheeky bastard
d1 $ s "bogdan:7*4" # begin 0.2 # end 0.5

-- shape produces wave shaping distortion?
once $ s "bogdan:6" # shape "0.5" # gain 0.6

-- TODO: Use within to apply an effect to only a part of a pattern!
-- TODO: Use fix to fix a specific kind of sample!
--The fix function applies another function to matching events in a pattern of controls.
-- For example:

d1 $ slow 2 $ fix (# crush 3) (n "[1,4]") $ n "0 1 2 3 4 5 6" # sound "arpy"

-- Anticipation: TODO
setcps 1

anticipate 3 silence

xfadeIn 1 4 $ s "jvbass(4,8)"

d1 $ sound "jvbass(3,8)"

anticipate 1 $ sound "bd sn"


-- TODO: weave to spread a control pattern over a list, successively offset
d1 $ weave 16 (pan sine)
  [sound "bd sn cp",
   sound "casio casio:1",
   sound "[jvbass*2 jvbass:2]/2",
   sound "hc*4"
  ]



d2 $ s "cp"

-- TODO: ur pattern  of pattern
-- Lets say you had three patterns (called 'a', 'b' and 'c'), and that you wanted to play them four cycles each, over twelve cycles in total. Here is one way to do it:
--
-- let pats =
--       [
--         ("a", stack [n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                      n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
--                     ]
--         ),
--         ("b", stack [n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                      n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
--                     ]
--         ),
--         ("c", stack [n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                      n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
--                     ]
--         )
--       ]
-- in
-- d1 $ ur 12 "a b c" pats []
--
-- In ur 12 "a b c" pats [], the 12 is the duration of the loop (in cycles), the "a b c" is the structure of named patterns, and pats is the lookup table, defined above. So the "a b c" pattern happens over the 12 cycles, with the a, b and c standing in for each of the three patterns given in the lookup table. Because there are three events in this pattern, and it happens over 12 cycles. then each event is four cycles long.
--
-- In the above, the fourth parameter is given as an empty list, but that is where you can put another lookup table, of functions rather than patterns this time. Here's an example:
--
-- let pats =
--       [
--         ("a", stack [n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                      n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
--                     ]
--         ),
--         ("b", stack [n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                      n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
--                     ]
--         ),
--         ("c", stack [n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                      n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
--                     ]
--         )
--       ]
--     fx = [("reverse", (# (room 0.8 # sz 0.99 # orbit 1))),
--           ("faster", fast 2)
--          ]
-- in
-- d1 $ ur 12 "a b:reverb c:faster" pats fx
--
-- In the above, b has the function applied that's named as reverb, while c is made to go faster.
--
-- It's also possible to schedule multiple patterns at once, like in the following:
--
-- let pats = [("drums", s "drum clap*2"),
--             ("melody", s "arpy:2 arpy:3 arpy:5"),
--             ("craziness", s "clap:4*8" # speed ( sine + 0.5))
--            ]
--     fx = [("higher", (# speed 2))]
-- in
-- d1 $ ur 8 "[drums, melody] [drums,craziness,melody] melody:higher" pats fx