squishjs 1.4.1 → 1.4.3

package/package.json

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

package/src/Asset.js

@@ -165,23 +165,34 @@ class Asset {
             const fileHash = this.getHash(assetId);
             const filePath = `${assetPath}/${fileHash}`;
 
-            const writeStream = fs.createWriteStream(filePath);
             const getModule = ASSET_URL.startsWith('https') ? https : http;
 
-            writeStream.on('close', () => {
-                resolve(filePath);
-            });
-
             getModule.get(`${ASSET_URL}/${assetId}`, (res) => {
                 if (res.statusCode !== 200) {
+                    res.resume();
                     reject('Bad response when downloading asset');
-                } else {
-                    writeStream.on('finish', () => {
-                        writeStream.close();
-                    });
-
-                    res.pipe(writeStream);
+                    return;
                 }
+
+                // Only open the cache file once we know the response is good —
+                // otherwise a failed download leaves a zero-byte file behind
+                // that reads back as a valid cache hit forever after.
+                const writeStream = fs.createWriteStream(filePath);
+
+                writeStream.on('close', () => {
+                    resolve(filePath);
+                });
+
+                writeStream.on('error', (error) => {
+                    fs.unlink(filePath, () => reject(error));
+                });
+
+                res.on('error', (error) => {
+                    writeStream.destroy();
+                    fs.unlink(filePath, () => reject(error));
+                });
+
+                res.pipe(writeStream);
             }).on('error', error => {
                 console.error('Failed to download asset');
                 console.error(error);

package/src/Squisher.js

@@ -35,7 +35,9 @@ class Squisher {
 
         if (this.game.tick) {
             const tickRate = this.gameMetadata && this.gameMetadata.tickRate ? this.gameMetadata.tickRate : DEFAULT_TICK_RATE;
-            setInterval(this.game.tick.bind(this.game), 1000 / tickRate);
+            // Keep the handle so consumers can end the tick loop (repeated
+            // session create/destroy in one process leaks it otherwise).
+            this._tickInterval = setInterval(this.game.tick.bind(this.game), 1000 / tickRate);
         }
     }
 
@@ -67,30 +69,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);
         }
 
@@ -123,7 +129,7 @@ class Squisher {
         return !!(sound && sound.enabled === false);
     }
 
-    squishHelper(node, squishedNodes, scale = {x: 1, y: 1}, playerMap = {}, playerIdFilter = new Set()) {
+    squishHelper(node, squishedNodes, scale = {x: 1, y: 1}, playerMap = {}, playerIdFilter = new Set(), sharedNodes = []) {
         if (!node.node.listeners.has(this)) {
             node.addListener(this);
         }
@@ -139,7 +145,13 @@ 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) {
@@ -154,10 +166,8 @@ class Squisher {
                 playerIdFilter.delete(id);
             }
         } else {
+            sharedNodes.push({ node, squished });
             Object.keys(playerMap).forEach(playerId => {
-                if (!playerMap[playerId]) {
-                    playerMap[Number(playerId)] = [];
-                }
                 if (!this._isAudioMutedFor(node, playerId)) {
                     playerMap[playerId].push(squished);
                 }
@@ -166,10 +176,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

@@ -28,12 +28,16 @@ const squishCoordinates2d = {
 
 		if (node.subType == subtypes.SHAPE_2D_CIRCLE) {
 			if (scale) {
+				// Math.floor on the integer byte is required, not decorative:
+				// a raw float here only decoded correctly because Node's
+				// Buffer truncated it on send. Consumers that don't go through
+				// Buffer (e.g. the in-browser LocalSession) would round.
 				const shiftedCenterX = clampCoord(squishHelper(scale.x, originalCoords[0]))
-				squished[0] = shiftedCenterX;
+				squished[0] = Math.floor(shiftedCenterX);
 				squished[1] = getFractional(shiftedCenterX);
 
 				const shiftedCenterY = clampCoord(squishHelper(scale.y, originalCoords[1]))
-				squished[2] = shiftedCenterY;
+				squished[2] = Math.floor(shiftedCenterY);
 				squished[3] = getFractional(shiftedCenterY);
 
 				let diagonal;
@@ -70,7 +74,7 @@ const squishCoordinates2d = {
 
 					const shifted = clampCoord(scaled + (removedSpace / 2));
 
-					squished[2 * i] = shifted;
+					squished[2 * i] = Math.floor(shifted);
 					squished[(2 * i) + 1] = getFractional(shifted);
 
 				} else {

package/test/Squisher.test.js

@@ -82,6 +82,36 @@ test("squisher does not crash on an asset node with an unregistered key", () =>
     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,