// Digital Vinyl! by kijjaz
//Step a => LPF b => dac; while(300::ms=>now) b.freq(a.next(Std.randf()) * 10);

// Shoot'em Up.. by kijjaz
//Step a => HPF b => dac; while(300::ms=>now) b.freq(a.next(Std.randf()) * 200);

//Intergallactic SoundCheck
//TriOsc s => PitShift p => p => dac; p.shift(1.0003); s.freq(30); while(ms=>now);

// sometimes, we've got a colony of pet bugs.. by kijjaz
//Noise a => LPF b => HPF c => dac; while(samp => now) c.freq(b.freq(a.last() * 10) * 10);

// just caught a new pet bug! by kijjaz
//Noise a => LPF b => LPF c => dac;  dac.gain(0.1); while(samp => now) b.freq(c.freq(a.last()*50) + b.last()*100);

//Alarm Low
//SinOsc a => SinOsc b => dac; b.sync(1); while(ms => now) b.last() * 119 => a.freq;

//Alarming Horn
//SqrOsc s => dac; while(100::samp => now) s.last() + s.phase() => s.phase;

//Broken Radio
//Noise s => PitShift p => p => dac; p.shift(0.2); s.gain(0.5); while(ms=>now);

// ZeroX Hi Hats
//Noise a => ZeroX b => dac; Phasor c => b; 4 => c.freq; second => now;

// ZeroX PWM impulse synth
//SawOsc a => ZeroX b => dac; TriOsc c => b; 110.1 => c.freq; hour => now;

// ZeroX frog (tried at 44.1khz, 48.0khz sample rate)
//SinOsc a => ZeroX b => dac; while(4.51::samp => now) b.last()*b.last() - a.freq() => a.freq;

// modified from above, this can sing quite beautifull
//SinOsc a => ZeroX b => dac; while(400.1::samp => now) b.last()*b.last()*311 - a.freq() => a.freq;

// Bossanova ZeroX
//SinOsc a => ZeroX b => dac; while(20.1::samp => now) b.last()*b.last()*10000 - a.freq() => a.freq;

//Motorcycle
//Noise n => SinOsc a => SinOsc b => SinOsc c => dac; c => a; c => b; b => a; a.gain(1.1); b.gain(125); c.gain(3); day => now;

// Sorry... wrong number -_-
//SinOsc a => dac; while(70::ms => now) now%second/ms * a.phase() - a.freq() => a.freq;

// how long is the reverb? (try with other kinds of reverb also)
//Impulse a => NRev b => ZeroX c => dac; a.next(1); hour => now;

// Take Cover! ChucK fights back!!
//Impulse a => LPF b => dac; a.next(1); b.set(-100000, 1000); hour => now;

// feedback, play with volume, touch microphone, whistle into microphone
//adc => SinOsc s => dac; adc.gain(85); day => now;

// Big Boss and his Eyeballs
//Impulse a => LPF b => dac; a.next(1); b.set(-10001, 1000); hour => now;

/* Lets try change that b.set above ^^^^
b.set(-696969, 869); // a lone motorcycle with no owner
b.set(-15000, 1000); // charging.. (for final blow)
b.set(-5999, 9999); // final blow!!! ahh.. missed -_-"
b.set(-2000, 9999); // warping back to base station
b.set(-1100, 6000); // summoning the Legendary Sword
b.set(-999999, 99999); // using the Legendary Sword to chop an onion
b.set(-21000, 99999); // head-chopping
b.set(-12700, 100); // STOP COOKING! we've got company
b.set(-12900, 100); // running...
b.set(-11400, 200); // They've got a Tank!!
b.set(-11800, 200); // Planet's polyrhythmic military marching band
b.set(-11800, 200); // The Marching Band run for their lives (always)
b.set(-10200, 120); // the tank fires..
b.set(8000, -1); // i'm invincible!!
b.set(-12000, -1); // The Legendary sword is powerful!!
b.set(-6969, -1); // kill!
b.set(-1000000, -1); // a drop of blood
b.set(-100500, -1); // keep punching
b.set(-101400, -1); // Kung-fu punching
b.set(-5555, 3000); // enough for today -_-
*/

// Start the Party!
//Step s => dac; float x; while(samp=>now) (now/3::ms)%3-x => x => s.next;

//Noise a => BPF f => dac; for(1 => int x; x < 360; x++){ f.set((x%7+1)*Std.fabs(2*Math.sin(x%73*x)+1), 20); 200::ms => now; }

//Noise a => BPF f => dac; for(1 => int x; x < 360000; x++){ f.set((x%7+1)*Std.fabs(2*Math.sin(x%73*x)+1), 20); 2::ms => now; }

// robot scan
//Step s => Gain g => g => SinOsc x => dac; while(Std.rand2(1, 100)::ms => now) Std.rand2(-1, 1) => s.next;

// Woo! .. hey anybody? woo woo!
//Phasor a => SinOsc b => SinOsc c => SinOsc d => Gain e => SinOsc f => dac; e.gain(800); day => now;

// Robotic circle of fifth
//SinOsc a => dac; while(125::ms => now) a.freq() * -1.5 => a.freq;

// Rise of the (cute) machine.
//SinOsc a => dac; while(20::ms => now) a.freq() * -1.01 => a.freq;

// a short 3n+1 melody
//SinOsc a => dac; while(40::ms => now) if (a.freq()%2==0) a.freq()/2=> a.freq; else a.freq()*3+1=>a.freq;

// Analysing...
//SinOsc a => dac; while(100::ms => now) if (a.freq()%4==0) a.freq()/4=> a.freq; else a.freq()*6+1=>a.freq;

// Great String!
//Mandolin a => SinOsc b => dac; 1 => b.sync; 4 => a.freq; 1000 => a.gain; a.noteOn(1); day => now;

//Mandolin Expanded..
/*
Mandolin a => SinOsc b => dac;

3 => b.sync;
4 => a.freq;
1000 => a.gain;

a.noteOn(1);
while(1)
   {
   4 => a.freq;
   while(maybe || maybe) a.freq() +2 => a.freq;
   Std.rand2(30, 42) * 3 => Std.mtof => b.freq;
   if(maybe && maybe)a.noteOn(1);
   1::second => now;
   }
*/

/*Needs Audio Input
         \/
*/
// ChucKtastic Vocoder inside of arcade game
//adc => PitShift p => dac; adc.gain(10); p.mix (1); p.shift (1.2); day => now;

// Demonic Vocoder
//adc => PitShift p => dac; adc.gain(10); 1 => p.mix; p.shift (0.8); day => now;

//adc => Gain g => SinOsc s =>  dac; 2000 => g.gain;0 => s.sync;1::day => now;

//adc => FFT fft =^ RMS rms => blackhole;SinOsc s => dac;256 => fft.size;Windowing.hann(256) => fft.window;while( true ){rms.upchuck() @=> UAnaBlob blob;blob.fval(0) * 400000 => s.freq;fft.size()::samp => now;}

/*
.===The Drum Sets==.
//Kick
//Impulse trig => LPF tone => SinOsc drive => dac; tone.set(50, 30); 1 => drive.sync;

// clave
//Impulse trig => HPF tone => SinOsc drive => dac; tone.set(2000, 100); 1 => drive.sync;

// cleaner clave
//Impulse trig => BPF tone => SinOsc drive => dac; tone.set(2000, 100); 1 => drive.sync;

// tom tom (set frequency at tone.set(freq, Q)
//Impulse trig => LPF tone => SinOsc drive => dac; tone.set(140, 30); 1 => drive.sync;

// cute rim-shot
//Impulse trig => LPF tone => TriOsc drive => dac; tone.set(600, 3); 1 => drive.sync;

// crude rim-shot
//Impulse trig => LPF tone => SawOsc drive => dac; tone.set(600, 5); 1 => drive.sync;

// GM High-Q-like sound, not nice
//Impulse trig => Gain g => g => Gain freq => SinOsc drum => dac; .99 => g.gain; 100 => freq.gain;

// longer High-Q
//Impulse trig => Gain g => g => Gain freq => SinOsc drum => dac; .999 => g.gain; 100 => freq.gain;

// electro bass drum, not nice
//Impulse trig => Gain g => g => Gain freq => TriOsc drum => dac; .9995 => g.gain; 1 => freq.gain;

// industrial china
//Impulse trig => LPF f => NRev rev => SinOsc drive => dac; f.set(6000, 2); 1 => drive.sync; 

//Test the drums...
69 => trig.next;
second => now;
*/

//Noise n => SawOsc s => HPF f => dac; f.set (500, 200); day => now;

//Noise n => SawOsc s => s => HPF f => dac; f.set (400, 300); day => now;

//Crackling, no randomization!
//Step s => dac; .5 => s.gain; float x; while(samp => now) Math.sin(x * 5.414369 + 1) => x => s.next;

// Crackling, more grounded.
//Step s => dac; .5 => s.gain; float x; while((maybe*40+6)::samp => now) Math.sin(x * 5.414369 + 1.19972) => x => s.next;

// Crackling, sandy.
//Step s => dac; .001 => s.gain; float x; while(samp => now) Math.tan(x * .09 + 1) => x => s.next;

// Digital Major Thingy
//Step s => dac; float x; while(samp => now) { ((x * 7 + (now / 125::ms) $ int % 64) % 30000 => x) / 15000 - 1 => s.next; }

// Glistering Thingy
//Step s => dac; float x; while(samp => now) { ((x * 99 + (now / 125::ms) $ int % 64) % 30000 => x) / 15000 - 1 => s.next; }

// Rotating Robotic Thingy
//Step s => dac; float x; while(samp => now) { ((x * 501 + (now / 125::ms) $ int % 64) % 30000 => x) / 15000 - 1 => s.next; }

// Another Must-post Thingy
//Step s => dac; int x; while(samp => now) { ((x * 49 + (now / 50::ms) $ int % 64) % 30000 => x) / 15000 - 1 => s.next; }

// Visualizing the Chaotic Duo.
//SinOsc s => dac; float x, y; while(samp => now) { (((x * pi => Math.cos) + y => y => Math.cos) + x => x) * y => s.freq; }

// Modulo together..
//SinOsc s => dac; float x, y; while(20::ms => now) { (x * 19 + y) % 256 => x; (y * 7 + 1) % 64 => y; x * y => s.freq; }

// Egg Factory
//Step a => dac; int x; while(samp => now) (a.last() * 40000 / (x % 7500/1000 + 1) + x++) % 20000 / 10000 - 1 => a.next;


// Accidentally Hatched
//Step a => dac; int x; while(samp => now) (a.last() * 8001 / (x % 3750/1000 + 1) + x++) % 20000 / 10000 - 1 => a.next;

// Phone Ring
//Step a => dac; int x; while(samp => now) (a.last() * 80000 / (x % 3000/1000 + 1) + x++) % 20000 / 10000 - 1 => a.next;

// Egg Factory Error
//Step a => dac; int x; while(samp => now) (a.last() * 80000 / (x % 11000/4000 + 1) + x++) % 20000 / 10000 - 1 => a.next;

// what a bird .. (successfully at sample rate = 44100)
//SqrOsc s1 => Gain g => g => SinOsc s2 => g; s2 => dac; 20 => s1.freq; day => now;


// super 8-bit bouncing ball
//SinOsc s1 => Gain g => g => SqrOsc s2 => g; s2 => dac; -.01 => s1.freq; day => now;

//Noise n=>dac.left;Noise m=>dac.right;int i;while(++i){0=>Std.srand;i*samp=>now;}

//SubNoise s=>dac;int n;while(++n%241+1=>s.rate){(n%83)*ms+ms=>now;5=>Std.srand;}

/*
SubNoise n => dac;

while(1)
    {
    ((now/2::second)$int)%8 + 2 => n.rate;
    now%250::ms+ms=>now;
    5 => Std.srand;
    }
*/

/* WOW!!!  My head is.. well I dunno where ma head is */