• # Vector2

An object representing a 2D vector. Based on the Vector2 class from LibGDX.

• Written by Rahat Ahmed.

## Vector2(x, y)

Constructor for Vector2.

```function Vector2(x, y) {
this.set(x, y);
}```

Adds given values to this vector. Returns this vector for chaining.

```Vector2.prototype.add = function(x, y) {
if(x instanceof Vector2)
{
this.x += x.x;
this.y += x.y;
}
else
{
this.x += x || 0;
this.y += y || 0;
}
return this;
};```
• ## angle

### angle()

Returns the angle in radians of this vector relative to the x-axis (counter-clockwise) in the range 0 to 2 * PI.

Rotates this vector to the given angle in radians. Returns this vector for chaining.

```Vector2.prototype.angle = function(rad) {
var angle = Math.atan2(this.y, this.x);
if(angle < 0) angle += Math.PI*2;
return angle;
};```
• ## angleDeg

### angleDeg()

Same as angle() but in degrees.

### angleDeg(degrees)

Same as angle(radians) but in degrees.

```Vector2.prototype.angleDeg = function(deg) {
if(deg !== undefined)
return this.angle(deg / 180 * Math.PI);
return this.angle() * 180 / Math.PI;
};```

## copy()

Returns a new identical Vector2.

```Vector2.prototype.clone = Vector2.prototype.copy = function() {
return new Vector2(this.x, this.y);
};```

## cross(x, y)

Returns the cross product of this vector and another.

```Vector2.prototype.cross = function(x, y) {
if(x instanceof Vector2)
return this.x * x.y - this.y * x.x;
return this.x * y - this.y * x;
};```

## distance(x, y)

Returns the distance between this vector and another.

```Vector2.prototype.distance = function(x, y) {
var distSq = this.distanceSq(x, y);
if(distSq === undefined)
return undefined;
return Math.sqrt(distSq);
};```

## distanceSq(x, y)

Returns the distance squared of this vector and another.

```Vector2.prototype.distanceSq = function(x, y) {
var dx, dy;
if(x instanceof Vector2)
{
dx = x.x - this.x;
dy = x.y - this.y;
}
else if(y !== undefined)
{
dx = x - this.x;
dy = y - this.y;
}
else
return undefined;
return dx * dx + dy * dy;
};```

## dot(x, y)

Returns the dot product of this vector and another.

```Vector2.prototype.dot = function(x, y) {
if(x instanceof Vector2)
return this.x * x.x + this.y * x.y;
return this.x * x + this.y * y;
};```
• ## equals

### equals(Vector2)

Returns true if this and another vector2 are equal.

### equals(Vector2, epsilon)

Returns true if this and another vector2 are equal within an epsilon.

### equals(x, y)

Returns true if this vector equals given x, y components.

### equals(x, y, epsilon)

Returns true if this vector equasl given x, y components within an epsilon.

```Vector2.prototype.equals = function(x, y, epsilon) {

if(x instanceof Vector2)
{
y = y || 0;
return Math.abs(this.x - x.x) <= y && Math.abs(this.y - x.y) <= y;
}
else if(y !== undefined)
{
epsilon = epsilon || 0;
return Math.abs(this.x - x) <= epsilon && Math.abs(this.y - y) <= epsilon;
}
else
return false;
};```
• ## length()

Returns the length of this vector.

```Vector2.prototype.length = function() {
return Math.sqrt(this.lengthSq());
};```
• ## lengthSq()

Returns the length squared of this vector.

```Vector2.prototype.lengthSq = function() {
return this.x * this.x + this.y * this.y;
};```
• ## negate()

Negates this vector. (Multiplies x and y by -1). Returns this vector for chaining.

```Vector2.prototype.negate = function() {
return this.scale(-1);
};```
• ## normalize()

Normalizes this vector. Returns this vector for chaining.

```Vector2.prototype.normalize = function() {
return this.scale(1/this.length());
};```

Rotates this vector by an angle in degrees counter-clockwise. Returns this vector for chaining.

```Vector2.prototype.rotate = function(rad) {
return this.set(this.x * cos - this.y * sin,
this.x * sin + this.y * cos);
};```
• ## rotateDeg(degrees)

Same as rotate but in degrees.

```Vector2.prototype.rotateDeg = function(deg) {
return this.rotate(deg / 180 * Math.PI)
};```

## scale(scaleX, scaleY)

Scales this vector by a scalar. Second argument to scale y separate from x is optional. Returns this vector for chaining.

```Vector2.prototype.scale = function(scaleX, scaleY) {
this.x *= scaleX;
this.y *= (scaleY || scaleX);
return this;
};```

## set(x, y)

Sets this vector to the given values. Returns this vector for chaining.

```Vector2.prototype.set = function(x, y) {
if(x instanceof Vector2)
{
this.x = x.x;
this.y = x.y;
}
else
{
this.x = x || 0;
this.y = y || 0;
}
return this;
};```

Set this vector by angle in degrees and magnitude. Returns this vector for chaining.

```Vector2.prototype.setPolar = function(rad, length) {
};```
• ## setPolarDeg(degrees, length)

Same as setPolar but in degrees.

```Vector2.prototype.setPolarDeg = function(deg, length) {
return this.setPolar(deg / 180 * Math.PI, length);
};```

## sub(x, y)

Same as add, but subtracting. Returns this vector for chaining.

```Vector2.prototype.sub = function(x, y) {
if(y !== undefined)
{
this.x -= x;
this.y -= y;
}
else
{
this.x -= x.x;
this.y -= x.y;
}
return this;
};```
• ## toString()

Returns a string representation of this vector.

```Vector2.prototype.toString = function() {
return "(" + this.x + ", " + this.y + ")";
};

module.exports = Vector2;```