@vpmedia/phaser 1.75.0 → 1.76.0

package/src/phaser/geom/matrix.test.js

@@ -0,0 +1,242 @@
+import { Matrix } from './matrix.js';
+import { Point } from './point.js';
+
+describe('Constructor', () => {
+  it('should set default values when no arguments are passed', () => {
+    const matrix = new Matrix();
+    expect(matrix.a).toBe(1);
+    expect(matrix.b).toBe(0);
+    expect(matrix.c).toBe(0);
+    expect(matrix.d).toBe(1);
+    expect(matrix.tx).toBe(0);
+    expect(matrix.ty).toBe(0);
+  });
+
+  it('should set values when arguments are passed', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    expect(matrix.a).toBe(2);
+    expect(matrix.b).toBe(3);
+    expect(matrix.c).toBe(4);
+    expect(matrix.d).toBe(5);
+    expect(matrix.tx).toBe(6);
+    expect(matrix.ty).toBe(7);
+  });
+});
+
+describe('fromArray', () => {
+  it('should set values from an array', () => {
+    const matrix = new Matrix();
+    const array = [2, 3, 4, 5, 6, 7];
+    matrix.fromArray(array);
+    expect(matrix.a).toBe(array[0]);
+    expect(matrix.b).toBe(array[1]);
+    expect(matrix.c).toBe(array[3]);
+    expect(matrix.d).toBe(array[4]);
+    expect(matrix.tx).toBe(array[2]);
+    expect(matrix.ty).toBe(array[5]);
+  });
+});
+
+describe('setTo', () => {
+  it('should set values when arguments are passed', () => {
+    const matrix = new Matrix();
+    const a = 2;
+    const b = 3;
+    const c = 4;
+    const d = 5;
+    const tx = 6;
+    const ty = 7;
+    matrix.setTo(a, b, c, d, tx, ty);
+    expect(matrix.a).toBe(a);
+    expect(matrix.b).toBe(b);
+    expect(matrix.c).toBe(c);
+    expect(matrix.d).toBe(d);
+    expect(matrix.tx).toBe(tx);
+    expect(matrix.ty).toBe(ty);
+  });
+
+  it('should return the matrix instance', () => {
+    const matrix = new Matrix();
+    const a = 2;
+    const b = 3;
+    const c = 4;
+    const d = 5;
+    const tx = 6;
+    const ty = 7;
+    expect(matrix.setTo(a, b, c, d, tx, ty)).toBe(matrix);
+  });
+});
+
+describe('clone', () => {
+  it('should return a copy of the matrix instance', () => {
+    const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
+    const matrix2 = matrix1.clone();
+    expect(matrix2.a).toBe(matrix1.a);
+    expect(matrix2.b).toBe(matrix1.b);
+    expect(matrix2.c).toBe(matrix1.c);
+    expect(matrix2.d).toBe(matrix1.d);
+    expect(matrix2.tx).toBe(matrix1.tx);
+    expect(matrix2.ty).toBe(matrix1.ty);
+  });
+});
+
+describe('copyTo', () => {
+  it('should copy values to another matrix instance', () => {
+    const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
+    const matrix2 = new Matrix();
+    matrix1.copyTo(matrix2);
+    expect(matrix2.a).toBe(matrix1.a);
+    expect(matrix2.b).toBe(matrix1.b);
+    expect(matrix2.c).toBe(matrix1.c);
+    expect(matrix2.d).toBe(matrix1.d);
+    expect(matrix2.tx).toBe(matrix1.tx);
+    expect(matrix2.ty).toBe(matrix1.ty);
+  });
+});
+
+describe('copyFrom', () => {
+  it('should copy values from another matrix instance', () => {
+    const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
+    const matrix2 = new Matrix();
+    matrix2.copyFrom(matrix1);
+    expect(matrix2.a).toBe(matrix1.a);
+    expect(matrix2.b).toBe(matrix1.b);
+    expect(matrix2.c).toBe(matrix1.c);
+    expect(matrix2.d).toBe(matrix1.d);
+    expect(matrix2.tx).toBe(matrix1.tx);
+    expect(matrix2.ty).toBe(matrix1.ty);
+  });
+});
+
+describe('apply', () => {
+  it('should apply the matrix to a point', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const point = new Point(1, 2);
+    const result = new Point();
+    matrix.apply(point, result);
+    expect(result.x).toBe(matrix.a * point.x + matrix.c * point.y + matrix.tx);
+    expect(result.y).toBe(matrix.b * point.x + matrix.d * point.y + matrix.ty);
+
+    matrix.setTo(8, 9, 10, 11, 12, 13);
+    matrix.apply(point, result);
+    expect(result.x).toBe(matrix.a * point.x + matrix.c * point.y + matrix.tx);
+    expect(result.y).toBe(matrix.b * point.x + matrix.d * point.y + matrix.ty);
+  });
+});
+
+describe('applyInverse', () => {
+  it('should apply the inverse of the matrix to a point', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const point = new Point(1, 2);
+    const result = new Point();
+    matrix.applyInverse(point, result);
+    expect(result.x).toBe(2.5);
+    expect(result.y).toBe(-2.5);
+  });
+});
+
+describe('translate', () => {
+  it('should add the translation values to the matrix', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const x = 1;
+    const y = 2;
+    matrix.translate(x, y);
+    expect(matrix.tx).toBe(7);
+    expect(matrix.ty).toBe(9);
+  });
+});
+
+describe('scale', () => {
+  it('should multiply the scaling values with the matrix', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const x = 1;
+    const y = 2;
+    matrix.scale(x, y);
+    expect(matrix.a).toBe(2);
+    expect(matrix.b).toBe(6);
+    expect(matrix.c).toBe(4);
+    expect(matrix.d).toBe(10);
+    expect(matrix.tx).toBe(6);
+    expect(matrix.ty).toBe(14);
+  });
+});
+
+describe('rotate', () => {
+  it('should multiply the rotation values with the matrix', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const angle = Math.PI / 2;
+    matrix.rotate(angle);
+    expect(matrix.a).toBe(-3);
+    expect(matrix.c).toBe(-5);
+    expect(matrix.tx).toBe(-7);
+  });
+});
+
+describe('append', () => {
+  it('should add the second matrix to the first one', () => {
+    const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
+    const matrix2 = new Matrix(8, 9, 10, 11, 12, 13);
+    matrix1.append(matrix2);
+    expect(matrix1.a).toBe(52);
+    expect(matrix1.d).toBe(85);
+    expect(matrix1.tx).toBe(82);
+  });
+});
+
+describe('identity', () => {
+  it('should set the values to the identity matrix', () => {
+    const matrix = new Matrix();
+    matrix.identity();
+    expect(matrix.a).toBe(1);
+    expect(matrix.c).toBe(0);
+    expect(matrix.tx).toBe(0);
+
+    matrix.setTo(2, 3, 4, 5, 6, 7);
+    matrix.identity();
+    expect(matrix.a).toBe(1);
+    expect(matrix.c).toBe(0);
+    expect(matrix.tx).toBe(0);
+  });
+});
+
+describe('toArray', () => {
+  it('should return the values as an array', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const result = matrix.toArray();
+    expect(result[0]).toBe(matrix.a);
+    expect(result[1]).toBe(matrix.c);
+    expect(result[2]).toBe(matrix.tx);
+    expect(result[3]).toBe(matrix.b);
+    expect(result[4]).toBe(matrix.d);
+    expect(result[5]).toBe(matrix.ty);
+
+    matrix.setTo(8, 9, 10, 11, 12, 13);
+    const result2 = matrix.toArray();
+    expect(result2[0]).toBe(matrix.a);
+    expect(result2[1]).toBe(matrix.c);
+    expect(result2[2]).toBe(matrix.tx);
+    expect(result2[3]).toBe(matrix.b);
+    expect(result2[4]).toBe(matrix.d);
+    expect(result2[5]).toBe(matrix.ty);
+  });
+
+  it('should return the values as an array with transposed coordinates', () => {
+    const matrix = new Matrix(2, 3, 4, 5, 6, 7);
+    const result = matrix.toArray(true);
+    expect(result[0]).toBe(matrix.a);
+    expect(result[1]).toBe(matrix.b);
+    expect(result[2]).toBe(0);
+    expect(result[3]).toBe(matrix.c);
+    expect(result[4]).toBe(matrix.d);
+    expect(result[5]).toBe(0);
+
+    matrix.setTo(8, 9, 10, 11, 12, 13);
+    const result2 = matrix.toArray(true);
+    expect(result2[0]).toBe(matrix.a);
+    expect(result2[1]).toBe(matrix.b);
+    expect(result2[2]).toBe(0);
+    expect(result2[3]).toBe(matrix.c);
+    expect(result2[4]).toBe(matrix.d);
+    expect(result2[5]).toBe(0);
+  });
+});

package/src/phaser/geom/point.test.js

@@ -0,0 +1,209 @@
+import { Point } from './point.js';
+
+describe('Point', () => {
+  it('should create a point with default values', () => {
+    const point = new Point();
+    expect(point.x).toBe(0);
+    expect(point.y).toBe(0);
+  });
+
+  it('should create a point with custom x and y values', () => {
+    const point = new Point(10, 20);
+    expect(point.x).toBe(10);
+    expect(point.y).toBe(20);
+  });
+
+  it('should copy from another point', () => {
+    const point1 = new Point(10, 20);
+    const point2 = new Point();
+    point2.copyFrom(point1);
+    expect(point2.x).toBe(10);
+    expect(point2.y).toBe(20);
+  });
+
+  it('should invert a point', () => {
+    const point = new Point(10, 20);
+    const invertedPoint = point.invert();
+    expect(invertedPoint.x).toBe(20);
+    expect(invertedPoint.y).toBe(10);
+  });
+
+  it('should set to x and y values', () => {
+    const point = new Point();
+    point.setTo(10, 20);
+    expect(point.x).toBe(10);
+    expect(point.y).toBe(20);
+  });
+
+  it('should set to y value as x value', () => {
+    const point = new Point();
+    point.setTo(10);
+    expect(point.x).toBe(10);
+    expect(point.y).toBe(10);
+  });
+
+  it('should add points', () => {
+    const point1 = new Point(10, 20);
+    const point2 = new Point(30, 40);
+    const sum = point1.add(point2.x, point2.y);
+    expect(sum.x).toBe(40);
+    expect(sum.y).toBe(60);
+  });
+
+  it('should subtract points', () => {
+    const point1 = new Point(10, 20);
+    const point2 = new Point(30, 40);
+    const difference = point1.subtract(point2.x, point2.y);
+    expect(difference.x).toBe(-20);
+    expect(difference.y).toBe(-20);
+  });
+
+  it('should multiply points', () => {
+    const point = new Point(10, 20);
+    const multipliedPoint = point.multiply(2, 3);
+    expect(multipliedPoint.x).toBe(20);
+    expect(multipliedPoint.y).toBe(60);
+  });
+
+  it('should divide points', () => {
+    const point1 = new Point(10, 20);
+    const point2 = new Point(2, 3);
+    const quotient = point1.divide(2, 3);
+    expect(quotient.x).toBe(5);
+    expect(quotient.y).toBeCloseTo(6.67);
+  });
+
+  it('should clamp x value', () => {
+    const point = new Point(-10, 20);
+    const clampedPoint = point.clampX(-5, 10);
+    expect(clampedPoint.x).toBe(-5);
+    expect(clampedPoint.y).toBe(20);
+  });
+
+  it('should clamp y value', () => {
+    const point = new Point(10, -20);
+    const clampedPoint = point.clampY(-5, 10);
+    expect(clampedPoint.x).toBe(10);
+    expect(clampedPoint.y).toBe(-5);
+  });
+
+  it('should clamp x and y values', () => {
+    const point = new Point(-10, -20);
+    const clampedPoint = point.clamp(-5, 10);
+    expect(clampedPoint.x).toBe(-5);
+    expect(clampedPoint.y).toBe(-5);
+  });
+
+  it('should clone a point', () => {
+    const point1 = new Point(10, 20);
+    const clonedPoint = point1.clone();
+    expect(clonedPoint.x).toBe(10);
+    expect(clonedPoint.y).toBe(20);
+  });
+
+  it('should copy to another point', () => {
+    const point1 = new Point(10, 20);
+    const point2 = new Point();
+    point1.copyTo(point2);
+    expect(point2.x).toBe(10);
+    expect(point2.y).toBe(20);
+  });
+
+  it('should calculate distance between two points', () => {
+    const point1 = new Point(0, 0);
+    const point2 = new Point(3, 4);
+    const distance = point1.distance(point2);
+    expect(distance).toBeCloseTo(5);
+  });
+
+  it('should check if two points are equal', () => {
+    const point1 = new Point(10, 20);
+    const point2 = new Point(10, 20);
+    expect(point1.equals(point2)).toBe(true);
+  });
+
+  it('should calculate angle between two points', () => {
+    const point1 = new Point(0, 0);
+    const point2 = new Point(3, 4);
+    const angle = point1.angle(point2, true);
+    expect(angle).toBeCloseTo(53.13);
+  });
+
+  it('should rotate a point around another point', () => {
+    const point1 = new Point(10, 20);
+    const rotatedPoint = point1.rotate(0, 0, Math.PI / 2, true);
+    expect(rotatedPoint.x).toBeCloseTo(9.447);
+    expect(rotatedPoint.y).toBeCloseTo(20.266);
+  });
+
+  it('should get magnitude of a point', () => {
+    const point = new Point(3, 4);
+    expect(point.getMagnitude()).toBeCloseTo(5);
+  });
+
+  it('should get magnitude squared of a point', () => {
+    const point = new Point(3, 4);
+    expect(point.getMagnitudeSq()).toBeCloseTo(25);
+  });
+
+  it('should set magnitude of a point', () => {
+    const point = new Point(3, 4);
+    const newPoint = point.setMagnitude(10);
+    expect(newPoint.x).toBe(6);
+    expect(newPoint.y).toBe(8);
+  });
+
+  it('should normalize a point', () => {
+    const point = new Point(3, 4);
+    const normalizedPoint = point.normalize();
+    expect(normalizedPoint.x).toBeCloseTo(0.6);
+    expect(normalizedPoint.y).toBeCloseTo(0.8);
+  });
+
+  it('should check if a point is zero', () => {
+    const point1 = new Point(0, 0);
+    const point2 = new Point(10, 20);
+    expect(point1.isZero()).toBe(true);
+    expect(point2.isZero()).toBe(false);
+  });
+
+  it('should calculate dot product of two points', () => {
+    const point1 = new Point(1, 1);
+    const point2 = new Point(2, 2);
+    expect(point1.dot(point2)).toBe(4);
+  });
+
+  it('should calculate cross product of two points', () => {
+    const point1 = new Point(1, 1);
+    const point2 = new Point(1, 2);
+    expect(point1.cross(point2)).toBe(1);
+  });
+
+  it('should get perpendicular point', () => {
+    const point = new Point(10, 20);
+    const perpPoint = point.perp();
+    expect(perpPoint.x).toBe(-20);
+    expect(perpPoint.y).toBe(10);
+  });
+
+  it('should get right-hand normal point', () => {
+    const point = new Point(10, 20);
+    const normalPoint = point.normalRightHand();
+    expect(normalPoint.x).toBe(-20);
+    expect(normalPoint.y).toBe(10);
+  });
+
+  it('should floor a point', () => {
+    const point = new Point(3.14, 4.23);
+    const flooredPoint = point.floor();
+    expect(flooredPoint.x).toBe(3);
+    expect(flooredPoint.y).toBe(4);
+  });
+
+  it('should ceil a point', () => {
+    const point = new Point(3.14, 4.23);
+    const ceiledPoint = point.ceil();
+    expect(ceiledPoint.x).toBe(4);
+    expect(ceiledPoint.y).toBe(5);
+  });
+});