bundle-bare.js

(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
/* globals document confirm btoa */
/* globals b2Vec2 */
// Global Vars

var worldRun = require("./world/run.js");

var graph_fns = require("./draw/plot-graphs.js");
var plot_graphs = graph_fns.plotGraphs;


// ======= WORLD STATE ======

var $graphList = document.querySelector("#graph-list");
var $graphTemplate = document.querySelector("#graph-template");

function stringToHTML(s){
  var temp = document.createElement('div');
  temp.innerHTML = s;
  return temp.children[0];
}

var states, runners, results, graphState = {};

function updateUI(key, scores){
  var $graph = $graphList.querySelector("#graph-" + key);
  var $newGraph = stringToHTML($graphTemplate.innerHTML);
  $newGraph.id = "graph-" + key;
  if($graph){
    $graphList.replaceChild($graph, $newGraph);
  } else {
    $graphList.appendChild($newGraph);
  }
  console.log($newGraph);
  var scatterPlotElem = $newGraph.querySelector(".scatterplot");
  scatterPlotElem.id = "graph-" + key + "-scatter";
  graphState[key] = plot_graphs(
    $newGraph.querySelector(".graphcanvas"),
    $newGraph.querySelector(".topscores"),
    scatterPlotElem,
    graphState[key],
    scores,
    {}
  );
}

var generationConfig = require("./generation-config");

var box2dfps = 60;
var max_car_health = box2dfps * 10;

var world_def = {
  gravity: new b2Vec2(0.0, -9.81),
  doSleep: true,
  floorseed: btoa(Math.seedrandom()),
  tileDimensions: new b2Vec2(1.5, 0.03),
  maxFloorTiles: 200,
  mutable_floor: false,
  box2dfps: box2dfps,
  motorSpeed: 20,
  max_car_health: max_car_health,
  schema: generationConfig.constants.schema
}

var manageRound = {
  genetic: require("./machine-learning/genetic-algorithm/manage-round.js"),
  annealing: require("./machine-learning/simulated-annealing/manage-round.js"),
};

var createListeners = function(key){
  return {
    preCarStep: function(){},
    carStep: function(){},
    carDeath: function(carInfo){
      carInfo.score.i = states[key].counter;
    },
    generationEnd: function(results){
      handleRoundEnd(key, results);
    }
  }
}

function generationZero(){
  var obj = Object.keys(manageRound).reduce(function(obj, key){
    obj.states[key] = manageRound[key].generationZero(generationConfig());
    obj.runners[key] = worldRun(
      world_def, obj.states[key].generation, createListeners(key)
    );
    obj.results[key] = [];
    graphState[key] = {}
    return obj;
  }, {states: {}, runners: {}, results: {}});
  states = obj.states;
  runners = obj.runners;
  results = obj.results;
}

function handleRoundEnd(key, scores){
  var previousCounter = states[key].counter;
  states[key] = manageRound[key].nextGeneration(
    states[key], scores, generationConfig()
  );
  runners[key] = worldRun(
    world_def, states[key].generation, createListeners(key)
  );
  if(states[key].counter === previousCounter){
    console.log(results);
    results[key] = results[key].concat(scores);
  } else {
    handleGenerationEnd(key);
    results[key] = [];
  }
}

function runRound(){
  var toRun = new Map();
  Object.keys(states).forEach(function(key){ toRun.set(key, states[key].counter) });
  console.log(toRun);
  while(toRun.size){
    console.log("running");
    Array.from(toRun.keys()).forEach(function(key){
      if(states[key].counter === toRun.get(key)){
        runners[key].step();
      } else {
        toRun.delete(key);
      }
    });
  }
}

function handleGenerationEnd(key){
  var scores = results[key];
  scores.sort(function (a, b) {
    if (a.score.v > b.score.v) {
      return -1
    } else {
      return 1
    }
  })
  updateUI(key, scores);
  results[key] = [];
}

function cw_resetPopulationUI() {
  $graphList.innerHTML = "";
}

function cw_resetWorld() {
  cw_resetPopulationUI();
  Math.seedrandom();
  generationZero();
}

document.querySelector("#new-population").addEventListener("click", function(){
  cw_resetPopulationUI()
  generationZero();
})


document.querySelector("#confirm-reset").addEventListener("click", function(){
  cw_confirmResetWorld()
})

document.querySelector("#fast-forward").addEventListener("click", function(){
  runRound();
})

function cw_confirmResetWorld() {
  if (confirm('Really reset world?')) {
    cw_resetWorld();
  } else {
    return false;
  }
}

cw_resetWorld();

},{"./draw/plot-graphs.js":6,"./generation-config":10,"./machine-learning/genetic-algorithm/manage-round.js":14,"./machine-learning/simulated-annealing/manage-round.js":16,"./world/run.js":17}],2:[function(require,module,exports){
module.exports={
  "wheelCount": 2,
  "wheelMinRadius": 0.2,
  "wheelRadiusRange": 0.5,
  "wheelMinDensity": 40,
  "wheelDensityRange": 100,
  "wheelMinFrictionExponent": -2,
  "wheelFrictionExponentRange": 3,
  "chassisDensityRange": 300,
  "chassisMinDensity": 30,
  "chassisMinAxis": 0.1,
  "chassisAxisRange": 1.1
}

},{}],3:[function(require,module,exports){
var carConstants = require("./car-constants.json");

module.exports = {
  worldDef: worldDef,
  carConstants: getCarConstants,
  generateSchema: generateSchema
}

function worldDef(){
  var box2dfps = 60;
  return {
    gravity: { y: 0 },
    doSleep: true,
    floorseed: "abc",
    maxFloorTiles: 200,
    mutable_floor: false,
    motorSpeed: 20,
    box2dfps: box2dfps,
    max_car_health: box2dfps * 10,
    tileDimensions: {
      width: 1.5,
      height: 0.03
    }
  };
}

function getCarConstants(){
  return carConstants;
}

function generateSchema(values){
  return {
    wheel_radius: {
      type: "float",
      length: values.wheelCount,
      min: values.wheelMinRadius,
      range: values.wheelRadiusRange,
      factor: 1,
    },
    wheel_density: {
      type: "float",
      length: values.wheelCount,
      min: values.wheelMinDensity,
      range: values.wheelDensityRange,
      factor: 1,
    },
    wheel_friction_exponent: {
      type: "float",
      length: values.wheelCount,
      min: values.wheelMinFrictionExponent,
      range: values.wheelFrictionExponentRange,
      factor: 1,
    },
    chassis_density: {
      type: "float",
      length: 1,
      min: values.chassisDensityRange,
      range: values.chassisMinDensity,
      factor: 1,
    },
    vertex_list: {
      type: "float",
      length: 12,
      min: values.chassisMinAxis,
      range: values.chassisAxisRange,
      factor: 1,
    },
    wheel_vertex: {
      type: "shuffle",
      length: 8,
      limit: values.wheelCount,
      factor: 1,
    },
  };
}

},{"./car-constants.json":2}],4:[function(require,module,exports){
/*
  globals b2RevoluteJointDef b2Vec2 b2BodyDef b2Body b2FixtureDef b2PolygonShape b2CircleShape
*/

var createInstance = require("../machine-learning/create-instance");

module.exports = defToCar;

function defToCar(normal_def, world, constants){
  var car_def = createInstance.applyTypes(constants.schema, normal_def)
  var instance = {};
  instance.chassis = createChassis(
    world, car_def.vertex_list, car_def.chassis_density
  );

  // Keep track of the lowest point so that we can place the car on the ground
  var relativeBottom = 100;
  // Loop through the vertices of the chassis to find the lowest point
  for (var i = 0; i < instance.chassis.vertex_list.length; i++) {
    if (instance.chassis.vertex_list[i].y < relativeBottom) {
      relativeBottom = instance.chassis.vertex_list[i].y;
    }
  }

  var i;

  var wheelCount = car_def.wheel_radius.length;

  instance.wheels = [];
  for (i = 0; i < wheelCount; i++) {
    instance.wheels[i] = createWheel(
      world,
      car_def.wheel_radius[i],
      car_def.wheel_density[i],
      car_def.wheel_friction_exponent[i]
    );
  }

  var carmass = instance.chassis.GetMass();
  for (i = 0; i < wheelCount; i++) {
    carmass += instance.wheels[i].GetMass();
  }

  var joint_def = new b2RevoluteJointDef();

  for (i = 0; i < wheelCount; i++) {
    var torque = carmass * -constants.gravity.y / car_def.wheel_radius[i];

    var randvertex = instance.chassis.vertex_list[car_def.wheel_vertex[i]];

    // Keep track of the lowest point of the wheels.
    var relativeWheelBottom = randvertex.y - car_def.wheel_radius[i];
    if (relativeWheelBottom < relativeBottom) {
      relativeBottom = relativeWheelBottom;
    }

    joint_def.localAnchorA.Set(randvertex.x, randvertex.y);
    joint_def.localAnchorB.Set(0, 0);
    joint_def.maxMotorTorque = torque;
    joint_def.motorSpeed = -constants.motorSpeed;
    joint_def.enableMotor = true;
    joint_def.bodyA = instance.chassis;
    joint_def.bodyB = instance.wheels[i];
    world.CreateJoint(joint_def);
  }

  // Set the car on the ground by setting the position of the chassis and then positioning the wheels where there are already attached. If I don't do this than the physics yanks the joints together so hard that it can send the car spinning or make it enter the ground.
  var position = instance.chassis.GetPosition();
  instance.chassis.SetPosition({x: position.x, y: - relativeBottom + world.startHeight});
  for (i = 0; i < wheelCount; i++) {
    var randvertex = instance.chassis.vertex_list[car_def.wheel_vertex[i]];
    instance.wheels[i].SetPosition(instance.chassis.GetWorldPoint(randvertex));
  }

  return instance;
}

function createChassis(world, vertexs, density) {

  var vertex_list = new Array();
  vertex_list.push(new b2Vec2(vertexs[0], 0));
  vertex_list.push(new b2Vec2(vertexs[1], vertexs[2]));
  vertex_list.push(new b2Vec2(0, vertexs[3]));
  vertex_list.push(new b2Vec2(-vertexs[4], vertexs[5]));
  vertex_list.push(new b2Vec2(-vertexs[6], 0));
  vertex_list.push(new b2Vec2(-vertexs[7], -vertexs[8]));
  vertex_list.push(new b2Vec2(0, -vertexs[9]));
  vertex_list.push(new b2Vec2(vertexs[10], -vertexs[11]));

  var body_def = new b2BodyDef();
  body_def.type = b2Body.b2_dynamicBody;
  body_def.position.Set(0.0, 4.0);

  var body = world.CreateBody(body_def);

  createChassisPart(body, vertex_list[0], vertex_list[1], density);
  createChassisPart(body, vertex_list[1], vertex_list[2], density);
  createChassisPart(body, vertex_list[2], vertex_list[3], density);
  createChassisPart(body, vertex_list[3], vertex_list[4], density);
  createChassisPart(body, vertex_list[4], vertex_list[5], density);
  createChassisPart(body, vertex_list[5], vertex_list[6], density);
  createChassisPart(body, vertex_list[6], vertex_list[7], density);
  createChassisPart(body, vertex_list[7], vertex_list[0], density);

  body.vertex_list = vertex_list;

  return body;
}


function createChassisPart(body, vertex1, vertex2, density) {
  var vertex_list = new Array();
  vertex_list.push(vertex1);
  vertex_list.push(vertex2);
  vertex_list.push(b2Vec2.Make(0, 0));
  var fix_def = new b2FixtureDef();
  fix_def.shape = new b2PolygonShape();
  fix_def.density = density;
  fix_def.friction = 10;
  fix_def.restitution = 0.2;
  fix_def.filter.groupIndex = -1;
  fix_def.shape.SetAsArray(vertex_list, 3);

  body.CreateFixture(fix_def);
}

function createWheel(world, radius, density, friction_exponent) {
  var body_def = new b2BodyDef();
  body_def.type = b2Body.b2_dynamicBody;
  body_def.position.Set(0, 0);

  var body = world.CreateBody(body_def);

  var fix_def = new b2FixtureDef();
  fix_def.shape = new b2CircleShape(radius);
  fix_def.density = density;
  fix_def.friction = Math.pow(10, friction_exponent);
  fix_def.restitution = 0.2;
  fix_def.filter.groupIndex = -1;

  body.CreateFixture(fix_def);
  return body;
}

},{"../machine-learning/create-instance":13}],5:[function(require,module,exports){


module.exports = {
  getInitialState: getInitialState,
  updateState: updateState,
  getStatus: getStatus,
  calculateScore: calculateScore,
};

function getInitialState(world_def){
  return {
    frames: 0,
    health: world_def.max_car_health,
    maxPositiony: 0,
    minPositiony: 0,
    maxPositionx: 0,
  };
}

function updateState(constants, worldConstruct, state){
  if(state.health <= 0){
    throw new Error("Already Dead");
  }
  if(state.maxPositionx > constants.finishLine){
    throw new Error("already Finished");
  }

  // console.log(state);
  // check health
  var position = worldConstruct.chassis.GetPosition();
  // check if car reached end of the path
  var nextState = {
    frames: state.frames + 1,
    maxPositionx: position.x > state.maxPositionx ? position.x : state.maxPositionx,
    maxPositiony: position.y > state.maxPositiony ? position.y : state.maxPositiony,
    minPositiony: position.y < state.minPositiony ? position.y : state.minPositiony
  };

  if (position.x > constants.finishLine) {
    return nextState;
  }

  if (position.x > state.maxPositionx + 0.001) {
    nextState.health = constants.max_car_health;
    return nextState;
  }
  nextState.health = state.health - 0.1;
  if (Math.abs(worldConstruct.chassis.GetLinearVelocity().x) < 0.001) {
    nextState.health -= 5;
  }
  return nextState;
}

function getStatus(state, constants){
  if(hasFailed(state, constants)) return -1;
  if(hasSuccess(state, constants)) return 1;
  return 0;
}

function hasFailed(state /*, constants */){
  return state.health <= 0;
}
function hasSuccess(state, constants){
  return state.maxPositionx > constants.finishLine;
}

function calculateScore(state, constants){
  var avgspeed = (state.maxPositionx / state.frames) * constants.box2dfps;
  var position = state.maxPositionx;
  var score = position + avgspeed;
  return {
    v: score,
    s: avgspeed,
    x: position,
    y: state.maxPositiony,
    y2: state.minPositiony
  }
}

},{}],6:[function(require,module,exports){
var scatterPlot = require("./scatter-plot");

module.exports = {
  plotGraphs: function(graphElem, topScoresElem, scatterPlotElem, lastState, scores, config) {
    lastState = lastState || {};
    var generationSize = scores.length
    var graphcanvas = graphElem;
    var graphctx = graphcanvas.getContext("2d");
    var graphwidth = 400;
    var graphheight = 250;
    var nextState = cw_storeGraphScores(
      lastState, scores, generationSize
    );
    console.log(scores, nextState);
    cw_clearGraphics(graphcanvas, graphctx, graphwidth, graphheight);
    cw_plotAverage(nextState, graphctx);
    cw_plotElite(nextState, graphctx);
    cw_plotTop(nextState, graphctx);
    cw_listTopScores(topScoresElem, nextState);
    nextState.scatterGraph = drawAllResults(
      scatterPlotElem, config, nextState, lastState.scatterGraph
    );
    return nextState;
  },
  clearGraphics: function(graphElem) {
    var graphcanvas = graphElem;
    var graphctx = graphcanvas.getContext("2d");
    var graphwidth = 400;
    var graphheight = 250;
    cw_clearGraphics(graphcanvas, graphctx, graphwidth, graphheight);
  }
};


function cw_storeGraphScores(lastState, cw_carScores, generationSize) {
  console.log(cw_carScores);
  return {
    cw_topScores: (lastState.cw_topScores || [])
    .concat([cw_carScores[0].score]),
    cw_graphAverage: (lastState.cw_graphAverage || []).concat([
      cw_average(cw_carScores, generationSize)
    ]),
    cw_graphElite: (lastState.cw_graphElite || []).concat([
      cw_eliteaverage(cw_carScores, generationSize)
    ]),
    cw_graphTop: (lastState.cw_graphTop || []).concat([
      cw_carScores[0].score.v
    ]),
    allResults: (lastState.allResults || []).concat(cw_carScores),
  }
}

function cw_plotTop(state, graphctx) {
  var cw_graphTop = state.cw_graphTop;
  var graphsize = cw_graphTop.length;
  graphctx.strokeStyle = "#C83B3B";
  graphctx.beginPath();
  graphctx.moveTo(0, 0);
  for (var k = 0; k < graphsize; k++) {
    graphctx.lineTo(400 * (k + 1) / graphsize, cw_graphTop[k]);
  }
  graphctx.stroke();
}

function cw_plotElite(state, graphctx) {
  var cw_graphElite = state.cw_graphElite;
  var graphsize = cw_graphElite.length;
  graphctx.strokeStyle = "#7BC74D";
  graphctx.beginPath();
  graphctx.moveTo(0, 0);
  for (var k = 0; k < graphsize; k++) {
    graphctx.lineTo(400 * (k + 1) / graphsize, cw_graphElite[k]);
  }
  graphctx.stroke();
}

function cw_plotAverage(state, graphctx) {
  var cw_graphAverage = state.cw_graphAverage;
  var graphsize = cw_graphAverage.length;
  graphctx.strokeStyle = "#3F72AF";
  graphctx.beginPath();
  graphctx.moveTo(0, 0);
  for (var k = 0; k < graphsize; k++) {
    graphctx.lineTo(400 * (k + 1) / graphsize, cw_graphAverage[k]);
  }
  graphctx.stroke();
}


function cw_eliteaverage(scores, generationSize) {
  var sum = 0;
  for (var k = 0; k < Math.floor(generationSize / 2); k++) {
    sum += scores[k].score.v;
  }
  return sum / Math.floor(generationSize / 2);
}

function cw_average(scores, generationSize) {
  var sum = 0;
  for (var k = 0; k < generationSize; k++) {
    sum += scores[k].score.v;
  }
  return sum / generationSize;
}

function cw_clearGraphics(graphcanvas, graphctx, graphwidth, graphheight) {
  graphcanvas.width = graphcanvas.width;
  graphctx.translate(0, graphheight);
  graphctx.scale(1, -1);
  graphctx.lineWidth = 1;
  graphctx.strokeStyle = "#3F72AF";
  graphctx.beginPath();
  graphctx.moveTo(0, graphheight / 2);
  graphctx.lineTo(graphwidth, graphheight / 2);
  graphctx.moveTo(0, graphheight / 4);
  graphctx.lineTo(graphwidth, graphheight / 4);
  graphctx.moveTo(0, graphheight * 3 / 4);
  graphctx.lineTo(graphwidth, graphheight * 3 / 4);
  graphctx.stroke();
}

function cw_listTopScores(elem, state) {
  var cw_topScores = state.cw_topScores;
  var ts = elem;
  ts.innerHTML = "<b>Top Scores:</b><br />";
  cw_topScores.sort(function (a, b) {
    if (a.v > b.v) {
      return -1
    } else {
      return 1
    }
  });

  for (var k = 0; k < Math.min(10, cw_topScores.length); k++) {
    var topScore = cw_topScores[k];
    // console.log(topScore);
    var n = "#" + (k + 1) + ":";
    var score = Math.round(topScore.v * 100) / 100;
    var distance = "d:" + Math.round(topScore.x * 100) / 100;
    var yrange =  "h:" + Math.round(topScore.y2 * 100) / 100 + "/" + Math.round(topScore.y * 100) / 100 + "m";
    var gen = "(Gen " + cw_topScores[k].i + ")"

    ts.innerHTML +=  [n, score, distance, yrange, gen].join(" ") + "<br />";
  }
}

function drawAllResults(scatterPlotElem, config, allResults, previousGraph){
  if(!scatterPlotElem) return;
  return scatterPlot(scatterPlotElem, allResults, config.propertyMap, previousGraph)
}

},{"./scatter-plot":7}],7:[function(require,module,exports){
/* globals vis Highcharts */

// Called when the Visualization API is loaded.

module.exports = highCharts;
function highCharts(elem, scores){
  var keys = Object.keys(scores[0].def);
  keys = keys.reduce(function(curArray, key){
    var l = scores[0].def[key].length;
    var subArray = [];
    for(var i = 0; i < l; i++){
      subArray.push(key + "." + i);
    }
    return curArray.concat(subArray);
  }, []);
  function retrieveValue(obj, path){
    return path.split(".").reduce(function(curValue, key){
      return curValue[key];
    }, obj);
  }

  var dataObj = Object.keys(scores).reduce(function(kv, score){
    keys.forEach(function(key){
      kv[key].data.push([
        retrieveValue(score.def, key), score.score.v
      ])
    })
    return kv;
  }, keys.reduce(function(kv, key){
    kv[key] = {
      name: key,
      data: [],
    }
    return kv;
  }, {}))
  Highcharts.chart(elem.id, {
      chart: {
          type: 'scatter',
          zoomType: 'xy'
      },
      title: {
          text: 'Property Value to Score'
      },
      xAxis: {
          title: {
              enabled: true,
              text: 'Normalized'
          },
          startOnTick: true,
          endOnTick: true,
          showLastLabel: true
      },
      yAxis: {
          title: {
              text: 'Score'
          }
      },
      legend: {
          layout: 'vertical',
          align: 'left',
          verticalAlign: 'top',
          x: 100,
          y: 70,
          floating: true,
          backgroundColor: (Highcharts.theme && Highcharts.theme.legendBackgroundColor) || '#FFFFFF',
          borderWidth: 1
      },
      plotOptions: {
          scatter: {
              marker: {
                  radius: 5,
                  states: {
                      hover: {
                          enabled: true,
                          lineColor: 'rgb(100,100,100)'
                      }
                  }
              },
              states: {
                  hover: {
                      marker: {
                          enabled: false
                      }
                  }
              },
              tooltip: {
                  headerFormat: '<b>{series.name}</b><br>',
                  pointFormat: '{point.x}, {point.y}'
              }
          }
      },
      series: keys.map(function(key){
        return dataObj[key];
      })
  });
}

function visChart(elem, scores, propertyMap, graph) {

  // Create and populate a data table.
  var data = new vis.DataSet();
  scores.forEach(function(scoreInfo){
    data.add({
      x: getProperty(scoreInfo, propertyMap.x),
      y: getProperty(scoreInfo, propertyMap.x),
      z: getProperty(scoreInfo, propertyMap.z),
      style: getProperty(scoreInfo, propertyMap.z),
      // extra: def.ancestry
    });
  });

  function getProperty(info, key){
    if(key === "score"){
      return info.score.v
    } else {
      return info.def[key];
    }
  }

  // specify options
  var options = {
    width:  '600px',
    height: '600px',
    style: 'dot-size',
    showPerspective: true,
    showLegend: true,
    showGrid: true,
    showShadow: false,

    // Option tooltip can be true, false, or a function returning a string with HTML contents
    tooltip: function (point) {
      // parameter point contains properties x, y, z, and data
      // data is the original object passed to the point constructor
      return 'score: <b>' + point.z + '</b><br>'; // + point.data.extra;
    },

    // Tooltip default styling can be overridden
    tooltipStyle: {
      content: {
        background    : 'rgba(255, 255, 255, 0.7)',
        padding       : '10px',
        borderRadius  : '10px'
      },
      line: {
        borderLeft    : '1px dotted rgba(0, 0, 0, 0.5)'
      },
      dot: {
        border        : '5px solid rgba(0, 0, 0, 0.5)'
      }
    },

    keepAspectRatio: true,
    verticalRatio: 0.5
  };

  var camera = graph ? graph.getCameraPosition() : null;

  // create our graph
  var container = elem;
  graph = new vis.Graph3d(container, data, options);

  if (camera) graph.setCameraPosition(camera); // restore camera position
  return graph;
}

},{}],8:[function(require,module,exports){

module.exports = generateRandom;
function generateRandom(){
  return Math.random();
}

},{}],9:[function(require,module,exports){
// http://sunmingtao.blogspot.com/2016/11/inbreeding-coefficient.html
module.exports = getInbreedingCoefficient;

function getInbreedingCoefficient(child){
  var nameIndex = new Map();
  var flagged = new Set();
  var convergencePoints = new Set();
  createAncestryMap(child, []);

  var storedCoefficients = new Map();

  return Array.from(convergencePoints.values()).reduce(function(sum, point){
    var iCo = getCoefficient(point);
    return sum + iCo;
  }, 0);

  function createAncestryMap(initNode){
    var itemsInQueue = [{ node: initNode, path: [] }];
    do{
      var item = itemsInQueue.shift();
      var node = item.node;
      var path = item.path;
      if(processItem(node, path)){
        var nextPath = [ node.id ].concat(path);
        itemsInQueue = itemsInQueue.concat(node.ancestry.map(function(parent){
          return {
            node: parent,
            path: nextPath
          };
        }));
      }
    }while(itemsInQueue.length);


    function processItem(node, path){
      var newAncestor = !nameIndex.has(node.id);
      if(newAncestor){
        nameIndex.set(node.id, {
          parents: (node.ancestry || []).map(function(parent){
            return parent.id;
          }),
          id: node.id,
          children: [],
          convergences: [],
        });
      } else {

        flagged.add(node.id)
        nameIndex.get(node.id).children.forEach(function(childIdentifier){
          var offsets = findConvergence(childIdentifier.path, path);
          if(!offsets){
            return;
          }
          var childID = path[offsets[1]];
          convergencePoints.add(childID);
          nameIndex.get(childID).convergences.push({
            parent: node.id,
            offsets: offsets,
          });
        });
      }

      if(path.length){
        nameIndex.get(node.id).children.push({
          child: path[0],
          path: path
        });
      }

      if(!newAncestor){
        return;
      }
      if(!node.ancestry){
        return;
      }
      return true;
    }
  }

  function getCoefficient(id){
    if(storedCoefficients.has(id)){
      return storedCoefficients.get(id);
    }
    var node = nameIndex.get(id);
    var val = node.convergences.reduce(function(sum, point){
      return sum + Math.pow(1 / 2, point.offsets.reduce(function(sum, value){
        return sum + value;
      }, 1)) * (1 + getCoefficient(point.parent));
    }, 0);
    storedCoefficients.set(id, val);

    return val;

  }
  function findConvergence(listA, listB){
    var ci, cj, li, lj;
    outerloop:
    for(ci = 0, li = listA.length; ci < li; ci++){
      for(cj = 0, lj = listB.length; cj < lj; cj++){
        if(listA[ci] === listB[cj]){
          break outerloop;
        }
      }
    }
    if(ci === li){
      return false;
    }
    return [ci, cj];
  }
}

},{}],10:[function(require,module,exports){
var carConstruct = require("../car-schema/construct.js");

var carConstants = carConstruct.carConstants();

var schema = carConstruct.generateSchema(carConstants);
var pickParent = require("./pickParent");
var selectFromAllParents = require("./selectFromAllParents");
const constants = {
  generationSize: 20,
  schema: schema,
  championLength: 1,
  mutation_range: 1,
  gen_mutation: 0.05,
};
module.exports = function(){
  var currentChoices = new Map();
  return Object.assign(
    {},
    constants,
    {
      selectFromAllParents: selectFromAllParents,
      generateRandom: require("./generateRandom"),
      pickParent: pickParent.bind(void 0, currentChoices),
    }
  );
}
module.exports.constants = constants

},{"../car-schema/construct.js":3,"./generateRandom":8,"./pickParent":11,"./selectFromAllParents":12}],11:[function(require,module,exports){
var nAttributes = 15;
module.exports = pickParent;

function pickParent(currentChoices, chooseId, key /* , parents */){
  if(!currentChoices.has(chooseId)){
    currentChoices.set(chooseId, initializePick())
  }
  // console.log(chooseId);
  var state = currentChoices.get(chooseId);
  // console.log(state.curparent);
  state.i++
  if(["wheel_radius", "wheel_vertex", "wheel_density", "wheel_friction_exponent"].indexOf(key) > -1){
    state.curparent = cw_chooseParent(state);
    return state.curparent;
  }
  state.curparent = cw_chooseParent(state);
  return state.curparent;

  function cw_chooseParent(state) {
    var curparent = state.curparent;
    var attributeIndex = state.i;
    var swapPoint1 = state.swapPoint1
    var swapPoint2 = state.swapPoint2
    // console.log(swapPoint1, swapPoint2, attributeIndex)
    if ((swapPoint1 == attributeIndex) || (swapPoint2 == attributeIndex)) {
      return curparent == 1 ? 0 : 1
    }
    return curparent
  }

  function initializePick(){
    var curparent = 0;

    var swapPoint1 = Math.floor(Math.random() * (nAttributes));
    var swapPoint2 = swapPoint1;
    while (swapPoint2 == swapPoint1) {
      swapPoint2 = Math.floor(Math.random() * (nAttributes));
    }
    var i = 0;
    return {
      curparent: curparent,
      i: i,
      swapPoint1: swapPoint1,
      swapPoint2: swapPoint2
    }
  }
}

},{}],12:[function(require,module,exports){
var getInbreedingCoefficient = require("./inbreeding-coefficient");

module.exports = simpleSelect;

function simpleSelect(parents){
  var totalParents = parents.length
  var r = Math.random();
  if (r == 0)
    return 0;
  return Math.floor(-Math.log(r) * totalParents) % totalParents;
}

function selectFromAllParents(parents, parentList, previousParentIndex) {
  var previousParent = parents[previousParentIndex];
  var validParents = parents.filter(function(parent, i){
    if(previousParentIndex === i){
      return false;
    }
    if(!previousParent){
      return true;
    }
    var child = {
      id: Math.random().toString(32),
      ancestry: [previousParent, parent].map(function(p){
        return {
          id: p.def.id,
          ancestry: p.def.ancestry
        }
      })
    }
    var iCo = getInbreedingCoefficient(child);
    console.log("inbreeding coefficient", iCo)
    if(iCo > 0.25){
      return false;
    }
    return true;
  })
  if(validParents.length === 0){
    return Math.floor(Math.random() * parents.length)
  }
  var totalScore = validParents.reduce(function(sum, parent){
    return sum + parent.score.v;
  }, 0);
  var r = totalScore * Math.random();
  for(var i = 0; i < validParents.length; i++){
    var score = validParents[i].score.v;
    if(r > score){
      r = r - score;
    } else {
      break;
    }
  }
  return i;
}

},{"./inbreeding-coefficient":9}],13:[function(require,module,exports){
var random = require("./random.js");

module.exports = {
  createGenerationZero(schema, generator){
    return Object.keys(schema).reduce(function(instance, key){
      var schemaProp = schema[key];
      var values = random.createNormals(schemaProp, generator);
      instance[key] = values;
      return instance;
    }, { id: Math.random().toString(32) });
  },
  createCrossBreed(schema, parents, parentChooser){
    var id = Math.random().toString(32);
    return Object.keys(schema).reduce(function(crossDef, key){
      var schemaDef = schema[key];
      var values = [];
      for(var i = 0, l = schemaDef.length; i < l; i++){
        var p = parentChooser(id, key, parents);
        values.push(parents[p][key][i]);
      }
      crossDef[key] = values;
      return crossDef;
    }, {
      id: id,
      ancestry: parents.map(function(parent){
        return {
          id: parent.id,
          ancestry: parent.ancestry,
        };
      })
    });
  },
  createMutatedClone(schema, generator, parent, factor, chanceToMutate){
    return Object.keys(schema).reduce(function(clone, key){
      var schemaProp = schema[key];
      var originalValues = parent[key];
      var values = random.mutateNormals(
        schemaProp, generator, originalValues, factor, chanceToMutate
      );
      clone[key] = values;
      return clone;
    }, {
      id: parent.id,
      ancestry: parent.ancestry
    });
  },
  applyTypes(schema, parent){
    return Object.keys(schema).reduce(function(clone, key){
      var schemaProp = schema[key];
      var originalValues = parent[key];
      var values;
      switch(schemaProp.type){
        case "shuffle" :
          values = random.mapToShuffle(schemaProp, originalValues); break;
        case "float" :
          values = random.mapToFloat(schemaProp, originalValues); break;
        case "integer":
          values = random.mapToInteger(schemaProp, originalValues); break;
        default:
          throw new Error(`Unknown type ${schemaProp.type} of schema for key ${key}`);
      }
      clone[key] = values;
      return clone;
    }, {
      id: parent.id,
      ancestry: parent.ancestry
    });
  },
}

},{"./random.js":15}],14:[function(require,module,exports){
var create = require("../create-instance");

module.exports = {
  generationZero: generationZero,
  nextGeneration: nextGeneration
}

function generationZero(config){
  var generationSize = config.generationSize,
  schema = config.schema;
  var cw_carGeneration = [];
  for (var k = 0; k < generationSize; k++) {
    var def = create.createGenerationZero(schema, function(){
      return Math.random()
    });
    def.index = k;
    cw_carGeneration.push(def);
  }
  return {
    counter: 0,
    generation: cw_carGeneration,
  };
}

function nextGeneration(
  previousState,
  scores,
  config
){
  var champion_length = config.championLength,
    generationSize = config.generationSize,
    selectFromAllParents = config.selectFromAllParents;

  var newGeneration = new Array();
  var newborn;
  var allTimeBest = previousState.allTimeBest;
  if (!allTimeBest || scores[0].score.v > allTimeBest.best_score) {
    allTimeBest = scores[0].def;
    allTimeBest.is_all_time_best = true;
  }
  var allTimeBestAdded = false;
  for (var k = 0; k < champion_length; k++) {
    scores[k].def.is_elite = true;
    scores[k].def.index = k;
    newGeneration.push(scores[k].def);
    if (scores[k].score.v > scores[k].def.best_score) {
      scores[k].def.best_score = scores[k].score.v;
    }
    if (allTimeBest.id == scores[k].def.id) {
      allTimeBestAdded = true;
    }
  }
  if (!allTimeBestAdded) {
    allTimeBest.is_elite = false;
    newGeneration.push(allTimeBest);
  }
  var parentList = [];
  for (k = champion_length; k < generationSize; k++) {
    var parent1 = selectFromAllParents(scores, parentList);
    var parent2 = parent1;
    while (parent2 == parent1) {
      parent2 = selectFromAllParents(scores, parentList, parent1);
    }
    var pair = [parent1, parent2]
    parentList.push(pair);
    newborn = makeChild(config,
      pair.map(function(parent) { return scores[parent].def; })
    );
    newborn = mutate(config, newborn);
    newborn.is_elite = false;
    newborn.index = k;
    newGeneration.push(newborn);
  }

  return {
    counter: previousState.counter + 1,
    generation: newGeneration,
    allTimeBest: allTimeBest
  };
}


function makeChild(config, parents){
  var schema = config.schema,
    pickParent = config.pickParent;
  return create.createCrossBreed(schema, parents, pickParent)
}


function mutate(config, parent){
  var schema = config.schema,
    mutation_range = config.mutation_range,
    gen_mutation = config.gen_mutation,
    generateRandom = config.generateRandom;
  return create.createMutatedClone(
    schema,
    generateRandom,
    parent,
    Math.max(mutation_range),
    gen_mutation
  )
}

},{"../create-instance":13}],15:[function(require,module,exports){


const random = {
  shuffleIntegers(prop, generator){
    return random.mapToShuffle(prop, random.createNormals({
      length: prop.length || 10,
      inclusive: true,
    }, generator));
  },
  createIntegers(prop, generator){
    return random.mapToInteger(prop, random.createNormals({
      length: prop.length,
      inclusive: true,
    }, generator));
  },
  createFloats(prop, generator){
    return random.mapToFloat(prop, random.createNormals({
      length: prop.length,
      inclusive: true,
    }, generator));
  },
  createNormals(prop, generator){
    var l = prop.length;
    var values = [];
    for(var i = 0; i < l; i++){
      values.push(
        createNormal(prop, generator)
      );
    }
    return values;
  },
  mutateShuffle(
    prop, generator, originalValues, mutation_range, chanceToMutate
  ){
    return random.mapToShuffle(prop, random.mutateNormals(
      prop, generator, originalValues, mutation_range, chanceToMutate
    ));
  },
  mutateIntegers(prop, generator, originalValues, mutation_range, chanceToMutate){
    return random.mapToInteger(prop, random.mutateNormals(
      prop, generator, originalValues, mutation_range, chanceToMutate
    ));
  },
  mutateFloats(prop, generator, originalValues, mutation_range, chanceToMutate){
    return random.mapToFloat(prop, random.mutateNormals(
      prop, generator, originalValues, mutation_range, chanceToMutate
    ));
  },
  mapToShuffle(prop, normals){
    var offset = prop.offset || 0;
    var limit = prop.limit || prop.length;
    var sorted = normals.slice().sort(function(a, b){
      return a - b;
    });
    return normals.map(function(val){
      return sorted.indexOf(val);
    }).map(function(i){
      return i + offset;
    }).slice(0, limit);
  },
  mapToInteger(prop, normals){
    prop = {
      min: prop.min || 0,
      range: prop.range || 10,
      length: prop.length
    }
    return random.mapToFloat(prop, normals).map(function(float){
      return Math.round(float);
    });
  },
  mapToFloat(prop, normals){
    prop = {
      min: prop.min || 0,
      range: prop.range || 1
    }
    return normals.map(function(normal){
      var min = prop.min;
      var range = prop.range;
      return min + normal * range
    })
  },
  mutateNormals(prop, generator, originalValues, mutation_range, chanceToMutate){
    var factor = (prop.factor || 1) * mutation_range
    return originalValues.map(function(originalValue){
      if(generator() > chanceToMutate){
        return originalValue;
      }
      return mutateNormal(
        prop, generator, originalValue, factor
      );
    });
  }
};

module.exports = random;

function mutateNormal(prop, generator, originalValue, mutation_range){
  if(mutation_range > 1){
    throw new Error("Cannot mutate beyond bounds");
  }
  var newMin = originalValue - 0.5;
  if (newMin < 0) newMin = 0;
  if (newMin + mutation_range  > 1)
    newMin = 1 - mutation_range;
  var rangeValue = createNormal({
    inclusive: true,
  }, generator);
  return newMin + rangeValue * mutation_range;
}

function createNormal(prop, generator){
  if(!prop.inclusive){
    return generator();
  } else {
    return generator() < 0.5 ?
    generator() :
    1 - generator();
  }
}

},{}],16:[function(require,module,exports){
var create = require("../create-instance");

module.exports = {
  generationZero: generationZero,
  nextGeneration: nextGeneration,
}

function generationZero(config){
  var oldStructure = create.createGenerationZero(
    config.schema, config.generateRandom
  );
  var newStructure = createStructure(config, 1, oldStructure);

  var k = 0;

  return {
    counter: 0,
    k: k,
    generation: [newStructure, oldStructure]
  }
}

function nextGeneration(previousState, scores, config){
  var nextState = {
    k: (previousState.k + 1)%config.generationSize,
    counter: previousState.counter + (previousState.k === config.generationSize ? 1 : 0)
  };
  // gradually get closer to zero temperature (but never hit it)
  var oldDef = previousState.curDef || previousState.generation[1];
  var oldScore = previousState.score || scores[1].score.v;

  var newDef = previousState.generation[0];
  var newScore = scores[0].score.v;


  var temp = Math.pow(Math.E, -nextState.counter / config.generationSize);

  var scoreDiff = newScore - oldScore;
  // If the next point is higher, change location
  if(scoreDiff > 0){
    nextState.curDef = newDef;
    nextState.score = newScore;
    // Else we want to increase likelyhood of changing location as we get
  } else if(Math.random() > Math.exp(-scoreDiff/(nextState.k * temp))){
    nextState.curDef = newDef;
    nextState.score = newScore;
  } else {
    nextState.curDef = oldDef;
    nextState.score = oldScore;
  }

  console.log(previousState, nextState);

  nextState.generation = [createStructure(config, temp, nextState.curDef)];

  return nextState;
}


function createStructure(config, mutation_range, parent){
  var schema = config.schema,
    gen_mutation = 1,
    generateRandom = config.generateRandom;
  return create.createMutatedClone(
    schema,
    generateRandom,
    parent,
    mutation_range,
    gen_mutation
  )

}

},{"../create-instance":13}],17:[function(require,module,exports){
/* globals btoa */
var setupScene = require("./setup-scene");
var carRun = require("../car-schema/run");
var defToCar = require("../car-schema/def-to-car");

module.exports = runDefs;
function runDefs(world_def, defs, listeners) {
  if (world_def.mutable_floor) {
    // GHOST DISABLED
    world_def.floorseed = btoa(Math.seedrandom());
  }

  var scene = setupScene(world_def);
  scene.world.Step(1 / world_def.box2dfps, 20, 20);
  console.log("about to build cars");
  var cars = defs.map((def, i) => {
    return {
      index: i,
      def: def,
      car: defToCar(def, scene.world, world_def),
      state: carRun.getInitialState(world_def)
    };
  });
  var alivecars = cars;
  return {
    scene: scene,
    cars: cars,
    step: function () {
      if (alivecars.length === 0) {
        throw new Error("no more cars");
      }
      scene.world.Step(1 / world_def.box2dfps, 20, 20);
      listeners.preCarStep();
      alivecars = alivecars.filter(function (car) {
        car.state = carRun.updateState(
          world_def, car.car, car.state
        );
        var status = carRun.getStatus(car.state, world_def);
        listeners.carStep(car);
        if (status === 0) {
          return true;
        }
        car.score = carRun.calculateScore(car.state, world_def);
        listeners.carDeath(car);

        var world = scene.world;
        var worldCar = car.car;
        world.DestroyBody(worldCar.chassis);

        for (var w = 0; w < worldCar.wheels.length; w++) {
          world.DestroyBody(worldCar.wheels[w]);
        }

        return false;
      })
      if (alivecars.length === 0) {
        listeners.generationEnd(cars);
      }
    }
  }

}

},{"../car-schema/def-to-car":4,"../car-schema/run":5,"./setup-scene":18}],18:[function(require,module,exports){
/* globals b2World b2Vec2 b2BodyDef b2FixtureDef b2PolygonShape */

/*

world_def = {
  gravity: {x, y},
  doSleep: boolean,
  floorseed: string,
  tileDimensions,
  maxFloorTiles,
  mutable_floor: boolean
}

*/

module.exports = function(world_def){

  var world = new b2World(world_def.gravity, world_def.doSleep);
  var floorTiles = cw_createFloor(
    world,
    world_def.floorseed,
    world_def.tileDimensions,
    world_def.maxFloorTiles,
    world_def.mutable_floor
  );

  var last_tile = floorTiles[
    floorTiles.length - 1
  ];
  var last_fixture = last_tile.GetFixtureList();
  var last_tile_position = last_tile.GetWorldPoint(
    last_fixture.GetShape().m_vertices[3]
  );

  // Loop through first several tiles to find a safe height for placing cars
  world.startHeight = -10;
  for (var i = 0; i < 20; i++) {
    var tile = floorTiles[i];
    var fixture = tile.GetFixtureList();
    var topRightVertice = tile.GetWorldPoint(fixture.GetShape().m_vertices[3]);
    var topLeftVertice = tile.GetWorldPoint(fixture.GetShape().m_vertices[0]);
    if (topRightVertice.y > world.startHeight) {
      world.startHeight = topRightVertice.y;
    }
    if (topLeftVertice.y > world.startHeight) {
      world.startHeight = topLeftVertice.y;
    }
    if (topRightVertice.x > 2) {
      break;
    }
  }
  world.finishLine = last_tile_position.x;
  return {
    world: world,
    floorTiles: floorTiles,
    finishLine: last_tile_position.x
  };
}

function cw_createFloor(world, floorseed, dimensions, maxFloorTiles, mutable_floor) {
  var last_tile = null;
  var tile_position = new b2Vec2(-5, 0);
  var cw_floorTiles = [];
  Math.seedrandom(floorseed);
  for (var k = 0; k < maxFloorTiles; k++) {
    if (!mutable_floor) {
      // keep old impossible tracks if not using mutable floors
      last_tile = cw_createFloorTile(
        world, dimensions, tile_position, (Math.random() * 3 - 1.5) * 1.5 * k / maxFloorTiles
      );
    } else {
      // if path is mutable over races, create smoother tracks
      last_tile = cw_createFloorTile(
        world, dimensions, tile_position, (Math.random() * 3 - 1.5) * 1.2 * k / maxFloorTiles
      );
    }
    cw_floorTiles.push(last_tile);
    var last_fixture = last_tile.GetFixtureList();
    tile_position = last_tile.GetWorldPoint(last_fixture.GetShape().m_vertices[3]);
  }
  return cw_floorTiles;
}


function cw_createFloorTile(world, dim, position, angle) {
  var body_def = new b2BodyDef();

  body_def.position.Set(position.x, position.y);
  var body = world.CreateBody(body_def);
  var fix_def = new b2FixtureDef();
  fix_def.shape = new b2PolygonShape();
  fix_def.friction = 0.5;

  var coords = new Array();
  coords.push(new b2Vec2(0, 0));
  coords.push(new b2Vec2(0, -dim.y));
  coords.push(new b2Vec2(dim.x, -dim.y));
  coords.push(new b2Vec2(dim.x, 0));

  var center = new b2Vec2(0, 0);

  var newcoords = cw_rotateFloorTile(coords, center, angle);

  fix_def.shape.SetAsArray(newcoords);

  body.CreateFixture(fix_def);
  return body;
}

function cw_rotateFloorTile(coords, center, angle) {
  return coords.map(function(coord){
    return {
      x: Math.cos(angle) * (coord.x - center.x) - Math.sin(angle) * (coord.y - center.y) + center.x,
      y: Math.sin(angle) * (coord.x - center.x) + Math.cos(angle) * (coord.y - center.y) + center.y,
    };
  });
}

},{}]},{},[1])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/bare.js","src/car-schema/car-constants.json","src/car-schema/construct.js","src/car-schema/def-to-car.js","src/car-schema/run.js","src/draw/plot-graphs.js","src/draw/scatter-plot.js","src/generation-config/generateRandom.js","src/generation-config/inbreeding-coefficient.js","src/generation-config/index.js","src/generation-config/pickParent.js","src/generation-config/selectFromAllParents.js","src/machine-learning/create-instance.js","src/machine-learning/genetic-algorithm/manage-round.js","src/machine-learning/random.js","src/machine-learning/simulated-annealing/manage-round.js","src/world/run.js","src/world/setup-scene.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpKA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/* globals document confirm btoa */\n/* globals b2Vec2 */\n// Global Vars\n\nvar worldRun = require(\"./world/run.js\");\n\nvar graph_fns = require(\"./draw/plot-graphs.js\");\nvar plot_graphs = graph_fns.plotGraphs;\n\n\n// ======= WORLD STATE ======\n\nvar $graphList = document.querySelector(\"#graph-list\");\nvar $graphTemplate = document.querySelector(\"#graph-template\");\n\nfunction stringToHTML(s){\n  var temp = document.createElement('div');\n  temp.innerHTML = s;\n  return temp.children[0];\n}\n\nvar states, runners, results, graphState = {};\n\nfunction updateUI(key, scores){\n  var $graph = $graphList.querySelector(\"#graph-\" + key);\n  var $newGraph = stringToHTML($graphTemplate.innerHTML);\n  $newGraph.id = \"graph-\" + key;\n  if($graph){\n    $graphList.replaceChild($graph, $newGraph);\n  } else {\n    $graphList.appendChild($newGraph);\n  }\n  console.log($newGraph);\n  var scatterPlotElem = $newGraph.querySelector(\".scatterplot\");\n  scatterPlotElem.id = \"graph-\" + key + \"-scatter\";\n  graphState[key] = plot_graphs(\n    $newGraph.querySelector(\".graphcanvas\"),\n    $newGraph.querySelector(\".topscores\"),\n    scatterPlotElem,\n    graphState[key],\n    scores,\n    {}\n  );\n}\n\nvar generationConfig = require(\"./generation-config\");\n\nvar box2dfps = 60;\nvar max_car_health = box2dfps * 10;\n\nvar world_def = {\n  gravity: new b2Vec2(0.0, -9.81),\n  doSleep: true,\n  floorseed: btoa(Math.seedrandom()),\n  tileDimensions: new b2Vec2(1.5, 0.03),\n  maxFloorTiles: 200,\n  mutable_floor: false,\n  box2dfps: box2dfps,\n  motorSpeed: 20,\n  max_car_health: max_car_health,\n  schema: generationConfig.constants.schema\n}\n\nvar manageRound = {\n  genetic: require(\"./machine-learning/genetic-algorithm/manage-round.js\"),\n  annealing: require(\"./machine-learning/simulated-annealing/manage-round.js\"),\n};\n\nvar createListeners = function(key){\n  return {\n    preCarStep: function(){},\n    carStep: function(){},\n    carDeath: function(carInfo){\n      carInfo.score.i = states[key].counter;\n    },\n    generationEnd: function(results){\n      handleRoundEnd(key, results);\n    }\n  }\n}\n\nfunction generationZero(){\n  var obj = Object.keys(manageRound).reduce(function(obj, key){\n    obj.states[key] = manageRound[key].generationZero(generationConfig());\n    obj.runners[key] = worldRun(\n      world_def, obj.states[key].generation, createListeners(key)\n    );\n    obj.results[key] = [];\n    graphState[key] = {}\n    return obj;\n  }, {states: {}, runners: {}, results: {}});\n  states = obj.states;\n  runners = obj.runners;\n  results = obj.results;\n}\n\nfunction handleRoundEnd(key, scores){\n  var previousCounter = states[key].counter;\n  states[key] = manageRound[key].nextGeneration(\n    states[key], scores, generationConfig()\n  );\n  runners[key] = worldRun(\n    world_def, states[key].generation, createListeners(key)\n  );\n  if(states[key].counter === previousCounter){\n    console.log(results);\n    results[key] = results[key].concat(scores);\n  } else {\n    handleGenerationEnd(key);\n    results[key] = [];\n  }\n}\n\nfunction runRound(){\n  var toRun = new Map();\n  Object.keys(states).forEach(function(key){ toRun.set(key, states[key].counter) });\n  console.log(toRun);\n  while(toRun.size){\n    console.log(\"running\");\n    Array.from(toRun.keys()).forEach(function(key){\n      if(states[key].counter === toRun.get(key)){\n        runners[key].step();\n      } else {\n        toRun.delete(key);\n      }\n    });\n  }\n}\n\nfunction handleGenerationEnd(key){\n  var scores = results[key];\n  scores.sort(function (a, b) {\n    if (a.score.v > b.score.v) {\n      return -1\n    } else {\n      return 1\n    }\n  })\n  updateUI(key, scores);\n  results[key] = [];\n}\n\nfunction cw_resetPopulationUI() {\n  $graphList.innerHTML = \"\";\n}\n\nfunction cw_resetWorld() {\n  cw_resetPopulationUI();\n  Math.seedrandom();\n  generationZero();\n}\n\ndocument.querySelector(\"#new-population\").addEventListener(\"click\", function(){\n  cw_resetPopulationUI()\n  generationZero();\n})\n\n\ndocument.querySelector(\"#confirm-reset\").addEventListener(\"click\", function(){\n  cw_confirmResetWorld()\n})\n\ndocument.querySelector(\"#fast-forward\").addEventListener(\"click\", function(){\n  runRound();\n})\n\nfunction cw_confirmResetWorld() {\n  if (confirm('Really reset world?')) {\n    cw_resetWorld();\n  } else {\n    return false;\n  }\n}\n\ncw_resetWorld();\n","module.exports={\n  \"wheelCount\": 2,\n  \"wheelMinRadius\": 0.2,\n  \"wheelRadiusRange\": 0.5,\n  \"wheelMinDensity\": 40,\n  \"wheelDensityRange\": 100,\n  \"wheelMinFrictionExponent\": -2,\n  \"wheelFrictionExponentRange\": 3,\n  \"chassisDensityRange\": 300,\n  \"chassisMinDensity\": 30,\n  \"chassisMinAxis\": 0.1,\n  \"chassisAxisRange\": 1.1\n}\n","var carConstants = require(\"./car-constants.json\");\n\nmodule.exports = {\n  worldDef: worldDef,\n  carConstants: getCarConstants,\n  generateSchema: generateSchema\n}\n\nfunction worldDef(){\n  var box2dfps = 60;\n  return {\n    gravity: { y: 0 },\n    doSleep: true,\n    floorseed: \"abc\",\n    maxFloorTiles: 200,\n    mutable_floor: false,\n    motorSpeed: 20,\n    box2dfps: box2dfps,\n    max_car_health: box2dfps * 10,\n    tileDimensions: {\n      width: 1.5,\n      height: 0.03\n    }\n  };\n}\n\nfunction getCarConstants(){\n  return carConstants;\n}\n\nfunction generateSchema(values){\n  return {\n    wheel_radius: {\n      type: \"float\",\n      length: values.wheelCount,\n      min: values.wheelMinRadius,\n      range: values.wheelRadiusRange,\n      factor: 1,\n    },\n    wheel_density: {\n      type: \"float\",\n      length: values.wheelCount,\n      min: values.wheelMinDensity,\n      range: values.wheelDensityRange,\n      factor: 1,\n    },\n    wheel_friction_exponent: {\n      type: \"float\",\n      length: values.wheelCount,\n      min: values.wheelMinFrictionExponent,\n      range: values.wheelFrictionExponentRange,\n      factor: 1,\n    },\n    chassis_density: {\n      type: \"float\",\n      length: 1,\n      min: values.chassisDensityRange,\n      range: values.chassisMinDensity,\n      factor: 1,\n    },\n    vertex_list: {\n      type: \"float\",\n      length: 12,\n      min: values.chassisMinAxis,\n      range: values.chassisAxisRange,\n      factor: 1,\n    },\n    wheel_vertex: {\n      type: \"shuffle\",\n      length: 8,\n      limit: values.wheelCount,\n      factor: 1,\n    },\n  };\n}\n","/*\n  globals b2RevoluteJointDef b2Vec2 b2BodyDef b2Body b2FixtureDef b2PolygonShape b2CircleShape\n*/\n\nvar createInstance = require(\"../machine-learning/create-instance\");\n\nmodule.exports = defToCar;\n\nfunction defToCar(normal_def, world, constants){\n  var car_def = createInstance.applyTypes(constants.schema, normal_def)\n  var instance = {};\n  instance.chassis = createChassis(\n    world, car_def.vertex_list, car_def.chassis_density\n  );\n\n  // Keep track of the lowest point so that we can place the car on the ground\n  var relativeBottom = 100;\n  // Loop through the vertices of the chassis to find the lowest point\n  for (var i = 0; i < instance.chassis.vertex_list.length; i++) {\n    if (instance.chassis.vertex_list[i].y < relativeBottom) {\n      relativeBottom = instance.chassis.vertex_list[i].y;\n    }\n  }\n\n  var i;\n\n  var wheelCount = car_def.wheel_radius.length;\n\n  instance.wheels = [];\n  for (i = 0; i < wheelCount; i++) {\n    instance.wheels[i] = createWheel(\n      world,\n      car_def.wheel_radius[i],\n      car_def.wheel_density[i],\n      car_def.wheel_friction_exponent[i]\n    );\n  }\n\n  var carmass = instance.chassis.GetMass();\n  for (i = 0; i < wheelCount; i++) {\n    carmass += instance.wheels[i].GetMass();\n  }\n\n  var joint_def = new b2RevoluteJointDef();\n\n  for (i = 0; i < wheelCount; i++) {\n    var torque = carmass * -constants.gravity.y / car_def.wheel_radius[i];\n\n    var randvertex = instance.chassis.vertex_list[car_def.wheel_vertex[i]];\n\n    // Keep track of the lowest point of the wheels.\n    var relativeWheelBottom = randvertex.y - car_def.wheel_radius[i];\n    if (relativeWheelBottom < relativeBottom) {\n      relativeBottom = relativeWheelBottom;\n    }\n\n    joint_def.localAnchorA.Set(randvertex.x, randvertex.y);\n    joint_def.localAnchorB.Set(0, 0);\n    joint_def.maxMotorTorque = torque;\n    joint_def.motorSpeed = -constants.motorSpeed;\n    joint_def.enableMotor = true;\n    joint_def.bodyA = instance.chassis;\n    joint_def.bodyB = instance.wheels[i];\n    world.CreateJoint(joint_def);\n  }\n\n  // Set the car on the ground by setting the position of the chassis and then positioning the wheels where there are already attached. If I don't do this than the physics yanks the joints together so hard that it can send the car spinning or make it enter the ground.\n  var position = instance.chassis.GetPosition();\n  instance.chassis.SetPosition({x: position.x, y: - relativeBottom + world.startHeight});\n  for (i = 0; i < wheelCount; i++) {\n    var randvertex = instance.chassis.vertex_list[car_def.wheel_vertex[i]];\n    instance.wheels[i].SetPosition(instance.chassis.GetWorldPoint(randvertex));\n  }\n\n  return instance;\n}\n\nfunction createChassis(world, vertexs, density) {\n\n  var vertex_list = new Array();\n  vertex_list.push(new b2Vec2(vertexs[0], 0));\n  vertex_list.push(new b2Vec2(vertexs[1], vertexs[2]));\n  vertex_list.push(new b2Vec2(0, vertexs[3]));\n  vertex_list.push(new b2Vec2(-vertexs[4], vertexs[5]));\n  vertex_list.push(new b2Vec2(-vertexs[6], 0));\n  vertex_list.push(new b2Vec2(-vertexs[7], -vertexs[8]));\n  vertex_list.push(new b2Vec2(0, -vertexs[9]));\n  vertex_list.push(new b2Vec2(vertexs[10], -vertexs[11]));\n\n  var body_def = new b2BodyDef();\n  body_def.type = b2Body.b2_dynamicBody;\n  body_def.position.Set(0.0, 4.0);\n\n  var body = world.CreateBody(body_def);\n\n  createChassisPart(body, vertex_list[0], vertex_list[1], density);\n  createChassisPart(body, vertex_list[1], vertex_list[2], density);\n  createChassisPart(body, vertex_list[2], vertex_list[3], density);\n  createChassisPart(body, vertex_list[3], vertex_list[4], density);\n  createChassisPart(body, vertex_list[4], vertex_list[5], density);\n  createChassisPart(body, vertex_list[5], vertex_list[6], density);\n  createChassisPart(body, vertex_list[6], vertex_list[7], density);\n  createChassisPart(body, vertex_list[7], vertex_list[0], density);\n\n  body.vertex_list = vertex_list;\n\n  return body;\n}\n\n\nfunction createChassisPart(body, vertex1, vertex2, density) {\n  var vertex_list = new Array();\n  vertex_list.push(vertex1);\n  vertex_list.push(vertex2);\n  vertex_list.push(b2Vec2.Make(0, 0));\n  var fix_def = new b2FixtureDef();\n  fix_def.shape = new b2PolygonShape();\n  fix_def.density = density;\n  fix_def.friction = 10;\n  fix_def.restitution = 0.2;\n  fix_def.filter.groupIndex = -1;\n  fix_def.shape.SetAsArray(vertex_list, 3);\n\n  body.CreateFixture(fix_def);\n}\n\nfunction createWheel(world, radius, density, friction_exponent) {\n  var body_def = new b2BodyDef();\n  body_def.type = b2Body.b2_dynamicBody;\n  body_def.position.Set(0, 0);\n\n  var body = world.CreateBody(body_def);\n\n  var fix_def = new b2FixtureDef();\n  fix_def.shape = new b2CircleShape(radius);\n  fix_def.density = density;\n  fix_def.friction = Math.pow(10, friction_exponent);\n  fix_def.restitution = 0.2;\n  fix_def.filter.groupIndex = -1;\n\n  body.CreateFixture(fix_def);\n  return body;\n}\n","\n\nmodule.exports = {\n  getInitialState: getInitialState,\n  updateState: updateState,\n  getStatus: getStatus,\n  calculateScore: calculateScore,\n};\n\nfunction getInitialState(world_def){\n  return {\n    frames: 0,\n    health: world_def.max_car_health,\n    maxPositiony: 0,\n    minPositiony: 0,\n    maxPositionx: 0,\n  };\n}\n\nfunction updateState(constants, worldConstruct, state){\n  if(state.health <= 0){\n    throw new Error(\"Already Dead\");\n  }\n  if(state.maxPositionx > constants.finishLine){\n    throw new Error(\"already Finished\");\n  }\n\n  // console.log(state);\n  // check health\n  var position = worldConstruct.chassis.GetPosition();\n  // check if car reached end of the path\n  var nextState = {\n    frames: state.frames + 1,\n    maxPositionx: position.x > state.maxPositionx ? position.x : state.maxPositionx,\n    maxPositiony: position.y > state.maxPositiony ? position.y : state.maxPositiony,\n    minPositiony: position.y < state.minPositiony ? position.y : state.minPositiony\n  };\n\n  if (position.x > constants.finishLine) {\n    return nextState;\n  }\n\n  if (position.x > state.maxPositionx + 0.001) {\n    nextState.health = constants.max_car_health;\n    return nextState;\n  }\n  nextState.health = state.health - 0.1;\n  if (Math.abs(worldConstruct.chassis.GetLinearVelocity().x) < 0.001) {\n    nextState.health -= 5;\n  }\n  return nextState;\n}\n\nfunction getStatus(state, constants){\n  if(hasFailed(state, constants)) return -1;\n  if(hasSuccess(state, constants)) return 1;\n  return 0;\n}\n\nfunction hasFailed(state /*, constants */){\n  return state.health <= 0;\n}\nfunction hasSuccess(state, constants){\n  return state.maxPositionx > constants.finishLine;\n}\n\nfunction calculateScore(state, constants){\n  var avgspeed = (state.maxPositionx / state.frames) * constants.box2dfps;\n  var position = state.maxPositionx;\n  var score = position + avgspeed;\n  return {\n    v: score,\n    s: avgspeed,\n    x: position,\n    y: state.maxPositiony,\n    y2: state.minPositiony\n  }\n}\n","var scatterPlot = require(\"./scatter-plot\");\n\nmodule.exports = {\n  plotGraphs: function(graphElem, topScoresElem, scatterPlotElem, lastState, scores, config) {\n    lastState = lastState || {};\n    var generationSize = scores.length\n    var graphcanvas = graphElem;\n    var graphctx = graphcanvas.getContext(\"2d\");\n    var graphwidth = 400;\n    var graphheight = 250;\n    var nextState = cw_storeGraphScores(\n      lastState, scores, generationSize\n    );\n    console.log(scores, nextState);\n    cw_clearGraphics(graphcanvas, graphctx, graphwidth, graphheight);\n    cw_plotAverage(nextState, graphctx);\n    cw_plotElite(nextState, graphctx);\n    cw_plotTop(nextState, graphctx);\n    cw_listTopScores(topScoresElem, nextState);\n    nextState.scatterGraph = drawAllResults(\n      scatterPlotElem, config, nextState, lastState.scatterGraph\n    );\n    return nextState;\n  },\n  clearGraphics: function(graphElem) {\n    var graphcanvas = graphElem;\n    var graphctx = graphcanvas.getContext(\"2d\");\n    var graphwidth = 400;\n    var graphheight = 250;\n    cw_clearGraphics(graphcanvas, graphctx, graphwidth, graphheight);\n  }\n};\n\n\nfunction cw_storeGraphScores(lastState, cw_carScores, generationSize) {\n  console.log(cw_carScores);\n  return {\n    cw_topScores: (lastState.cw_topScores || [])\n    .concat([cw_carScores[0].score]),\n    cw_graphAverage: (lastState.cw_graphAverage || []).concat([\n      cw_average(cw_carScores, generationSize)\n    ]),\n    cw_graphElite: (lastState.cw_graphElite || []).concat([\n      cw_eliteaverage(cw_carScores, generationSize)\n    ]),\n    cw_graphTop: (lastState.cw_graphTop || []).concat([\n      cw_carScores[0].score.v\n    ]),\n    allResults: (lastState.allResults || []).concat(cw_carScores),\n  }\n}\n\nfunction cw_plotTop(state, graphctx) {\n  var cw_graphTop = state.cw_graphTop;\n  var graphsize = cw_graphTop.length;\n  graphctx.strokeStyle = \"#C83B3B\";\n  graphctx.beginPath();\n  graphctx.moveTo(0, 0);\n  for (var k = 0; k < graphsize; k++) {\n    graphctx.lineTo(400 * (k + 1) / graphsize, cw_graphTop[k]);\n  }\n  graphctx.stroke();\n}\n\nfunction cw_plotElite(state, graphctx) {\n  var cw_graphElite = state.cw_graphElite;\n  var graphsize = cw_graphElite.length;\n  graphctx.strokeStyle = \"#7BC74D\";\n  graphctx.beginPath();\n  graphctx.moveTo(0, 0);\n  for (var k = 0; k < graphsize; k++) {\n    graphctx.lineTo(400 * (k + 1) / graphsize, cw_graphElite[k]);\n  }\n  graphctx.stroke();\n}\n\nfunction cw_plotAverage(state, graphctx) {\n  var cw_graphAverage = state.cw_graphAverage;\n  var graphsize = cw_graphAverage.length;\n  graphctx.strokeStyle = \"#3F72AF\";\n  graphctx.beginPath();\n  graphctx.moveTo(0, 0);\n  for (var k = 0; k < graphsize; k++) {\n    graphctx.lineTo(400 * (k + 1) / graphsize, cw_graphAverage[k]);\n  }\n  graphctx.stroke();\n}\n\n\nfunction cw_eliteaverage(scores, generationSize) {\n  var sum = 0;\n  for (var k = 0; k < Math.floor(generationSize / 2); k++) {\n    sum += scores[k].score.v;\n  }\n  return sum / Math.floor(generationSize / 2);\n}\n\nfunction cw_average(scores, generationSize) {\n  var sum = 0;\n  for (var k = 0; k < generationSize; k++) {\n    sum += scores[k].score.v;\n  }\n  return sum / generationSize;\n}\n\nfunction cw_clearGraphics(graphcanvas, graphctx, graphwidth, graphheight) {\n  graphcanvas.width = graphcanvas.width;\n  graphctx.translate(0, graphheight);\n  graphctx.scale(1, -1);\n  graphctx.lineWidth = 1;\n  graphctx.strokeStyle = \"#3F72AF\";\n  graphctx.beginPath();\n  graphctx.moveTo(0, graphheight / 2);\n  graphctx.lineTo(graphwidth, graphheight / 2);\n  graphctx.moveTo(0, graphheight / 4);\n  graphctx.lineTo(graphwidth, graphheight / 4);\n  graphctx.moveTo(0, graphheight * 3 / 4);\n  graphctx.lineTo(graphwidth, graphheight * 3 / 4);\n  graphctx.stroke();\n}\n\nfunction cw_listTopScores(elem, state) {\n  var cw_topScores = state.cw_topScores;\n  var ts = elem;\n  ts.innerHTML = \"<b>Top Scores:</b><br />\";\n  cw_topScores.sort(function (a, b) {\n    if (a.v > b.v) {\n      return -1\n    } else {\n      return 1\n    }\n  });\n\n  for (var k = 0; k < Math.min(10, cw_topScores.length); k++) {\n    var topScore = cw_topScores[k];\n    // console.log(topScore);\n    var n = \"#\" + (k + 1) + \":\";\n    var score = Math.round(topScore.v * 100) / 100;\n    var distance = \"d:\" + Math.round(topScore.x * 100) / 100;\n    var yrange =  \"h:\" + Math.round(topScore.y2 * 100) / 100 + \"/\" + Math.round(topScore.y * 100) / 100 + \"m\";\n    var gen = \"(Gen \" + cw_topScores[k].i + \")\"\n\n    ts.innerHTML +=  [n, score, distance, yrange, gen].join(\" \") + \"<br />\";\n  }\n}\n\nfunction drawAllResults(scatterPlotElem, config, allResults, previousGraph){\n  if(!scatterPlotElem) return;\n  return scatterPlot(scatterPlotElem, allResults, config.propertyMap, previousGraph)\n}\n","/* globals vis Highcharts */\n\n// Called when the Visualization API is loaded.\n\nmodule.exports = highCharts;\nfunction highCharts(elem, scores){\n  var keys = Object.keys(scores[0].def);\n  keys = keys.reduce(function(curArray, key){\n    var l = scores[0].def[key].length;\n    var subArray = [];\n    for(var i = 0; i < l; i++){\n      subArray.push(key + \".\" + i);\n    }\n    return curArray.concat(subArray);\n  }, []);\n  function retrieveValue(obj, path){\n    return path.split(\".\").reduce(function(curValue, key){\n      return curValue[key];\n    }, obj);\n  }\n\n  var dataObj = Object.keys(scores).reduce(function(kv, score){\n    keys.forEach(function(key){\n      kv[key].data.push([\n        retrieveValue(score.def, key), score.score.v\n      ])\n    })\n    return kv;\n  }, keys.reduce(function(kv, key){\n    kv[key] = {\n      name: key,\n      data: [],\n    }\n    return kv;\n  }, {}))\n  Highcharts.chart(elem.id, {\n      chart: {\n          type: 'scatter',\n          zoomType: 'xy'\n      },\n      title: {\n          text: 'Property Value to Score'\n      },\n      xAxis: {\n          title: {\n              enabled: true,\n              text: 'Normalized'\n          },\n          startOnTick: true,\n          endOnTick: true,\n          showLastLabel: true\n      },\n      yAxis: {\n          title: {\n              text: 'Score'\n          }\n      },\n      legend: {\n          layout: 'vertical',\n          align: 'left',\n          verticalAlign: 'top',\n          x: 100,\n          y: 70,\n          floating: true,\n          backgroundColor: (Highcharts.theme && Highcharts.theme.legendBackgroundColor) || '#FFFFFF',\n          borderWidth: 1\n      },\n      plotOptions: {\n          scatter: {\n              marker: {\n                  radius: 5,\n                  states: {\n                      hover: {\n                          enabled: true,\n                          lineColor: 'rgb(100,100,100)'\n                      }\n                  }\n              },\n              states: {\n                  hover: {\n                      marker: {\n                          enabled: false\n                      }\n                  }\n              },\n              tooltip: {\n                  headerFormat: '<b>{series.name}</b><br>',\n                  pointFormat: '{point.x}, {point.y}'\n              }\n          }\n      },\n      series: keys.map(function(key){\n        return dataObj[key];\n      })\n  });\n}\n\nfunction visChart(elem, scores, propertyMap, graph) {\n\n  // Create and populate a data table.\n  var data = new vis.DataSet();\n  scores.forEach(function(scoreInfo){\n    data.add({\n      x: getProperty(scoreInfo, propertyMap.x),\n      y: getProperty(scoreInfo, propertyMap.x),\n      z: getProperty(scoreInfo, propertyMap.z),\n      style: getProperty(scoreInfo, propertyMap.z),\n      // extra: def.ancestry\n    });\n  });\n\n  function getProperty(info, key){\n    if(key === \"score\"){\n      return info.score.v\n    } else {\n      return info.def[key];\n    }\n  }\n\n  // specify options\n  var options = {\n    width:  '600px',\n    height: '600px',\n    style: 'dot-size',\n    showPerspective: true,\n    showLegend: true,\n    showGrid: true,\n    showShadow: false,\n\n    // Option tooltip can be true, false, or a function returning a string with HTML contents\n    tooltip: function (point) {\n      // parameter point contains properties x, y, z, and data\n      // data is the original object passed to the point constructor\n      return 'score: <b>' + point.z + '</b><br>'; // + point.data.extra;\n    },\n\n    // Tooltip default styling can be overridden\n    tooltipStyle: {\n      content: {\n        background    : 'rgba(255, 255, 255, 0.7)',\n        padding       : '10px',\n        borderRadius  : '10px'\n      },\n      line: {\n        borderLeft    : '1px dotted rgba(0, 0, 0, 0.5)'\n      },\n      dot: {\n        border        : '5px solid rgba(0, 0, 0, 0.5)'\n      }\n    },\n\n    keepAspectRatio: true,\n    verticalRatio: 0.5\n  };\n\n  var camera = graph ? graph.getCameraPosition() : null;\n\n  // create our graph\n  var container = elem;\n  graph = new vis.Graph3d(container, data, options);\n\n  if (camera) graph.setCameraPosition(camera); // restore camera position\n  return graph;\n}\n","\nmodule.exports = generateRandom;\nfunction generateRandom(){\n  return Math.random();\n}\n","// http://sunmingtao.blogspot.com/2016/11/inbreeding-coefficient.html\nmodule.exports = getInbreedingCoefficient;\n\nfunction getInbreedingCoefficient(child){\n  var nameIndex = new Map();\n  var flagged = new Set();\n  var convergencePoints = new Set();\n  createAncestryMap(child, []);\n\n  var storedCoefficients = new Map();\n\n  return Array.from(convergencePoints.values()).reduce(function(sum, point){\n    var iCo = getCoefficient(point);\n    return sum + iCo;\n  }, 0);\n\n  function createAncestryMap(initNode){\n    var itemsInQueue = [{ node: initNode, path: [] }];\n    do{\n      var item = itemsInQueue.shift();\n      var node = item.node;\n      var path = item.path;\n      if(processItem(node, path)){\n        var nextPath = [ node.id ].concat(path);\n        itemsInQueue = itemsInQueue.concat(node.ancestry.map(function(parent){\n          return {\n            node: parent,\n            path: nextPath\n          };\n        }));\n      }\n    }while(itemsInQueue.length);\n\n\n    function processItem(node, path){\n      var newAncestor = !nameIndex.has(node.id);\n      if(newAncestor){\n        nameIndex.set(node.id, {\n          parents: (node.ancestry || []).map(function(parent){\n            return parent.id;\n          }),\n          id: node.id,\n          children: [],\n          convergences: [],\n        });\n      } else {\n\n        flagged.add(node.id)\n        nameIndex.get(node.id).children.forEach(function(childIdentifier){\n          var offsets = findConvergence(childIdentifier.path, path);\n          if(!offsets){\n            return;\n          }\n          var childID = path[offsets[1]];\n          convergencePoints.add(childID);\n          nameIndex.get(childID).convergences.push({\n            parent: node.id,\n            offsets: offsets,\n          });\n        });\n      }\n\n      if(path.length){\n        nameIndex.get(node.id).children.push({\n          child: path[0],\n          path: path\n        });\n      }\n\n      if(!newAncestor){\n        return;\n      }\n      if(!node.ancestry){\n        return;\n      }\n      return true;\n    }\n  }\n\n  function getCoefficient(id){\n    if(storedCoefficients.has(id)){\n      return storedCoefficients.get(id);\n    }\n    var node = nameIndex.get(id);\n    var val = node.convergences.reduce(function(sum, point){\n      return sum + Math.pow(1 / 2, point.offsets.reduce(function(sum, value){\n        return sum + value;\n      }, 1)) * (1 + getCoefficient(point.parent));\n    }, 0);\n    storedCoefficients.set(id, val);\n\n    return val;\n\n  }\n  function findConvergence(listA, listB){\n    var ci, cj, li, lj;\n    outerloop:\n    for(ci = 0, li = listA.length; ci < li; ci++){\n      for(cj = 0, lj = listB.length; cj < lj; cj++){\n        if(listA[ci] === listB[cj]){\n          break outerloop;\n        }\n      }\n    }\n    if(ci === li){\n      return false;\n    }\n    return [ci, cj];\n  }\n}\n","var carConstruct = require(\"../car-schema/construct.js\");\n\nvar carConstants = carConstruct.carConstants();\n\nvar schema = carConstruct.generateSchema(carConstants);\nvar pickParent = require(\"./pickParent\");\nvar selectFromAllParents = require(\"./selectFromAllParents\");\nconst constants = {\n  generationSize: 20,\n  schema: schema,\n  championLength: 1,\n  mutation_range: 1,\n  gen_mutation: 0.05,\n};\nmodule.exports = function(){\n  var currentChoices = new Map();\n  return Object.assign(\n    {},\n    constants,\n    {\n      selectFromAllParents: selectFromAllParents,\n      generateRandom: require(\"./generateRandom\"),\n      pickParent: pickParent.bind(void 0, currentChoices),\n    }\n  );\n}\nmodule.exports.constants = constants\n","var nAttributes = 15;\nmodule.exports = pickParent;\n\nfunction pickParent(currentChoices, chooseId, key /* , parents */){\n  if(!currentChoices.has(chooseId)){\n    currentChoices.set(chooseId, initializePick())\n  }\n  // console.log(chooseId);\n  var state = currentChoices.get(chooseId);\n  // console.log(state.curparent);\n  state.i++\n  if([\"wheel_radius\", \"wheel_vertex\", \"wheel_density\", \"wheel_friction_exponent\"].indexOf(key) > -1){\n    state.curparent = cw_chooseParent(state);\n    return state.curparent;\n  }\n  state.curparent = cw_chooseParent(state);\n  return state.curparent;\n\n  function cw_chooseParent(state) {\n    var curparent = state.curparent;\n    var attributeIndex = state.i;\n    var swapPoint1 = state.swapPoint1\n    var swapPoint2 = state.swapPoint2\n    // console.log(swapPoint1, swapPoint2, attributeIndex)\n    if ((swapPoint1 == attributeIndex) || (swapPoint2 == attributeIndex)) {\n      return curparent == 1 ? 0 : 1\n    }\n    return curparent\n  }\n\n  function initializePick(){\n    var curparent = 0;\n\n    var swapPoint1 = Math.floor(Math.random() * (nAttributes));\n    var swapPoint2 = swapPoint1;\n    while (swapPoint2 == swapPoint1) {\n      swapPoint2 = Math.floor(Math.random() * (nAttributes));\n    }\n    var i = 0;\n    return {\n      curparent: curparent,\n      i: i,\n      swapPoint1: swapPoint1,\n      swapPoint2: swapPoint2\n    }\n  }\n}\n","var getInbreedingCoefficient = require(\"./inbreeding-coefficient\");\n\nmodule.exports = simpleSelect;\n\nfunction simpleSelect(parents){\n  var totalParents = parents.length\n  var r = Math.random();\n  if (r == 0)\n    return 0;\n  return Math.floor(-Math.log(r) * totalParents) % totalParents;\n}\n\nfunction selectFromAllParents(parents, parentList, previousParentIndex) {\n  var previousParent = parents[previousParentIndex];\n  var validParents = parents.filter(function(parent, i){\n    if(previousParentIndex === i){\n      return false;\n    }\n    if(!previousParent){\n      return true;\n    }\n    var child = {\n      id: Math.random().toString(32),\n      ancestry: [previousParent, parent].map(function(p){\n        return {\n          id: p.def.id,\n          ancestry: p.def.ancestry\n        }\n      })\n    }\n    var iCo = getInbreedingCoefficient(child);\n    console.log(\"inbreeding coefficient\", iCo)\n    if(iCo > 0.25){\n      return false;\n    }\n    return true;\n  })\n  if(validParents.length === 0){\n    return Math.floor(Math.random() * parents.length)\n  }\n  var totalScore = validParents.reduce(function(sum, parent){\n    return sum + parent.score.v;\n  }, 0);\n  var r = totalScore * Math.random();\n  for(var i = 0; i < validParents.length; i++){\n    var score = validParents[i].score.v;\n    if(r > score){\n      r = r - score;\n    } else {\n      break;\n    }\n  }\n  return i;\n}\n","var random = require(\"./random.js\");\n\nmodule.exports = {\n  createGenerationZero(schema, generator){\n    return Object.keys(schema).reduce(function(instance, key){\n      var schemaProp = schema[key];\n      var values = random.createNormals(schemaProp, generator);\n      instance[key] = values;\n      return instance;\n    }, { id: Math.random().toString(32) });\n  },\n  createCrossBreed(schema, parents, parentChooser){\n    var id = Math.random().toString(32);\n    return Object.keys(schema).reduce(function(crossDef, key){\n      var schemaDef = schema[key];\n      var values = [];\n      for(var i = 0, l = schemaDef.length; i < l; i++){\n        var p = parentChooser(id, key, parents);\n        values.push(parents[p][key][i]);\n      }\n      crossDef[key] = values;\n      return crossDef;\n    }, {\n      id: id,\n      ancestry: parents.map(function(parent){\n        return {\n          id: parent.id,\n          ancestry: parent.ancestry,\n        };\n      })\n    });\n  },\n  createMutatedClone(schema, generator, parent, factor, chanceToMutate){\n    return Object.keys(schema).reduce(function(clone, key){\n      var schemaProp = schema[key];\n      var originalValues = parent[key];\n      var values = random.mutateNormals(\n        schemaProp, generator, originalValues, factor, chanceToMutate\n      );\n      clone[key] = values;\n      return clone;\n    }, {\n      id: parent.id,\n      ancestry: parent.ancestry\n    });\n  },\n  applyTypes(schema, parent){\n    return Object.keys(schema).reduce(function(clone, key){\n      var schemaProp = schema[key];\n      var originalValues = parent[key];\n      var values;\n      switch(schemaProp.type){\n        case \"shuffle\" :\n          values = random.mapToShuffle(schemaProp, originalValues); break;\n        case \"float\" :\n          values = random.mapToFloat(schemaProp, originalValues); break;\n        case \"integer\":\n          values = random.mapToInteger(schemaProp, originalValues); break;\n        default:\n          throw new Error(`Unknown type ${schemaProp.type} of schema for key ${key}`);\n      }\n      clone[key] = values;\n      return clone;\n    }, {\n      id: parent.id,\n      ancestry: parent.ancestry\n    });\n  },\n}\n","var create = require(\"../create-instance\");\n\nmodule.exports = {\n  generationZero: generationZero,\n  nextGeneration: nextGeneration\n}\n\nfunction generationZero(config){\n  var generationSize = config.generationSize,\n  schema = config.schema;\n  var cw_carGeneration = [];\n  for (var k = 0; k < generationSize; k++) {\n    var def = create.createGenerationZero(schema, function(){\n      return Math.random()\n    });\n    def.index = k;\n    cw_carGeneration.push(def);\n  }\n  return {\n    counter: 0,\n    generation: cw_carGeneration,\n  };\n}\n\nfunction nextGeneration(\n  previousState,\n  scores,\n  config\n){\n  var champion_length = config.championLength,\n    generationSize = config.generationSize,\n    selectFromAllParents = config.selectFromAllParents;\n\n  var newGeneration = new Array();\n  var newborn;\n  var allTimeBest = previousState.allTimeBest;\n  if (!allTimeBest || scores[0].score.v > allTimeBest.best_score) {\n    allTimeBest = scores[0].def;\n    allTimeBest.is_all_time_best = true;\n  }\n  var allTimeBestAdded = false;\n  for (var k = 0; k < champion_length; k++) {\n    scores[k].def.is_elite = true;\n    scores[k].def.index = k;\n    newGeneration.push(scores[k].def);\n    if (scores[k].score.v > scores[k].def.best_score) {\n      scores[k].def.best_score = scores[k].score.v;\n    }\n    if (allTimeBest.id == scores[k].def.id) {\n      allTimeBestAdded = true;\n    }\n  }\n  if (!allTimeBestAdded) {\n    allTimeBest.is_elite = false;\n    newGeneration.push(allTimeBest);\n  }\n  var parentList = [];\n  for (k = champion_length; k < generationSize; k++) {\n    var parent1 = selectFromAllParents(scores, parentList);\n    var parent2 = parent1;\n    while (parent2 == parent1) {\n      parent2 = selectFromAllParents(scores, parentList, parent1);\n    }\n    var pair = [parent1, parent2]\n    parentList.push(pair);\n    newborn = makeChild(config,\n      pair.map(function(parent) { return scores[parent].def; })\n    );\n    newborn = mutate(config, newborn);\n    newborn.is_elite = false;\n    newborn.index = k;\n    newGeneration.push(newborn);\n  }\n\n  return {\n    counter: previousState.counter + 1,\n    generation: newGeneration,\n    allTimeBest: allTimeBest\n  };\n}\n\n\nfunction makeChild(config, parents){\n  var schema = config.schema,\n    pickParent = config.pickParent;\n  return create.createCrossBreed(schema, parents, pickParent)\n}\n\n\nfunction mutate(config, parent){\n  var schema = config.schema,\n    mutation_range = config.mutation_range,\n    gen_mutation = config.gen_mutation,\n    generateRandom = config.generateRandom;\n  return create.createMutatedClone(\n    schema,\n    generateRandom,\n    parent,\n    Math.max(mutation_range),\n    gen_mutation\n  )\n}\n","\n\nconst random = {\n  shuffleIntegers(prop, generator){\n    return random.mapToShuffle(prop, random.createNormals({\n      length: prop.length || 10,\n      inclusive: true,\n    }, generator));\n  },\n  createIntegers(prop, generator){\n    return random.mapToInteger(prop, random.createNormals({\n      length: prop.length,\n      inclusive: true,\n    }, generator));\n  },\n  createFloats(prop, generator){\n    return random.mapToFloat(prop, random.createNormals({\n      length: prop.length,\n      inclusive: true,\n    }, generator));\n  },\n  createNormals(prop, generator){\n    var l = prop.length;\n    var values = [];\n    for(var i = 0; i < l; i++){\n      values.push(\n        createNormal(prop, generator)\n      );\n    }\n    return values;\n  },\n  mutateShuffle(\n    prop, generator, originalValues, mutation_range, chanceToMutate\n  ){\n    return random.mapToShuffle(prop, random.mutateNormals(\n      prop, generator, originalValues, mutation_range, chanceToMutate\n    ));\n  },\n  mutateIntegers(prop, generator, originalValues, mutation_range, chanceToMutate){\n    return random.mapToInteger(prop, random.mutateNormals(\n      prop, generator, originalValues, mutation_range, chanceToMutate\n    ));\n  },\n  mutateFloats(prop, generator, originalValues, mutation_range, chanceToMutate){\n    return random.mapToFloat(prop, random.mutateNormals(\n      prop, generator, originalValues, mutation_range, chanceToMutate\n    ));\n  },\n  mapToShuffle(prop, normals){\n    var offset = prop.offset || 0;\n    var limit = prop.limit || prop.length;\n    var sorted = normals.slice().sort(function(a, b){\n      return a - b;\n    });\n    return normals.map(function(val){\n      return sorted.indexOf(val);\n    }).map(function(i){\n      return i + offset;\n    }).slice(0, limit);\n  },\n  mapToInteger(prop, normals){\n    prop = {\n      min: prop.min || 0,\n      range: prop.range || 10,\n      length: prop.length\n    }\n    return random.mapToFloat(prop, normals).map(function(float){\n      return Math.round(float);\n    });\n  },\n  mapToFloat(prop, normals){\n    prop = {\n      min: prop.min || 0,\n      range: prop.range || 1\n    }\n    return normals.map(function(normal){\n      var min = prop.min;\n      var range = prop.range;\n      return min + normal * range\n    })\n  },\n  mutateNormals(prop, generator, originalValues, mutation_range, chanceToMutate){\n    var factor = (prop.factor || 1) * mutation_range\n    return originalValues.map(function(originalValue){\n      if(generator() > chanceToMutate){\n        return originalValue;\n      }\n      return mutateNormal(\n        prop, generator, originalValue, factor\n      );\n    });\n  }\n};\n\nmodule.exports = random;\n\nfunction mutateNormal(prop, generator, originalValue, mutation_range){\n  if(mutation_range > 1){\n    throw new Error(\"Cannot mutate beyond bounds\");\n  }\n  var newMin = originalValue - 0.5;\n  if (newMin < 0) newMin = 0;\n  if (newMin + mutation_range  > 1)\n    newMin = 1 - mutation_range;\n  var rangeValue = createNormal({\n    inclusive: true,\n  }, generator);\n  return newMin + rangeValue * mutation_range;\n}\n\nfunction createNormal(prop, generator){\n  if(!prop.inclusive){\n    return generator();\n  } else {\n    return generator() < 0.5 ?\n    generator() :\n    1 - generator();\n  }\n}\n","var create = require(\"../create-instance\");\n\nmodule.exports = {\n  generationZero: generationZero,\n  nextGeneration: nextGeneration,\n}\n\nfunction generationZero(config){\n  var oldStructure = create.createGenerationZero(\n    config.schema, config.generateRandom\n  );\n  var newStructure = createStructure(config, 1, oldStructure);\n\n  var k = 0;\n\n  return {\n    counter: 0,\n    k: k,\n    generation: [newStructure, oldStructure]\n  }\n}\n\nfunction nextGeneration(previousState, scores, config){\n  var nextState = {\n    k: (previousState.k + 1)%config.generationSize,\n    counter: previousState.counter + (previousState.k === config.generationSize ? 1 : 0)\n  };\n  // gradually get closer to zero temperature (but never hit it)\n  var oldDef = previousState.curDef || previousState.generation[1];\n  var oldScore = previousState.score || scores[1].score.v;\n\n  var newDef = previousState.generation[0];\n  var newScore = scores[0].score.v;\n\n\n  var temp = Math.pow(Math.E, -nextState.counter / config.generationSize);\n\n  var scoreDiff = newScore - oldScore;\n  // If the next point is higher, change location\n  if(scoreDiff > 0){\n    nextState.curDef = newDef;\n    nextState.score = newScore;\n    // Else we want to increase likelyhood of changing location as we get\n  } else if(Math.random() > Math.exp(-scoreDiff/(nextState.k * temp))){\n    nextState.curDef = newDef;\n    nextState.score = newScore;\n  } else {\n    nextState.curDef = oldDef;\n    nextState.score = oldScore;\n  }\n\n  console.log(previousState, nextState);\n\n  nextState.generation = [createStructure(config, temp, nextState.curDef)];\n\n  return nextState;\n}\n\n\nfunction createStructure(config, mutation_range, parent){\n  var schema = config.schema,\n    gen_mutation = 1,\n    generateRandom = config.generateRandom;\n  return create.createMutatedClone(\n    schema,\n    generateRandom,\n    parent,\n    mutation_range,\n    gen_mutation\n  )\n\n}\n","/* globals btoa */\nvar setupScene = require(\"./setup-scene\");\nvar carRun = require(\"../car-schema/run\");\nvar defToCar = require(\"../car-schema/def-to-car\");\n\nmodule.exports = runDefs;\nfunction runDefs(world_def, defs, listeners) {\n  if (world_def.mutable_floor) {\n    // GHOST DISABLED\n    world_def.floorseed = btoa(Math.seedrandom());\n  }\n\n  var scene = setupScene(world_def);\n  scene.world.Step(1 / world_def.box2dfps, 20, 20);\n  console.log(\"about to build cars\");\n  var cars = defs.map((def, i) => {\n    return {\n      index: i,\n      def: def,\n      car: defToCar(def, scene.world, world_def),\n      state: carRun.getInitialState(world_def)\n    };\n  });\n  var alivecars = cars;\n  return {\n    scene: scene,\n    cars: cars,\n    step: function () {\n      if (alivecars.length === 0) {\n        throw new Error(\"no more cars\");\n      }\n      scene.world.Step(1 / world_def.box2dfps, 20, 20);\n      listeners.preCarStep();\n      alivecars = alivecars.filter(function (car) {\n        car.state = carRun.updateState(\n          world_def, car.car, car.state\n        );\n        var status = carRun.getStatus(car.state, world_def);\n        listeners.carStep(car);\n        if (status === 0) {\n          return true;\n        }\n        car.score = carRun.calculateScore(car.state, world_def);\n        listeners.carDeath(car);\n\n        var world = scene.world;\n        var worldCar = car.car;\n        world.DestroyBody(worldCar.chassis);\n\n        for (var w = 0; w < worldCar.wheels.length; w++) {\n          world.DestroyBody(worldCar.wheels[w]);\n        }\n\n        return false;\n      })\n      if (alivecars.length === 0) {\n        listeners.generationEnd(cars);\n      }\n    }\n  }\n\n}\n","/* globals b2World b2Vec2 b2BodyDef b2FixtureDef b2PolygonShape */\n\n/*\n\nworld_def = {\n  gravity: {x, y},\n  doSleep: boolean,\n  floorseed: string,\n  tileDimensions,\n  maxFloorTiles,\n  mutable_floor: boolean\n}\n\n*/\n\nmodule.exports = function(world_def){\n\n  var world = new b2World(world_def.gravity, world_def.doSleep);\n  var floorTiles = cw_createFloor(\n    world,\n    world_def.floorseed,\n    world_def.tileDimensions,\n    world_def.maxFloorTiles,\n    world_def.mutable_floor\n  );\n\n  var last_tile = floorTiles[\n    floorTiles.length - 1\n  ];\n  var last_fixture = last_tile.GetFixtureList();\n  var last_tile_position = last_tile.GetWorldPoint(\n    last_fixture.GetShape().m_vertices[3]\n  );\n\n  // Loop through first several tiles to find a safe height for placing cars\n  world.startHeight = -10;\n  for (var i = 0; i < 20; i++) {\n    var tile = floorTiles[i];\n    var fixture = tile.GetFixtureList();\n    var topRightVertice = tile.GetWorldPoint(fixture.GetShape().m_vertices[3]);\n    var topLeftVertice = tile.GetWorldPoint(fixture.GetShape().m_vertices[0]);\n    if (topRightVertice.y > world.startHeight) {\n      world.startHeight = topRightVertice.y;\n    }\n    if (topLeftVertice.y > world.startHeight) {\n      world.startHeight = topLeftVertice.y;\n    }\n    if (topRightVertice.x > 2) {\n      break;\n    }\n  }\n  world.finishLine = last_tile_position.x;\n  return {\n    world: world,\n    floorTiles: floorTiles,\n    finishLine: last_tile_position.x\n  };\n}\n\nfunction cw_createFloor(world, floorseed, dimensions, maxFloorTiles, mutable_floor) {\n  var last_tile = null;\n  var tile_position = new b2Vec2(-5, 0);\n  var cw_floorTiles = [];\n  Math.seedrandom(floorseed);\n  for (var k = 0; k < maxFloorTiles; k++) {\n    if (!mutable_floor) {\n      // keep old impossible tracks if not using mutable floors\n      last_tile = cw_createFloorTile(\n        world, dimensions, tile_position, (Math.random() * 3 - 1.5) * 1.5 * k / maxFloorTiles\n      );\n    } else {\n      // if path is mutable over races, create smoother tracks\n      last_tile = cw_createFloorTile(\n        world, dimensions, tile_position, (Math.random() * 3 - 1.5) * 1.2 * k / maxFloorTiles\n      );\n    }\n    cw_floorTiles.push(last_tile);\n    var last_fixture = last_tile.GetFixtureList();\n    tile_position = last_tile.GetWorldPoint(last_fixture.GetShape().m_vertices[3]);\n  }\n  return cw_floorTiles;\n}\n\n\nfunction cw_createFloorTile(world, dim, position, angle) {\n  var body_def = new b2BodyDef();\n\n  body_def.position.Set(position.x, position.y);\n  var body = world.CreateBody(body_def);\n  var fix_def = new b2FixtureDef();\n  fix_def.shape = new b2PolygonShape();\n  fix_def.friction = 0.5;\n\n  var coords = new Array();\n  coords.push(new b2Vec2(0, 0));\n  coords.push(new b2Vec2(0, -dim.y));\n  coords.push(new b2Vec2(dim.x, -dim.y));\n  coords.push(new b2Vec2(dim.x, 0));\n\n  var center = new b2Vec2(0, 0);\n\n  var newcoords = cw_rotateFloorTile(coords, center, angle);\n\n  fix_def.shape.SetAsArray(newcoords);\n\n  body.CreateFixture(fix_def);\n  return body;\n}\n\nfunction cw_rotateFloorTile(coords, center, angle) {\n  return coords.map(function(coord){\n    return {\n      x: Math.cos(angle) * (coord.x - center.x) - Math.sin(angle) * (coord.y - center.y) + center.x,\n      y: Math.sin(angle) * (coord.x - center.x) + Math.cos(angle) * (coord.y - center.y) + center.y,\n    };\n  });\n}\n"]}