@moderrkowo/jsgl
Version:
Client-side JavaScript library for creating web 2D games. Focusing at objective game.
335 lines (317 loc) • 8.44 kB
text/typescript
import { IsInRange, Lerp, floor } from '../utils/math/MathUtils';
/** @group Important Classes */
export class Vector2 {
/**
* X component of vector.
* @property
*/
public x: number;
/**
* Y component of vector.
* @property
*/
public y: number;
/**
* Constructs a new Vector2 with the given components.
* @param x - X component
* @param y - Y component
* @constructor
*/
public constructor(x = 0, y = 0) {
if (typeof x !== 'number') throw new Error('X must be an number!');
if (typeof y !== 'number') throw new Error('Y must be an number!');
this.x = x;
this.y = y;
}
// Static Methods
/**
* Performs Linear Interpolation on Vectors2 with given decimal midpoint
* @method
* @param a - The first Vector2
* @param b - The second Vector2
* @param c - The decimal midpoint
* @returns Vector2 after Linear Interpolation.
* @example
* const a = new JSGL.Vector2(3, 9);
* const b = new JSGL.Vector2(5, 2);
* JSGL.Vector2.Lerp(a, b, 0); // (3, 9)
* JSGL.Vector2.Lerp(a, b, 0.5); // (4, 5.5)
* JSGL.Vector2.Lerp(a, b, 1); // (5, 2)
*/
public static Lerp(a: Vector2, b: Vector2, c = 0): Vector2 {
return new Vector2(Lerp(a.x, b.x, c), Lerp(a.y, b.y, c));
}
/**
* Returns the new Vector2 with maximum X and Y coordinates from first and second Vector2
* @method
* @param a - The first Vector2
* @param b - The second Vector2
* @returns The new Vector2 with maximum X and Y
* @example
* const a = new JSGL.Vector2(3, 9);
* const b = new JSGL.Vector2(5, 2);
* const max = JSGL.Vector2.Max(a, b); // (5, 9)
*/
public static Max(a: Vector2, b: Vector2): Vector2 {
return new Vector2(Math.max(a.x, b.x), Math.max(a.y, b.y));
}
/**
* Returns the new Vector2 with minimum X and Y coordinates from first and second Vector2
* @method
* @param a - The first Vector2
* @param b - The second Vector2
* @returns The new Vector2 with minimum X and Y
* @example
* const a = new JSGL.Vector2(3, 9);
* const b = new JSGL.Vector2(5, 2);
* const min = JSGL.Vector2.Min(a, b); // (3, 2)
*/
public static Min(a: Vector2, b: Vector2): Vector2 {
return new Vector2(Math.min(a.x, b.x), Math.min(a.y, b.y));
}
/**
* Returns is `point` between given 2D range.
* @method
* @param min - The minimal range
* @param max - The maximum range
* @param point - The point
* @returns is `point` between range.
* @example
* const min = new JSGL.Vector2(5, 5);
* const max = new JSGL.Vector2(7, 7);
* JSGL.Vector2.IsPointIn(min, max, new JSGL.Vector2(6, 5));
*/
public static IsPointIn(min: Vector2, max: Vector2, point: Vector2): boolean {
return IsInRange(point.x, min.x, max.x) && IsInRange(point.y, min.y, max.y);
}
/**
* Returns true if two vectors are equal.
* @method
* @param v - The first Vector2
* @param v2 - The second Vector2
* @returns are vectors equal
* @example
* const vector1 = new JSGL.Vector2(2, 4);
* const vector2 = new JSGL.Vector2(2, 4);
* JSGL.Vector2.Equal(vector1, vector2);
*/
public static Equal(v?: Vector2, v2?: Vector2): boolean {
if (v === undefined || v2 === undefined) return false;
if (!(v instanceof Vector2) || !(v2 instanceof Vector2)) return false;
return v.x === v2.x && v.y === v2.y;
}
// Accesors
/**
* @returns (0, 0)
*/
public static get zero() {
return new Vector2(0, 0);
}
/**
* @returns (1, 1)
*/
public static get one() {
return new Vector2(1, 1);
}
/**
* @returns (0, 1)
*/
public static get up() {
return new Vector2(0, 1);
}
/**
* @returns (0, -1)
*/
public static get down() {
return new Vector2(0, -1);
}
/**
* @returns (1, 0)
*/
public static get right() {
return new Vector2(1, 0);
}
/**
* @returns (-1, 0)
*/
public static get left() {
return new Vector2(-1, 0);
}
public get magnitude() {
return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
}
// Instance Methods
/**
* Sets components to given Vector2 or X, Y.
* @method
* @param x - The Vector2 or X-coordinate
* @param y - The Y-coordinate (if `x` isn't Vector2)
* @returns This reference
* @example
* vector2.set(exampleVector);
* vector2.set(x, y);
*/
public set(x: number | Vector2, y?: number): Vector2 {
if (x === undefined) return this;
if (x instanceof Vector2) {
this.x = x.x;
this.y = x.y;
} else if (typeof x === 'number') {
this.x = x;
if (y !== undefined && typeof y === 'number') {
this.y = y;
} else {
this.y = 0;
}
}
return this;
}
/**
* Adds given Vector2 or X, Y to this Vector2 components.
* @method
* @param x - The Vector2 or X-coordinate
* @param y - The Y-coordinate (if `x` isn't Vector2)
* @returns This reference
* @example
* vector2.add(exampleVector);
* vector2.add(x, y);
*/
public add(x: number | Vector2, y?: number): Vector2 {
if (x instanceof Vector2) {
this.x += x.x;
this.y += x.y;
} else if (
typeof x === 'number' &&
y !== undefined &&
typeof y === 'number'
) {
this.x += x;
this.y += y;
}
return this;
}
/**
* Substracts given Vector2 or X, Y to this Vector2 components.
* @method
* @param x - The Vector2 or X-coordinate
* @param y - The Y-coordinate (if `x` isn't Vector2)
* @returns This reference
* @example
* vector2.subtract(exampleVector);
* vector2.subtract(x, y);
*/
public subtract(x: number | Vector2, y?: number): Vector2 {
if (x instanceof Vector2) {
this.x -= x.x;
this.y -= x.y;
} else if (
typeof x === 'number' &&
y !== undefined &&
typeof y === 'number'
) {
this.x -= x;
this.y -= y;
}
return this;
}
/**
* Multiplies component by scalar or Vector2.
* @method
* @param x - The Vector2 or scalar
* @returns This reference
* @example
* vector2.multiply(exampleVector);
* vector2.multiply(scalar);
*/
public multiply(x: number | Vector2): Vector2 {
if (x instanceof Vector2) {
this.x *= x.x;
this.y *= x.y;
} else if (typeof x === 'number') {
this.x *= x;
this.y *= x;
}
return this;
}
/**
* Divides component by scalar or Vector2.
* @method
* @param x - The Vector2 or scalar
* @returns This reference
* @example
* vector2.divide(exampleVector);
* vector2.divide(scalar);
*/
public divide(x: number | Vector2): Vector2 {
if (x instanceof Vector2) {
this.x /= x.x;
this.y /= x.y;
} else if (typeof x === 'number') {
this.x /= x;
this.y /= x;
}
return this;
}
/**
* Returns distance between Vector2 or X, Y coordinate.
* @method
* @param x - The Vector2 or X-coordinate
* @param y - The Y-coordinate (if `x` isn't Vector2)
* @returns The distance between vectors
* @example
* vector2.distance(exampleVector);
* vector2.distance(0, 0);
*/
public distance(x: number | Vector2, y?: number): number {
if (x instanceof Vector2) {
return Math.sqrt(
Math.pow(Math.abs(this.x - x.x), 2) +
Math.pow(Math.abs(this.y - x.y), 2)
);
} else if (
typeof x === 'number' &&
y !== undefined &&
typeof y === 'number'
) {
return Math.sqrt(
Math.pow(Math.abs(this.x - x), 2) + Math.pow(Math.abs(this.y - y), 2)
);
}
throw new Error('Invalid params!');
}
/**
* Floors the X, Y components.
* @method
* @returns The reference
* @example
* vector2.floor();
*/
public floor(): Vector2 {
this.x = floor(this.x);
this.y = floor(this.y);
return this;
}
/**
* Returns true if two vectors are equal.
* @method
* @param v - The second Vector2
* @returns are vectors equal
* @example
* const vector1 = new JSGL.Vector2(2, 4);
* const vector2 = new JSGL.Vector2(2, 4);
* vector1.equal(vector2);
*/
public equal(v?: Vector2): boolean {
if (v === undefined) return false;
if (!(v instanceof Vector2)) return false;
return this.x === v.x && this.y === v.y;
}
/**
* Clones the Vector2.
* @method
* @returns The clone
*/
public clone(): Vector2 {
return new Vector2(this.x, this.y);
}
}