brick-engine-js 1.0.1 → 1.0.2

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

@@ -1,113 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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);
-        });
-    });
-});