squishjs 0.6.42 → 0.7.2

package/src/squishHelpers/coordinates2d.js

@@ -0,0 +1,98 @@
+const { getFractional } = require('../util');
+const subtypes = require('../subtypes');
+
+const COORDINATES_2D_SUBTYPE = 52;
+
+const squishHelper = (scale, coord) => {
+	const scaledCenter = scale * coord;
+	const removedSpaceCenter = Math.round(100 * (1 - scale));
+	return scaledCenter + (removedSpaceCenter / 2);
+}
+
+const squishCoordinates2d = {
+	type: COORDINATES_2D_SUBTYPE,
+	squish: (p, scale, node) => {
+		const originalCoords = p.flat();
+		const squished = new Array(originalCoords.length * 2);
+
+		if (node.subType == subtypes.SHAPE_2D_CIRCLE) {
+			if (scale) {
+				const shiftedCenterX = squishHelper(scale.x, originalCoords[0])
+				squished[0] = shiftedCenterX;
+				squished[1] = getFractional(shiftedCenterX);
+
+				const shiftedCenterY = squishHelper(scale.y, originalCoords[1])
+				squished[2] = shiftedCenterY;
+				squished[3] = getFractional(shiftedCenterY);
+
+				let diagonal;
+				if (scale.x === scale.y) {
+					diagonal = scale.x * originalCoords[2];
+				} else {
+					// probably broken
+					diagonal = Math.sqrt( Math.pow(100 * scale.x, 2) + Math.pow(100 * scale.y, 2)) * (originalCoords[2] / 100);
+				}
+
+				squished[4] = Math.floor(diagonal);
+				squished[5] = getFractional(diagonal);
+			} else {
+				const centerX = originalCoords[0];
+				squished[0] =  Math.floor(centerX);
+				squished[1] = getFractional(centerX);
+
+				const centerY = originalCoords[1];
+				squished[2] = Math.floor(centerY);
+				squished[3] = getFractional(centerY);
+
+				const radius = originalCoords[2];
+				squished[4] = Math.round(radius);
+				squished[5] = getFractional(radius);
+			}
+		} else {
+			for (const i in originalCoords) {
+				if (scale) {
+					const isX = i % 2 == 0;
+					const scaleValue = isX ? scale.x : scale.y;
+					const scaled = scaleValue * originalCoords[i];
+
+					const removedSpace = Math.round(100 * (1 - scaleValue));
+
+					const shifted = 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])));
+				}
+			}
+		}
+
+		return squished;
+	},
+	dependsOn: ['subType'],
+	unsquish: (squished, { subType }) => {
+		const unsquished = new Array(squished.length / 2);
+		for (let i = 0; i < squished.length; i += 2) {
+			const value = squished[i] + (squished[i + 1] / 100);
+			unsquished[i / 2] = value;
+		}
+
+		if (subType === subtypes.SHAPE_2D_POLYGON || subType === subtypes.SHAPE_2D_LINE) {
+			const coordPairs = new Array(unsquished.length / 2);
+			for (let i = 0; i < unsquished.length; i += 2) {
+				coordPairs[i / 2] = [unsquished[i], unsquished[i + 1]];
+			}
+
+			return coordPairs;
+		}
+
+		return unsquished;
+	}
+}
+
+module.exports = {
+    COORDINATES_2D_SUBTYPE,
+    squishCoordinates2d
+};

package/src/squishHelpers/effect.js

@@ -0,0 +1,55 @@
+const EFFECTS_SUBTYPE = 49;
+
+const squishEffect = {
+	type: EFFECTS_SUBTYPE,
+	squish: (a) => {
+		if (a['shadow']) {
+			const assetKey = 'shadow';
+			let squishedLength = assetKey.length + 4; // + 4 for color
+			if (a['shadow'].blur) {
+				squishedLength += 2;
+			}
+			const squishedEffects = new Array(squishedLength);
+			for (let i = 0; i < assetKey.length; i++) {
+				squishedEffects[i] = assetKey.codePointAt(i);
+			}
+			squishedEffects[assetKey.length] = a.shadow.color[0];
+			squishedEffects[assetKey.length + 1] = a.shadow.color[1];
+			squishedEffects[assetKey.length + 2] = a.shadow.color[2];
+			squishedEffects[assetKey.length + 3] = a.shadow.color[3];
+
+			if (a.shadow.blur) {
+				squishedEffects[assetKey.length + 4] = Math.floor(a.shadow.blur / 10)
+				squishedEffects[assetKey.length + 5] = a.shadow.blur % 10
+			}
+
+			return squishedEffects;
+		}
+	},
+	unsquish: (squished) => {
+		// 'shadow' is all (for now)
+		const assetKey = String.fromCodePoint.apply(null, squished.slice(0, 6));
+		const color = squished.slice(6, 10);
+		let blur;
+		if (squished.length > 10) {
+			blur = squished[10] * 10 + squished[11];
+		}
+
+		const unsquished = {
+			[assetKey]: {
+				color
+			}
+		};
+
+		if (blur) {
+			unsquished[assetKey].blur = blur;
+		}
+
+		return unsquished;
+	}
+}
+
+module.exports = {
+    EFFECTS_SUBTYPE,
+    squishEffect
+};

package/src/squishHelpers/fill.js

@@ -0,0 +1,16 @@
+const FILL_SUBTYPE = 53;
+
+const squishFill = {
+	type: FILL_SUBTYPE,
+	squish: (c) => {
+		return [c[0], c[1], c[2], c[3]];
+	},
+	unsquish: (squished) => {
+		return [squished[0], squished[1], squished[2], squished[3]];
+	}
+}
+
+module.exports = {
+    FILL_SUBTYPE,
+    squishFill
+};

package/src/squishHelpers/handleClick.js

@@ -0,0 +1,16 @@
+const ONCLICK_SUBTYPE = 50;
+
+const squishHandleClick = {
+	type: ONCLICK_SUBTYPE,
+	squish: (a) => {
+		return a ? [1] : [0];
+	},
+	unsquish: (a) => {
+		return a[0] === 1;
+	}
+}
+
+module.exports = {
+    ONCLICK_SUBTYPE,
+    squishHandleClick
+};

package/src/squishHelpers/id.js

@@ -0,0 +1,16 @@
+const ID_SUBTYPE = 43;
+
+const squishId = {
+	type: ID_SUBTYPE,
+	squish: (i) => {
+		return [i];
+	},
+	unsquish: (arr) => {
+		return arr[0];
+	}
+}
+
+module.exports = {
+    ID_SUBTYPE,
+    squishId
+};

package/src/squishHelpers/input.js

@@ -0,0 +1,22 @@
+const INPUT_SUBTYPE = 51;
+
+const squishInput = {
+	type: INPUT_SUBTYPE,
+	squish: (a) => {
+		const squished = new Array(a.type.length);
+		for (let i = 0; i < a.type.length; i++) {
+			squished[i] = a.type.codePointAt(i);
+		}
+		return squished;
+	},
+	unsquish: (squished) => {
+		return {
+			type: String.fromCodePoint.apply(null, squished)
+		}
+	}
+}
+
+module.exports = {
+    INPUT_SUBTYPE,
+    squishInput
+};

package/src/squishHelpers/playerIds.js

@@ -0,0 +1,12 @@
+const PLAYER_ID_SUBTYPE = 44;
+
+const squishPlayerIds = {
+	type: PLAYER_ID_SUBTYPE,
+	squish: (i) => i,
+	unsquish: (squished) => squished
+}
+
+module.exports = {
+    PLAYER_ID_SUBTYPE,
+    squishPlayerIds
+};

package/src/squishHelpers/pos.js

@@ -0,0 +1,23 @@
+const POS_SUBTYPE = 45;
+
+const squishHelper = (position) => {
+	return Math.round(100 * (position - Math.floor(position)))
+}
+
+const squishPos = {
+	type: POS_SUBTYPE,
+	squish: (p) => {
+		return [Math.floor(p.x), squishHelper(p.x), Math.floor(p.y), squishHelper(p.y)]
+	},
+	unsquish: (squished) => {
+		return {
+			x: squished[0] + squished[1] / 100,
+			y: squished[2] + squished[3] / 100
+		}
+	}
+}
+
+module.exports = {
+    POS_SUBTYPE,
+    squishPos
+};

package/src/squishHelpers/size.js

@@ -0,0 +1,23 @@
+const SIZE_SUBTYPE = 46;
+
+const squishHelper = (size) => {
+	Math.round(100 * (size- Math.floor(size)))
+}
+
+const squishSize = {
+	type: SIZE_SUBTYPE,
+	squish: (s) => {
+		return [Math.floor(s.x), squishHelper(s.x), Math.floor(s.y), squishHelper(s.y)]
+	},
+	unsquish: (squished) => {
+		return {
+			x: squished[0] + squished[1] / 100,
+			y: squished[2] + squished[3] / 100
+		}
+	}
+}
+
+module.exports = {
+    SIZE_SUBTYPE,
+    squishSize
+};

package/src/squishHelpers/subType.js

@@ -0,0 +1,16 @@
+const SUBTYPE_TYPE = 55;
+
+const squishSubType = {
+	type: SUBTYPE_TYPE,
+	squish: (a) => {
+		return [a];
+	},
+	unsquish: (s) => {
+		return s[0];
+	}
+}
+
+module.exports = {
+    SUBTYPE_TYPE,
+    squishSubType
+};

package/src/squishHelpers/text.js

@@ -0,0 +1,154 @@
+const { hypLength } = require('../util')
+const Colors = require('../Colors');
+const { squishColor } = require('./color')
+
+const TEXT_SUBTYPE = 47;
+
+const squishText = {
+	type: TEXT_SUBTYPE,
+	squish: (t, scale) => {
+		const textX = scale ? (t.x * scale.x) + Math.round(100 * (1 - scale.x)) / 2 : t.x;
+		const textY = scale ? (t.y * scale.y) + Math.round(100 * (1 - scale.y)) / 2 : t.y;
+
+		const align = t.align || 'left';
+		const squishedText = new Array(t.text.length + 10 + align.length);
+
+		squishedText[0] = Math.floor(textX);
+		squishedText[1] = Math.round(100 * (textX - Math.floor(textX)));
+
+		squishedText[2] = Math.floor(textY);
+		squishedText[3] = Math.round(100 * (textY - Math.floor(textY)));
+
+		const textSize = t.size || 1;
+		const scaledTextSize = scale ? textSize * hypLength(scale.x, scale.y) : textSize;
+
+		squishedText[4] = Math.floor(scaledTextSize);
+		squishedText[5] = Math.round(100 * (scaledTextSize - Math.floor(scaledTextSize)));
+
+		const textColor = t.color || Colors.BLACK;
+		const squishedTextColor = squishColor.squish(textColor);
+
+		for (let i = 0; i < squishedTextColor.length; i++) {
+			squishedText[6 + i] = squishedTextColor[i];
+		}
+
+		squishedText[6 + squishedTextColor.length] = 3 * [...align].length;
+
+		let j = 0;
+		for (let i = 0; i < [...align].length; i++) {
+			const codePointToInsert = [...align][i].codePointAt(0);
+			const codePointString = codePointToInsert.toString();
+			let ting;
+			if (codePointString.length == 1) {
+				ting = [`00`, `00`, `0${codePointString}`];
+			} else if (codePointString.length == 2) {
+				ting = [`00`, `00`, `${codePointString}`];
+			} else if (codePointString.length == 3) {
+				ting = [`00`, `0${codePointString.charAt(0)}`, `${codePointString.charAt(1)}${codePointString.charAt(2)}`];
+			} else if (codePointString.length == 4) {
+				ting = [`00`, `${codePointString.charAt(0)}${codePointString.charAt(1)}`, `${codePointString.charAt(2)}${codePointString.charAt(3)}`];
+			} else if (codePointString.length == 5) {
+				ting = [`0${codePointString.charAt(0)}`, `${codePointString.charAt(1)}${codePointString.charAt(2)}`, `${codePointString.charAt(3)}${codePointString.charAt(4)}`];
+			} else {
+				ting = [`${codePointString.charAt(0)}${codePointString.charAt(1)}`, `${codePointString.charAt(2)}${codePointString.charAt(3)}`, `${codePointString.charAt(4)}${codePointString.charAt(5)}`];
+			}
+			squishedText[6 + squishedTextColor.length + 1 + j] = Number(ting[0]);
+			squishedText[6 + squishedTextColor.length + 1 + j + 1] = Number(ting[1]);
+			squishedText[6 + squishedTextColor.length + 1 + j + 2] = Number(ting[2]);
+			j += 3;
+		}
+
+		let k = 0;
+		for (let i = 0; i <  [...t.text].length; i++) {
+			const codePointToInsert = [...t.text][i].codePointAt(0);
+			const codePointString = codePointToInsert.toString();
+			let ting;
+			if (codePointString.length == 1) {
+				ting = [`00`, `00`, `0${codePointString}`];
+			} else if (codePointString.length == 2) {
+				ting = [`00`, `00`, `${codePointString}`];
+			} else if (codePointString.length == 3) {
+				ting = [`00`, `0${codePointString.charAt(0)}`, `${codePointString.charAt(1)}${codePointString.charAt(2)}`];
+			} else if (codePointString.length == 4) {
+				ting = [`00`, `${codePointString.charAt(0)}${codePointString.charAt(1)}`, `${codePointString.charAt(2)}${codePointString.charAt(3)}`];
+			} else if (codePointString.length == 5) {
+				ting = [`0${codePointString.charAt(0)}`, `${codePointString.charAt(1)}${codePointString.charAt(2)}`, `${codePointString.charAt(3)}${codePointString.charAt(4)}`];
+			} else {
+				ting = [`${codePointString.charAt(0)}${codePointString.charAt(1)}`, `${codePointString.charAt(2)}${codePointString.charAt(3)}`, `${codePointString.charAt(4)}${codePointString.charAt(5)}`];
+			}
+			squishedText[6 + squishedTextColor.length + 1 + j + k] = Number(ting[0]);
+			squishedText[6 + squishedTextColor.length + 1 + j + k + 1] = Number(ting[1]);
+			squishedText[6 + squishedTextColor.length + 1 + j + k + 2] = Number(ting[2]);
+
+			k += 3;
+		}
+
+		return squishedText;
+	},
+	unsquish: (squished) => {
+		const textPosX = squished[0] + squished[1] / 100;
+		const textPosY = squished[2] + squished[3] / 100;
+		const textSize = squished[4] + squished[5] / 100;
+		const textColor = squished.slice(6, 10);
+		const textAlignLength = squished[10];
+		const textAlignVal = squished.slice(11, 11 + textAlignLength);
+		const textVal = squished.slice(11 + textAlignLength);
+
+		let alignCodePoints = [];
+		for (let i = 0; i < textAlignVal.length; i+=3) {
+			let firstChunk = textAlignVal[i].toString();
+			if (firstChunk.length == 1) {
+				firstChunk = `0${firstChunk}`;
+			}
+
+			let secondChunk = textAlignVal[i + 1].toString();
+			if (secondChunk.length == 1) {
+				secondChunk = `0${secondChunk}`;
+			}
+
+			let thirdChunk = textAlignVal[i + 2].toString();
+			if (thirdChunk.length == 1) {
+				thirdChunk = `0${thirdChunk}`;
+			}
+
+			const codePoint = firstChunk + secondChunk + thirdChunk;
+			alignCodePoints.push(codePoint);
+		}
+
+		const textCodePoints = [];
+		for (let i = 0; i < textVal.length; i+=3) {
+			let firstChunk = textVal[i].toString();
+			if (firstChunk.length == 1) {
+				firstChunk = `0${firstChunk}`;
+			}
+			let secondChunk = textVal[i + 1].toString();
+			if (secondChunk.length == 1) {
+				secondChunk = `0${secondChunk}`;
+			}
+			let thirdChunk = textVal[i + 2].toString();
+			if (thirdChunk.length == 1) {
+				thirdChunk = `0${thirdChunk}`;
+			}
+
+			const codePoint = firstChunk + secondChunk + thirdChunk;
+			textCodePoints.push(codePoint);
+		}
+
+		const align = String.fromCodePoint.apply(null, alignCodePoints);
+		const text = String.fromCodePoint.apply(null, textCodePoints);
+
+		return {
+			x: textPosX,
+			y: textPosY,
+			text: text,
+			size: textSize,
+			color: textColor,
+			align
+		};
+	}
+}
+
+module.exports = {
+    TEXT_SUBTYPE,
+    squishText
+};

package/src/subtype-mappings.js

@@ -0,0 +1,10 @@
+const { GameNode } = require('./GameNode');
+const subtypes = require('./subtypes');
+
+module.exports = {
+    [[subtypes.ASSET]]: GameNode.Asset,
+    [[subtypes.TEXT]]: GameNode.Text,
+    [[subtypes.SHAPE_2D_POLYGON]]: GameNode.Shape,
+    [[subtypes.SHAPE_2D_CIRCLE]]: GameNode.Shape,
+    [[subtypes.SHAPE_2D_LINE]]: GameNode.Shape
+};

package/src/subtypes.js

@@ -0,0 +1,7 @@
+module.exports = {
+    ASSET: 1,
+    TEXT: 2,
+    SHAPE_2D_POLYGON: 3,
+    SHAPE_2D_CIRCLE: 4,
+    SHAPE_2D_LINE: 5
+};

package/src/terrain/defs.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,156 @@
+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);
+    }
+};