@umicat/phaser-sdk 1.0.13 → 1.0.15

package/dist/scene/SceneLoader.js

@@ -109,6 +109,20 @@ export function preloadSceneAssets(scene, sceneFile, manifest) {
         queueAssetLoad(scene, asset);
         state.requestedAssetIds.add(id);
     }
+    // Audio assets are GLOBAL — BGM / SFX are played from code (`sound.play(key)`),
+    // not attached to a scene entity — so the entity walk above never collects
+    // them and they'd never load. Eagerly load every audio asset in the manifest
+    // so `cache.audio.has(key)` is true and the game can play it with no manual
+    // BootScene preload. (Without this, registering BGM in the manifest silently
+    // produced no sound — the asset existed but was never queued.)
+    for (const asset of manifest.assets ?? []) {
+        if (asset.kind !== 'audio')
+            continue;
+        if (state.requestedAssetIds.has(asset.id))
+            continue;
+        queueAssetLoad(scene, asset);
+        state.requestedAssetIds.add(asset.id);
+    }
 }
 function collectAssetIds(entities, manifest, resolveTilemapFile) {
     const ids = new Set();
@@ -345,10 +359,15 @@ function queueAssetLoad(scene, asset) {
             }
             return;
         case 'audio':
-            scene.load.audio(asset.textureKey, asset.path);
+            // Fall back to `id` when `textureKey` is absent. Audio (and json) entries
+            // are naturally written as `{ id, path, kind:'audio' }` — "textureKey" is
+            // a misnomer for a sound — so an agent/human routinely omits it. Without
+            // the fallback the clip loads under key `undefined` and `sound.play(id)`
+            // silently no-ops (the "generated BGM never plays" bug).
+            scene.load.audio(asset.textureKey || asset.id, asset.path);
             return;
         case 'json':
-            scene.load.json(asset.textureKey, asset.path);
+            scene.load.json(asset.textureKey || asset.id, asset.path);
             return;
         default: {
             const exhaustive = asset.kind;

package/dist/screenshot/ScreenshotManager.js

@@ -16,8 +16,52 @@ export function setupScreenshotListener(game) {
                 console.error('[UmicatSDK] Screenshot failed:', e);
             }
         }
+        else if (event.data?.type === 'screenshotRegion') {
+            // Marquee-to-chat: the host drew a selection rect over the iframe (in
+            // iframe-relative CSS px); crop the canvas to it here, where the canvas's
+            // on-screen position + intrinsic resolution are known (handles letterbox
+            // bars + display scaling). Responds with the cropped PNG.
+            try {
+                const r = event.data.rect;
+                const dataUrl = cropCanvasRegion(game, r);
+                window.parent.postMessage({ type: 'screenshot_region_result', dataUrl, requestId: event.data.requestId }, '*');
+            }
+            catch (e) {
+                console.error('[UmicatSDK] Region screenshot failed:', e);
+                window.parent.postMessage({ type: 'screenshot_region_result', dataUrl: null, requestId: event.data?.requestId }, '*');
+            }
+        }
     });
 }
+/**
+ * Crop the game canvas to a rect given in iframe-relative CSS pixels (the host's
+ * marquee). Maps display px → intrinsic canvas px via the canvas's bounding rect
+ * + resolution (uniform scale — Phaser FIT preserves aspect), clamps to bounds.
+ */
+function cropCanvasRegion(game, rect) {
+    const canvas = game.canvas;
+    const cr = canvas.getBoundingClientRect();
+    if (cr.width <= 0 || cr.height <= 0)
+        return null;
+    const scale = canvas.width / cr.width; // intrinsic px per displayed px
+    let sx = Math.round((rect.x - cr.x) * scale);
+    let sy = Math.round((rect.y - cr.y) * scale);
+    let sw = Math.round(rect.width * scale);
+    let sh = Math.round(rect.height * scale);
+    // Clamp to the canvas (the marquee can run past the letterboxed edges).
+    sx = Math.max(0, Math.min(sx, canvas.width - 1));
+    sy = Math.max(0, Math.min(sy, canvas.height - 1));
+    sw = Math.max(1, Math.min(sw, canvas.width - sx));
+    sh = Math.max(1, Math.min(sh, canvas.height - sy));
+    const out = document.createElement('canvas');
+    out.width = sw;
+    out.height = sh;
+    const ctx = out.getContext('2d');
+    if (!ctx)
+        return null;
+    ctx.drawImage(canvas, sx, sy, sw, sh, 0, 0, sw, sh);
+    return out.toDataURL('image/png');
+}
 /**
  * Take a screenshot programmatically (e.g., from within a scene).
  * Returns a base64 data URL of the current canvas.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umicat/phaser-sdk",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Umicat Phaser 3 SDK — game infrastructure for the Umicat platform",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",