squishjs 1.0.5 → 1.0.7

package/README.md

@@ -1,119 +1,59 @@
-Squish is a way to utility package for [Homegames-core](https://github.com/homegamesio/homegames-core) and [Homegames-web](https://github.com/homegamesio/homegames-web). It contains several utilities and the class definitions for the entities most important to running Homegames.
+## Squish
+This repo contains the game library used by homegames-core and homegames-web to efficiently serialize & deserialize game data. 
 
-Below the term `First Class` is used to describe several functions and variables. This means those values should be treated as immutable, and in the case of functions are called automatically.
+## squish/unsquish
+This is just serialization/deserialization. Conceptually similar to [protobufs](https://protobuf.dev/), squish contains schema definitions shared by the server and client that lets us transmit game data as efficiently as possible. 
 
-## Exported Features
-* squish
-* unsquish
-* gameNode
-* GameNode
-* Colors
-* Game
-* Shapes
-* ShapeUtils
-* terrainGenerator
-
-## squish
-squish is a first class function that is used to compress the information of the game down to a set of integers. This compresses the data required to rendering down.
-
-## unsquish
-unsquish is a first class function that is used to uncompress squished entities. This uncompresses the data that was squished down for more easy manipulation and usage.
-
-## gameNode
-gameNode is the most foundational component to Homegames. The contents of a game is made up of a set of gameNodes that define entities, and display logic. Wrapped in a listener it contains the following:
-* id :- a first calss numeric identification number. It is unique in a Game.
-* color :- Defines the display color of the gameNode. See **Colors**
-* handleClick :- a function that defines what happens if a user clicks on the gameNode. The function passed in will automatically be called, and will pass the player who clicked as the argument.
-* coordinates2d :- an array of coordinates in a two dimensional plane that defines the vertices of the gameNode. It is recommened that **ShapeUtils** is used
-* border :- a number that defines the thickness of the border on the gameNode
-* fill :- Defines the color that fills the gameNode. See **Colors**
-* text :- Defines the text (if any) that will be displayed by the gameNode. It has the form
-  * text :- The text to be displayed;
-  * x :- The x-position of the top-left corner of the text. This is relative to the entire screen
-  * y :- The y-position of the top-left corner of the text. This is relative to the entire screen
-  * size :- The font size of the text
-  * align :- 'left' | 'center' | 'right'
-  * color :- The Color of the text, see **Colors**
-* asset :- Defines an asset (image, video, etc) to be displayed by the gameNode. Takes the form:
-  * assetInfo :- The information for the display of the asset.
-  * onClick :- a function that defines what happens if a user clicks on the asset. The function passed in will automatically be called, and will pass the player who clicked as the argument.
-  * coordinates2d :- an array of coordinates in a two dimensional plane that defines the vertices of the gameNode. It is recommened that **ShapeUtils** is used
-  * playerIds :- An array of player identification numbers. Defining who can see this asset.
-* effects :- Defines any additional effects applied to the gameNode.
-* input :- Defines whether the gameNode should accept an input or not. Takes the form:
-  * type :- 'text' | 'file'
-  * oninput :- A function that will be called with the inputting player's identification number and the data of the input.  (player: number, data: any) => void;
-* playerIds :- An array of player identification numbers, that defines which players can see and interact with the gameNode.
-* listeners :- The set of listeners attached to the gameNode.
-* _animation :- An interval or timeout that can be used to modify the gameNode, such as lightening the color over time to give it a fade in, or darkening the color over time to give it a fade out.
-* onStateChange :- A first class function that will notify listeners of a state change.
-* addListener :- A first class function that will attach an additional listener to the gameNode.
-
-## GameNode
-A helpful wrapper and the recommended way of generatin a gameNode. It gives you the following:
-* Asset :- Generates a gameNode with an asset attached to it
-  * Example Call: `Asset(onClick: (player) => console.log(player), coordinates2d: [[0, 1], [2, 1], [2, 3], [0, 3], [0, 1]], assetInfo: { myAsset: { pos: { x: 0, y: 1 }, size: {  x: 2, y: 3 }}}, playerIds: [2])`
-  * This will generate an asset based on `myAsset` and on clicking on the asset the asset will log out the clicking player.
-* Shape :- Generates a generic two dimenstional gameNode
-  * Example Call: `Shape({ color: COLORS.CANDY_RED, onClick: (player) => console.log(player), shapeType: Shapes.POLYGON, coordinates2d: [[0, 1], [2, 1], [2, 3], [0, 3], [0, 1]], border: 2, fill: COLORS.CANDY_RED, playerIds: [2], null, null })`
-  * This will generate a rectangle of color COLORS.CANDY_RED, visible to player of identification number 2, and onClick will log out the player clicking.
-* Text :- Generates a gameNode with text attached to it.
-  * Example Call: `Text({ textInfo: { text: "My Text", color: COLORS.CANDY_RED, align: 'center',  x: 2, y: 3, size: 1 }, playerIds: [2] })`
-  * This will generate a gameNode with texting starting at the (2, 3) position, visible to player of identification number 2. The Text will be centered and CANDY_RED, and will be "My Text".
-
-## Colors
-Colors is a utility for using shared homegames RGBA values. Colors is exported as an object with two keys: COLORS & randomColor.
-
-**COLORS** is an object that takes the form of: `string -> RGBA Array`. For example we can GET the RBGA value for Homegames CANDY_RED (RGBA of [246, 84, 106, 255]) by doing the following `COLORS.CANDY_RED`. Thus COLORS serves as a map between strings and in-built colors.
-
-**randomColor** is a function that takes the form: `string[] => RGBA array`. It is a function to get a random RGBA from the set of RGBA that Homegames provides. It can take in array of strings that limits the options, allowing for the exclusion of certain RGBA values from returning. For example we can call this function like `randomColor(["CANDY_RED"])` which would return an RGBA array from the set of COLORS while preventing CANDY_RED from being a possible return value.
-
-
-## Game
-Game is the base class definition for a game in Homegames. Most games will extend the definition to Game, and leverage most or all of its internal logic. Game holds the following Member Variables:
-* players :- Object of the form `player id -> player object`
-* timeouts :- Array of NodeJS.Timeout that holds the timeout triggered logic for the Game
-* intervals :- Array of NodeJS.Timeout  that holds the interval triggered logic for the Game
-* listeners :- the list of all listeners on this Game.
-* root :- The base GameNode of this game, for which all other GameNodes are children
-
-Game also holds the following Instance Functions
-* _hgAddPlayer :- This is a first class function, and is used to add a player to the Game's `players` value.
-* _hgRemovePlayer :- This is a first class function, and is used to remmove a player from the Game's `players` value.
-* addStateListener :- This is a first class function, and is used to add a listener to the Game's `listeners` value.
-* removeStateListener :- This is a first class function, and is used to remove a listener from the Game's `listeners` value.
-* getRoot :- This is a function and returns the Game's `root` value. An example call would be: `getRoot()`. It is expected that this function is overwritten in the extending class's definition.
-* setTimeout :- This is a function, and is used to add a timeout to the Game's `timeouts` value. It takes in two arguments a function to be called at the end of the timer, and how long the timer should be. An example call would be: `setTimeout( () => console.log("Welcome to Homegames"), 200)`
-* setInterval :- This is a function, and is used to add an interval to the Game's `intervals` value. It takes in two arguments a function to be called at the end of the timer, and how long the timer should be. An example call would be: `intervals(() => console.log("Welcome to Homegames"), 200)`
-* close :- This is a first class function, and is used to clear all `timeouts` and `intervals` from the Game, as the Game instance is spun down.
-
-## Shapes
-Shapes is functionally an enum of the types of shapes Homegames supports.
-
-## ShapeUtils
-ShapeUtils is a utility for building shapes for use in GameNodes. ShapeUtils is exported as an object with two keys rectangle & triangle.
-
-**rectangle** is a function that takes the form `(startX, startY, width, height) => the rectangle's coordinate set`. Thus rectangle creates an array from the starting x position, the starting y position, the width, and the height that defines the vertices of the rectangle. An example call would be: `rectangle(0, 1, 2, 3)` which would create a rectangle with the top-left corner at (0,1), and bottom-right corner at (2, 4).
-
-**triangle** is a function that takes the form `(x1, y1, x2, y2, x3, y3) => the triangle's coordinate set`. Thus triangle creates an array from provided vertex pairings. An example call would be `triangle(0, 1, 2, 3, 4, 5)` which would create a triangle with vertices at (0, 1), (2, 3), (4, 5).
-
-## terrainGenerator
-terrainGenerator is a utility function that generates a "board" from the provided information. This "board" functions as a map, defining regions of the board that are randomly marked to be "filled". This can be used to procedurally generate fields of play with parts of the map unaccessible to players. The "board" is guaranteed that all un-filled points are contiguous. An example call would be: `terrainGenerator({ x: 50, y: 100 }, { x: 2, y: 3 }, 5)`. This would generate board of area 50 * 100. The "filled" regions would be of area 2 * 3, and a maximum of 5 such "filled" regions will be placed. The outcome of this would be two-dimensionl area, where each element has the form
 ```
-{
-  filled: boolean
-  north: boolean
-  south: boolean
-  east: boolean
-  west: boolean
+const { squish, unsquish, Colors, GameNode, Shapes, ShapeUtils } = require('squish-1006');
+const node = new GameNode.Shape({
+  shapeType: Shapes.POLYGON,
+  fill: Colors.COLORS.RED,
+  coordinates2d: ShapeUtils.rectangle(20, 20, 10, 10)
+});
+
+const squished = squish(node);
+[
+  3,           0,            0,            53,
+  2,           43,           0,            11,
+  [Number: 0], [Number: 0],  [Number: 32], [Number: 61],
+  [Number: 3], [Number: 90], [Number: 63], [Number: 44],
+  44,          0,            3,            53,
+  0,           7,            255,          0,
+  0,           255,          55,           0,
+  4,           3,            52,           0,
+  23,          20,           0,            20,
+  0,           30,           0,            20,
+  0,           30,           0,            30,
+  0,           20,           0,            30,
+  0,           20,           0,            20,
+  0
+]
+
+const unsquished = unsquish(squished);
+Shape {
+  node: InternalGameNode {
+    id: [Number: 326103906344],
+    children: [],
+    color: undefined,
+    handleClick: undefined,
+    coordinates2d: [ [Array], [Array], [Array], [Array], [Array] ],
+    border: undefined,
+    fill: [ 255, 0, 0, 255 ],
+    text: undefined,
+    asset: undefined,
+    effects: null,
+    input: null,
+    listeners: Set(0) {},
+    playerIds: [],
+    subType: 3
+  },
+  id: [Number: 326103906344]
 }
 ```
-**filled** of true means this place can be marked as inaccessible to players
-
-**north** of true means from this place a player can move "north".
 
-**south** of true means from this place a player can move "south".
-
-**east** of true means from this place a player can move "east".
+## Game
+The `Game` class is a base class that allows external components (eg. a `Squisher`) to listen to state updates. All games in Homegames extend the `Game` class.
 
-**west** of true means from this place a player can move "west".
+## Versioning
+Homegames core & web use multiple versions of squish. This allows games using older versions of squish to remain compatible with newer versions of Homegames.

package/package.json

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

package/src/BaseNode.js

@@ -1,17 +1,15 @@
-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));
+const gameNode = (color, onClick, coordinates2d, border, fill, text, asset, playerIds, effects, input, subtype, id, onHover, offHover) => {
+    return new InternalGameNode(color, onClick, coordinates2d, border, fill, text, asset, playerIds, effects, input, subtype, id, onHover, offHover);
 };
 
 class BaseNode {
-    constructor({color, onClick, coordinates2d, border, fill, textInfo, assetInfo, playerIds, effects, input, subtype, node, id}) {
+    constructor({color, onClick, coordinates2d, border, fill, textInfo, assetInfo, playerIds, effects, input, subtype, node, id, onHover, offHover }) {
         if (node) {
             this.node = node;
         } else {
-            this.node = gameNode(color, onClick, coordinates2d, border, fill, textInfo, assetInfo, playerIds, effects, input, subtype, id);
+            this.node = gameNode(color, onClick, coordinates2d, border, fill, textInfo, assetInfo, playerIds, effects, input, subtype, id, onHover, offHover);
         }
 
         this.id = this.node.id;
@@ -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/GameNode.js

@@ -15,7 +15,7 @@ const subtypeToShapeType = {
 };
 
 class Shape extends BaseNode {
-    constructor({ color, onClick, shapeType, coordinates2d, border, fill, playerIds, effects, input, node, id }) {
+    constructor({ color, onClick, shapeType, coordinates2d, border, fill, playerIds, effects, input, node, id, onHover, offHover }) {
         if ((!coordinates2d || !shapeType) && !(node)) {
             throw new Error("Shape requires coordinates2d and shapeType");
         }
@@ -31,7 +31,9 @@ class Shape extends BaseNode {
             input,
             node,
             subtype: shapeTypeToSubtype[shapeType],
-            id
+            id,
+            onHover,
+            offHover
         });
     }
 
@@ -81,7 +83,7 @@ class Text extends BaseNode {
 }
 
 class Asset extends BaseNode {
-    constructor({ assetInfo, onClick, coordinates2d, playerIds, effects, node, id }) {
+    constructor({ assetInfo, onClick, coordinates2d, playerIds, effects, node, id, onHover, offHover }) {
         if (!assetInfo && !node) {
             throw new Error("Asset node requires assetInfo");
         }
@@ -94,7 +96,9 @@ class Asset extends BaseNode {
             effects,
             node,
             subtype: SUBTYPES.ASSET,
-            id
+            id,
+            onHover,
+            offHover
         });
     }
 

package/src/InternalGameNode.js

@@ -1,5 +1,5 @@
 class InternalGameNode {
-    constructor(color, onClick, coordinates2d, border, fill, text, asset, playerIds = [], effects = null, input = null, subType = null, id = null) {
+    constructor(color, onClick, coordinates2d, border, fill, text, asset, playerIds = [], effects = null, input = null, subType = null, id = null, onHover, offHover) {
         this.id = id ? Number(id) : Math.floor(Math.random() * 999999999999);
         this.children = new Array();
         this.color = color;
@@ -17,11 +17,12 @@ class InternalGameNode {
         }
         this.playerIds = playerIds || [];
         this.subType = subType;
+        this.onHover = onHover;
+        this.offHover = offHover;
     }
 
     addChild(node) {
         this.children.push(node);
-        this.onStateChange();
     }
 
     addChildren(...nodes) {
@@ -37,8 +38,6 @@ class InternalGameNode {
                 clearInterval(this._animation);
             }
             this.children.splice(removeIndex, 1);
-            // hack to invoke update listener
-            this.id = this.id;
         }
     }
 

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/**/*"
-    ]
-}