@unboxy/phaser-sdk 0.2.0

package/dist/core/UnboxyGame.d.ts

@@ -0,0 +1,20 @@
+import Phaser from 'phaser';
+export interface UnboxyGameOptions {
+    /** Game width in pixels */
+    width: number;
+    /** Game height in pixels */
+    height: number;
+    /** Phaser scene classes to register */
+    scenes: (new (...args: any[]) => Phaser.Scene)[];
+    /** Background color (default: '#1a1a2e') */
+    backgroundColor?: string;
+    /** Enable pixel art rendering (default: false) */
+    pixelArt?: boolean;
+    /** Custom physics config (default: arcade with no gravity) */
+    physics?: Phaser.Types.Core.PhysicsConfig;
+}
+/**
+ * Create an Unboxy-enhanced Phaser game instance.
+ * Includes built-in integrations: screenshot capture, preserveDrawingBuffer, etc.
+ */
+export declare function createUnboxyGame(options: UnboxyGameOptions): Phaser.Game;

package/dist/core/UnboxyGame.js

@@ -0,0 +1,33 @@
+import Phaser from 'phaser';
+import { setupScreenshotListener } from '../screenshot/ScreenshotManager.js';
+import { setupRecordingListener } from '../recording/RecordingManager.js';
+/**
+ * Create an Unboxy-enhanced Phaser game instance.
+ * Includes built-in integrations: screenshot capture, preserveDrawingBuffer, etc.
+ */
+export function createUnboxyGame(options) {
+    const config = {
+        type: Phaser.AUTO,
+        backgroundColor: options.backgroundColor ?? '#1a1a2e',
+        scale: {
+            mode: Phaser.Scale.FIT,
+            autoCenter: Phaser.Scale.CENTER_BOTH,
+            width: options.width,
+            height: options.height,
+        },
+        render: {
+            preserveDrawingBuffer: true,
+        },
+        pixelArt: options.pixelArt ?? false,
+        physics: options.physics ?? {
+            default: 'arcade',
+            arcade: { gravity: { x: 0, y: 0 }, debug: false },
+        },
+        scene: options.scenes,
+    };
+    const game = new Phaser.Game(config);
+    // Built-in integrations
+    setupScreenshotListener(game);
+    setupRecordingListener(game);
+    return game;
+}

package/dist/core/UnboxyScene.d.ts

@@ -0,0 +1,19 @@
+import Phaser from 'phaser';
+/**
+ * Base scene class with common Unboxy utilities.
+ * Extend this instead of Phaser.Scene for built-in helpers.
+ */
+export declare class UnboxyScene extends Phaser.Scene {
+    /**
+     * Create a simple text button with hover effects.
+     */
+    protected createButton(x: number, y: number, text: string, style?: Phaser.Types.GameObjects.Text.TextStyle, onClick?: () => void): Phaser.GameObjects.Text;
+    /**
+     * Shake the camera briefly (e.g., on damage).
+     */
+    protected shakeCamera(duration?: number, intensity?: number): void;
+    /**
+     * Flash the camera briefly (e.g., on hit).
+     */
+    protected flashCamera(duration?: number, r?: number, g?: number, b?: number): void;
+}

package/dist/core/UnboxyScene.js

@@ -0,0 +1,38 @@
+import Phaser from 'phaser';
+/**
+ * Base scene class with common Unboxy utilities.
+ * Extend this instead of Phaser.Scene for built-in helpers.
+ */
+export class UnboxyScene extends Phaser.Scene {
+    /**
+     * Create a simple text button with hover effects.
+     */
+    createButton(x, y, text, style, onClick) {
+        const btn = this.add.text(x, y, text, {
+            fontSize: '20px',
+            color: '#ffffff',
+            backgroundColor: '#4662D8',
+            padding: { x: 16, y: 8 },
+            ...style,
+        })
+            .setOrigin(0.5)
+            .setInteractive({ useHandCursor: true });
+        btn.on('pointerover', () => btn.setAlpha(0.8));
+        btn.on('pointerout', () => btn.setAlpha(1));
+        if (onClick)
+            btn.on('pointerdown', onClick);
+        return btn;
+    }
+    /**
+     * Shake the camera briefly (e.g., on damage).
+     */
+    shakeCamera(duration = 100, intensity = 0.01) {
+        this.cameras.main.shake(duration, intensity);
+    }
+    /**
+     * Flash the camera briefly (e.g., on hit).
+     */
+    flashCamera(duration = 100, r = 255, g = 255, b = 255) {
+        this.cameras.main.flash(duration, r, g, b);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createUnboxyGame } from './core/UnboxyGame.js';
+export type { UnboxyGameOptions } from './core/UnboxyGame.js';
+export { UnboxyScene } from './core/UnboxyScene.js';
+export { setupScreenshotListener, takeScreenshot } from './screenshot/ScreenshotManager.js';
+export { setupRecordingListener } from './recording/RecordingManager.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+// Core
+export { createUnboxyGame } from './core/UnboxyGame.js';
+export { UnboxyScene } from './core/UnboxyScene.js';
+// Screenshot
+export { setupScreenshotListener, takeScreenshot } from './screenshot/ScreenshotManager.js';
+// Recording
+export { setupRecordingListener } from './recording/RecordingManager.js';

package/dist/recording/RecordingManager.d.ts

@@ -0,0 +1,11 @@
+import Phaser from 'phaser';
+/**
+ * Sets up postMessage listeners for video recording of the game canvas.
+ *
+ * Parent sends: 'startRecording'
+ * Game responds: { type: 'recordingStarted' }
+ *
+ * Parent sends: 'stopRecording'
+ * Game responds: { type: 'recordingComplete', data: string (base64 data URL), mimeType: string }
+ */
+export declare function setupRecordingListener(game: Phaser.Game): void;

package/dist/recording/RecordingManager.js

@@ -0,0 +1,59 @@
+let mediaRecorder = null;
+let recordedChunks = [];
+/**
+ * Sets up postMessage listeners for video recording of the game canvas.
+ *
+ * Parent sends: 'startRecording'
+ * Game responds: { type: 'recordingStarted' }
+ *
+ * Parent sends: 'stopRecording'
+ * Game responds: { type: 'recordingComplete', data: string (base64 data URL), mimeType: string }
+ */
+export function setupRecordingListener(game) {
+    window.addEventListener('message', (event) => {
+        if (event.data === 'startRecording') {
+            try {
+                const canvas = game.canvas;
+                if (!canvas)
+                    return;
+                recordedChunks = [];
+                const stream = canvas.captureStream(30);
+                // Pick best available codec
+                const mimeType = MediaRecorder.isTypeSupported('video/webm;codecs=vp9')
+                    ? 'video/webm;codecs=vp9'
+                    : 'video/webm';
+                mediaRecorder = new MediaRecorder(stream, {
+                    mimeType,
+                    videoBitsPerSecond: 1500000, // 1.5 Mbps
+                });
+                mediaRecorder.ondataavailable = (e) => {
+                    if (e.data.size > 0)
+                        recordedChunks.push(e.data);
+                };
+                mediaRecorder.onstop = () => {
+                    const blob = new Blob(recordedChunks, { type: 'video/webm' });
+                    const reader = new FileReader();
+                    reader.onloadend = () => {
+                        window.parent.postMessage({
+                            type: 'recordingComplete',
+                            data: reader.result,
+                            mimeType: 'video/webm',
+                        }, '*');
+                    };
+                    reader.readAsDataURL(blob);
+                };
+                mediaRecorder.start(1000); // collect data every 1 second
+                window.parent.postMessage({ type: 'recordingStarted' }, '*');
+            }
+            catch (e) {
+                console.error('[UnboxySDK] Recording failed to start:', e);
+                window.parent.postMessage({ type: 'recordingError', error: String(e) }, '*');
+            }
+        }
+        if (event.data === 'stopRecording') {
+            if (mediaRecorder && mediaRecorder.state !== 'inactive') {
+                mediaRecorder.stop();
+            }
+        }
+    });
+}

package/dist/screenshot/ScreenshotManager.d.ts

@@ -0,0 +1,14 @@
+import Phaser from 'phaser';
+/**
+ * Sets up a postMessage listener that captures the game canvas
+ * when the parent window requests a screenshot.
+ *
+ * Parent sends: { type: 'screenshot' }
+ * Game responds: { type: 'screenshot_result', dataUrl: string }
+ */
+export declare function setupScreenshotListener(game: Phaser.Game): void;
+/**
+ * Take a screenshot programmatically (e.g., from within a scene).
+ * Returns a base64 data URL of the current canvas.
+ */
+export declare function takeScreenshot(game: Phaser.Game): string | null;

package/dist/screenshot/ScreenshotManager.js

@@ -0,0 +1,33 @@
+/**
+ * Sets up a postMessage listener that captures the game canvas
+ * when the parent window requests a screenshot.
+ *
+ * Parent sends: { type: 'screenshot' }
+ * Game responds: { type: 'screenshot_result', dataUrl: string }
+ */
+export function setupScreenshotListener(game) {
+    window.addEventListener('message', (event) => {
+        if (event.data?.type === 'screenshot') {
+            try {
+                const dataUrl = game.canvas.toDataURL('image/png');
+                window.parent.postMessage({ type: 'screenshot_result', dataUrl }, '*');
+            }
+            catch (e) {
+                console.error('[UnboxySDK] Screenshot failed:', e);
+            }
+        }
+    });
+}
+/**
+ * Take a screenshot programmatically (e.g., from within a scene).
+ * Returns a base64 data URL of the current canvas.
+ */
+export function takeScreenshot(game) {
+    try {
+        return game.canvas.toDataURL('image/png');
+    }
+    catch (e) {
+        console.error('[UnboxySDK] Screenshot failed:', e);
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@unboxy/phaser-sdk",
+  "version": "0.2.0",
+  "description": "Unboxy Phaser 3 SDK — game infrastructure for the Unboxy platform",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "phaser": "^3.60.0"
+  },
+  "devDependencies": {
+    "phaser": "^3.80.0",
+    "typescript": "^5.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "UNLICENSED",
+  "private": false
+}