brick-engine-js 1.0.1

package/src/core/module/grid/engines/GridMovementEngine.ts

@@ -0,0 +1,113 @@
+import { Cell, Coordinate, Vector, Piece } from '../../../types/Types';
+import { Grid } from '../../../types/modules';
+
+/**
+ * Handles movement and projection logic for the game grid.
+ */
+export default class GridMovementEngine {
+    constructor(private grid: Grid) {}
+
+    /**
+     * Attempts to shift a collection of cells (a piece) in a given direction.
+     */
+    movePiece(piece: Piece, direction: Vector): Piece | null {
+        const newPiece: Piece = piece.map(cell => ({
+            ...cell,
+            coordinate: {
+                x: cell.coordinate.x + (direction.x || 0),
+                y: cell.coordinate.y + (direction.y || 0),
+            },
+        }));
+
+        const isPartofSelf = (coord: Coordinate) => piece.some(c => c.coordinate.x === coord.x && c.coordinate.y === coord.y);
+
+        const isInvalid = newPiece.some(cell => {
+            if (!this.grid.isValidCoordinate(cell.coordinate)) return true;
+            return this.grid.isCellActive(cell.coordinate) && !isPartofSelf(cell.coordinate);
+        });
+
+        return isInvalid ? null : newPiece;
+    }
+
+    movePieceLeft(piece: Piece): Piece | null {
+        return this.movePiece(piece, { x: -1, y: 0 });
+    }
+    movePieceRight(piece: Piece): Piece | null {
+        return this.movePiece(piece, { x: 1, y: 0 });
+    }
+    movePieceUp(piece: Piece): Piece | null {
+        return this.movePiece(piece, { x: 0, y: -1 });
+    }
+    movePieceDown(piece: Piece): Piece | null {
+        return this.movePiece(piece, { x: 0, y: 1 });
+    }
+
+    /**
+     * Attempts to shift a single cell in a given direction.
+     */
+    moveCell(cell: Cell, direction: Vector): Cell | null {
+        const newCoord = {
+            x: cell.coordinate.x + (direction.x || 0),
+            y: cell.coordinate.y + (direction.y || 0),
+        };
+
+        if (!this.grid.isValidCoordinate(newCoord) || this.grid.isCellActive(newCoord)) {
+            return null;
+        }
+
+        return { ...cell, coordinate: newCoord };
+    }
+
+    moveCellLeft(cell: Cell): Cell | null {
+        return this.moveCell(cell, { x: -1, y: 0 });
+    }
+    moveCellRight(cell: Cell): Cell | null {
+        return this.moveCell(cell, { x: 1, y: 0 });
+    }
+    moveCellUp(cell: Cell): Cell | null {
+        return this.moveCell(cell, { x: 0, y: -1 });
+    }
+    moveCellDown(cell: Cell): Cell | null {
+        return this.moveCell(cell, { x: 0, y: 1 });
+    }
+
+    getDropPath(piece: Piece): Piece {
+        let currentPiece = piece;
+        let nextPiece = this.movePieceDown(currentPiece);
+        while (nextPiece !== null) {
+            currentPiece = nextPiece;
+            nextPiece = this.movePieceDown(currentPiece);
+        }
+        return currentPiece;
+    }
+
+    getRisePath(piece: Piece): Piece {
+        let currentPiece = piece;
+        let nextPiece = this.movePieceUp(currentPiece);
+        while (nextPiece !== null) {
+            currentPiece = nextPiece;
+            nextPiece = this.movePieceUp(currentPiece);
+        }
+        return currentPiece;
+    }
+
+    getReachPathLeft(piece: Piece): Piece {
+        let currentPiece = piece;
+        let nextPiece = this.movePieceLeft(currentPiece);
+        while (nextPiece !== null) {
+            currentPiece = nextPiece;
+            nextPiece = this.movePieceLeft(currentPiece);
+        }
+        return currentPiece;
+    }
+
+    getReachPathRight(piece: Piece): Piece {
+        let currentPiece = piece;
+        let nextPiece = this.movePieceRight(currentPiece);
+        while (nextPiece !== null) {
+            currentPiece = nextPiece;
+            nextPiece = this.movePieceRight(currentPiece);
+        }
+        return currentPiece;
+    }
+}

package/src/core/module/grid/engines/GridRegionEngine.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import GridRegionEngine from './GridRegionEngine';
+import { Grid } from '../../../types/modules';
+import { Color } from '../../../types/enums';
+
+describe('GridRegionEngine', () => {
+    let engine: GridRegionEngine;
+    let mockGrid: Grid;
+
+    beforeEach(() => {
+        // [ARRANGE] Mock Grid facade
+        mockGrid = {
+            width: 10,
+            height: 20,
+            isValidCoordinate: vi.fn(),
+            isCellActive: vi.fn(),
+            setCellValue: vi.fn(),
+            setCellColor: vi.fn(),
+            stampCell: vi.fn(),
+        } as unknown as Grid;
+        engine = new GridRegionEngine(mockGrid);
+    });
+
+    describe('isAreaOccupied', () => {
+        it('should return true if any coordinate is out of bounds', () => {
+            // [ARRANGE]
+            const coords = [
+                { x: 0, y: 0 },
+                { x: -1, y: 0 },
+            ];
+            vi.mocked(mockGrid.isValidCoordinate).mockImplementation(c => c.x >= 0);
+
+            // [ACT]
+            const result = engine.isAreaOccupied(coords);
+
+            // [ASSERT]
+            expect(result).toBe(true);
+        });
+
+        it('should return true if any coordinate is already active', () => {
+            // [ARRANGE]
+            const coords = [
+                { x: 1, y: 1 },
+                { x: 2, y: 2 },
+            ];
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockImplementation(c => c.x === 2);
+
+            // [ACT]
+            const result = engine.isAreaOccupied(coords);
+
+            // [ASSERT]
+            expect(result).toBe(true);
+        });
+
+        it('should return false if all coordinates are valid and inactive', () => {
+            // [ARRANGE]
+            const coords = [
+                { x: 1, y: 1 },
+                { x: 2, y: 2 },
+            ];
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.isAreaOccupied(coords);
+
+            // [ASSERT]
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('fillArea', () => {
+        it('should call setCellValue and setCellColor for every cell in the defined rectangle', () => {
+            // [ARRANGE]
+            const start = { x: 1, y: 1 };
+            const end = { x: 2, y: 2 };
+            const value = 5;
+            const color = Color.RED;
+
+            // [ACT]
+            engine.fillArea(start, end, value, color);
+
+            // [ASSERT]
+            // (1,1), (1,2), (2,1), (2,2) -> 4 cells
+            expect(mockGrid.setCellValue).toHaveBeenCalledTimes(4);
+            expect(mockGrid.setCellValue).toHaveBeenCalledWith({ x: 1, y: 1 }, 5);
+            expect(mockGrid.setCellColor).toHaveBeenCalledWith({ x: 1, y: 1 }, Color.RED);
+            expect(mockGrid.setCellValue).toHaveBeenCalledWith({ x: 2, y: 2 }, 5);
+        });
+
+        it('should handle coordinates provided in reverse order', () => {
+            // [ARRANGE]
+            const start = { x: 2, y: 2 };
+            const end = { x: 1, y: 1 };
+
+            // [ACT]
+            engine.fillArea(start, end, 5, Color.RED);
+
+            // [ASSERT]
+            expect(mockGrid.setCellValue).toHaveBeenCalledTimes(4);
+        });
+    });
+
+    describe('stampPiece', () => {
+        it('should call grid.stampCell for each cell in the piece', () => {
+            // [ARRANGE]
+            const piece = [
+                { coordinate: { x: 1, y: 1 }, value: 1, color: Color.RED },
+                { coordinate: { x: 1, y: 2 }, value: 1, color: Color.RED },
+            ];
+
+            // [ACT]
+            engine.stampPiece(piece);
+
+            // [ASSERT]
+            expect(mockGrid.stampCell).toHaveBeenCalledTimes(2);
+            expect(mockGrid.stampCell).toHaveBeenCalledWith(piece[0]);
+            expect(mockGrid.stampCell).toHaveBeenCalledWith(piece[1]);
+        });
+    });
+
+    describe('stampCell', () => {
+        it('should delegate to setCellValue and setCellColor', () => {
+            // [ARRANGE]
+            const cell = { coordinate: { x: 5, y: 5 }, value: 2, color: Color.BLUE };
+
+            // [ACT]
+            engine.stampCell(cell);
+
+            // [ASSERT]
+            expect(mockGrid.setCellValue).toHaveBeenCalledWith({ x: 5, y: 5 }, 2);
+            expect(mockGrid.setCellColor).toHaveBeenCalledWith({ x: 5, y: 5 }, Color.BLUE);
+        });
+    });
+});

package/src/core/module/grid/engines/GridRegionEngine.ts

@@ -0,0 +1,52 @@
+import { Color } from '../../../types/enums';
+import { Cell, Coordinate, Piece } from '../../../types/Types';
+import { Grid } from '../../../types/modules';
+
+/**
+ * Handles region-based operations (areas, stamps, and occupancy) on the grid.
+ */
+export default class GridRegionEngine {
+    constructor(private grid: Grid) {}
+
+    /**
+     * Checks if any of the provided coordinates are already occupied or out of bounds.
+     */
+    isAreaOccupied(coordinates: Coordinate[]): boolean {
+        return coordinates.some(coord => {
+            if (!this.grid.isValidCoordinate(coord)) return true;
+            return this.grid.isCellActive(coord);
+        });
+    }
+
+    /**
+     * Fills a rectangular region defined by two corners with a specific value and color.
+     */
+    fillArea(start: Coordinate, end: Coordinate, value: number, color: Color): void {
+        const xMin = Math.max(0, Math.min(start.x, end.x));
+        const xMax = Math.min(this.grid.width - 1, Math.max(start.x, end.x));
+        const yMin = Math.max(0, Math.min(start.y, end.y));
+        const yMax = Math.min(this.grid.height - 1, Math.max(start.y, end.y));
+
+        for (let y = yMin; y <= yMax; y++) {
+            for (let x = xMin; x <= xMax; x++) {
+                this.grid.setCellValue({ x, y }, value);
+                this.grid.setCellColor({ x, y }, color);
+            }
+        }
+    }
+
+    /**
+     * Updates multiple coordinates simultaneously with their specific values and colors.
+     */
+    stampPiece(piece: Piece): void {
+        piece.forEach(cell => this.grid.stampCell(cell));
+    }
+
+    /**
+     * Updates a single coordinate with a specific value and color from a Cell.
+     */
+    stampCell(cell: Cell): void {
+        this.grid.setCellValue(cell.coordinate, cell.value);
+        this.grid.setCellColor(cell.coordinate, cell.color);
+    }
+}

package/src/core/module/grid/engines/GridTransformEngine.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import GridTransformEngine from './GridTransformEngine';
+import { Grid } from '../../../types/modules';
+import { Color } from '../../../types/enums';
+
+describe('GridTransformEngine', () => {
+    let engine: GridTransformEngine;
+    let mockGrid: Grid;
+
+    beforeEach(() => {
+        // [ARRANGE] Mock Grid facade
+        mockGrid = {
+            isValidCoordinate: vi.fn(),
+            isCellActive: vi.fn(),
+        } as unknown as Grid;
+        engine = new GridTransformEngine(mockGrid);
+    });
+
+    describe('rotatePiece', () => {
+        it('should rotate a piece 90 degrees clockwise around origin', () => {
+            // [ARRANGE]
+            // Origin (5,5), Cell at (5,4) (above)
+            // Clockwise rotation should move it to (6,5) (right)
+            const piece = [{ coordinate: { x: 5, y: 4 }, value: 1, color: Color.RED }];
+            const origin = { x: 5, y: 5 };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(false);
+
+            // [ACT]
+            const result = engine.rotatePiece(piece, origin, true);
+
+            // [ASSERT]
+            expect(result).not.toBeNull();
+            expect(result![0].coordinate).toEqual({ x: 6, y: 5 });
+        });
+
+        it('should return null if rotation results in a collision', () => {
+            // [ARRANGE]
+            const piece = [{ coordinate: { x: 5, y: 4 }, value: 1, color: Color.RED }];
+            const origin = { x: 5, y: 5 };
+            vi.mocked(mockGrid.isValidCoordinate).mockReturnValue(true);
+            vi.mocked(mockGrid.isCellActive).mockReturnValue(true); // Obstacle at (6,5)
+
+            // [ACT]
+            const result = engine.rotatePiece(piece, origin, true);
+
+            // [ASSERT]
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getPieceBounds', () => {
+        it('should return correct min and max coordinates', () => {
+            // [ARRANGE]
+            const piece = [
+                { coordinate: { x: 1, y: 10 }, value: 1, color: Color.RED },
+                { coordinate: { x: 5, y: 2 }, value: 1, color: Color.RED },
+            ];
+
+            // [ACT]
+            const bounds = engine.getPieceBounds(piece);
+
+            // [ASSERT]
+            expect(bounds.min).toEqual({ x: 1, y: 2 });
+            expect(bounds.max).toEqual({ x: 5, y: 10 });
+        });
+    });
+
+    describe('mirrorPiece', () => {
+        it('should mirror piece across X axis (horizontal mirror)', () => {
+            // [ARRANGE]
+            // Piece at X: 1, 2, 3. Center is 2.
+            // 1 mirrors to 3, 2 stays 2, 3 mirrors to 1.
+            const piece = [
+                { coordinate: { x: 1, y: 1 }, value: 1, color: Color.RED },
+                { coordinate: { x: 3, y: 1 }, value: 1, color: Color.RED },
+            ];
+
+            // [ACT]
+            const result = engine.mirrorPiece(piece, 'x');
+
+            // [ASSERT]
+            expect(result.map(c => c.coordinate.x)).toContain(1);
+            expect(result.map(c => c.coordinate.x)).toContain(3);
+        });
+
+        it('should handle single cell pieces for mirroring', () => {
+            // [ARRANGE]
+            const piece = [{ coordinate: { x: 5, y: 5 }, value: 1, color: Color.RED }];
+
+            // [ACT]
+            const result = engine.mirrorPiece(piece, 'y');
+
+            // [ASSERT]
+            expect(result[0].coordinate).toEqual({ x: 5, y: 5 });
+        });
+    });
+});

package/src/core/module/grid/engines/GridTransformEngine.ts

@@ -0,0 +1,70 @@
+import { Coordinate, Axis, Piece } from '../../../types/Types';
+import { Grid } from '../../../types/modules';
+
+/**
+ * Handles geometric transformations for pieces on the grid.
+ */
+export default class GridTransformEngine {
+    constructor(private grid: Grid) {}
+
+    /**
+     * Attempts to rotate a piece 90 degrees around a specific origin.
+     */
+    rotatePiece(piece: Piece, origin: Coordinate, clockwise: boolean = true): Piece | null {
+        const newPiece: Piece = piece.map(cell => {
+            const relX = cell.coordinate.x - origin.x;
+            const relY = cell.coordinate.y - origin.y;
+
+            const newRelX = clockwise ? -relY : relY;
+            const newRelY = clockwise ? relX : -relX;
+
+            return {
+                ...cell,
+                coordinate: {
+                    x: origin.x + newRelX,
+                    y: origin.y + newRelY,
+                },
+            };
+        });
+
+        const isPartofSelf = (coord: Coordinate) => piece.some(c => c.coordinate.x === coord.x && c.coordinate.y === coord.y);
+
+        const isInvalid = newPiece.some(cell => {
+            if (!this.grid.isValidCoordinate(cell.coordinate)) return true;
+            return this.grid.isCellActive(cell.coordinate) && !isPartofSelf(cell.coordinate);
+        });
+
+        return isInvalid ? null : newPiece;
+    }
+
+    /**
+     * Mirrors a piece across a specific axis relative to its bounding box.
+     */
+    mirrorPiece(piece: Piece, axis: Axis): Piece {
+        if (piece.length === 0) return [];
+
+        const bounds = this.getPieceBounds(piece);
+        const center = axis === 'x' ? (bounds.min.x + bounds.max.x) / 2 : (bounds.min.y + bounds.max.y) / 2;
+
+        return piece.map(cell => ({
+            ...cell,
+            coordinate: {
+                x: axis === 'x' ? Math.round(2 * center - cell.coordinate.x) : cell.coordinate.x,
+                y: axis === 'y' ? Math.round(2 * center - cell.coordinate.y) : cell.coordinate.y,
+            },
+        }));
+    }
+
+    /**
+     * Calculates the bounding box of a piece.
+     */
+    getPieceBounds(piece: Piece): { min: Coordinate; max: Coordinate } {
+        const xs = piece.map(c => c.coordinate.x);
+        const ys = piece.map(c => c.coordinate.y);
+
+        return {
+            min: { x: Math.min(...xs), y: Math.min(...ys) },
+            max: { x: Math.max(...xs), y: Math.max(...ys) },
+        };
+    }
+}

package/src/core/module/renderer/DisplayRenderer.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type p5 from 'p5';
+import DisplayRenderer from './DisplayRenderer';
+import { Color } from '../../types/enums';
+import { GameModules } from '../../types/Types';
+import { State } from '../../types/modules';
+
+describe('DisplayRenderer', () => {
+    let renderer: DisplayRenderer;
+    let mockP5: Record<string, unknown>;
+    let mockGraphics: Record<string, unknown>;
+
+    beforeEach(() => {
+        mockGraphics = {
+            background: vi.fn(),
+            strokeWeight: vi.fn(),
+            noFill: vi.fn(),
+            stroke: vi.fn(),
+            rect: vi.fn(),
+        };
+
+        mockP5 = {
+            createGraphics: vi.fn().mockReturnValue(mockGraphics),
+            push: vi.fn(),
+            pop: vi.fn(),
+            image: vi.fn(),
+            translate: vi.fn(),
+            strokeWeight: vi.fn(),
+            stroke: vi.fn(),
+            noFill: vi.fn(),
+            rect: vi.fn(),
+            fill: vi.fn(),
+            width: 1000,
+            height: 1000,
+        };
+
+        renderer = new DisplayRenderer(mockP5 as unknown as p5);
+        renderer.setup({
+            display: { width: 600, height: 900, origin: { x: 50, y: 50 } },
+            hud: { width: 400, height: 900, origin: { x: 650, y: 50 } },
+            cell: { size: 50 },
+        });
+    });
+
+    describe('render', () => {
+        it('should draw static background and then grid cells', () => {
+            // [ARRANGE]
+            const grid = [[{ coordinate: { x: 0, y: 0 }, value: 1, color: Color.RED }]];
+            const mockModules = {
+                state: { isColorEnabled: () => true, isPlaying: () => true },
+            } as unknown as GameModules;
+
+            // [ACT]
+            renderer.render(grid, mockModules);
+
+            // [ASSERT]
+            expect(mockP5.image).toHaveBeenCalledWith(mockGraphics, 0, 0);
+            expect(mockP5.translate).toHaveBeenCalledWith(50, 50); // display origin + 0*50
+            expect(mockP5.rect).toHaveBeenCalled();
+        });
+    });
+
+    describe('renderCell', () => {
+        it('should use DEFAULT color if color mode is disabled', () => {
+            const cell = { coordinate: { x: 0, y: 0 }, value: 1, color: Color.RED };
+            const mockState = { isColorEnabled: () => false, isPlaying: () => true } as unknown as State;
+
+            // [ACT]
+            (renderer as unknown as { renderCell: (c: unknown, s: unknown) => void })['renderCell'](cell, mockState);
+
+            // [ASSERT]
+            expect(mockP5.stroke).toHaveBeenCalledWith(Color.DEFAULT);
+        });
+
+        it('should use INACTIVE color if cell value is 0', () => {
+            const cell = { coordinate: { x: 0, y: 0 }, value: 0, color: Color.RED };
+            const mockState = { isColorEnabled: () => true, isPlaying: () => true } as unknown as State;
+
+            // [ACT]
+            (renderer as unknown as { renderCell: (c: unknown, s: unknown) => void })['renderCell'](cell, mockState);
+
+            // [ASSERT]
+            expect(mockP5.stroke).toHaveBeenCalledWith(Color.INACTIVE);
+        });
+    });
+});