// Generated by CoffeeScript 1.7.1
(function() {
  var $z,
    __slice = [].slice,
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

  $z = {};

  $z.Factory = (function() {
    function Factory() {}

    Factory.inactive = {};

    Factory.spawn = function(klass, config, callback) {
      var old;
      if (this.inactive[klass] === void 0) {
        this.inactive[klass] = [];
      }
      if (this.inactive[klass].length === 0) {
        old = new klass(config);
      } else {
        old = this.inactive[klass].pop();
        if (old.is_sleeping === false || old.is_removed === false) {
          console.log('$z.Factory.spawn: not sleeping & unremoved instance found in inactive list!', old);
          $z.Factory.spawn(klass, config);
          return;
        }
        if (old.wake != null) {
          old.wake(config);
        } else {
          $z.Utils.set(old, config);
        }
      }
      if (typeof callback === "function") {
        callback(old);
      }
      return old;
    };

    Factory.sleep = function(instance) {
      var _ref;
      if (instance === void 0) {
        console.log('$z.Factory.sleep(): undefined input', instance);
        return;
      }
      if (instance.is_sleeping === true) {
        console.log('$z.Factory.sleep(): sleeping instance', instance, this.inactive[instance.constructor].indexOf(instance));
        return;
      }
      if ((_ref = this.inactive[instance.constructor]) != null) {
        _ref.push(instance);
      }
    };

    return Factory;

  })();

  $z.Gamescore = (function() {
    function Gamescore() {}

    Gamescore.value = 0;

    Gamescore.increment = 100;

    Gamescore.initialLives = 2;

    Gamescore.lives = Gamescore.initialLives;

    Gamescore.increment_value = function() {
      return this.value += this.increment;
    };

    Gamescore.decrement_value = function() {
      return this.value -= this.increment;
    };

    return Gamescore;

  })();

  $z.ImageLoader = (function() {
    function ImageLoader() {}

    ImageLoader.loading = false;

    ImageLoader.cache = {};

    ImageLoader.loadingStats = {
      total: null,
      count: null,
      finalCallback: null
    };

    ImageLoader.load = function(url) {
      var img;
      if (this.cache[url] != null) {
        this.callbackHandler();
      } else {
        img = new Image();
        img.onload = $z.ImageLoader.callbackHandler;
        img.src = url;
        this.cache[url] = img;
      }
      return img;
    };

    ImageLoader.callbackHandler = function() {
      $z.ImageLoader.loadingStats.count++;
      if ($z.ImageLoader.loadingStats.count === $z.ImageLoader.loadingStats.total) {
        $z.ImageLoader.loadingStats.finalCallback();
        $z.ImageLoader.loading = false;
      }
    };

    ImageLoader.preload = function(imageList, callback) {
      var url, _i, _len;
      if (this.loading) {
        return;
      }
      this.loading = true;
      this.loadingStats.total = imageList.length;
      this.loadingStats.count = 0;
      this.loadingStats.finalCallback = callback;
      for (_i = 0, _len = imageList.length; _i < _len; _i++) {
        url = imageList[_i];
        this.load(url);
      }
    };

    return ImageLoader;

  })();

  $z.Utils = (function() {
    function Utils() {}

    Utils.fullscreen = function() {
      var elem;
      elem = document.body.parentNode;
      if (elem.requestFullscreen) {
        return elem.requestFullscreen();
      } else if (elem.msRequestFullscreen) {
        return elem.msRequestFullscreen();
      } else if (elem.mozRequestFullScreen) {
        return elem.mozRequestFullScreen();
      } else if (elem.webkitRequestFullscreen) {
        return elem.webkitRequestFullscreen();
      }
    };

    Utils.defaultscreen = function() {
      var elem;
      elem = document;
      if (elem.exitFullscreen) {
        return elem.exitFullscreen();
      } else if (elem.msExitFullscreen) {
        return elem.msExitFullscreen();
      } else if (elem.mozExitFullScreen) {
        return elem.mozExitFullScreen();
      } else if (elem.webkitExitFullscreen) {
        return elem.webkitExitFullscreen();
      }
    };

    Utils.index_pop = function(array, index) {
      var length, swap;
      length = array.length;
      if (index < array.length - 1) {
        swap = array[index];
        array[index] = array[length - 1];
        array[length - 1] = swap;
      }
      return array.pop();
    };

    Utils.delayedLoop = function(dur, Niter, callback, finalCallback) {
      var i, runLoop;
      if (dur == null) {
        dur = 1000;
      }
      if (finalCallback == null) {
        finalCallback = void 0;
      }
      i = 0;
      runLoop = function() {
        callback(i);
        if (++i === Niter) {
          if (typeof finalCallback === "function") {
            finalCallback();
          }
          return;
        }
        return setTimeout(runLoop, dur);
      };
      return runLoop();
    };

    Utils.set = function(obj, config) {
      var x, _results;
      _results = [];
      for (x in config) {
        _results.push(obj[x] = config[x]);
      }
      return _results;
    };

    Utils.clone = function(obj) {
      var key, temp;
      if (obj === null || typeof obj !== "object") {
        return obj;
      }
      temp = new obj.constructor();
      for (key in obj) {
        temp[key] = $z.Utils.clone(obj[key]);
      }
      return temp;
    };

    Utils.addChainedAttributeAccessor = function(obj, attr) {
      return obj[attr] = function() {
        var newValues;
        newValues = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
        if (newValues.length === 0) {
          return obj['_' + attr];
        } else {
          obj['_' + attr] = newValues[0];
          obj.image.attr(attr, obj['_' + attr]);
          return obj;
        }
      };
    };

    Utils.timestamp = function() {
      return Date.now();
    };

    Utils.angle = function(a) {
      return 2 * Math.PI * a / 360;
    };

    Utils.path_seg = function(p) {
      var a;
      a = p.pathSegTypeAsLetter;
      switch (a) {
        case 'M':
        case 'm':
          return [a, p.x, p.y].join(" ");
        case 'L':
        case 'l':
          return [a, p.x, p.y].join(" ");
        case 'A':
        case 'a':
          return [a, p.r, p.r, p.rot, p.c, p.d, p.x, p.y].join(" ");
        case 'C':
        case 'c':
          return [a, p.x1, p.y1, p.x2, p.y2, p.x, p.y].join(" ");
        case 'S':
        case 's':
          return [a, p.x2, p.y2, p.x, p.y].join(" ");
        case 'Q':
        case 'q':
          return [a, p.x1, p.y1, p.x, p.y].join(" ");
        case 'T':
        case 't':
          return [a, p.x, p.y].join(" ");
        case 'Z':
        case 'z':
          return a;
      }
    };

    Utils.d = function(path) {
      var p;
      return ((function() {
        var _i, _len, _results;
        _results = [];
        for (_i = 0, _len = path.length; _i < _len; _i++) {
          p = path[_i];
          _results.push(this.path_seg(p));
        }
        return _results;
      }).call(this)).join(" ");
    };

    Utils.pathTween = function(d, i, a) {
      var interp, prec;
      prec = 4;
      interp = function(d, path) {
        var distances, dt, n0, n1, p, points;
        n0 = path.getTotalLength();
        p = path.cloneNode();
        p.setAttribute("d", d);
        n1 = p.getTotalLength();
        distances = [0];
        i = 0;
        dt = prec / Math.max(n0, n1);
        while ((i += dt) < 1) {
          distances.push(i);
        }
        distances.push(1);
        points = distances.map(function(t) {
          var p0, p1;
          p0 = path.getPointAtLength(t * n0);
          p1 = p.getPointAtLength(t * n1);
          return d3.interpolate([p0.x, p0.y], [p1.x, p1.y]);
        });
        return function(t) {
          if (t < 1) {
            return "M" + points.map(function(p) {
              return p(t);
            }).join("L");
          } else {
            return d;
          }
        };
      };
      return interp(d, this);
    };

    Utils.bilinear_interp = function(matrix, x, y) {
      var dxc, dxf, dyc, dyf, interp, tol, xc, xf, yc, yf;
      tol = 1e-100;
      xf = Math.floor(x);
      xc = Math.ceil(x + tol);
      yf = Math.floor(y);
      yc = Math.ceil(y + tol);
      dxf = x - xf;
      dxc = xc - x;
      dyf = y - yf;
      dyc = yc - y;
      interp = matrix[yf][xf] * dxc * dyc + matrix[yf][xc] * dxf * dyc + matrix[yc][xf] * dxc * dyf + matrix[yc][xc] * dxf * dyf;
      return interp;
    };

    return Utils;

  })();

  $z.Element = (function() {
    function Element(config) {
      this.config = config != null ? config : {};
      this.d = $z.Factory.spawn($z.Vec);
      this.ri = $z.Factory.spawn($z.Vec);
      this.rj = $z.Factory.spawn($z.Vec);
      this.r_temp = $z.Factory.spawn($z.Vec);
      this.dr_temp = $z.Factory.spawn($z.Vec);
      this.line = $z.Factory.spawn($z.Vec);
      this.normal = $z.Factory.spawn($z.Vec);
      this.lshift = $z.Factory.spawn($z.Vec);
      this.vPar = $z.Factory.spawn($z.Vec);
      this.vPerp = $z.Factory.spawn($z.Vec);
      this.uPar = $z.Factory.spawn($z.Vec);
      this.uPerp = $z.Factory.spawn($z.Vec);
      this.dt = this.config.dt || 0.25;
      this.r = this.config.r || $z.Factory.spawn($z.Vec);
      this.dr = this.config.dr || $z.Factory.spawn($z.Vec);
      this.v = this.config.v || $z.Factory.spawn($z.Vec);
      this.f = this.config.f || $z.Factory.spawn($z.Vec);
      this.fcopy = $z.Utils.clone(this.config.f) || $z.Factory.spawn($z.Vec);
      this.force_param = this.config.force_param || [];
      this.size = this.config.size || 0;
      this.bb_width = this.config.bb_width || 0;
      this.bb_height = this.config.bb_height || 0;
      this.left = this.config.bb_width || 0;
      this.right = this.config.bb_height || 0;
      this.top = this.config.top || 0;
      this.bottom = this.config.bottom || 0;
      this.collision = this.config.collision || true;
      this.tol = this.config.tol || 0.25;
      this._stroke = this.config.stroke || "none";
      this._fill = this.config.fill || "black";
      this.angle = this.config.angle || 0;
      this.is_root = this.config.is_root || false;
      this.is_bullet = this.config.is_bullet || false;
      this.type = this.config.type || null;
      this.image = this.config.image || null;
      this.overlay = this.config.overlay || null;
      this.g = d3.select("#game_g").append("g").attr("transform", "translate(" + this.r.x + "," + this.r.y + ")").style('opacity', 0).datum(this);
      this.g = this.config.g || this.g;
      this.svg = this.config.svg || $z.Game.instance.svg;
      this.game_g = this.config.game_g || $z.Game.instance.g;
      this.quadtree = this.config.quadtree || null;
      this.tick = this.config.tick || $z.Physics.euler;
      this.is_removed = false;
      this.is_sleeping = false;
      this.is_flashing = false;
      this._cleanup = true;
      $z.Utils.addChainedAttributeAccessor(this, 'fill');
      $z.Utils.addChainedAttributeAccessor(this, 'stroke');
    }

    Element.prototype.reaction = function(element) {
      return element != null ? element.reaction() : void 0;
    };

    Element.prototype.BB = function() {
      this.left = this.r.x - 0.5 * this.bb_width;
      this.right = this.r.x + 0.5 * this.bb_width;
      this.top = this.r.y - 0.5 * this.bb_height;
      return this.bottom = this.r.y + 0.5 * this.bb_height;
    };

    Element.prototype.draw = function() {
      this.g.attr("transform", "translate(" + this.r.x + "," + this.r.y + ") rotate(" + (360 * 0.5 * this.angle / Math.PI) + ")");
    };

    Element.prototype.remove_check = function(n) {
      if (this.is_root || this.is_bullet) {
        this.reaction(n);
        return true;
      }
      return false;
    };

    Element.prototype.offscreen = function() {
      return this.r.x < -this.size || this.r.y < -this.size || this.r.x > $z.Game.width + this.size || this.r.y > $z.Game.height + this.size;
    };

    Element.prototype.fadeIn = function(dur, callback) {
      if (dur == null) {
        dur = 30;
      }
      if (dur != null) {
        return this.g.transition().duration(dur).ease('linear').style("opacity", 1).each('end', function(d) {
          return typeof callback === "function" ? callback(d) : void 0;
        });
      } else {
        this.g.style("opacity", 1);
        return typeof callback === "function" ? callback(this) : void 0;
      }
    };

    Element.prototype.fadeOut = function(dur, callback) {
      if (dur == null) {
        dur = 30;
      }
      return this.g.transition().duration(dur).ease('linear').style("opacity", 0).each('end', function(d) {
        return typeof callback === "function" ? callback(d) : void 0;
      });
    };

    Element.prototype.flash = function(dur, color, scaleFactor, initialOpacity) {
      if (dur == null) {
        dur = 1000;
      }
      if (color == null) {
        color = '#FFF';
      }
      if (scaleFactor == null) {
        scaleFactor = 3;
      }
      if (initialOpacity == null) {
        initialOpacity = 0.4;
      }
      if (this.is_flashing) {
        return;
      }
      this.is_flashing = true;
      return this.overlay.style('fill', color).style('opacity', initialOpacity).transition().duration(dur).attr('transform', 'scale(' + scaleFactor + ')').style('opacity', 0).ease('linear').each('end', (function(_this) {
        return function() {
          _this.overlay.attr('transform', 'scale(1)');
          return _this.is_flashing = false;
        };
      })(this));
    };

    Element.prototype.start = function(duration, callback) {
      var index;
      if (duration == null) {
        duration = void 0;
      }
      if (callback == null) {
        callback = (function(_this) {
          return function() {
            return _this.collision = true;
          };
        })(this);
      }
      if (this.is_sleeping) {
        console.log('element.start: is_sleeping... bug?');
        return;
      }
      index = $z.Collision.list.indexOf(this);
      if (index === -1) {
        $z.Collision.list.push(this);
      } else {
        console.log('element.start: this element is already on the physics list! bug?');
      }
      this.is_removed = false;
      this.draw();
      this.fadeIn(duration, callback);
    };

    Element.prototype.cleanup = function(_cleanup) {
      this._cleanup = _cleanup != null ? _cleanup : this._cleanup;
      if (this._cleanup && this.offscreen()) {
        return this.remove();
      }
    };

    Element.prototype.sleep = function() {
      $z.Factory.sleep(this);
      this.is_sleeping = true;
    };

    Element.prototype.remove = function(dur) {
      if (dur == null) {
        dur = 30;
      }
      if (this.is_removed || !this.collision) {
        return;
      }
      this.collision = false;
      if (dur > 0) {
        this.fadeOut(dur, (function(d) {
          return d.is_removed = true;
        }));
      } else {
        this.is_removed = true;
      }
    };

    Element.prototype.spawn = function() {
      this.wake();
      this.start();
      return this;
    };

    Element.prototype.init = function() {
      this.r.x = 0;
      this.r.y = 0;
      this.dr.x = 0;
      this.dr.y = 0;
      this.v.x = 0;
      this.v.y = 0;
      this.f.x = 0;
      this.f.y = 0;
      return this;
    };

    Element.prototype.wake = function(config) {
      this.is_sleeping = false;
      this.init();
      if (config != null) {
        $z.Utils.set(this, config);
      }
      return this;
    };

    Element.prototype.scale = function(scalingFactor, dur, callback) {
      if (scalingFactor == null) {
        scalingFactor = 10;
      }
      if (dur == null) {
        dur = void 0;
      }
      if (callback == null) {
        callback = function() {};
      }
      if (dur != null) {
        return this.image.transition().duration(dur).ease('linear').attr('transform', 'scale(' + scalingFactor + ')').each('end', callback);
      } else {
        this.image.attr('transform', 'scale(' + scalingFactor + ')');
        return callback();
      }
    };

    return Element;

  })();

  $z.Game = (function() {
    var current_height, current_width, get_scale, image_preload_callback;

    Game.width = null;

    Game.height = null;

    Game.scale = 1;

    Game.audioSwitch = true;

    Game.musicSwitch = true;

    Game.instance = null;

    Game.message_color = "#FFF";

    Game.width = 800;

    Game.height = 600;

    Game.maxdim = Math.max(Game.width, Game.height);

    function Game(config) {
      this.config = config != null ? config : {};
      this.images_loaded = false;
      this.element = [];
      this.div = d3.select("#game_div");
      this.svg = d3.select("#game_svg");
      if (this.svg.empty()) {
        this.svg = this.div.append('svg').attr('id', 'game_svg');
      }
      this.svg.attr("viewBox", '0 0 ' + $z.Game.width + ' ' + $z.Game.height).attr("preserveAspectRatio", "xMidYMin meet").attr('width', '100%').style('max-height', '100%');
      this.scale = 1;
      this.g = d3.select("#game_g");
      if (this.g.empty()) {
        this.g = this.svg.append('g');
      }
      this.g.attr('id', 'game_g');
      $z.Game.instance = this;
      $z.Game.instance.div.style('opacity', 0);
      this.preload_images();
    }

    image_preload_callback = function() {
      var dur;
      $z.Game.instance.images_loaded = true;
      $z.Game.instance.start();
      dur = 1000;
      return $z.Game.instance.div.transition().duration(dur).style('opacity', 1);
    };

    Game.prototype.preload_images = function(image_list, preload_callback) {
      var dur;
      if (image_list == null) {
        image_list = $z.Game.instance.image_list;
      }
      if ((image_list != null) && (image_list.length != null) && image_list.length > 0) {
        return $z.ImageLoader.preload(image_list, image_preload_callback);
      } else {
        dur = 1000;
        return $z.Game.instance.div.transition().duration(dur).style('opacity', 1);
      }
    };

    current_width = function(padding) {
      var element, x;
      if (padding == null) {
        padding = 8;
      }
      element = window.top.document.body;
      x = $(element).width();
      x = Math.min(x, $(window).width());
      x = Math.min(x, $(window.top).width());
      if (x > padding && padding > 0) {
        return x = x - padding;
      }
    };

    current_height = function(padding) {
      var element, y;
      if (padding == null) {
        padding = 124;
      }
      element = window.top;
      y = $(element).height();
      if (y > padding && padding > 0) {
        y = y - padding;
      }
      return y;
    };

    get_scale = function() {
      var max_scale, min_scale, r1, r2, scale;
      r1 = current_width() / $z.Game.width;
      r2 = current_height() / $z.Game.height;
      scale = r1 <= r2 ? r1 : r2;
      max_scale = 1.0;
      min_scale = 0.39;
      return scale = Math.max(min_scale, Math.min(max_scale, scale));
    };

    Game.prototype.start = function() {
      $z.Physics.start();
      if (typeof Gameprez !== "undefined" && Gameprez !== null) {
        Gameprez.start();
      }
    };

    Game.prototype.stop = function(callback) {
      if (callback == null) {
        callback = function() {};
      }
      this.cleanup();
      $z.Physics.stop();
      if (typeof Gameprez !== "undefined" && Gameprez !== null) {
        Gameprez.end($z.Gamescore.value, callback);
      } else {
        callback();
      }
    };

    Game.prototype.cleanup = function() {
      this.g.selectAll('g').each(function(d) {
        return d != null ? d.remove() : void 0;
      });
    };

    Game.prototype.message = function(txt, callback, dur) {
      var ready, spacing;
      if (dur == null) {
        dur = 1000;
      }
      callback || (callback = function() {});
      this.g.selectAll('.game_message').remove();
      spacing = 10;
      ready = this.g.append("text").attr('class', 'game_message').text(txt).attr("stroke", "none").attr("fill", $z.Game.message_color).attr("font-size", "36").attr("x", $z.Game.width / 2 - txt.length * spacing).attr("y", $z.Game.height / 2 + 20).attr('font-family', 'arial').attr('font-weight', 'bold').attr('opacity', 0).transition().duration(dur).style("opacity", 1).transition().duration(dur).style('opacity', 0).remove().each('end', callback);
    };

    return Game;

  })();

  $z.Circle = (function(_super) {
    __extends(Circle, _super);

    function Circle(config) {
      var _base;
      this.config = config != null ? config : {};
      (_base = this.config).size || (_base.size = 15);
      Circle.__super__.constructor.call(this, this.config);
      this.type = 'Circle';
      this.BB();
      this.image = this.g.append("circle").attr("r", this.size).attr("x", 0).attr("y", 0);
      this.overlay = this.g.append("circle").style('opacity', 0).attr("r", this.size).attr("x", 0).attr("y", 0);
      this.stroke(this._stroke);
      this.fill(this._fill);
    }

    Circle.prototype.draw = function() {
      Circle.__super__.draw.apply(this, arguments);
      return this.image.attr("r", this.size);
    };

    Circle.prototype.BB = function(size) {
      this.size = size != null ? size : this.size;
      this.bb_width = 2 * this.size;
      this.bb_height = 2 * this.size;
      return Circle.__super__.BB.apply(this, arguments);
    };

    return Circle;

  })($z.Element);

  $z.Polygon = (function(_super) {
    __extends(Polygon, _super);

    function Polygon(config) {
      this.config = config != null ? config : {};
      Polygon.__super__.constructor.call(this, this.config);
      this.type = 'Polygon';
      this.path = this.config.path || this.default_path();
      this.image = this.g.append("path");
      this.overlay = this.g.append("path").style('opacity', 0).attr("x", 0).attr("y", 0);
      this.fill(this._fill);
      this.stroke(this._stroke);
      this.set_path();
    }

    Polygon.prototype.default_path = function() {
      var invsqrt3;
      invsqrt3 = 1 / Math.sqrt(3);
      return [
        {
          pathSegTypeAsLetter: 'M',
          x: -this.size,
          y: this.size * invsqrt3,
          react: true
        }, {
          pathSegTypeAsLetter: 'L',
          x: 0,
          y: -2 * this.size * invsqrt3,
          react: true
        }, {
          pathSegTypeAsLetter: 'L',
          x: this.size,
          y: this.size * invsqrt3,
          react: true
        }, {
          pathSegTypeAsLetter: 'Z'
        }
      ];
    };

    Polygon.prototype.d_attr = function() {
      return $z.Utils.d(this.path);
    };

    Polygon.prototype.polygon_path = function() {
      var i, _i, _ref;
      for (i = _i = 0, _ref = this.path.length - 2; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
        this.path[i].r = $z.Factory.spawn($z.Vec, this.path[i]).subtract(this.path[(i + 1) % (this.path.length - 1)]);
        this.path[i].n = $z.Factory.spawn($z.Vec, {
          x: -this.path[i].r.y,
          y: this.path[i].r.x
        }).normalize();
      }
      this.BB();
    };

    Polygon.prototype.set_path = function(path) {
      var i, maxd, maxnode, node, _i, _ref;
      this.path = path != null ? path : this.path;
      this.pathref = this.path.map(function(d) {
        return $z.Utils.clone(d);
      });
      this.polygon_path();
      maxnode = this.path[0];
      this.path[0].d = maxnode.x * maxnode.x + maxnode.y * maxnode.y;
      maxd = this.path[0].d;
      for (i = _i = 1, _ref = this.path.length - 2; 1 <= _ref ? _i <= _ref : _i >= _ref; i = 1 <= _ref ? ++_i : --_i) {
        node = this.path[i];
        node.d = node.x * node.x + node.y * node.y;
        if (node.d > maxd) {
          maxnode = this.path[i];
        }
      }
      this.maxnode = $z.Factory.spawn($z.Vec, maxnode);
      this.size = this.maxnode.length();
      this.image.attr("d", this.d_attr());
      return this.overlay.attr("d", this.d_attr());
    };

    Polygon.prototype.BB = function() {
      var i, xmax, xmin, ymax, ymin, _i, _ref;
      xmax = this.path[0].x;
      ymax = this.path[0].y;
      xmin = xmax;
      ymin = ymax;
      for (i = _i = 1, _ref = this.path.length - 1; 1 <= _ref ? _i < _ref : _i > _ref; i = 1 <= _ref ? ++_i : --_i) {
        if (this.path[i].x > xmax) {
          xmax = this.path[i].x;
        }
        if (this.path[i].x < xmin) {
          xmin = this.path[i].x;
        }
        if (this.path[i].y > ymax) {
          ymax = this.path[i].y;
        }
        if (this.path[i].y < ymin) {
          ymin = this.path[i].y;
        }
      }
      this.bb_width = xmax - xmin;
      this.bb_height = ymax - ymin;
      return Polygon.__super__.BB.apply(this, arguments);
    };

    Polygon.prototype.rotate_path = function() {
      var c, i, s, seg, _i, _ref;
      for (i = _i = 0, _ref = this.path.length - 1; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
        seg = this.path[i];
        if (seg.x == null) {
          continue;
        }
        c = Math.cos(this.angle);
        s = Math.sin(this.angle);
        seg.x = c * this.pathref[i].x - s * this.pathref[i].y;
        seg.y = s * this.pathref[i].x + c * this.pathref[i].y;
      }
      this.polygon_path();
    };

    return Polygon;

  })($z.Element);

  $z.Collision = (function() {
    var circle_circle_dist, circle_lineseg_dist, lineseg_intersect, name, nearest_node, sort, z_check;

    function Collision() {}

    Collision.use_bb = false;

    Collision.list = [];

    Collision.update_quadtree = function(force_update) {
      var data;
      if (force_update == null) {
        force_update = false;
      }
      if (!(this.list.length > 0)) {
        return;
      }
      data = this.list.filter(function(d) {
        return d.collision;
      }).map(function(d) {
        return {
          x: d.r.x,
          y: d.r.y,
          d: d
        };
      });
      return this.quadtree = d3.geom.quadtree(data);
    };

    Collision.quadtree = Collision.update_quadtree();

    Collision.resolve = function(m, n) {
      var iter, maxiter, reaction, _results;
      maxiter = 32;
      iter = 1;
      reaction = false;
      _results = [];
      while ($z.Collision.check(m, n, reaction) && iter <= maxiter) {
        m.tick();
        n.tick();
        _results.push(iter++);
      }
      return _results;
    };

    Collision.detect = function() {
      var d, i, length, size, x0, x3, y0, y3, _results;
      if (!(this.list.length > 0)) {
        return;
      }
      this.update_quadtree();
      length = this.list.length;
      i = 0;
      _results = [];
      while (i < length) {
        d = this.list[i];
        if (d.collision) {
          size = 2 * (d.size + d.tol);
          x0 = d.r.x - size;
          x3 = d.r.x + size;
          y0 = d.r.y - size;
          y3 = d.r.y + size;
          this.quadtree.visit(function(node, x1, y1, x2, y2) {
            var p;
            p = node.point;
            if (p !== null) {
              if (p.is_removed) {
                return false;
              }
              if (!(d !== p.d && p.d.collision)) {
                return false;
              }
              if ((p.x >= x0) && (p.x < x3) && (p.y >= y0) && (p.y < y3)) {
                $z.Collision.check(d, p.d);
              }
            }
            return x1 >= x3 || y1 >= y3 || x2 < x0 || y2 < y0;
          });
        }
        length = this.list.length;
        _results.push(i++);
      }
      return _results;
    };

    name = [null, null];

    sort = [null, null];

    Collision.check = function(ei, ej, reaction) {
      var collision, d, m, n, reaction_type;
      if (reaction == null) {
        reaction = true;
      }
      name[0] = ei.type;
      name[1] = ej.type;
      sort[0] = ei.type;
      sort[1] = ej.type;
      sort.sort();
      if (name[0] === sort[0] && name[1] === sort[1]) {
        m = ei;
        n = ej;
      } else {
        m = ej;
        n = ei;
      }
      m.d.collision = false;
      n.d.collision = false;
      switch (m.type) {
        case 'Circle':
          switch (n.type) {
            case 'Circle':
              d = this.circle_circle(m, n);
              reaction_type = 'circle_circle';
              break;
            case 'Polygon':
              d = this.circle_polygon(m, n);
              reaction_type = 'circle_polygon';
          }
          break;
        case 'Polygon':
          switch (n.type) {
            case 'Polygon':
              d = this.polygon_polygon(m, n);
              reaction_type = 'polygon_polygon';
          }
      }
      if (d.collision && reaction) {
        $z.Reaction[reaction_type](m, n, d);
      }
      collision = d.collision;
      return collision;
    };

    Collision.rectangle_rectangle = function(m, n) {
      var not_intersect;
      m.BB();
      n.BB();
      not_intersect = n.left > m.right || n.right < m.left || n.top > m.bottom || n.bottom < m.top;
      return !not_intersect;
    };

    Collision.circle_circle = function(m, n) {
      var d;
      if (this.use_bb) {
        if (this.rectangle_rectangle(m, n)) {
          d = circle_circle_dist(m, n);
          d.collision = true;
        } else {
          d = {
            collision: false
          };
        }
      } else {
        d = circle_circle_dist(m, n);
        d.collision = d.dist <= d.dmin ? true : false;
      }
      return d;
    };

    Collision.circle_polygon = function(circle, polygon) {
      var d, i, _i, _ref;
      if (this.use_bb) {
        if (this.rectangle_rectangle(circle, polygon)) {
          i = nearest_node(polygon, circle);
          d = circle_lineseg_dist(circle, polygon, i);
          d.i = i;
          d.collision = true;
        } else {
          d = {
            collision: false
          };
        }
      } else {
        for (i = _i = 0, _ref = polygon.path.length - 2; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
          if (!polygon.path[i].react) {
            continue;
          }
          d = circle_lineseg_dist(circle, polygon, i);
          if (d.dist > circle.size) {
            continue;
          }
          d.i = i;
          d.collision = true;
          break;
        }
      }
      return d;
    };

    Collision.polygon_polygon = function(m, n) {
      var d, i, j, _i, _j, _ref, _ref1;
      if (this.use_bb) {
        if (this.rectangle_rectangle(m, n)) {
          d = circle_circle_dist(m, n);
          d.i = nearest_node(m, n);
          d.j = nearest_node(n, m);
          d.collision = true;
        } else {
          d = {
            collision: false
          };
        }
      } else {
        d = circle_circle_dist(m, n);
        d.collision = false;
        if (d.dist <= d.dmin) {
          for (i = _i = 0, _ref = m.path.length - 2; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
            for (j = _j = 0, _ref1 = n.path.length - 2; 0 <= _ref1 ? _j <= _ref1 : _j >= _ref1; j = 0 <= _ref1 ? ++_j : --_j) {
              if (!lineseg_intersect(m, n, i, j)) {
                continue;
              }
              d.i = i;
              d.j = j;
              d.collision = true;
              break;
            }
            if (d.collision) {
              break;
            }
          }
        }
      }
      return d;
    };

    nearest_node = function(m, n) {
      var d, i, nn, nnd, node, _i, _ref;
      nn = m.path[0];
      nnd = (nn.x + m.r.x - n.r.x) * (nn.x + m.r.x - n.r.x) + (nn.y + m.r.y - n.r.y) * (nn.y + m.r.y - n.r.y);
      for (i = _i = 1, _ref = this.path.length - 2; 1 <= _ref ? _i <= _ref : _i >= _ref; i = 1 <= _ref ? ++_i : --_i) {
        node = m.path[i];
        d = (node.x + m.r.x - n.r.x) * (node.x + m.r.x - n.r.x) + (node.y + m.r.y - n.r.y) * (node.y + m.r.y - n.r.y);
        if (d < nnd) {
          nn = m.path[i];
        }
      }
      return m.path.indexOf(nn);
    };

    circle_circle_dist = function(m, n) {
      var d;
      d = m.d.init(m.r).subtract(n.r);
      d.dist = Math.sqrt(d.x * d.x + d.y * d.y);
      d.dmin = m.size + n.size;
      return d;
    };

    circle_lineseg_dist = function(circle, polygon, i) {
      var d, dr, r, ri, rj, rr, t;
      ri = polygon.path[i];
      rj = circle.rj.init(z_check(polygon.path, i));
      r = circle.r_temp.init(circle.rj).subtract(ri);
      rr = r.x * r.x + r.y * r.y;
      dr = circle.dr_temp.init(circle.r).subtract(ri).subtract(polygon.r);
      t = (r.x * dr.x + r.y * dr.y) / rr;
      if (t < 0) {

      } else if (t > 1) {
        dr.x = circle.r.x - rj.x - polygon.r.x;
        dr.y = circle.r.y - rj.y - polygon.r.y;
      } else {
        dr.x = r.x * t + ri.x + polygon.r.x;
        dr.y = r.y * t + ri.y + polygon.r.y;
        dr.x *= -1;
        dr.y *= -1;
        dr.x += circle.r.x;
        dr.y += circle.r.y;
      }
      d = circle.d.init(dr);
      d.t = t;
      d.r = [r.x, r.y];
      d.rr = rr;
      d.dist = Math.sqrt(dr.x * dr.x + dr.y * dr.y);
      return d;
    };

    lineseg_intersect = function(m, n, i, j) {
      var A1, A2, B1, B2, C1, C2, check1, check2, check3, check4, det, ri, rj, si, sj, x, y, _ref, _ref1, _ref2, _ref3;
      ri = m.ri.init(m.path[i]);
      rj = m.rj.init(z_check(m.path, i));
      si = n.ri.init(n.path[j]);
      sj = n.rj.init(z_check(n.path, j));
      A1 = rj.y - ri.y;
      B1 = ri.x - rj.x;
      C1 = A1 * (ri.x + m.r.x) + B1 * (ri.y + m.r.y);
      A2 = sj.y - si.y;
      B2 = si.x - sj.x;
      C2 = A2 * (si.x + n.r.x) + B2 * (si.y + n.r.y);
      det = A1 * B2 - A2 * B1;
      if (det === 0) {
        return false;
      }
      x = (B2 * C1 - B1 * C2) / det;
      y = (A1 * C2 - A2 * C1) / det;
      check1 = (Math.min(ri.x, rj.x) - m.tol <= (_ref = x - m.r.x) && _ref <= Math.max(ri.x, rj.x) + m.tol);
      check2 = (Math.min(si.x, sj.x) - n.tol <= (_ref1 = x - n.r.x) && _ref1 <= Math.max(si.x, sj.x) + n.tol);
      check3 = (Math.min(ri.y, rj.y) - m.tol <= (_ref2 = y - m.r.y) && _ref2 <= Math.max(ri.y, rj.y) + m.tol);
      check4 = (Math.min(si.y, sj.y) - n.tol <= (_ref3 = y - n.r.y) && _ref3 <= Math.max(si.y, sj.y) + n.tol);
      if (check1 && check2 && check3 && check4) {
        return true;
      } else {
        return false;
      }
    };

    z_check = function(seg, i) {
      switch (seg[i + 1].pathSegTypeAsLetter) {
        case 'z':
        case 'Z':
          return seg[0];
        default:
          return seg[i + 1];
      }
    };

    return Collision;

  })();

  $z.Force = (function() {
    function Force() {}

    Force.dr = {
      x: 0,
      y: 0
    };

    Force.rpx = {
      x: 0,
      y: 0
    };

    Force.rmx = {
      x: 0,
      y: 0
    };

    Force.rpy = {
      x: 0,
      y: 0
    };

    Force.rmy = {
      x: 0,
      y: 0
    };

    Force["eval"] = function(element, param, f, accumulateSwitch) {
      var emx, emy, epx, epy, fx, fy, r2, r3;
      if (accumulateSwitch == null) {
        accumulateSwitch = false;
      }
      if ((param != null ? param.type : void 0) == null) {
        console.log('Force.eval: undefined param type, param:', param);
        f.x = 0;
        f.y = 0;
        return f;
      }
      switch (param.type) {
        case 'constant':
          fx = param.fx;
          fy = param.fy;
          break;
        case 'friction':
          fx = -param.alpha * element.v.x;
          fy = -param.alpha * element.v.y;
          break;
        case 'spring':
          fx = -(element.r.x - param.cx);
          fy = -(element.r.y - param.cy);
          break;
        case 'charge':
        case 'gravity':
          this.dr.x = param.cx - element.r.x;
          this.dr.y = param.cy - element.r.y;
          r2 = this.dr.x * this.dr.x + this.dr.y * this.dr.y;
          r3 = r2 * Math.sqrt(r2);
          fx = param.q * this.dr.x / r3;
          fy = param.q * this.dr.y / r3;
          break;
        case 'random':
          fx = 2 * (Math.random() - 0.5) * param.xScale;
          fy = 2 * (Math.random() - 0.5) * param.yScale;
          if (element.r.x > param.xBound) {
            fx = -param.fxBound;
          }
          if (element.r.y > param.yBound) {
            fy = -param.fyBound;
          }
          if (element.r.x < 0) {
            fx = param.fxBound;
          }
          if (element.r.y < 0) {
            fy = param.fyBound;
          }
          break;
        case 'gradient':
          this.rpx.x = element.r.x;
          this.rpx.y = element.r.y;
          this.rpx.x += param.tol;
          this.rmx.x = element.r.x;
          this.rmx.y = element.r.y;
          this.rmx.x -= param.tol;
          this.rpy.x = element.r.x;
          this.rpy.y = element.r.y;
          this.rpy.y += param.tol;
          this.rmy.x = element.r.x;
          this.rmy.y = element.r.y;
          this.rmy.y -= param.tol;
          epx = param.energy(this.rpx);
          emx = param.energy(this.rmx);
          epy = param.energy(this.rpy);
          emy = param.energy(this.rmy);
          if (!((epx != null) && (emx != null) && (epy != null) && (emy != null))) {
            fx = 0;
            fy = 0;
            break;
          }
          fx = -0.5 * (epx - emx) / param.tol;
          fy = -0.5 * (epy - emy) / param.tol;
      }
      if (accumulateSwitch) {
        f.x += fx;
        f.y += fy;
      } else {
        f.x = fx;
        f.y = fy;
      }
      return f;
    };

    return Force;

  })();

  $z.Physics = (function() {
    function Physics() {}

    Physics.fps = 240;

    Physics.elapsedTime = 0;

    Physics.tick = 1000 / Physics.fps;

    Physics.maxElapsedTime = 100 * Physics.tick;

    Physics.Nstep = 2;

    Physics.off = true;

    Physics.game = null;

    Physics.callbacks = [];

    Physics.debug = false;

    Physics.timestamp = void 0;

    Physics.paused = false;

    Physics.euler = function(element, dt) {
      var accumulateSwitch;
      if (dt == null) {
        dt = Physics.tick;
      }
      if (element.cleanup()) {
        return;
      }
      element.f.x = 0;
      element.f.y = 0;
      accumulateSwitch = true;
      element.force_param.forEach(function(param) {
        return $z.Force["eval"](element, param, element.f, accumulateSwitch);
      });
      element.v.add(element.f.scale(dt));
      element.dr.init(element.v).scale(dt);
      element.r.add(element.dr);
    };

    Physics.integrate = function(t) {
      var fps;
      if (Physics.off) {
        return true;
      }
      Physics.elapsedTime = t - Physics.timestamp;
      if (Physics.debug) {
        fps = 1000 / elapsedTime;
        console.log('Physics.integrate:', 'dt: ', elapsedTime, 't: ', t, 'timestamp: ', Physics.timestamp, 'dt_chk: ', t - Physics.timestamp, 'fps: ' + fps);
      }
      Physics.timestamp = t;
      Physics.update();
      return Physics.off;
    };

    Physics.update = function() {
      Physics.step();
      $z.Collision.detect();
      Physics.draw_all();
      return Physics.run_callbacks();
    };

    Physics.step = function() {
      var element, index, stepCount, _results;
      stepCount = 0;
      _results = [];
      while (stepCount < Physics.Nstep) {
        stepCount++;
        index = $z.Collision.list.length;
        _results.push((function() {
          var _results1;
          _results1 = [];
          while (index--) {
            if ($z.Collision.list[index].is_removed) {
              _results1.push($z.Utils.index_pop($z.Collision.list, index).sleep());
            } else {
              element = $z.Collision.list[index];
              element.tick(element, Physics.elapsedTime / Physics.Nstep);
              if (Physics.debug) {
                _results1.push(console.log('Physics.update', 'index:', index, 'fps:', fps, 'r.x:', $z.Collision.list[index].r.x, 'r.y:', $z.Collision.list[index].r.y));
              } else {
                _results1.push(void 0);
              }
            }
          }
          return _results1;
        })());
      }
      return _results;
    };

    Physics.run_callbacks = function() {
      var bool, index, _results;
      index = Physics.callbacks.length;
      _results = [];
      while (index--) {
        if (Physics.callbacks.length === 0) {
          break;
        }
        bool = Physics.callbacks[index](Physics.timestamp);
        if (bool) {
          _results.push($z.Utils.index_pop(Physics.callbacks, index));
        } else {
          _results.push(void 0);
        }
      }
      return _results;
    };

    Physics.draw_all = function() {
      var element, index, _results;
      index = $z.Collision.list.length;
      _results = [];
      while (index--) {
        element = $z.Collision.list[index];
        _results.push(element.draw());
      }
      return _results;
    };

    Physics.start = function() {
      var blurCallback;
      if (!Physics.off) {
        return;
      }
      Physics.off = false;
      Physics.timestamp = 0;
      d3.timer(Physics.integrate);
      blurCallback = function() {
        Physics.paused = true;
        return Physics.stop();
      };
      $(window).blur(null);
      $(window).focus(null);
      $(window).blur(blurCallback);
      $(window).focus(function() {
        if (!Physics.off) {
          return;
        }
        Physics.paused = false;
        if ($z.Gamescore.lives >= 0) {
          return $z.Game.instance.message('GET READY', function() {
            if (Physics.paused) {
              return;
            }
            Physics.timestamp = 0;
            return Physics.start();
          });
        }
      });
    };

    Physics.stop = function() {
      if (Physics.off) {
        return;
      }
      Physics.off = true;
      Physics.timestamp = void 0;
      setTimeout(Physics.update, 2 * Physics.tick);
    };

    return Physics;

  })();

  $z.Reaction = (function() {
    function Reaction() {}

    Reaction.circle_circle = function(m, n, d) {
      var line, overstep, shift;
      if (m.remove_check(n) || n.remove_check(m)) {
        return;
      }
      line = m.line.init(d).normalize();
      overstep = Math.max(d.dmin - d.dist, 0);
      shift = 0.5 * (Math.max(m.tol, n.tol) + overstep);
      $z.Reaction.elastic_collision(m, n, line, shift);
      m.reaction(n);
    };

    Reaction.circle_polygon = function(circle, polygon, d) {
      var intersecting_segment, normal, shift;
      if (circle.remove_check(polygon) || polygon.remove_check(circle)) {
        return;
      }
      intersecting_segment = polygon.path[d.i];
      normal = intersecting_segment.n;
      shift = 0.5 * Math.max(circle.tol, polygon.tol);
      $z.Reaction.elastic_collision(circle, polygon, normal, shift);
    };

    Reaction.polygon_polygon = function(m, n, d) {
      var dot_a, dot_b, mseg, normal, nseg, segj, shift;
      if (m.remove_check(n) || n.remove_check(m)) {
        return;
      }
      mseg = m.path[d.i];
      nseg = n.path[d.j];
      dot_a = mseg.n.dot(d);
      dot_b = nseg.n.dot(d);
      if (Math.abs(dot_a) > Math.abs(dot_b)) {
        normal = m.normal.init(mseg.n).scale(dot_a / Math.abs(dot_a));
        segj = nseg;
      } else {
        normal = m.normal.init(nseg.n).scale(dot_b / Math.abs(dot_b));
        segj = mseg;
      }
      shift = 0.5 * Math.max(m.tol, n.tol);
      $z.Reaction.elastic_collision(m, n, normal, shift);
      m.reaction(n);
    };

    Reaction.elastic_collision = function(m, n, line, shift) {
      var cPar, dPar, iter, lshift, maxiter, reaction, uPar, uPerp, vPar, vPerp;
      lshift = m.lshift.init(line).scale(shift);
      maxiter = 32;
      iter = 1;
      reaction = false;
      while ($z.Collision.check(m, n, reaction) && iter <= maxiter) {
        m.r = m.r.add(lshift);
        n.r = n.r.subtract(lshift);
        iter++;
      }
      cPar = m.v.dot(line);
      vPar = m.vPar.init(line).scale(cPar);
      vPerp = m.vPerp.init(m.v).subtract(vPar);
      dPar = n.v.dot(line);
      uPar = m.uPar.init(line).scale(dPar);
      uPerp = m.uPerp.init(n.v).subtract(uPar);
      uPar.add(vPerp);
      vPar.add(uPerp);
      m.v.x = uPar.x;
      m.v.y = uPar.y;
      n.v.x = vPar.x;
      n.v.y = vPar.y;
    };

    return Reaction;

  })();

  $z.ForceParam = (function() {
    function ForceParam(config) {
      this.config = config != null ? config : {};
      this.type = this.config.type || 'constant';
      switch (this.type) {
        case 'constant':
          this.fx = this.config.x || 0;
          this.fy = this.config.y || 0;
          break;
        case 'friction':
          this.alpha = this.config.alpha || 1;
          this.vscale = this.config.vscale || .99;
          this.vcut = this.config.vcut || 1e-2;
          break;
        case 'spring':
          this.cx = this.config.cx || 0;
          this.cy = this.config.cy || 0;
          break;
        case 'charge':
        case 'gravity':
          this.cx = this.config.cx || 0;
          this.cy = this.config.cy || 0;
          this.q = this.config.q || 1;
          break;
        case 'random':
          this.xScale = this.config.xScale || 1;
          this.yScale = this.config.yScale || 1;
          this.fxBound = this.config.fxBound || 10;
          this.fyBound = this.config.fyBound || 10;
          break;
        case 'gradient':
          this.tol = this.config.tol || 0.1;
          this.energy = this.config.energy || function(r) {};
      }
    }

    return ForceParam;

  })();

  $z.Vec = (function() {
    function Vec(config) {
      this.config = config != null ? config : {};
      this.x = this.config.x || 0;
      this.y = this.config.y || 0;
    }

    Vec.prototype.init = function(v) {
      if (v == null) {
        v = {
          x: 0,
          y: 0
        };
      }
      this.x = v.x;
      this.y = v.y;
      return this;
    };

    Vec.prototype.scale = function(c) {
      this.x *= c;
      this.y *= c;
      return this;
    };

    Vec.prototype.add = function(v) {
      this.x += v.x;
      this.y += v.y;
      return this;
    };

    Vec.prototype.subtract = function(v) {
      this.x -= v.x;
      this.y -= v.y;
      return this;
    };

    Vec.prototype.rotate = function(a) {
      var c, s;
      c = Math.cos(a);
      s = Math.sin(a);
      this.x = c * this.x - s * this.y;
      this.y = s * this.x + c * this.y;
      return this;
    };

    Vec.prototype.dot = function(v) {
      return this.x * v.x + this.y * v.y;
    };

    Vec.prototype.length_squared = function() {
      return this.dot(this);
    };

    Vec.prototype.length = function() {
      return Math.sqrt(this.length_squared());
    };

    Vec.prototype.normalize = function(length) {
      var inverseLength;
      if (length == null) {
        length = 1;
      }
      inverseLength = length / this.length();
      this.x *= inverseLength;
      this.y *= inverseLength;
      return this;
    };

    Vec.prototype.dist_squared = function(v) {
      var dx, dy;
      dx = this.x - v.x;
      dy = this.y - v.y;
      return dx * dx + dy * dy;
    };

    Vec.prototype.dist = function(v) {
      return Math.sqrt(this.dist_squared(v));
    };

    return Vec;

  })();

  $z.Drop = (function(_super) {
    __extends(Drop, _super);

    function Drop(config) {
      var dur;
      this.config = config != null ? config : {};
      this.config.size = this.config.size || .6;
      Drop.__super__.constructor.call(this, this.config);
      this.fill('navy');
      this.stroke('none');
      this.image.attr('opacity', '0.6');
      this.lifetime = $z.Utils.timestamp();
      this.max_lifetime = 2e4;
      this.fadeIn(dur = 250);
    }

    Drop.prototype.init = function() {
      this.lifetime = $z.Utils.timestamp();
      return Drop.__super__.init.apply(this, arguments);
    };

    Drop.prototype.cleanup = function() {
      this.lifetime = $z.Utils.timestamp() - this.lifetime;
      if (this.lifetime > this.max_lifetime) {
        this.remove();
      }
      this.lifetime = $z.Utils.timestamp() - this.lifetime;
      if (this.offscreen()) {
        if (this.r.x > $z.Game.width) {
          this.r.x = this.r.x % $z.Game.width;
        }
        if (this.r.x < 0) {
          this.r.x = $z.Game.width + this.r.x;
        }
        if (this.r.y < 0) {
          this.r.y = 0;
          this.v.y = Math.abs(this.v.y);
          this.r.x = (this.r.x + $z.Game.width * 0.5) % $z.Game.width;
        }
        if (this.r.y > $z.Game.height) {
          this.r.y = $z.Game.height;
          this.v.y = -Math.abs(this.v.y);
          this.r.x = (this.r.x + $z.Game.width * 0.5) % $z.Game.width;
        }
      }
    };

    return Drop;

  })($z.Circle);

  $z.Rainflow = (function(_super) {
    __extends(Rainflow, _super);

    function Rainflow(config) {
      var V, drops, dur, inst, prompt;
      this.config = config != null ? config : {};
      this.drop = __bind(this.drop, this);
      $z.Game.height = 180;
      $z.Game.width = 360;
      Rainflow.__super__.constructor.apply(this, arguments);
      this.map_width = 360;
      this.map_height = 180;
      this.image = this.g.append('image').attr('xlink:href', 'earth_elevation6.png').attr('height', this.map_height).attr('width', this.map_width);
      this.root = $z.Factory.spawn($z.Root);
      this.numel = this.config.numel || 20;
      this.elevation = [];
      this.lastdrop = $z.Utils.timestamp();
      this.raining = false;
      drops = (function(_this) {
        return function(text) {
          var row;
          row = text.split('\n');
          _this.elevation = row.map(function(d) {
            return d.split(',').map(function(d) {
              return Number(d);
            });
          });
          _this.elevation.pop();
          _this.gravity_param = {
            tol: 1,
            energy: V,
            type: 'gradient'
          };
          _this.friction_param = {
            alpha: .02,
            type: 'friction'
          };
          _this.svg.on("click", _this.drop);
          return _this.start();
        };
      })(this);
      prompt = this.g.append("text").text("").attr("stroke", "black").attr("fill", "deepskyblue").attr("font-size", "36").attr("x", this.map_width / 2 - 100).attr("y", this.map_height / 4).attr('font-family', 'arial').attr('font-weight', 'bold').attr('opacity', 0);
      prompt.text("RAINFLOW");
      dur = 1500;
      prompt.transition().duration(dur).attr('opacity', 1).transition().duration(dur).delay(dur).attr('opacity', 0).remove();
      inst = this.g.append("text").text("").attr("stroke", "none").attr("fill", "white").attr("font-size", 10).attr("x", this.map_width / 2 - 45).attr("y", this.map_height / 4 + 40).attr('font-family', 'arial').attr('font-weight', 'bold').attr('opacity', 0);
      inst.text("click to make it rain");
      inst.transition().duration(dur).attr('opacity', 1).transition().duration(dur).attr('opacity', 0).remove().each('end', function() {
        return d3.text('topo_flip.csv', drops);
      });
      V = (function(_this) {
        return function(r) {
          var energy, scale, x, y;
          x = r.x;
          y = r.y;
          if (x < 0) {
            x = _this.elevation[0].length - 1 + x % (_this.elevation[0].length - 1);
          }
          if (x > _this.elevation[0].length - 1) {
            x = x % (_this.elevation[0].length - 1);
          }
          if (y < 0) {
            y = _this.elevation.length - 1 + y % (_this.elevation.length - 1);
          }
          if (y > _this.elevation.length - 1) {
            y = y % (_this.elevation.length - 1);
          }
          scale = 1e-6;
          return energy = scale * $z.Utils.bilinear_interp(_this.elevation, x, y);
        };
      })(this);
    }

    Rainflow.prototype.drop = function(r) {
      var clear, config, dr, dur, i, int, new_drop, stamp, _i, _ref;
      if (r == null) {
        r = this.root.r;
      }
      stamp = $z.Utils.timestamp();
      if (this.raining) {
        return;
      }
      this.raining = true;
      this.lastdrop = stamp;
      config = [];
      for (i = _i = 0, _ref = this.numel - 1; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
        dr = $z.Factory.spawn($z.Vec, {
          x: 2 * this.root.size * (Math.random() - 0.5),
          y: 2 * this.root.size * (Math.random() - 0.5)
        });
        config.push({
          r: $z.Factory.spawn($z.Vec, r).add(dr),
          force_param: [$z.Factory.spawn($z.ForceParam, this.gravity_param), $z.Factory.spawn($z.ForceParam, this.friction_param)],
          width: this.map_width,
          height: this.map_height
        });
      }
      if (!(config.length > 0)) {
        return;
      }
      dur = 10;
      new_drop = function() {
        $z.Factory.spawn($z.Drop, config.pop()).start();
        if (config.length === 0) {
          clear();
          return $z.Game.instance.raining = false;
        }
      };
      int = setInterval(new_drop, dur);
      return clear = function() {
        return clearInterval(int);
      };
    };

    return Rainflow;

  })($z.Game);

  $(document).ready(function() {
    return new $z.Rainflow();
  });

  $z.Root = (function(_super) {
    __extends(Root, _super);

    function Root(config) {
      this.config = config != null ? config : {};
      this.move = __bind(this.move, this);
      this.config.size = this.config.size || 1.5;
      Root.__super__.constructor.call(this, this.config);
      this.svg.style("cursor", "none");
      this.fill('none');
      this.stroke('navy');
      this.image.attr('opacity', 0.4).attr('stroke-width', 1);
      this.svg.on("mousemove", this.move);
      this.is_root = true;
      this.tick = function() {};
      this.g.style('opacity', 1);
    }

    Root.prototype.move = function(node) {
      var xy;
      if (node == null) {
        node = this.svg.node();
      }
      xy = d3.mouse(node);
      this.r.x = xy[0];
      this.r.y = xy[1];
      return this.draw();
    };

    return Root;

  })($z.Circle);

}).call(this);