@unboxy/phaser-sdk 0.2.22 → 0.2.24

package/dist/editor/EditorBridge.js

@@ -2,6 +2,7 @@ import Phaser from 'phaser';
 import { getEntityRegistry } from '../scene/EntityRegistry.js';
 import { parseColor, spawnEntity } from '../scene/spawnEntity.js';
 import { resolveRenderScript } from '../scene/renderScripts.js';
+import { getManifest } from '../scene/SceneLoader.js';
 import { EditorOverlayScene, EDITOR_OVERLAY_KEY } from './EditorOverlayScene.js';
 import { getEditorState, setEditorActive, setSelection, } from './EditorState.js';
 /**
@@ -209,15 +210,15 @@ function hitTest(game, worldX, worldY) {
     let topmost = null;
     let topmostDepth = -Infinity;
     for (const go of registry.all()) {
-        const withBounds = go;
-        if (typeof withBounds.getBounds !== 'function')
+        const r = entityHitRect(go);
+        if (!r)
             continue;
-        const r = withBounds.getBounds();
         if (worldX < r.x || worldX > r.x + r.width)
             continue;
         if (worldY < r.y || worldY > r.y + r.height)
             continue;
-        const depth = typeof withBounds.depth === 'number' ? withBounds.depth : 0;
+        const withDepth = go;
+        const depth = typeof withDepth.depth === 'number' ? withDepth.depth : 0;
         if (depth >= topmostDepth) {
             topmostDepth = depth;
             topmost = go;
@@ -225,6 +226,37 @@ function hitTest(game, worldX, worldY) {
     }
     return topmost;
 }
+/**
+ * Compute a hit-test rectangle for a spawned entity in world coords.
+ *
+ * 1. If the entity has `editorHitWidth` / `editorHitHeight` set in data
+ *    (code-rendered entities — Graphics has no intrinsic bounds), use
+ *    those centered on the entity's x/y.
+ * 2. Otherwise fall back to Phaser's `getBounds()` (works for Sprite,
+ *    Rectangle, Arc, Container — anything with a Size component).
+ *
+ * Returns null if neither path yields a usable rect.
+ */
+function entityHitRect(go) {
+    const hitW = go.getData('editorHitWidth');
+    const hitH = go.getData('editorHitHeight');
+    if (typeof hitW === 'number' && typeof hitH === 'number') {
+        const positioned = go;
+        return {
+            x: positioned.x - hitW / 2,
+            y: positioned.y - hitH / 2,
+            width: hitW,
+            height: hitH,
+        };
+    }
+    const withBounds = go;
+    if (typeof withBounds.getBounds !== 'function')
+        return null;
+    const r = withBounds.getBounds();
+    if (r.width === 0 && r.height === 0)
+        return null;
+    return { x: r.x, y: r.y, width: r.width, height: r.height };
+}
 function findRegistry(game) {
     for (const scene of game.scene.getScenes(false)) {
         const reg = getEntityRegistry(scene);
@@ -353,23 +385,49 @@ async function createEntity(game, entity, manifestAsset) {
         console.warn('[unboxy/editor] createEntity: world scene has no entity registry');
         return;
     }
+    // Resolve which AssetRecord to use for the lazy-load probe. Three paths:
+    //   1. Host passed `manifestAsset` (asset is brand-new) — use that.
+    //   2. Already in manifest but not provided (re-drag of existing asset)
+    //      — look it up via the cached manifest.
+    //   3. Non-sprite entity (no asset needed) — leave undefined.
+    let assetForLoad = manifestAsset;
+    if (!assetForLoad && entity.kind === 'sprite') {
+        const visual = entity.visual;
+        const assetId = visual?.assetId;
+        if (assetId) {
+            try {
+                const manifest = getManifest(scene);
+                assetForLoad = manifest.assets.find((a) => a.id === assetId);
+            }
+            catch {
+                /* manifest not in cache — should not happen in edit mode */
+            }
+        }
+    }
     // Lazy-load texture if needed (sprite + asset not yet in cache).
-    if (manifestAsset &&
+    if (assetForLoad &&
         entity.kind === 'sprite' &&
-        !scene.textures.exists(manifestAsset.textureKey)) {
-        await loadAssetIntoScene(scene, manifestAsset);
+        !scene.textures.exists(assetForLoad.textureKey)) {
+        await loadAssetIntoScene(scene, assetForLoad);
     }
     const ctx = {
         scene,
         registry,
         resolveAsset: (id) => {
-            // For ad-hoc creation we may not have full manifest access. Rely on
-            // the host to have stamped the right textureKey/path into the asset
-            // we received via manifestAsset; fallback to a synthetic record so
-            // spawnEntity can still find a textureKey.
             if (manifestAsset && manifestAsset.id === id)
                 return manifestAsset;
-            throw new Error(`[unboxy/editor] createEntity: asset '${id}' not in manifest payload — host must include manifestAsset`);
+            // Fallback: look up in the manifest cache. Covers re-drag of an
+            // already-in-manifest asset where the host omitted manifestAsset.
+            try {
+                const manifest = getManifest(scene);
+                const found = manifest.assets.find((a) => a.id === id);
+                if (found)
+                    return found;
+            }
+            catch {
+                /* fall through to throw */
+            }
+            throw new Error(`[unboxy/editor] createEntity: asset '${id}' not found in manifest`);
         },
         resolveRenderScript: undefined,
     };

package/dist/editor/EditorOverlayScene.js

@@ -190,10 +190,24 @@ export class EditorOverlayScene extends Phaser.Scene {
     }
 }
 function computeBounds(go) {
-    // Most game objects implement getBounds; Container does too.
+    // Code-rendered entities stash hit dimensions on data because Phaser
+    // Graphics has no intrinsic bounds. Use those when present.
+    const hitW = go.getData('editorHitWidth');
+    const hitH = go.getData('editorHitHeight');
+    if (typeof hitW === 'number' && typeof hitH === 'number') {
+        const positioned = go;
+        return {
+            x: positioned.x - hitW / 2,
+            y: positioned.y - hitH / 2,
+            width: hitW,
+            height: hitH,
+        };
+    }
     const withBounds = go;
     if (typeof withBounds.getBounds !== 'function')
         return null;
     const r = withBounds.getBounds();
+    if (r.width === 0 && r.height === 0)
+        return null;
     return { x: r.x, y: r.y, width: r.width, height: r.height };
 }

package/dist/scene/spawnEntity.js

@@ -94,6 +94,8 @@ function createGroup(ctx, entity) {
     return container;
 }
 function createCodeRendered(ctx, entity) {
+    const w = entity.visual.width ?? 64;
+    const h = entity.visual.height ?? 64;
     const render = ctx.resolveRenderScript?.(entity.visual.script);
     if (!render) {
         // Slice 3.5: render scripts have a registry now, but a missing entry
@@ -102,21 +104,35 @@ function createCodeRendered(ctx, entity) {
         // the user sees the entity exists but the visual is unresolved.
         const ph = ctx.scene.add.graphics();
         ph.fillStyle(0x666666, 0.4);
-        ph.fillRect(-16, -16, 32, 32);
+        ph.fillRect(-w / 2, -h / 2, w, h);
         ph.lineStyle(2, 0xff8800, 0.9);
-        ph.strokeRect(-16, -16, 32, 32);
-        // Annotate so editor / debug overlays can identify.
+        ph.strokeRect(-w / 2, -h / 2, w, h);
+        sizeForHitTest(ph, w, h);
         ph.setData('renderScriptMissing', entity.visual.script);
         return ph;
     }
     const g = ctx.scene.add.graphics();
     const params = entity.visual.params ?? {};
     render(g, params);
+    sizeForHitTest(g, w, h);
     // Stash data needed for live re-render from EditorBridge.applyEdit.
     g.setData('renderScriptPath', entity.visual.script);
     g.setData('renderScriptParams', params);
     return g;
 }
+/**
+ * Phaser Graphics doesn't track its drawn area — `getBounds()` returns
+ * a 0×0 rect because the Graphics class doesn't include the Size/Origin
+ * mixins. Rather than fight Phaser's class hierarchy with method casts,
+ * stash the editor hit area on the GameObject's data manager. The editor
+ * overlay reads these before falling back to `getBounds()`. The implicit
+ * convention: hit area is centered on the GameObject's x/y, matching how
+ * render scripts conventionally draw around (0, 0).
+ */
+function sizeForHitTest(g, width, height) {
+    g.setData('editorHitWidth', width);
+    g.setData('editorHitHeight', height);
+}
 function applyTransform(go, t) {
     // Most game objects implement Transform; Container does too. Cast through
     // a permissive shape so this works for sprite/rect/circle/container alike.

package/dist/scene/types.d.ts

@@ -116,6 +116,14 @@ export interface CodeRenderedVisual {
     /** Path to render script, e.g. `"src/visuals/boss-renderer.ts"`. */
     script: string;
     params?: Record<string, unknown>;
+    /**
+     * Optional bounds used for editor hit-testing (click + drag) and the
+     * selection rectangle. Phaser Graphics has no intrinsic size, so we set
+     * it explicitly. Defaults to 64×64 centered on the entity. The agent can
+     * override per-entity when the script draws something larger or smaller.
+     */
+    width?: number;
+    height?: number;
 }
 export type WorldVisual = SpriteVisual | PrimitiveVisual | CodeRenderedVisual;
 export type WorldEntityKind = 'sprite' | 'primitive' | 'code-rendered' | 'group' | 'tilemap' | 'trigger';

package/package.json

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