squishjs 1.4.0 → 1.4.2

package/.claude/settings.local.json

@@ -2,7 +2,8 @@
   "permissions": {
     "allow": [
       "Read(//Users/josephgarcia/homegames/homegames-client/**)",
-      "Read(//Users/josephgarcia/homegames/homegames-web/**)"
+      "Read(//Users/josephgarcia/homegames/homegames-web/**)",
+      "Read(//Users/josephgarcia/homegames/homegamesio/**)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squishjs",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "squish & unsquish stuff",
   "scripts": {
     "test": "node testRunner.js"

package/src/Squisher.js

@@ -67,30 +67,34 @@ class Squisher {
         let toSquish = [];
 
         const playerMap = {};
+        // Shared (visible-to-everyone) nodes in traversal order, kept so a
+        // player frame created mid-traversal can be seeded with everything
+        // shared that was squished before that player's first scoped node.
+        const sharedNodes = [];
 
         if (this.customBottomLayer) {
             const squishedLayer = [];
-            this.squishHelper(this.customBottomLayer.root, squishedLayer, this.customBottomLayer.scale, playerMap);
+            this.squishHelper(this.customBottomLayer.root, squishedLayer, this.customBottomLayer.scale, playerMap, new Set(), sharedNodes);
             toSquish.push(squishedLayer);
         }
-        
+
         for (const layerIndex in layers) {
             const squishedLayer = [];
             const layerInfo = layers[layerIndex];
-            
+
             const layerScale = layerInfo.scale ? {
                 x: this.scale.x * layerInfo.scale.x,
                 y: this.scale.y * layerInfo.scale.y
             } : this.scale;
 
-            this.squishHelper(layerInfo.root, squishedLayer, scale || layerScale, playerMap);
+            this.squishHelper(layerInfo.root, squishedLayer, scale || layerScale, playerMap, new Set(), sharedNodes);
             toSquish.push(squishedLayer);
         }
 
 
-        if (this.customTopLayer) {            
+        if (this.customTopLayer) {
             const squishedLayer = [];
-            this.squishHelper(this.customTopLayer.root, squishedLayer, this.customTopLayer.scale, playerMap);
+            this.squishHelper(this.customTopLayer.root, squishedLayer, this.customTopLayer.scale, playerMap, new Set(), sharedNodes);
             toSquish.push(squishedLayer);
         }
 
@@ -111,7 +115,19 @@ class Squisher {
         return this.initialize();
     }
 
-    squishHelper(node, squishedNodes, scale = {x: 1, y: 1}, playerMap = {}, playerIdFilter = new Set()) {
+    // Whether an audio node should be withheld from a player who has muted
+    // sound. Non-audio nodes (and unregistered assets) are never withheld.
+    // Applied consistently in both the player-scoped and broadcast paths.
+    _isAudioMutedFor(node, playerId) {
+        if (!node.node.asset) return false;
+        const assetKey = Object.keys(node.node.asset)[0];
+        const assetInfo = this.gameAssets && this.gameAssets[assetKey] && this.gameAssets[assetKey].info;
+        if (!assetInfo || assetInfo.type !== 'audio') return false;
+        const sound = this.playerSettings[playerId] && this.playerSettings[playerId].SOUND;
+        return !!(sound && sound.enabled === false);
+    }
+
+    squishHelper(node, squishedNodes, scale = {x: 1, y: 1}, playerMap = {}, playerIdFilter = new Set(), sharedNodes = []) {
         if (!node.node.listeners.has(this)) {
             node.addListener(this);
         }
@@ -127,11 +143,19 @@ class Squisher {
             let playerIdsToRemove = new Set();
             for (let playerId of playerIdFilter) {
                 if (!playerMap[playerId]) {
-                    playerMap[Number(playerId)] = [];
-                } 
+                    // First scoped node seen for this player. Seed their frame
+                    // with every shared node squished so far — otherwise the
+                    // frame would be missing everything shared (root
+                    // background included) that preceded it in traversal.
+                    playerMap[Number(playerId)] = sharedNodes
+                        .filter(shared => !this._isAudioMutedFor(shared.node, playerId))
+                        .map(shared => shared.squished);
+                }
 
                 if (node.node.playerIds.length === 0 || node.node.playerIds.findIndex(i => Number(i) === Number(playerId)) >= 0) {
-                    playerMap[playerId].push(squished);
+                    if (!this._isAudioMutedFor(node, playerId)) {
+                        playerMap[playerId].push(squished);
+                    }
                 } else {
                     playerIdsToRemove.add(playerId);
                 }
@@ -140,17 +164,9 @@ class Squisher {
                 playerIdFilter.delete(id);
             }
         } else {
+            sharedNodes.push({ node, squished });
             Object.keys(playerMap).forEach(playerId => {
-                if (!playerMap[playerId]) {
-                    playerMap[Number(playerId)] = [];
-                }
-                if (node.node.asset) {
-                    const assetInfo = this.gameAssets[Object.keys(node.node.asset)[0]]?.info;
-                    if (assetInfo.type === 'audio' && this.playerSettings[playerId]?.SOUND && !this.playerSettings[playerId].SOUND.enabled) {
-                    } else {
-                        playerMap[playerId].push(squished);
-                    }
-                } else {
+                if (!this._isAudioMutedFor(node, playerId)) {
                     playerMap[playerId].push(squished);
                 }
             })
@@ -158,10 +174,10 @@ class Squisher {
 
         for (let i = 0; i < node.node.children.length; i++) {
 //            if (node.node.children[i].node.playerIds
-            // make a new set so child calls within a single generation arent 
+            // make a new set so child calls within a single generation arent
             // modifying the same filter set
             const pathFilter = new Set(playerIdFilter);
-            this.squishHelper(node.node.children[i], squishedNodes, scale, playerMap, pathFilter);
+            this.squishHelper(node.node.children[i], squishedNodes, scale, playerMap, pathFilter, sharedNodes);
         }
 
     }

package/src/squishHelpers/coordinates2d.js

@@ -3,6 +3,17 @@ const subtypes = require('../subtypes');
 
 const COORDINATES_2D_SUBTYPE = 52;
 
+// The wire format packs each coordinate's integer part into a single unsigned
+// byte, so any value outside [0, 255] wraps on transport — e.g. a vertex at
+// -1.4 floors to -2, which becomes byte 254 and unsquishes to ~254.6. For a
+// shape with some on-screen vertices that turns the whole polygon into a
+// screen-spanning smear. Coordinates are only meaningful inside the 0–100
+// plane; clamp to the byte-safe range so off-plane geometry pins near the edge
+// instead of exploding. Values 100–255 are preserved so content can still slide
+// off the right/bottom edge cleanly.
+const BYTE_MAX = 255;
+const clampCoord = (v) => (v < 0 ? 0 : (v > BYTE_MAX ? BYTE_MAX : v));
+
 const squishHelper = (scale, coord) => {
 	const scaledCenter = scale * coord;
 	const removedSpaceCenter = Math.round(100 * (1 - scale));
@@ -17,11 +28,11 @@ const squishCoordinates2d = {
 
 		if (node.subType == subtypes.SHAPE_2D_CIRCLE) {
 			if (scale) {
-				const shiftedCenterX = squishHelper(scale.x, originalCoords[0])
+				const shiftedCenterX = clampCoord(squishHelper(scale.x, originalCoords[0]))
 				squished[0] = shiftedCenterX;
 				squished[1] = getFractional(shiftedCenterX);
 
-				const shiftedCenterY = squishHelper(scale.y, originalCoords[1])
+				const shiftedCenterY = clampCoord(squishHelper(scale.y, originalCoords[1]))
 				squished[2] = shiftedCenterY;
 				squished[3] = getFractional(shiftedCenterY);
 
@@ -36,11 +47,11 @@ const squishCoordinates2d = {
 				squished[4] = Math.floor(diagonal);
 				squished[5] = getFractional(diagonal);
 			} else {
-				const centerX = originalCoords[0];
+				const centerX = clampCoord(originalCoords[0]);
 				squished[0] =  Math.floor(centerX);
 				squished[1] = getFractional(centerX);
 
-				const centerY = originalCoords[1];
+				const centerY = clampCoord(originalCoords[1]);
 				squished[2] = Math.floor(centerY);
 				squished[3] = getFractional(centerY);
 
@@ -57,14 +68,15 @@ const squishCoordinates2d = {
 
 					const removedSpace = Math.round(100 * (1 - scaleValue));
 
-					const shifted = scaled + (removedSpace / 2);
+					const shifted = clampCoord(scaled + (removedSpace / 2));
 
 					squished[2 * i] = shifted;
 					squished[(2 * i) + 1] = getFractional(shifted);
 
 				} else {
-					squished[2 * i] = Math.floor(originalCoords[i]);
-					squished[(2 * i) + 1] = Math.round(100 * (originalCoords[i] - Math.floor(originalCoords[i])));
+					const coord = clampCoord(originalCoords[i]);
+					squished[2 * i] = Math.floor(coord);
+					squished[(2 * i) + 1] = Math.round(100 * (coord - Math.floor(coord)));
 				}
 			}
 		}

package/src/util/views.js

@@ -93,7 +93,14 @@ const getView = (plane, view, playerIds, translation = {}, scale = {}) => {
             }
 
             if (shouldInclude) {
-                const copied = node.clone({handleClick: node.node.handleClick === null || node.node.handleClick === undefined ? null : node.node.handleClick});
+                const copied = node.clone({
+                    handleClick: node.node.handleClick === null || node.node.handleClick === undefined ? null : node.node.handleClick,
+                    // Preserve the source node's id so each view-clone keeps a
+                    // stable id across frames. Without this, clone() assigns a
+                    // fresh random id every frame, so the client's hover logic
+                    // sees the node "change" every frame and spams onhover/offhover.
+                    id: node.node.id
+                });
                 
                 if (translatedCoords && translatedCoords.length) {
                     if (copied.node.text) {

package/test/Squisher.test.js

@@ -4,6 +4,9 @@ const Squisher = require('../src/Squisher');
 const { unsquish } = require('../src/squish');
 
 const { FakeGame, verifyArrayEquality, rectNode, textNode, polygonNode, circleNode, lineNode } = require('./utils');
+const { GameNode } = require('../src/GameNode');
+const Shapes = require('../src/Shapes');
+const ShapeUtils = require('../src/util/shapes');
 
 test("squisher listener coalesces state changes", () => {
 
@@ -50,4 +53,93 @@ test("squisher listener coalesces state changes", () => {
     assert(timesInvoked === 1);
 });
 
+test("squisher does not crash on an asset node with an unregistered key", () => {
+    // Reproduces the mid-upload case: a GameNode.Asset referencing a key that
+    // isn't in gameAssets yet. Must not throw while building per-player frames.
+    const root = rectNode({ x: 0, y: 0, width: 100, height: 100 });
+
+    const scoped = new GameNode.Shape({
+        shapeType: Shapes.POLYGON,
+        coordinates2d: ShapeUtils.rectangle(0, 0, 10, 10),
+        fill: COLORS.RED,
+        playerIds: [1]
+    });
+
+    const assetNode = new GameNode.Asset({
+        coordinates2d: ShapeUtils.rectangle(0, 0, 10, 10),
+        assetInfo: { 'unregistered-key': { pos: { x: 2, y: 2 }, size: { x: 5, y: 5 } } }
+    });
+
+    root.addChild(scoped);
+    root.addChild(assetNode);
+
+    const game = new FakeGame([{ root, scale: { x: 1, y: 1 } }]);
+    const squisher = new Squisher({ game });
+
+    squisher.squish(game.getLayers()); // must not throw
+    const frame = squisher.getPlayerFrame(1);
+    // Unregistered asset is treated as non-audio, so it's still delivered.
+    assert(frame && frame.length >= 1);
+});
+
+test("player frame includes shared nodes squished before the player's first scoped node", () => {
+    // The root background and an early shared sibling precede the scoped
+    // node in traversal order. The player's frame must still contain them
+    // (seeded on frame creation), in draw order.
+    const root = rectNode({ x: 0, y: 0, width: 100, height: 100, fill: COLORS.WHITE });
+    const earlyShared = rectNode({ x: 1, y: 1, width: 5, height: 5, fill: COLORS.GREEN });
+    const scoped = new GameNode.Shape({
+        shapeType: Shapes.POLYGON,
+        coordinates2d: ShapeUtils.rectangle(2, 2, 5, 5),
+        fill: COLORS.BLUE,
+        playerIds: [7]
+    });
+    const lateShared = rectNode({ x: 3, y: 3, width: 5, height: 5, fill: COLORS.RED });
+
+    root.addChild(earlyShared);
+    root.addChild(scoped);
+    root.addChild(lateShared);
+
+    const game = new FakeGame([{ root, scale: { x: 1, y: 1 } }]);
+    const squisher = new Squisher({ game });
+
+    const frame = squisher.getPlayerFrame(7);
+    assert(frame.length === 4);
+    const fills = frame.map(squished => unsquish(squished).node.fill);
+    verifyArrayEquality(fills[0], COLORS.WHITE);
+    verifyArrayEquality(fills[1], COLORS.GREEN);
+    verifyArrayEquality(fills[2], COLORS.BLUE);
+    verifyArrayEquality(fills[3], COLORS.RED);
+});
+
+test("squisher withholds muted audio from a player-scoped subtree", () => {
+    const root = new GameNode.Shape({
+        shapeType: Shapes.POLYGON,
+        coordinates2d: ShapeUtils.rectangle(0, 0, 100, 100),
+        fill: COLORS.WHITE,
+        playerIds: [1]
+    });
+
+    const audioNode = new GameNode.Asset({
+        coordinates2d: ShapeUtils.rectangle(0, 0, 10, 10),
+        assetInfo: { 'song': { pos: { x: 0, y: 0 }, size: { x: 1, y: 1 } } }
+    });
+    root.addChild(audioNode);
+
+    const game = new FakeGame([{ root, scale: { x: 1, y: 1 } }]);
+    const squisher = new Squisher({ game });
+    squisher.gameAssets = { song: { info: { type: 'audio' } } };
+
+    // Sound on (default): the audio node reaches player 1.
+    squisher.squish(game.getLayers());
+    const withSound = squisher.getPlayerFrame(1).length;
+
+    // Mute player 1: the audio node is withheld even though it's player-scoped.
+    squisher.updatePlayerSettings(1, { SOUND: { enabled: false } });
+    squisher.squish(game.getLayers());
+    const muted = squisher.getPlayerFrame(1).length;
+
+    assert(muted === withSound - 1);
+});
+