squishjs 1.3.6 → 1.3.8

package/package.json

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

package/src/Asset.js

@@ -1,4 +1,8 @@
 const path = require('path');
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const crypto = require('crypto');
 const { getAppDataPath } = require('./utils');
 
 // assets is the old stuff, save it for backward compatibility
@@ -20,14 +24,6 @@ class Asset {
         if (data) {
             this.data = data;
         }
-
-        // this is dumb. was trying something but made it dumb.
-        this.https = require('https');
-        this.http = require('http');
-        this.fs = require('fs');
-        this.crypto = require('crypto');
-        this.path = require('path');
-        this.process = require('process');
     }
 
     getConfigValue(key, _default = undefined) {
@@ -62,9 +58,9 @@ class Asset {
         let _config = {};
         
         for (let i = 0; i < options.length; i++) {
-            if (this.fs.existsSync(`${options[i]}/config.json`)) {
+            if (fs.existsSync(`${options[i]}/config.json`)) {
                 console.log(`Using config at ${options[i]}`);
-                _config = JSON.parse(this.fs.readFileSync(`${options[i]}/config.json`));
+                _config = JSON.parse(fs.readFileSync(`${options[i]}/config.json`));
                 break;
             }
         }
@@ -76,7 +72,7 @@ class Asset {
 
 
     getHash(str) {
-        const shasum = this.crypto.createHash('sha1');
+        const shasum = crypto.createHash('sha1');
         shasum.update(str);
         return shasum.digest('hex');
     };
@@ -95,10 +91,10 @@ class Asset {
     existsLocally() {
         return new Promise((resolve, reject) => {
             if (this.data) {
-                resolve(true);
+                return resolve(true);
             }
             const fileLocation = this.getFileLocation(this.info.id);
-            this.fs.exists(fileLocation, (exists) => {
+            fs.exists(fileLocation, (exists) => {
                 resolve(exists && fileLocation);
             });
         });
@@ -118,14 +114,14 @@ class Asset {
         } else {
             const fileLocation2 = await downloadFileSync(this.info.id, HG_ASSET_PATH);
             this.initialized = true;
-            return fileLocation;
+            return fileLocation2;
         }
     }
     
     download(force) {
         const HG_ASSET_PATH = path.join(getAppDataPath(), 'asset-cache');
-        if (!this.fs.existsSync(HG_ASSET_PATH)) {
-            this.fs.mkdirSync(HG_ASSET_PATH);
+        if (!fs.existsSync(HG_ASSET_PATH)) {
+            fs.mkdirSync(HG_ASSET_PATH);
         }
         return new Promise((resolve, reject) => {
             this.existsLocally().then(fileLocation => {
@@ -150,7 +146,7 @@ class Asset {
                 resolve(this.data);
             } else {
                 this.download().then(fileLocation => {
-                    this.fs.readFile(fileLocation, (err, buf) => {
+                    fs.readFile(fileLocation, (err, buf) => {
                         if (err) {
                             reject(err);
                         } else {
@@ -164,13 +160,13 @@ class Asset {
         }); 
     }
     
-    doDownload(assetId, path) {
+    doDownload(assetId, assetPath) {
         return new Promise((resolve, reject) => {
             const fileHash = this.getHash(assetId);
-            const filePath = `${path}/${fileHash}`;
+            const filePath = `${assetPath}/${fileHash}`;
 
-            const writeStream = this.fs.createWriteStream(filePath);
-            const getModule = this.https;
+            const writeStream = fs.createWriteStream(filePath);
+            const getModule = ASSET_URL.startsWith('https') ? https : http;
 
             writeStream.on('close', () => {
                 resolve(filePath);

package/src/BaseNode.js

@@ -104,7 +104,7 @@ class BaseNode {
                 this.node.fill = params.fill;
             }
             if (params.coordinates2d) {
-                this.node.coordinates2d = coordinates2d;
+                this.node.coordinates2d = params.coordinates2d;
             }
         }
         this.node.onStateChange();

package/src/Game.js

@@ -11,7 +11,7 @@ class Game {
     }
 
     removeStateListener(listener) {
-        this.listeners.remove(listener);
+        this.listeners.delete(listener);
     }
 
     findNode(id) {

package/src/Squisher.js

@@ -11,7 +11,7 @@ class Squisher {
 
         this.game = game;
         this.gameMetadata = game.constructor.metadata && game.constructor.metadata();
-        this.assets = {};
+        this._assetBufferCache = {};
         this.playerSettings = {};
 
         this.customBottomLayer = customBottomLayer;
@@ -42,7 +42,7 @@ class Squisher {
     }
 
     removeListener(listener) {
-        this.listeners.remove(listener);
+        this.listeners.delete(listener);
     }
 
     unsquish(node) {
@@ -97,9 +97,11 @@ class Squisher {
     }
 
     handleNewAsset(key, asset) {
-        return new Promise((resolve, reject) => {
-            this.initialize().then(resolve);
-        });
+        // Invalidate just this key so initialize() re-fetches only its data
+        if (this._assetBufferCache) {
+            delete this._assetBufferCache[key];
+        }
+        return this.initialize();
     }
 
     squishHelper(node, squishedNodes, scale = {x: 1, y: 1}, playerMap = {}, playerIdFilter = new Set()) {
@@ -171,9 +173,6 @@ class Squisher {
 
     initialize() {
         return new Promise((resolve, reject) => {
-            
-
-                const assets = Object.assign({}, this.assets || {});
 
                 const gameMetadata = this.game.constructor.metadata && this.game.constructor.metadata();
 
@@ -192,64 +191,89 @@ class Squisher {
                     Object.assign(gameAssets, this.game.getAssets());
                 }
 
-                const allAssets = Object.assign(assets, gameAssets);
+                const assetTypeMap = {
+                    'image': 1,
+                    'audio': 2,
+                    'font': 3
+                };
+
+                const assetKeys = Object.keys(gameAssets);
+                const totalCount = assetKeys.length;
+
+                if (totalCount === 0) {
+                    this.assetBundle = Buffer.alloc(0);
+                    resolve(this.assetBundle);
+                    return;
+                }
+
+                if (!this._assetBufferCache) {
+                    this._assetBufferCache = {};
+                }
 
-                let assetBundleSize = 0;
                 let finishedCount = 0;
-                const totalCount = Object.keys(allAssets).length;
-    
-                for (const key in allAssets) {
-                    allAssets[key].getData().then(buf => {
-                        const assetKeyLength = 32;
-                        let keyIndex = 0;
-                        const assetKeyArray = new Array(32);
-                        while (keyIndex < assetKeyLength && keyIndex < key.length) {
-                            assetKeyArray[keyIndex] = key.charCodeAt(keyIndex);
-                            keyIndex++;
+                const perAssetBuffers = new Array(totalCount);
+
+                for (let idx = 0; idx < totalCount; idx++) {
+                    const key = assetKeys[idx];
+
+                    // If we already have a packed buffer for this key, reuse it
+                    if (this._assetBufferCache[key]) {
+                        perAssetBuffers[idx] = this._assetBufferCache[key];
+                        finishedCount += 1;
+                        if (finishedCount === totalCount) {
+                            this.assetBundle = Buffer.concat(perAssetBuffers);
+                            resolve(this.assetBundle);
                         }
-    
-                        const encodedLength = (buf.length + assetKeyLength).toString(36);
-                        
-                        const assetTypeMap = {
-                            'image': 1,
-                            'audio': 2,
-                            'font': 3
-                        };
-   
-                        const assetType = assetTypeMap[allAssets[key].info.type];
-    
+                        continue;
+                    }
+
+                    gameAssets[key].getData().then(buf => {
+                        const assetKeyLength = 32;
                         const encodedMaxLength = 10;
-                        let encodedLengthString = '';
-                        for (let i = 0; i < (encodedMaxLength - encodedLength.length); i++) {
-                            encodedLengthString += '0';
+
+                        const headerLength = 2 + encodedMaxLength + assetKeyLength;
+                        const assetBuf = Buffer.alloc(headerLength + buf.length);
+
+                        assetBuf[0] = ASSET_TYPE;
+                        assetBuf[1] = assetTypeMap[gameAssets[key].info.type];
+
+                        // Encode the length (data + key length) as base-36, left-padded
+                        const encodedLength = (buf.length + assetKeyLength).toString(36);
+                        const padLen = encodedMaxLength - encodedLength.length;
+                        for (let i = 0; i < padLen; i++) {
+                            assetBuf[2 + i] = 48; // '0' charCode
                         }
-                        for (let j = encodedLength.length; j < encodedMaxLength; j++) {
-                            encodedLengthString +=  encodedLength.charAt(j - encodedLength.length);
+                        for (let i = 0; i < encodedLength.length; i++) {
+                            assetBuf[2 + padLen + i] = encodedLength.charCodeAt(i);
                         }
-                        const encodedLengthArray = new Array(encodedMaxLength);
-                        for (let i = 0; i < encodedMaxLength; i++) {
-                            encodedLengthArray[i] = encodedLength.charCodeAt(i);
+
+                        // Write asset key (up to 32 chars, rest stays 0)
+                        const keyWriteLen = Math.min(assetKeyLength, key.length);
+                        for (let i = 0; i < keyWriteLen; i++) {
+                            assetBuf[2 + encodedMaxLength + i] = key.charCodeAt(i);
                         }
-    
-                        this.assets[key] = [ASSET_TYPE, assetType, ...encodedLengthArray, ...assetKeyArray, ...buf];
-                        assetBundleSize += this.assets[key].length;
-                        finishedCount += 1;
 
-                        if (finishedCount == totalCount) {
-                            const newAssetBundle = new Array(assetBundleSize);
-                            for (let index = 0; index < assetBundleSize; index++) {
-                                for (const key in this.assets) {
-                                    for (let y = 0; y < this.assets[key].length; y++) {
-                                        newAssetBundle[index++] = this.assets[key][y];
-                                    }
-                                }
+                        // Copy the raw asset data
+                        if (Buffer.isBuffer(buf)) {
+                            buf.copy(assetBuf, headerLength);
+                        } else {
+                            for (let i = 0; i < buf.length; i++) {
+                                assetBuf[headerLength + i] = buf[i];
                             }
-                            this.assetBundle = newAssetBundle;
-                            resolve(newAssetBundle);
+                        }
+
+                        this._assetBufferCache[key] = assetBuf;
+                        perAssetBuffers[idx] = assetBuf;
+                        finishedCount += 1;
+
+                        if (finishedCount === totalCount) {
+                            this.assetBundle = Buffer.concat(perAssetBuffers);
+                            resolve(this.assetBundle);
                         }
                     }).catch(err => {
                         console.error('Unable to get asset data for key ' + key);
                         console.error(err);
+                        reject(err);
                     });
                 }