brick-engine-js 1.0.1

package/src/index.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import * as BrickEngine from './index';
+
+describe('index (Library Exports)', () => {
+    it('should export the core modules and configurations', () => {
+        // [ASSERT]
+        expect(BrickEngine.Game).toBeDefined();
+        expect(BrickEngine.GameView).toBeDefined();
+        expect(BrickEngine.configs).toBeDefined();
+
+        // Exported enums/types check
+        expect(BrickEngine.Color).toBeDefined();
+        expect(BrickEngine.FontSize).toBeDefined();
+    });
+});

package/src/index.ts

@@ -0,0 +1,9 @@
+// Library Exports Only
+export * from './core/types/enums';
+export * from './core/types/Interfaces';
+export * from './core/types/modules';
+export * from './core/types/Types';
+export * from './types/interfaces';
+export { default as Game } from './core/Game';
+export { default as GameView } from './view/GameView';
+export { default as configs } from './config/configs';

package/src/main.test.ts

@@ -0,0 +1,137 @@
+/** @vitest-environment jsdom */
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+import p5 from 'p5';
+import Game from './core/Game';
+
+// Mocking everything before importing main.ts logic
+const createMockGame = () => ({
+    setup: vi.fn(),
+    setSwitchHandler: vi.fn(),
+    propagateSwitchHandler: vi.fn(),
+    draw: vi.fn(),
+    modules: {
+        state: { turnOn: vi.fn(), turnOff: vi.fn(), isOn: vi.fn() },
+        control: { subscribe: vi.fn() },
+        time: { update: vi.fn() },
+    },
+    view: {
+        unbindControls: vi.fn(),
+        bindControls: vi.fn(),
+        updateDebuggerGameModules: vi.fn(),
+        setupDebugger: vi.fn(),
+    },
+});
+
+const mockGame = createMockGame();
+
+vi.mock('p5', () => {
+    return {
+        default: vi.fn().mockImplementation(function (sketch: (p: unknown) => void) {
+            const p = {
+                loop: vi.fn(),
+                noLoop: vi.fn(),
+                setup: vi.fn(),
+                draw: vi.fn(),
+            };
+            sketch(p);
+            return p;
+        }),
+    };
+});
+
+vi.mock('./view/GameView', () => {
+    return {
+        default: vi.fn().mockImplementation(function () {
+            return {
+                build: vi.fn().mockReturnValue({ canvas: {}, canvasHeight: 100, canvasWidth: 100 }),
+                bindControls: vi.fn(),
+                unbindControls: vi.fn(),
+                setupDebugger: vi.fn(),
+                updateDebuggerGameModules: vi.fn(),
+            };
+        }),
+    };
+});
+
+vi.mock('./menu/GameMenu', () => {
+    return {
+        default: vi.fn().mockImplementation(function () {
+            return mockGame;
+        }),
+    };
+});
+
+vi.mock('./core/Debugger', () => ({
+    default: vi.fn().mockImplementation(function () {
+        return { setup: vi.fn(), update: vi.fn(), destroy: vi.fn() };
+    }),
+}));
+
+vi.mock('./config/env', () => ({
+    isClientMode: vi.fn(),
+    isServerMode: vi.fn(),
+}));
+
+vi.mock('@client-game', () => ({
+    default: vi.fn().mockImplementation(function () {
+        return mockGame;
+    }),
+}));
+
+vi.mock('./menu/GameMenuSingleton', () => ({
+    default: {
+        setInstance: vi.fn(),
+        getInstance: vi.fn().mockReturnValue(mockGame),
+    },
+}));
+
+vi.mock('./config/styles', () => ({}));
+
+describe('main.ts', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+
+    it('should initialize the p5 instance and GameMenu in server mode', async () => {
+        const { isClientMode, isServerMode } = await import('./config/env');
+        const GameMenu = (await import('./menu/GameMenu')).default;
+
+        (isClientMode as unknown as Mock).mockReturnValue(false);
+        (isServerMode as unknown as Mock).mockReturnValue(true);
+
+        const main = await import('./main');
+
+        expect(p5).toHaveBeenCalled();
+        expect(GameMenu).toHaveBeenCalled();
+        expect(main.p5Instance).toBeDefined();
+    });
+
+    it('should initialize ClientGame in client mode', async () => {
+        const { isClientMode, isServerMode } = await import('./config/env');
+        const ClientGame = (await import('@client-game')).default;
+
+        (isClientMode as unknown as Mock).mockReturnValue(true);
+        (isServerMode as unknown as Mock).mockReturnValue(false);
+
+        await import('./main');
+
+        expect(ClientGame).toHaveBeenCalled();
+    });
+
+    it('should handle game switching', async () => {
+        const { isClientMode, isServerMode } = await import('./config/env');
+        (isClientMode as unknown as Mock).mockReturnValue(false);
+        (isServerMode as unknown as Mock).mockReturnValue(true);
+
+        await import('./main');
+
+        const switchHandler = (mockGame.setSwitchHandler as unknown as Mock).mock.calls[0][0];
+        const nextGame = createMockGame();
+
+        switchHandler(nextGame as unknown as Game);
+
+        expect(nextGame.setup).toHaveBeenCalled();
+        expect(nextGame.modules.state.turnOn).toHaveBeenCalled();
+    });
+});

package/src/main.ts

@@ -0,0 +1,77 @@
+import p5 from 'p5';
+import Game from './core/Game';
+import GameView from './view/GameView';
+import GameMenu from './menu/GameMenu';
+
+import './config/styles';
+
+import { isClientMode, isServerMode } from './config/env';
+import ClientGame from '@client-game';
+import { ControlEventType, ControlKey } from './core/types/enums';
+import GameMenuSingleton from './menu/GameMenuSingleton';
+
+export const p5Instance = new p5((p: p5) => {
+    const view = new GameView(p, document.body);
+    let activeGame: Game;
+
+    if (isClientMode()) {
+        // In client mode, we instantiate the game provided via alias
+        activeGame = new ClientGame(p, view);
+        activeGame.gameId = 'client-game';
+    } else if (isServerMode()) {
+        // In server mode, we instantiate the game menu
+        activeGame = new GameMenu(p, view);
+        activeGame.gameId = 'game-menu';
+        GameMenuSingleton.setInstance(activeGame as GameMenu);
+    } else {
+        throw new Error('Invalid APP_MODE');
+    }
+
+    // Register the switch handler
+    activeGame.setSwitchHandler((newGame: Game) => {
+        try {
+            // Unbind the previous game controls
+            activeGame.view.unbindControls();
+
+            // Propagate the switch handler to the new game
+            newGame.propagateSwitchHandler(activeGame);
+
+            // Set the new game
+            activeGame = newGame;
+            activeGame.setup();
+
+            // Update debugger
+            activeGame.view.updateDebuggerGameModules(activeGame.modules);
+
+            // Bind the new game controls
+            activeGame.view.bindControls(activeGame.modules.control);
+            activeGame.modules.state.turnOn();
+
+            // Setup exit and power buttons
+            if (isServerMode() && newGame !== GameMenuSingleton.getInstance()) {
+                newGame.modules.control.subscribe(ControlKey.EXIT, ControlEventType.PRESSED, () => {
+                    newGame.switchGame(GameMenuSingleton.getInstance());
+                });
+
+                newGame.modules.control.subscribe(ControlKey.POWER, ControlEventType.PRESSED, () => {
+                    newGame.switchGame(GameMenuSingleton.getInstance());
+                    activeGame.modules.state.turnOff();
+                });
+            }
+        } catch (error) {
+            console.error('Error switching game:', error);
+        }
+        p.loop();
+    });
+
+    p.setup = () => {
+        activeGame.setup();
+        activeGame.view.setupDebugger(activeGame.modules);
+        activeGame.view.setupSessionModal();
+    };
+
+    p.draw = () => {
+        activeGame.draw();
+        activeGame.view.updateDebugger();
+    };
+}, document.body);

package/src/menu/GameMenu.test.ts

@@ -0,0 +1,157 @@
+/** @vitest-environment jsdom */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import GameMenu from './GameMenu';
+import GameView from '../view/GameView';
+import p5 from 'p5';
+import { ControlEventType, ControlKey } from '../core/types/enums';
+
+// Mock GameRepository to avoid external dependencies
+vi.mock('./GameRepository', () => {
+    return {
+        default: vi.fn().mockImplementation(function () {
+            return {
+                games: [
+                    { id: '1', name: 'Game 1', url: 'url1' },
+                    { id: '2', name: 'Game 2', url: 'url2' },
+                ],
+            };
+        }),
+    };
+});
+
+// Mock GameManager
+vi.mock('./manager/GameManager', () => {
+    return {
+        default: vi.fn().mockImplementation(function () {
+            return {
+                handleGameSwitch: vi.fn(),
+            };
+        }),
+    };
+});
+
+describe('GameMenu', () => {
+    let menu: GameMenu;
+    let mockP5: Record<string, unknown>;
+    let mockView: Record<string, unknown>;
+
+    beforeEach(() => {
+        vi.stubGlobal('localStorage', {
+            getItem: vi.fn().mockReturnValue(null),
+            setItem: vi.fn(),
+            clear: vi.fn(),
+        });
+
+        vi.stubGlobal(
+            'AudioContext',
+            vi.fn().mockImplementation(function () {
+                return {
+                    createGain: vi.fn().mockReturnValue({
+                        connect: vi.fn(),
+                        gain: { setValueAtTime: vi.fn() },
+                    }),
+                    createBufferSource: vi.fn().mockReturnValue({
+                        connect: vi.fn(),
+                        start: vi.fn(),
+                        buffer: null,
+                    }),
+                    destination: {},
+                    decodeAudioData: vi.fn().mockResolvedValue({}),
+                    resume: vi.fn().mockResolvedValue({}),
+                };
+            }),
+        );
+
+        vi.stubGlobal(
+            'fetch',
+            vi.fn().mockResolvedValue({
+                arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(0)),
+            }),
+        );
+
+        mockP5 = {
+            deltaTime: 16,
+            noLoop: vi.fn(),
+            push: vi.fn(),
+            pop: vi.fn(),
+            translate: vi.fn(),
+            strokeWeight: vi.fn(),
+            stroke: vi.fn(),
+            noFill: vi.fn(),
+            rect: vi.fn(),
+            fill: vi.fn(),
+            text: vi.fn(),
+            textFont: vi.fn(),
+            textSize: vi.fn(),
+            textAlign: vi.fn(),
+            image: vi.fn(),
+            createGraphics: vi.fn().mockReturnValue({
+                background: vi.fn(),
+                strokeWeight: vi.fn(),
+                noFill: vi.fn(),
+                stroke: vi.fn(),
+                rect: vi.fn(),
+            }),
+        };
+
+        mockView = {
+            build: vi.fn(),
+            bindControls: vi.fn(),
+            showSessionModal: vi.fn(),
+        };
+
+        menu = new GameMenu(mockP5 as unknown as p5, mockView as unknown as GameView);
+        menu.setup();
+    });
+
+    it('should cycle through games on LEFT/RIGHT arrow press', () => {
+        const { control, state } = menu.modules;
+
+        // Ensure game is ON and STARTED/PLAYING
+        state.turnOn();
+        state.startGame();
+
+        expect(state.isPlaying()).toBe(true);
+
+        // Initial selection should be 0 (Game 1)
+        expect((menu as unknown as Record<string, unknown>)['_gameSelectionPointer']).toBe(0);
+
+        // Press RIGHT
+        control.notify(ControlKey.RIGHT, ControlEventType.PRESSED);
+        expect((menu as unknown as Record<string, unknown>)['_gameSelectionPointer']).toBe(1);
+
+        // Press RIGHT again (should cycle)
+        control.notify(ControlKey.RIGHT, ControlEventType.PRESSED);
+        expect((menu as unknown as Record<string, unknown>)['_gameSelectionPointer']).toBe(0);
+
+        // Press LEFT (should cycle back)
+        control.notify(ControlKey.LEFT, ControlEventType.PRESSED);
+        expect((menu as unknown as Record<string, unknown>)['_gameSelectionPointer']).toBe(1);
+    });
+
+    it('should handle game switch on ACTION press', () => {
+        const { control, state } = menu.modules;
+        state.turnOn();
+        state.startGame();
+
+        expect(state.isStarted()).toBe(true);
+
+        const managerSpy = (menu as unknown as { _gameManager: { handleGameSwitch: import('vitest').Mock } })._gameManager.handleGameSwitch;
+
+        control.notify(ControlKey.ACTION, ControlEventType.PRESSED);
+
+        expect(managerSpy).toHaveBeenCalledWith(expect.objectContaining({ name: 'Game 1' }), menu);
+    });
+
+    it('should play theme when turned on', () => {
+        const { state, sound } = menu.modules;
+
+        // Mock play to resolve
+        const soundSpy = vi.spyOn(sound, 'play').mockResolvedValue(undefined as unknown as void);
+
+        state.turnOn();
+
+        expect(state.isOn()).toBe(true);
+        expect(soundSpy).toHaveBeenCalled();
+    });
+});

package/src/menu/GameMenu.ts

@@ -0,0 +1,124 @@
+import p5 from 'p5';
+import GameView from '../view/GameView';
+import Game from '../core/Game';
+import { ControlEventType, ControlKey, FontAlign, FontSize, FontVerticalAlign, Sound, StateProperty } from '../core/types/enums';
+import GameRepository from './GameRepository';
+import GameManager from './manager/GameManager';
+
+export default class GameMenu extends Game {
+    private _gameSelectionPointer = 0;
+    private _isLoading = false;
+
+    private _gameRepository = new GameRepository();
+    private _gameManager = new GameManager();
+
+    constructor(p: p5, view: GameView) {
+        super(p, view);
+    }
+
+    setupGame() {
+        const { state, control, sound } = this.modules;
+
+        control.subscribe(ControlKey.ACTION, ControlEventType.PRESSED, () => {
+            if (this._isLoading) return;
+
+            if (state.isStarted()) {
+                const selectedGame = this._gameRepository.games[this._gameSelectionPointer];
+                this._gameManager.handleGameSwitch(selectedGame, this);
+            }
+        });
+
+        control.subscribe(ControlKey.LEFT, ControlEventType.PRESSED, () => {
+            if (state.isPlaying()) {
+                sound.play(Sound.ACTION_1);
+                if (this._gameSelectionPointer === 0) {
+                    this._gameSelectionPointer = this._gameRepository.games.length - 1;
+                } else {
+                    this._gameSelectionPointer--;
+                }
+            }
+        });
+
+        control.subscribe(ControlKey.RIGHT, ControlEventType.PRESSED, () => {
+            if (state.isPlaying()) {
+                sound.play(Sound.ACTION_1);
+                if (this._gameSelectionPointer === this._gameRepository.games.length - 1) {
+                    this._gameSelectionPointer = 0;
+                } else {
+                    this._gameSelectionPointer++;
+                }
+            }
+        });
+
+        state.subscribe(StateProperty.ON, on => {
+            if (on) {
+                sound.play(Sound.START_THEME);
+            }
+        });
+    }
+
+    update() {}
+
+    render() {
+        const { text } = this.modules;
+
+        const { p } = this;
+        p.push();
+
+        text.setTextSize(FontSize.LARGE);
+        text.setActiveText();
+        text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.BOTTOM);
+
+        text.textOnDisplay('Menu', { x: 0.5, y: 0.15 });
+
+        text.setTextSize(FontSize.SMALL);
+
+        text.textOnDisplay('Choose a game and', { x: 0.5, y: 0.25 });
+        text.textOnDisplay('Press action to play', { x: 0.5, y: 0.32 });
+
+        text.setTextAlign(FontAlign.RIGHT, FontVerticalAlign.BOTTOM);
+        text.textOnDisplay('<', { x: 0.1, y: 0.54 });
+
+        text.setTextAlign(FontAlign.LEFT, FontVerticalAlign.BOTTOM);
+        text.textOnDisplay('>', { x: 0.9, y: 0.54 });
+
+        text.setTextSize(FontSize.MEDIUM);
+        text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.BOTTOM);
+        text.textOnDisplay(this._gameRepository.games[this._gameSelectionPointer].name, { x: 0.5, y: 0.55 });
+
+        text.setTextSize(FontSize.EXTRA_SMALL);
+        text.setTextAlign(FontAlign.LEFT, FontVerticalAlign.BOTTOM);
+
+        text.textOnDisplay('Left:    Previous option', { x: 0.05, y: 0.78 });
+        text.textOnDisplay('Right:   Next option', { x: 0.05, y: 0.84 });
+        text.textOnDisplay('Action:  Select', { x: 0.05, y: 0.9 });
+
+        p.pop();
+    }
+
+    drawTitleScreen() {
+        const { text } = this.modules;
+
+        this.p.push();
+
+        text.setTextSize(FontSize.LARGE);
+        text.setActiveText();
+        text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.TOP);
+
+        text.textOnDisplay('Menu', { x: 0.5, y: 0.15 });
+
+        text.setTextSize(FontSize.SMALL);
+
+        text.textOnDisplay('Wellcome to your', { x: 0.5, y: 0.25 });
+        text.textOnDisplay('favorite brick game', { x: 0.5, y: 0.32 });
+        text.textOnDisplay('simulator!', { x: 0.5, y: 0.39 });
+        text.textOnDisplay('Press start', { x: 0.5, y: 0.66 });
+        text.textOnDisplay('to continue.', { x: 0.5, y: 0.72 });
+
+        this.p.pop();
+    }
+
+    drawGameOverScreen() {
+        // Menu doesn't have a game over screen
+    }
+}

package/src/menu/GameMenuSingleton.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import GameMenuSingleton from './GameMenuSingleton';
+import GameMenu from './GameMenu';
+
+describe('GameMenuSingleton', () => {
+    it('should store and retrieve a GameMenu instance', () => {
+        const mockInstance = { name: 'MockGameMenu' } as unknown as GameMenu;
+
+        GameMenuSingleton.setInstance(mockInstance);
+        const retrieved = GameMenuSingleton.getInstance();
+
+        expect(retrieved).toBe(mockInstance);
+        expect((retrieved as unknown as { name: string }).name).toBe('MockGameMenu');
+    });
+
+    it('should overwrite the previous instance when setInstance is called again', () => {
+        const mockInstance1 = { id: 1 } as unknown as GameMenu;
+        const mockInstance2 = { id: 2 } as unknown as GameMenu;
+
+        GameMenuSingleton.setInstance(mockInstance1);
+        expect(GameMenuSingleton.getInstance()).toBe(mockInstance1);
+
+        GameMenuSingleton.setInstance(mockInstance2);
+        expect(GameMenuSingleton.getInstance()).toBe(mockInstance2);
+    });
+});

package/src/menu/GameMenuSingleton.ts

@@ -0,0 +1,13 @@
+import GameMenu from './GameMenu';
+
+export default class GameMenuSingleton {
+    private static _instance: GameMenu;
+
+    static setInstance(instance: GameMenu) {
+        GameMenuSingleton._instance = instance;
+    }
+
+    static getInstance(): GameMenu {
+        return GameMenuSingleton._instance;
+    }
+}

package/src/menu/GameRepository.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import GameRepository from './GameRepository';
+
+describe('GameRepository', () => {
+    beforeEach(() => {
+        vi.stubGlobal(
+            'fetch',
+            vi.fn().mockResolvedValue({
+                ok: true,
+                json: vi.fn().mockResolvedValue({
+                    games: [{ id: 'test-game', name: 'Test Game', url: 'http://localhost:8080/game.bundle.js' }],
+                }),
+            }),
+        );
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+
+    it('should start with a loading state', () => {
+        const repo = new GameRepository();
+        expect(repo.games).toBeDefined();
+        expect(repo.games.length).toBeGreaterThan(0);
+        expect(repo.games[0].name).toBe('Loading...');
+        expect(repo.games[0].id).toBe('loading');
+    });
+
+    it('should load games asynchronously', async () => {
+        const repo = new GameRepository();
+        // Wait for the microtask queue to process the fetch
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        expect(repo.games[0].id).toBe('test-game');
+        expect(repo.games[0].name).toBe('Test Game');
+        expect(repo.games[0].url).toBe('http://localhost:8080/game.bundle.js');
+    });
+
+    it('should return a frozen list of games', () => {
+        const repo = new GameRepository();
+        const games = repo.games;
+
+        // This should throw in strict mode, or at least not change if we tried to mutate it
+        expect(Object.isFrozen(games)).toBe(true);
+    });
+});

package/src/menu/GameRepository.ts

@@ -0,0 +1,47 @@
+import { GameEntry } from '../types/interfaces';
+
+export default class GameRepository {
+    private _games: GameEntry[] = [{ id: 'loading', name: 'Loading...', url: '' }];
+
+    constructor() {
+        this.fetchGames();
+    }
+
+    private async fetchGames(): Promise<void> {
+        try {
+            // Read from injected env variables, or fallback to local
+            const supabaseUrl = process.env.SUPABASE_URL || 'http://127.0.0.1:54321';
+            const anonKey = process.env.SUPABASE_ANON_KEY || '';
+
+            const headers: HeadersInit = {};
+            if (anonKey) {
+                headers['Authorization'] = `Bearer ${anonKey}`;
+            }
+
+            const response = await fetch(`${supabaseUrl}/functions/v1/list`, {
+                headers,
+            });
+
+            if (!response.ok) {
+                throw new Error(`Error fetching games: ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (data && data.games && data.games.length > 0) {
+                this._games = data.games.map((game: GameEntry) => ({
+                    id: game.id,
+                    name: game.name,
+                    url: game.url,
+                }));
+            } else {
+                this._games = [{ id: 'empty', name: 'Not found', url: '' }];
+            }
+        } catch (error) {
+            console.error(error);
+            this._games = [{ id: 'error', name: 'Error', url: '' }];
+        }
+    }
+
+    get games(): readonly GameEntry[] {
+        return Object.freeze(this._games);
+    }
+}