Vector Library

As we move forward in game programming, it would be very useful to have a library for working with vectors and vector-like objects. Particularly, functionality like normalizing, dot product, addition and subtraction, all are commonly used in game math.

To implement such a library we would like to place all the related code in a module by itself, say Vector, which we could include in other files. Let's place this module in its own JavaScript file, vector.js, and export it with the CommonJS Module pattern:

``````module.exports = exports = {
subtract: subtract,
dotProduct: dotProduct,
magnitude: magnitude,
normalize: normalize,
rotate: rotate,
perpendicular: perpendicular
}
``````

We populate our exported object with functions as our properties, thus when we include the file in another one, i.e.:

``````const Vector = require('./vector');
``````

We can use these functions by referencing the property names:

``````var a = {x: 10, y: 10}
var b = {x: 5, y: -5}
``````

The vector `c` is the result of the addition of vectors `a` and `b`, and will be `{x: 15, y: 5}`.

In most programming languages, we'd also want to define a vector class that would have properties `x` and `y`, but as a dynamically-typed programming language, we can supply any object to our functions and, provided it has an `x` and `y` property, everything will work.

All that is left is to implement the various vector operations.

Adding and subtracting vectors is simply a matter of adding or subtracting their x and y components:

``````function add(a, b) {
return {
x: a.x + b.x,
y: a.y + b.y
}
}

function subtract(a, b) {
return {
x: a.x - b.x,
y: a.y - b.y
}
}
``````

## Vector Dot Product

The dot product is the sum of the products of the vector's x and y components:

``````function dotProduct(a, b) {
return a.x * b.x + a.y + b.y;
}
``````

## Vector magnitude

The magnitude (or length) of the vector is calculated using Pythagoras's theorem:

``````function magnitude(a) {
return Math.sqrt(a.x * a.x + b.x * b.x);
}
``````

## Vector Normalization

Normalizing (scaling to magnitude 1) a vector is a simple matter of dividing its components by the magnitude:

``````function normalize(a) {
var mag = magnitude(a);
return {
x: a.x / mag,
y: a.y / mag
}
}
``````

Rotation about the z-axis is accomplished by multiplying the vector by a rotation matrix. This can be expressed by extrapolating the matrix mulptiplication into two equations, one to calculate x and one to calculate y:

``````function rotate(a) {
return {
x: a.x * Math.cos(angle) - a.y * Math.sin(angle),
y: a.x * Math.sin(angle) + a.y * Math.cos(angle)
}
}
``````

## Finding a Perpendicular Vector

Another useful ability is finding a perpendicular vector. We can do this by flipping the x and y axis, and inverting one of their signs:

``````function perpendicular(a) {
return {
x: -a.y,
y: a.x
}
}
``````