brick-engine-js 1.0.1 → 1.0.2

package/src/index.test.ts

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

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

@@ -1,137 +0,0 @@
-/** @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

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

@@ -1,157 +0,0 @@
-/** @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

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

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

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

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

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