squishjs 1.0.4 → 1.0.6

package/package.json

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

package/src/BaseNode.js

@@ -1,9 +1,7 @@
-const listenable = require("./util/listenable");
 const InternalGameNode = require('./InternalGameNode');
 
 const gameNode = (color, onClick, coordinates2d, border, fill, text, asset, playerIds, effects, input, subtype, id) => {
-    const node = new InternalGameNode(color, onClick, coordinates2d, border, fill, text, asset, playerIds, effects, input, subtype, id);
-    return listenable(node, node.onStateChange.bind(node));
+    return new InternalGameNode(color, onClick, coordinates2d, border, fill, text, asset, playerIds, effects, input, subtype, id);
 };
 
 class BaseNode {
@@ -45,22 +43,30 @@ class BaseNode {
         }
     }
 
-    addChild(child) {
+    addChild(child, notifyListeners = true) {
         this.node.addChild(child);
+        if (notifyListeners) {
+            this.node.onStateChange();
+        }
     }
 
     addChildren(...nodes) {
         for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex++) {
-            this.addChild(nodes[nodeIndex]);
+            this.addChild(nodes[nodeIndex], false);
         }
+
+        this.node.onStateChange();
     }
 
     getChildren() {
         return this.node.children;
     }
 
-    removeChild(nodeId) {
+    removeChild(nodeId, notifyListeners = true) {
         this.node.removeChild(nodeId);
+        if (notifyListeners) {
+            this.node.onStateChange();
+        }
     }
 
     addListener(listener) {
@@ -89,14 +95,23 @@ class BaseNode {
 
     clearChildren(excludedNodeIds) {
         this.node.clearChildren(excludedNodeIds);
+        this.node.onStateChange();
     }
 
-    clone() {
-        throw new Error("Clone not implemented");
+    update( params = {} ) {
+        if (params) {
+            if (params.fill) {
+                this.node.fill = params.fill;
+            }
+            if (params.coordinates2d) {
+                this.node.coordinates2d = coordinates2d;
+            }
+        }
+        this.node.onStateChange();
     }
 
-    free() {
-        this.node.free();
+    clone() {
+        throw new Error("Clone not implemented");
     }
 }
 

package/src/InternalGameNode.js

@@ -21,7 +21,6 @@ class InternalGameNode {
 
     addChild(node) {
         this.children.push(node);
-        this.onStateChange();
     }
 
     addChildren(...nodes) {
@@ -37,8 +36,6 @@ class InternalGameNode {
                 clearInterval(this._animation);
             }
             this.children.splice(removeIndex, 1);
-            // hack to invoke update listener
-            this.id = this.id;
         }
     }
 

package/src/Squisher.js

@@ -147,21 +147,6 @@ class Squisher {
             this.squishHelper(node.node.children[i], squishedNodes, scale, playerMap, pathFilter);
         }
 
-        // debug
-        for (let k in playerMap) {
-            for (let squished in playerMap[k]) {
-                const unsquished = unsquish(playerMap[k][squished]);
-                if (unsquished.node.playerIds.length > 0 && unsquished.node.playerIds.findIndex(i => Number(i) === Number(k)) < 0) {
-                    console.log(unsquished.node.playerIds);
-                    console.log(k);
-console.log(unsquished.node.playerIds.indexOf(k));
-                    if (k != 254) {
-                        throw new Error('fuk');
-                    }
-                }
-            }
-        }
-
     }
 
     getJson() {

package/test/Squisher.test.js

@@ -39,10 +39,13 @@ test("squisher listener", () => {
     assert(timesInvoked === 0);
 
     root.node.color = COLORS.BLACK;
+    root.node.onStateChange();
 
     assert(timesInvoked === 1);
 
     root.node.color = COLORS.GREEN;
+    root.node.onStateChange();
+
     assert(timesInvoked === 2);
 });
 

package/test/main.test.js

@@ -3,7 +3,7 @@ const { GameNode } = require('../src/GameNode');
 const { COLORS } = require("../src/Colors");
 const Shapes = require('../src/Shapes');
 const ShapeUtils = require('../src/util/shapes');
-const { verifyArrayEquality } = require('./utils');
+const { verifyArrayEquality, rectNode, FakeGame } = require('./utils');
 const Squisher = require('../src/Squisher');
 const Game = require('../src/Game');
 
@@ -361,7 +361,7 @@ test("big big text", () => {
 test("allocate a bunch of nodes", () => {
     const initialMemUsage = process.memoryUsage();
 
-    const nodeCount = Math.pow(10, 2);
+    const nodeCount = Math.pow(10, 3);
     
     const root = new GameNode.Text({
             textInfo: {
@@ -404,10 +404,47 @@ test("allocate a bunch of nodes", () => {
 
         root.addChild(gameNode);
         root.removeChild(gameNode.node.id);
-        gameNode.free();
     }
 
     const postMemUsage = process.memoryUsage();
     assert(postMemUsage.heapTotal - initialMemUsage.heapTotal <= (.05 * initialMemUsage.heapTotal)); 
 });
 
+test("Simple shape with updates", () => {
+    const base = rectNode({ x: 0, y: 0, width: 100, height: 100, fill: COLORS.RED });
+
+    const game = new FakeGame([
+        {
+            root: base
+        }
+    ]);
+
+    const squisher = new Squisher({ game });
+
+    let updateCount = 0;
+    // add listener so squisher cares about update
+    squisher.addListener(() => {
+        updateCount++;
+    });
+    
+    const initialState = Array.from(squisher.state);
+    assert(initialState.length === 1);
+
+    verifyArrayEquality(unsquish(initialState[0]).node.fill, COLORS.RED);
+
+    base.update({
+        fill: COLORS.BLUE
+    });
+
+    const state2 = Array.from(squisher.state);
+    verifyArrayEquality(unsquish(state2[0]).node.fill, COLORS.BLUE);
+
+    base.update({
+        fill: COLORS.GREEN
+    });
+
+    const state3 = Array.from(squisher.state);
+    verifyArrayEquality(unsquish(state3[0]).node.fill, COLORS.GREEN);
+});
+
+

package/src/terrain/defs.ts

@@ -1,16 +0,0 @@
-export interface pointDef {
-    x: number;
-    y: number;
-};
-
-export interface boardInfo {
-    filled: boolean;
-    north: boolean;
-    south: boolean;
-    east: boolean;
-    west: boolean;
-	wentSouth?: boolean;
-	wentEast?: boolean;
-	wentNorth?: boolean;
-	wentWest?: boolean;
-};

package/src/terrain/index.ts

@@ -1,156 +0,0 @@
-import { getRandomTerrain, getRandomStartPoint } from './terrainFunctions';
-import { pointDef, boardInfo } from './defs';
-
-interface dimensionDef {
-    width: number;
-    height: number;
-};
-
-export const terrainGenerator = (boardBounds: pointDef = { x: 100, y: 100 }, terrainBounds: pointDef = { x: 5, y: 5 }, numberOfTerrainElements = 5) => {
-    const { width, height } = getBoardDimensions(boardBounds, terrainBounds);
-    let board = initializeBoard(width, height);
-    const keyPoint = {
-        x: Math.floor(Math.random() * width),
-        y: Math.floor(Math.random() * height)
-    };
-    board = generateTerrain(board, keyPoint, numberOfTerrainElements, width, height);
-    return board;
-};
-
-const getBoardDimensions = (boardBounds: pointDef, terrainBounds: pointDef): dimensionDef => {
-    const boardX = boardBounds.x;
-    const boardY = boardBounds.y;
-    const terrainX = terrainBounds.x;
-    const terrainY = terrainBounds.y;
-    return {
-        width: Math.floor(boardX/terrainX),
-        height: Math.floor(boardY/terrainY)
-    };
-};
-
-const initializeBoard = (width: number, height: number): boardInfo[][] => {
-    const board: boardInfo[][] = [];
-
-    const defaultInfo: boardInfo = {
-        filled: false,
-        north: true,
-        south: true,
-        east: true,
-        west: true
-    };
-
-    for(let i = 0; i < width; i++) {
-        board[i] = [];
-        for (let j = 0; j < height; j++) {
-            const info = { ...defaultInfo };
-            if (i === 0) {
-                info.west = false;
-            } else if (i === width - 1) {
-                info.east = false;
-            }
-            if (j === 0) {
-                info.north = false;
-            } else if (j === height - 1) {
-                info.south = false;
-            }
-            board[i].push(info);
-        }
-    }
-    return board;
-};
-
-const deepClone = (toCopy: boardInfo[][]) => {
-    const toReturn: boardInfo[][] = [];
-    toCopy.forEach((row, rowNum) => {
-        toReturn[rowNum] = [];
-        row.forEach(elem => {
-            toReturn[rowNum].push({ ...elem });
-        });
-    });
-    return toReturn;
-};
-
-const cleanUpBoard = (board: boardInfo[][]) => {
-    for (let i = 0; i < board.length; i++) {
-        for (let j = 0; j < board[i].length; j++) {
-            board[i][j] = {
-                filled: board[i][j].filled,
-                north: board[i][j].north,
-                south: board[i][j].south,
-                east: board[i][j].east,
-                west: board[i][j].west
-            };
-        }
-    }
-};
-
-const verifyKeyPoint = (board: boardInfo[][], keyPoint: pointDef, boardWidth: number, boardHeight: number) => {
-    const pointsVerified = [];
-    for (let x = 0; x < boardWidth; x++) {
-        for (let y = 0; y < boardHeight; y++) {
-            const pointsOnCurrentPath = [];
-            const currentPoint = { x, y };
-            while(true) {
-                const boardPoint = board[currentPoint.x][currentPoint.y];
-                if (
-                    (pointsVerified.findIndex(point => point.x === currentPoint.x && point.y === currentPoint.y) > -1) ||
-                    (currentPoint.x === keyPoint.x && currentPoint.y === keyPoint.y) ||
-                    (boardPoint.filled)
-                ) {
-                     /*
-                        if we already know we can reach the keyPoint from our test point or
-                        if we are at the key point or
-                        if we are in a filled point, just skip the iteration, no need to test this point further
-                    */
-                    pointsVerified.push(...pointsOnCurrentPath);
-                    break;
-                } else if(
-                    (!boardPoint.north || boardPoint.wentNorth) &&
-                    (!boardPoint.south || boardPoint.wentSouth) &&
-                    (!boardPoint.east || boardPoint.wentEast) &&
-                    (!boardPoint.west || boardPoint.wentWest)
-                ) {
-                    /*
-                        if we have exhausted all possible movements for a point, and not reached the keypoint
-                        then this possibleBoard is not workable
-                    */
-                    return false;
-                }
-                pointsOnCurrentPath.push({ ...currentPoint });
-                if (boardPoint.south && !boardPoint.wentSouth) {
-                    boardPoint.wentSouth = true;
-                    currentPoint.y = currentPoint.y + 1;
-                } else if (boardPoint.east && !boardPoint.wentEast) {
-                    boardPoint.wentEast = true;
-                    currentPoint.x = currentPoint.x + 1;
-                } else if (boardPoint.north && !boardPoint.wentNorth) {
-                    boardPoint.wentNorth = true;
-                    currentPoint.y = currentPoint.y - 1;
-                } else if (boardPoint.west && !boardPoint.wentWest) {
-                    boardPoint.wentWest = true;
-                    currentPoint.x = currentPoint.x - 1;
-                } else {
-                    return false;
-                }
-            }
-            cleanUpBoard(board);
-        }
-    }
-    return true;
-};
-
-const generateTerrain = (board: boardInfo[][], keyPoint: pointDef, toPlace: number, boardWidth: number, boardHeight: number, numberOfIterations = 0): boardInfo[][] => {
-    if (toPlace === 0 || numberOfIterations === 3) {
-        return board;
-    }
-    const possibleBoard = deepClone(board);
-    const terrainFunction = getRandomTerrain();
-    const terrainStartPoint = getRandomStartPoint(boardWidth, boardHeight, keyPoint);
-    terrainFunction(possibleBoard, terrainStartPoint, boardWidth, boardHeight, keyPoint);
-    const temp = verifyKeyPoint(possibleBoard, keyPoint, boardWidth, boardHeight);
-    if (temp) {
-        return generateTerrain(possibleBoard, keyPoint, toPlace - 1, boardWidth, boardHeight, 0);
-    } else {
-        return generateTerrain(board, keyPoint, toPlace, boardWidth, boardHeight, numberOfIterations + 1);
-    }
-};

package/src/terrain/terrainFunctions.ts

@@ -1,142 +0,0 @@
-import { pointDef, boardInfo } from './defs';
-
-const placeTerrain = (board: boardInfo[][], { x, y }: pointDef, boardWidth: number, boardHeight: number, keyPoint: pointDef) => {
-    if (x < 0 || x >= boardWidth) {
-        return;
-    } else if (y < 0 || y >= boardHeight) {
-        return;
-    } else if ( x === keyPoint.x && y === keyPoint.y) {
-        return;
-    }
-
-    if (!board[x][y].filled) {
-        if (board[x][y].north) {
-            board[x][y - 1].south = false;
-        }
-        if (board[x][y].south) {
-            board[x][y + 1].north = false;
-        }
-        if (board[x][y].east) {
-            board[x + 1][y].west = false;
-        }
-        if (board[x][y].west) {
-            board[x - 1][y].east = false;
-        }
-        board[x][y].filled = true;
-        board[x][y].north = false;
-        board[x][y].south = false;
-        board[x][y].east = false;
-        board[x][y].west = false;
-    }
-}
-
-const square = (board: boardInfo[][], { x, y }: pointDef, boardWidth: number, boardHeight: number, keyPoint: pointDef) => {
-    const option = Math.floor(Math.random() * 4);
-    placeTerrain(board, { x, y }, boardWidth, boardHeight, keyPoint);
-    if (option === 0) {	// start point is top left
-        placeTerrain(board, { x: x + 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 1, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 1) { // start point is top right
-        placeTerrain(board, { x: x - 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 2) { // start point is bottom left
-        placeTerrain(board, { x, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 1, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-    } else { // start point is bottom right
-        placeTerrain(board, { x, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-    }
-};
-
-const line = (board: boardInfo[][], { x, y }: pointDef, boardWidth: number, boardHeight: number, keyPoint: pointDef) => {
-    const option = Math.floor(Math.random() * 4);
-    placeTerrain(board, { x, y }, boardWidth, boardHeight, keyPoint);
-    if (option === 0) {	// start point is top
-        placeTerrain(board, { x, y: y + 1}, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y + 2 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y + 3 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 1) { // start point is left
-        placeTerrain(board, { x: x + 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 2, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 3, y }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 2) { // start point is right
-        placeTerrain(board, { x: x - 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 2, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 3, y }, boardWidth, boardHeight, keyPoint);
-    } else { // start point is bottom
-        placeTerrain(board, { x, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y - 2 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y - 3 }, boardWidth, boardHeight, keyPoint);
-    }
-};
-
-const bentLine = (board: boardInfo[][], { x, y }: pointDef, boardWidth: number, boardHeight: number, keyPoint: pointDef) => {
-    const option = Math.floor(Math.random() * 4);
-    placeTerrain(board, { x, y }, boardWidth, boardHeight, keyPoint);
-    if (option === 0) {	// start point is top
-        placeTerrain(board, { x, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y + 2 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 1, y: y + 2 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 1) { // start point is left
-        placeTerrain(board, { x: x + 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 2, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 2, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 2) { // start point is right
-        placeTerrain(board, { x: x - 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 2, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 2, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-    } else { // start point is bottom
-        placeTerrain(board, { x, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x, y: y - 2 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y - 2 }, boardWidth, boardHeight, keyPoint);
-    }
-};
-
-const zShape = (board: boardInfo[][], { x, y }: pointDef, boardWidth: number, boardHeight: number, keyPoint: pointDef) => {
-    const option = Math.floor(Math.random() * 4);
-    placeTerrain(board, { x, y }, boardWidth, boardHeight, keyPoint);
-    if (option === 0) {	// start point is top
-        placeTerrain(board, { x, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y + 2 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 1) { // start point is left
-        placeTerrain(board, { x: x + 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 1, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x + 2, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-    } else if (option === 2) { // start point is right
-        placeTerrain(board, { x: x - 1, y }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 2, y: y + 1 }, boardWidth, boardHeight, keyPoint);
-    } else { // start point is bottom
-        placeTerrain(board, { x, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y - 1 }, boardWidth, boardHeight, keyPoint);
-        placeTerrain(board, { x: x - 1, y: y - 2 }, boardWidth, boardHeight, keyPoint);
-    }
-};
-
-const terrainFunctions = [
-    square,
-    line,
-    bentLine,
-    zShape
-];
-
-export const getRandomTerrain = () => {
-    return terrainFunctions[Math.floor(Math.random() * terrainFunctions.length)];
-};
-
-export const getRandomStartPoint = (boardWidth: number, boardHeight: number, keyPoint: pointDef) => {
-    const startPoint = {
-        x: Math.floor(Math.random() * boardWidth),
-        y: Math.floor(Math.random() * boardHeight)
-    };
-    while (startPoint.x === keyPoint.x && startPoint.y === keyPoint.y) {
-        startPoint.x = Math.floor(Math.random() * boardWidth);
-        startPoint.y = Math.floor(Math.random() * boardHeight);
-    }
-    return startPoint;
-};

package/src/util/index.ts

@@ -1,6 +0,0 @@
-export const hypLength = (x: number, y: number) => Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
-
-// get the first 2 digits after the decimal
-export const getFractional = (number: number) => {
-    return Math.round(100 * (number - Math.floor(number)));
-};

package/src/util/listenable.js

@@ -1,27 +0,0 @@
-const listenable = function(obj, onChange) {
-    const handler = {
-        get(target, property, receiver) {
-            return Reflect.get(target, property, receiver);
-        },
-        defineProperty(target, property, descriptor) {
-            const change = Reflect.defineProperty(target, property, descriptor);
-            onChange && onChange();
-            return change;
-        },
-        deleteProperty(target, property) {
-            const change = Reflect.deleteProperty(target, property);
-            onChange && onChange();
-            return change;
-        }
-    };
-
-    const revocable = Proxy.revocable(obj, handler);
-
-    obj.free = () => {
-        revocable.revoke();
-    }
-
-    return revocable.proxy;
-};
-
-module.exports = listenable;

package/src/util/listenable.ts

@@ -1,20 +0,0 @@
-import { gameNodeDef, internalGameNodeDef } from '../sharedDefs';
-export default (obj: internalGameNodeDef, onChange: () => void) => {
-    const handler = {
-        get(target: Object, property: PropertyKey, receiver: any) {
-            return Reflect.get(target, property, receiver);
-        },
-        defineProperty(target: Object, property: PropertyKey, descriptor: PropertyDescriptor) {
-            const change = Reflect.defineProperty(target, property, descriptor);
-            onChange && onChange();
-            return change;
-        },
-        deleteProperty(target: Object, property: PropertyKey) {
-            const change = Reflect.deleteProperty(target, property);
-            onChange && onChange();
-            return change;
-        }
-    };
-
-    return new Proxy(obj, handler);
-};

package/src/util/shapes.ts

@@ -1,18 +0,0 @@
-export const rectangle = (startX: number, startY: number, width: number, height: number) => {
-    return [
-        [startX, startY],
-        [startX + width, startY],
-        [startX + width, startY + height],
-        [startX, startY + height],
-        [startX, startY],
-    ];
-};
-
-export const triangle = (x1: number, y1: number, x2: number, y2: number, x3: number, y3: number) => {
-    return [
-        [x1, y1],
-        [x2, y2],
-        [x3, y3],
-        [x1, y1]
-    ];
-};

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-    "compilerOptions": {
-        "lib": ["es2019"],
-        "target": "es2015",
-        "module": "commonjs",
-        "declaration": true,
-        "noEmitOnError": true,
-        "noImplicitAny": true,
-        "experimentalDecorators": true,
-        "sourceMap": false,
-        "inlineSourceMap": true,
-        "outDir": "./dist"
-    },
-    "exclude": [
-        "dist",
-        "test",
-        "node_modules"
-    ],
-    "include": [
-        "src/**/*"
-    ]
-}