How to Launch Things

//global declarations
   var g = -9.80665;
   var time = 0; //time
   var v0 = 10;//initial velocity (muzzle)
   var theta = Math.PI/4;//trajectory angle
   var x0 = 0;//initial position
   var y0 = 0;
   var target = {"X":0,"y":0,"active":false};

//x and y are the coordinates that were clicked by the user
function defineTrajectory(x,y){
    tanTheta1 = quadraticFormula(g*x*x/(2*v0*v0),x,-(y-y0)+(g*x*x/(2*v0*v0)),1);
    tanTheta2 = quadraticFormula(g*x*x/(2*v0*v0),x,-(y-y0)+(g*x*x/(2*v0*v0)),-1);
    //two solutions, so we pick positive first
    if (tanTheta1 > 0) theta = Math.atan(tanTheta1);
    else theta = Math.atan(tanTheta2);
    //this updates the visual layout to reflect the angle
    $('#angle').val(theta*180/Math.PI);
    //this tells us where to draw the big red target
    target.x = x;
    target.y = y;
    target.active = true;
    //then we calculate the rest of the trajectory
    //using the big four and then draw the scene
    calcValues();
    drawScene();
    drawTrajectory();
}
function quadraticFormula(a,b,c,sign){
    if (b*b-(4*a*c) < 0) return false;//imaginary solution
    return (-b+(sign*Math.sqrt(b*b-(4*a*c))))/(2*a);
}

RANDOM.norm(n) 

RANDOM.inorm(n) 

RANDOM.exp(n) 

RANDOM.invexp(n) 

RANDOM.gamma(alpha,beta) 

RANDOM.igamma(alpha,beta) 

RANDOM.chi2(k) 

RANDOM.coinFlip(weight) 

The code:

var RANDOM = { //returns random between 0 and 1, normal distribution centered on 0.5
    "norm": function(n) {
        if (!(n > 2 && n <= 5)) n = 2;
        var nrand = 0;
        n = Math.floor(n);
        for (var i = 1;i<=n*2;i++){
            nrand += Math.random();
        }
        return nrand/(2*n);
    },
    "inorm": function(n) { //returns random between 0 and 1
        if (!(n > 2 && n <= 5)) n = 2;
        var nrand = 0;
        n = Math.floor(n);
        for (var i = 1;i<=n*2;i++){
            nrand += Math.random();
        }
        return ((1 - Math.abs((nrand-n) / n))*(Math.abs(nrand-n)/(nrand-n)) + 1)/2;
    },
    "exp": function(n) { //returns greater than 0
        if (!(n > 2 && n <= 5)) n = 2;
        var nrand = Math.random();
        for (var i = 2;i<=n;i++){
            nrand *= Math.random();
        }
        return 2*nrand;
    },
    "invexp": function(n) { //returns less than 0
        return -RANDOM.exp(n);
    },
    "gamma3": function(alpha) { //Kundu and Gupta algorithm 3 http://home.iitk.ac.in/~kundu/paper120.pdf
        if (!alpha || Math.abs(alpha) > 1) alpha = 1; //alpha between 0 and 1
        var d = 1.0334 - (0.0766*Math.exp(2.2942*alpha));
        var a = Math.pow(2,alpha)*Math.pow(1-Math.exp(-d/2),alpha);
        var b = alpha*Math.pow(d,alpha-1)*Math.exp(-d);
        var c = a + b;
        var U = Math.random();
        var X = (U <= a/(a+b)) ? -2*Math.log(1-(Math.pow(c*U,1/alpha)/2)) : -Math.log(c*(1-U)/(alpha*Math.pow(d,alpha-1)));
        var V = Math.random();
        if (X <= d) {
            var mess = (Math.pow(X,alpha-1)*Math.exp(-X/2))/(Math.pow(2,alpha-1)*Math.pow(1-Math.exp(-X/2),alpha-1));
            if (V <= mess) return X;
            else return this.gamma3(alpha);
        } else { //X > d
            if (V <= Math.pow(d/X,1-alpha)) return X;
            else return this.gamma3(alpha);
        }
        //output is > 0 and possibly > 1
    },
    "gamma": function(alpha,beta) { //Martino and Luengo http://arxiv.org/pdf/1304.3800.pdf luca@tsc.uc3m.es luengod@ieee.org
        if (!alpha || alpha <= 0) alpha = 1; //alpha >= 1 if negative or 0
        if (alpha > 0 && alpha < 1) return this.gamma3(alpha); // use different algorithm
        if (!beta || beta <= 0) beta = 1; //beta > 0
        var alphap = Math.floor(alpha);
        var X = Math.random();
        for (var i=2;i<=alphap;i++){
            X *= Math.random();
        } 
        var betap = (alpha < 2) ? beta/alpha : beta*(alphap-1)/(alpha-1);
        X = -Math.log(X)/betap;
        var Kp = (alpha < 2) ? Math.exp(1-alpha)*Math.pow(alpha/beta,alpha-1) : Math.exp(alphap-alpha)*Math.pow((alpha-1)/beta,alpha-alphap);
        //then accept with prob p(X)/pi(X)
        if (alphap >= 2) {
            if (Kp*Math.pow(X,alphap-1)*Math.exp(-betap*X) >= Math.pow(X,alpha-1)*Math.exp(-beta*X)) return X/alpha;
                else return this.gamma(alpha,beta);
            }
        else if (alphap < 2) {
            if (Kp*Math.exp(-betap*X) >= Math.pow(X,alpha-1)*Math.exp(-beta*X)) return X/alpha;
            else return this.gamma(alpha,beta);
        }
    },
    "igamma": function(alpha,beta) { // returns less than 0
        return -RANDOM.gamma(alpha,beta);
    },
    "chi2": function(k) { // returns greater than 0
        var nrand = RANDOM.norm(2);
        nrand = nrand*nrand;
        if (!k || k <= 1) return nrand;
        for (var i=2;i<=k;i++){
            var krand = RANDOM.norm(2);
            krand = krand*krand;
            nrand += krand;
        }
        return nrand;
    },
    "coinFlip": function(weight){
        if (!weight || weight < 1) weight = 2;
        if (Math.random() > 1/weight) return 1;
        else return 0;
    }
};
//Copyright 2016 Trevor Gast: codeandcompose.com
//RANDOM, non-uniform random generators (5 May 2016)
//GNU General Public License

Re...CURSES!

//this function takes two parameters:
//alt is altitude in meters
//To is temperature offset in Kelvin
function getAtmosphere(alt,To) {
    // constants!
    var R = 287.058; //gas constant
    var TEMP = 288.15; //in Kelvin
    var ATM1 = 101325; //in Pascals
    var DENSITY = 1.225; //in kg/cubic meter

    // range check (altitude in meters)
    if (alt > 84852) alt = 84852;
    if (alt < 0) alt = 0;

    //this is our OUT. no infinite recursion!
    //it returns 1 standard atmosphere at sea level in an object
    if (alt === 0) { //sea level
        return {"alt":alt,"T":TEMP+To,"To":To,"p":ATM1,"rho":DENSITY};
    } 

    // THIS IS WHERE THE MAGIC HAPPENS!
    // the function calls ITSELF...
    var atm0 = getAtmosphere(getAltRange(alt),To);
    // getAltRange() is a simple function that returns the altitude for
    // the "layer" beneath. This is used to find the correct lapse rate
    // and equation below...

    // lapseRate() returns the rate used to calculate temp for a given layer
    // here is where the calculation is done.
    // notice it uses output from itself (atm0)
    if (lapseRate(alt) != 0) {
        var T1 = atm0.T + lapseRate(alt)*(alt-getAltRange(alt));
        var rho1 = atm0.rho*Math.pow(T1/atm0.T,(-9.80665/(lapseRate(alt)*R)-1));
        var p1 = atm0.p*Math.pow(T1/atm0.T,-9.80665/(lapseRate(alt)*R)); 
    } else { // lapseRate = 0
        var con = Math.pow(Math.E,-9.80665/(R*atm0.T)*(alt-getAltRange(alt)));
        var T1 = atm0.T
        var p1 = atm0.p * con;
        var rho1 = atm0.rho * con;
    }

    // calculations "complete" it returns the data as an object
    return {"alt":alt,"T":T1,"To":To,"p":p1,"rho":rho1};
}

Music, Audio and Timing

var lastBeatTime = null;
var lastBeat = null;
var nextBeatTime = null; // when will the next beat occur
var nextBeat = null; // 32 total (8 bars of 4)
var nextFrameTime = null; // when will the next frame draw?
// tempo (in beats per minute)
var tempo = 125.0;
// these must be recalculated if the tempo changes 
var secondsPerBeat = 60.0 / tempo;
var framesPerBeat = 3600 / tempo;

var calibration = -0.001; 
// use this to fudge the click time back for accuracy (clicking late "sounds" correct)

window.onload = function (){
 
    //make sure the webkit Audio API is available
    try {   // Fix up for prefixing
        window.AudioContext = window.AudioContext||window.webkitAudioContext;
        audioctx = new AudioContext();
    } catch(e) {
        alert('Web Audio API is not supported in this browser');
    }

    //load the audio (code for this class is below)
    gMusic.parseAudioFile();
}

function startMusic(){
    secondsPerBeat = 60.0 / tempo;
    framesPerBeat = 3600 / tempo;
    nextBeat = 32;
    lastBeat = 31;
    nextBeatTime = audioctx.currentTime;
    lastBeatTime = nextBeatTime - secondsPerBeat;

}

function scheduler(time){
    //schedule the next beat
    lastBeat = nextBeat;
    lastBeatTime = nextBeatTime;
    if (nextBeat === 16) nextBeat = 1;
        else nextBeat++;
    nextBeatTime += 60.0 / tempo; // schedule the next quarter note
    scheduleSound(nextBeat,nextBeatTime);
}

function scheduleSound(beatNumber,time){
    // create an oscillator -- it makes the beep
    var osc = audioctx.createOscillator();
    osc.connect( audioctx.destination );
    if (beatNumber % 32 === 1) {
        gMusic.playSound("Pad1.wav",time);
  }
    if (beatNumber % 16 === 1) {
        gMusic.playSound("Beat1.wav",time);
        gMusic.playSound("Drums3.5.wav",time + (secondsPerBeat*2.5));
    }
}

function animate(){
    var NOW = audioctx.currentTime; //gets the time of the last draw...when is now?
    nextFrameTime = NOW + (1 / 60); // calculate when this frame draw will occur
    if (nextBeatTime <= nextFrameTime) scheduler(nextFrameTime);
    //calculate the part of the beat the frame will draw at (as a percentage)
    var bp = Math.round((nextFrameTime - lastBeatTime) / (nextBeatTime - lastBeatTime) * 100);
      
    // ALL OTHER ANIMATION OCCURS
}

playSound: function (name,time) {
    //first find the buffer
    var b = null;
    for(var i = this.sounds.length - 1; i >=0; i--) {
        // find the buffer for the name
        if(this.sounds[i].name === name) b = this.sounds[i].buffer;
    }
    // if we don't find the sound, do nothing
    if (!b) return;

    var soundSource = audioctx.createBufferSource();
    //schedule the sound
    soundSource.buffer = b;
    soundSource.connect(audioctx.destination);
    soundSource.start(time);
}