@futdevpro/fsm-dynamo 1.7.3 → 1.7.6

package/src/_utils/vector2.util.ts

@@ -2,32 +2,40 @@
 import { Dynamo_Trigonometry } from './trigonometry.util';
 
 export class Vector2 {
-  private _x: number;
+  readonly isVector2: boolean = true;
+
+  private _x: number = 0;
   set x (value: number) {
     this._x = value;
+
     this.calcMagnitude();
-  };
+  }
   get x (): number { 
     return this._x;
   }
 
-  private _y: number;
+  private _y: number = 0;
   set y (value: number) {
     this._y = value;
+    
     this.calcMagnitude();
-  };
+  }
   get y (): number { 
     return this._y;
   }
 
-  private _magintude: number;
+  private _magintude: number = 0;
   get magintude (): number { 
     return this._magintude;
   }
 
-  constructor(x: number, y: number) {
+  constructor(
+    x: number = 0, 
+    y: number = 0
+  ) {
     this._x = x;
     this._y = y;
+
     this.calcMagnitude();
   }
 
@@ -48,21 +56,32 @@ export class Vector2 {
     return this.plus(a, this.negative(b));
   }
   minus(vector: Vector2): void {
-    this.newVector(Vector2.minus(this, vector));
+    this.newValues(Vector2.minus(this, vector));
   }
 
   static plus(a: Vector2, b: Vector2): Vector2 {
     return new Vector2(a.x + b.x, a.y + b.y);
   }
   plus(vector: Vector2): void {
-    this.newVector(Vector2.plus(this, vector));
+    this.newValues(Vector2.plus(this, vector));
   }
+  static add = this.plus;
+  add = this.plus;
 
+  /** returns new multiplied Vector2 */
   static multiply(v: Vector2, n: number): Vector2 {
     return new Vector2(v.x * n, v.y * n);
   }
   multiply(n: number): void {
-    this.newVector(Vector2.multiply(this, n));
+    this.newValues(Vector2.multiply(this, n));
+  }
+
+  /** returns new divided Vector2 */
+  static divide(v: Vector2, n: number): Vector2 {
+    return new Vector2(v.x / n, v.y / n);
+  }
+  divide(n: number): void {
+    this.newValues(Vector2.divide(this, n));
   }
 
   static negative(v: Vector2): Vector2 {
@@ -72,18 +91,19 @@ export class Vector2 {
     return Vector2.negative(this);
   }
   negate(): void {
-    this.newVector(Vector2.negative(this));
+    this.newValues(Vector2.negative(this));
   }
 
   static rebase(v: Vector2, baseFrom: Vector2, baseTo: Vector2): Vector2 {
     return this.plus(v, this.minus(baseTo, baseFrom));
   }
   rebase(baseFrom: Vector2, baseTo: Vector2): void {
-    this.newVector(Vector2.rebase(this, baseFrom, baseTo));
+    this.newValues(Vector2.rebase(this, baseFrom, baseTo));
   }
 
   static rotate(vector: Vector2, angle: number): Vector2 {
     const rad = Dynamo_Trigonometry.angleToRadians(angle);
+
     return this.rotateRad(vector, rad);
   }
   static rotateRad(vector: Vector2, rad: number): Vector2 {
@@ -91,29 +111,76 @@ export class Vector2 {
     const sin = Math.sin(rad);
     const newX = (vector.x * cos) - (vector.y * sin);
     const newY = (vector.x * sin) + (vector.y * cos);
+
     return new Vector2(newX, newY);
   }
   rotate(angle: number): void {
-    this.newVector(Vector2.rotate(this, angle));
+    this.newValues(Vector2.rotate(this, angle));
   }
   rotateRad(rad: number): void {
-    this.newVector(Vector2.rotateRad(this, rad));
+    this.newValues(Vector2.rotateRad(this, rad));
   }
 
-  private newVector(newV: Vector2): void {
+  private newValues(newV: Vector2): void {
     this.newXY(newV.x, newV.y);
   }
   newXY(newX: number, newY: number): void {
     this._x = newX;
     this._y = newY;
+
     this.calcMagnitude();
   }
 
-  private calcMagnitude() {
+  //// AI-ed
+  angle(from: Vector2, to: Vector2): number {
+    return Vector2.angle(from, to);
+  }
+  static angle(from: Vector2, to: Vector2): number {
+    return Dynamo_Trigonometry.radiansToAngle(Vector2.angleRad(from, to));
+  }
+  static angleRad(from: Vector2, to: Vector2): number {
+    return Math.atan2(to.y - from.y, to.x - from.x);
+  }
+  deg(): number {
+    return Vector2.deg(this);
+  }
+  static deg(vector: Vector2): number {
+    return Dynamo_Trigonometry.radiansToAngle(Vector2.rad(vector));
+  }
+  static rad(vector: Vector2): number {
+    return Math.atan2(vector.y, vector.x);
+  }
+
+  floor(): Vector2 {
+    return Vector2.floor(this);
+  }
+  static floor(v: Vector2): Vector2 {
+    return new Vector2(Math.floor(v.x), Math.floor(v.y));
+  }
+  /////
+
+  direction(to: Vector2): Vector2 {
+    return Vector2.direction(this, to);
+  }
+  static direction(from: Vector2, to: Vector2): Vector2 {
+    return Vector2.minus(to, from);
+  }
+
+  static normalize(v: Vector2): Vector2 {
+    return Vector2.multiply(v, 1 / v.magintude);
+  }
+  normalize(): void {
+    this.newValues(Vector2.normalize(this));
+  }
+  normalized(): Vector2 {
+    return Vector2.normalize(this);
+  }
+
+  private calcMagnitude(): void {
     this._magintude = Dynamo_Trigonometry.getHypotenuse(this._x, this._y);
   }
 
-  clone() {
+  clone(): Vector2 {
     return new Vector2(this._x, this._y);
   }
 }