SimpleSim Vector

vector.js

(function(exports) {

  /**
   * Creates a new Vector.
   *
   * @param {number} [opt_x = 0] The x location.
   * @param {number} [opt_y = 0] The y location.
   * @constructor
   */
  function Vector(opt_x, opt_y) {
    var x = opt_x || 0,
        y = opt_y || 0;
    this.x = x;
    this.y = y;
  }

  /**
   * Adds a vector to this vector.
   *
   * @param {Object} vector The vector to add.
   * @returns {Object} This vector.
   */
  Vector.prototype.add = function(vector) {
    this.x += vector.x;
    this.y += vector.y;
    return this;
  };

  /**
   * Subtracts a vector from this vector.
   *
   * @param {Object} vector The vector to subtract.
   * @returns {Object} This vector.
   */
  Vector.prototype.sub = function(vector) {
    this.x -= vector.x;
    this.y -= vector.y;
    return this;
  };

  /**
   * Multiplies this vector by a passed value.
   *
   * @param {number} n Vector will be multiplied by this number.
   * @returns {Object} This vector.
   */
  Vector.prototype.mult = function(n) {
    this.x *= n;
    this.y *= n;
    return this;
  };

  /**
   * Divides this vector by a passed value.
   *
   * @param {number} n Vector will be divided by this number.
   * @returns {Object} This vector.
   */
  Vector.prototype.div = function(n) {
    this.x = this.x / n;
    this.y = this.y / n;
    return this;
  };

  /**
   * Calculates the magnitude of this vector.
   *
   * @returns {number} The vector's magnitude.
   */
  Vector.prototype.mag = function() {
    return Math.sqrt((this.x * this.x) + (this.y * this.y));
  };

  /**
   * Limits the vector's magnitude.
   *
   * @param {number} opt_high The upper bound of the vector's magnitude
   * @param {number} opt_low The lower bound of the vector's magnitude.
   * @returns {Object} This vector.
   */
  Vector.prototype.limit = function(opt_high, opt_low) {
    var high = opt_high || null,
        low = opt_low || null;
    if (high && this.mag() > high) {
      this.normalize();
      this.mult(high);
    }
    if (low && this.mag() < low) {
      this.normalize();
      this.mult(low);
    }
    return this;
  };

  /**
   * Divides a vector by its magnitude to reduce its magnitude to 1.
   * Typically used to retrieve the direction of the vector for later manipulation.
   *
   * @returns {Object} This vector.
   */
  Vector.prototype.normalize = function() {
    var m = this.mag();
    if (m !== 0) {
      return this.div(m);
    }
  };

  /**
   * Rotates a vector using a passed angle in radians.
   *
   * @param {number} radians The angle to rotate in radians.
   * @returns {Object} This vector.
   */
  Vector.prototype.rotate = function(radians) {
    var cos = Math.cos(radians),
      sin = Math.sin(radians),
      x = this.x,
      y = this.y;

    this.x = x * cos - y * sin;
    this.y = x * sin + y * cos;
    return this;
  };

  exports.Vector = Vector;

}(exports));