basic matrix tests

Author: serbanghita

packages/matrix/src/matrix.test.ts

@@ -1,40 +1,73 @@
-import {createFlatMatrix, createMatrix} from "./matrix";
+import {
+    createFlatMatrix,
+    createMatrix,
+    getTileCoordinates, getTileFromCoordinates,
+    getTileRowAndColumn,
+} from "./matrix";
 
 describe('createMatrix', () => {
     test('createMatrix(1, 1)', () => {
-        const m = createMatrix(1, 1);
+        const m = createMatrix({ width: 1, height: 1, tileSize: 16 });
         expect(m).toEqual([[0]]);
     });
 
     test('createMatrix(1, 2)', () => {
-        const m = createMatrix(1, 2);
+        const m = createMatrix({ width: 1, height: 2, tileSize: 16 });
         expect(m).toEqual([[0], [0]]);
     });
 
     test('createMatrix(3, 3)', () => {
-        const m = createMatrix(3, 3);
+        const m = createMatrix({ width: 3, height: 3, tileSize: 16 });
         expect(m).toEqual([[0,0,0], [0,0,0], [0,0,0]]);
     });
 
     test('createMatrix(3, 4)', () => {
-        const m = createMatrix(3, 4);
+        const m = createMatrix({ width: 3, height: 4, tileSize: 16 });
         expect(m).toEqual([[0,0,0], [0,0,0], [0,0,0], [0,0,0]]);
     });
 });
 
 describe('createFlatMatrix', () => {
     test('createFlatMatrix(1, 1)', () => {
-        const m = createFlatMatrix(1, 1);
+        const m = createFlatMatrix({ width: 1, height: 1, tileSize: 16 });
         expect(m).toEqual([0]);
     });
 
     test('createFlatMatrix(1, 2)', () => {
-        const m = createFlatMatrix(1, 2);
+        const m = createFlatMatrix({ width: 1, height: 2, tileSize: 16 });
         expect(m).toEqual([0, 0]);
     });
 
     test('createFlatMatrix(3, 3)', () => {
-        const m = createFlatMatrix(3, 3);
+        const m = createFlatMatrix({ width: 3, height: 3, tileSize: 16 });
         expect(m).toEqual([0,0,0,0,0,0,0,0,0]);
     })
+});
+
+describe('tile', () => {
+
+    test('getTileRowAndColumn', () => {
+        const matrixConfig = { width: 40, height: 30, tileSize: 16 };
+
+        expect(getTileRowAndColumn(0, matrixConfig)).toEqual({row: 0, column: 0}); // first tile.
+        expect(getTileRowAndColumn(129, matrixConfig)).toEqual({row: 3, column: 9});
+        expect(getTileRowAndColumn(1199, matrixConfig)).toEqual({row: 29, column: 39}); // last tile.
+    });
+
+    test('getTileCoordinates', () => {
+        const matrixConfig = { width: 40, height: 30, tileSize: 16 };
+
+        expect(getTileCoordinates(0, matrixConfig)).toEqual({x: 0, y: 0});
+        expect(getTileCoordinates(129, matrixConfig)).toEqual({x: 144, y: 48});
+        expect(getTileCoordinates(1199, matrixConfig)).toEqual({x: 624, y: 464});
+    });
+
+    test('getTileFromCoordinates', () => {
+        const matrixConfig = { width: 40, height: 30, tileSize: 16 };
+
+        expect(getTileFromCoordinates(0, 0, matrixConfig)).toEqual(0);
+        expect(getTileFromCoordinates(144, 48, matrixConfig)).toEqual(129);
+        expect(getTileFromCoordinates(624, 464, matrixConfig)).toEqual(1199);
+    });
+
 });

packages/matrix/src/matrix.ts

@@ -12,7 +12,7 @@ export type MatrixConfig = {
 }
 
 export function createMatrix(matrixConfig: MatrixConfig): Array<MatrixTile[]> {
-    const grid = [];
+    const grid: Array<Array<number>> = [];
 
     for (let row = 1; row <= matrixConfig.height; row++) {
         grid[row - 1] = [];
@@ -28,16 +28,23 @@ export function createFlatMatrix(matrixConfig: MatrixConfig) {
     return new Array(matrixConfig.width * matrixConfig.height).fill(MatrixTile.FREE);
 }
 
-export function getXYFromTile(tile: number, matrixConfig: MatrixConfig) {
+export function getTileCoordinates(tile: number, matrixConfig: MatrixConfig) {
     return {
-        x: Math.floor(tile / matrixConfig.width),
-        y: (tile % matrixConfig.width)
+        x: (matrixConfig.tileSize * (tile % matrixConfig.width)),
+        y: (Math.floor(tile / matrixConfig.width) * matrixConfig.tileSize)
     }
 }
 
-export function getTileFromXY<T extends MatrixConfig>(x: number, y: number, matrixConfig: T): number {
+export function getTileRowAndColumn(tile: number, matrixConfig: MatrixConfig) {
+    return {
+        row: Math.floor(tile / matrixConfig.width),
+        column: (tile % matrixConfig.width)
+    }
+}
+
+export function getTileFromCoordinates<T extends MatrixConfig>(x: number, y: number, matrixConfig: T): number {
     const tileIndex = Math.floor(x / matrixConfig.tileSize) +
-        (matrixConfig.width * matrixConfig.tileSize) * Math.floor(y / matrixConfig.tileSize);
+        matrixConfig.width * Math.floor(y / matrixConfig.tileSize);
 
     if (tileIndex < 0 || tileIndex > ((matrixConfig.width * matrixConfig.height) - 1)) {
         throw new Error(`Invalid tile ${tileIndex} resulted from ${x} and ${y}`);