quoridor - npm Package Compare versions

Comparing version 2.1.6 to 2.1.7

lib/consts.d.ts

@@ -1,4 +0,5 @@
-import { DecrementableHorizontalPiecePosition, DecrementableHorizontalWallPosition, DecrementableVerticalPiecePosition, DecrementableVerticalWallPosition, HorizontallyDecrementablePawnPosition, HorizontallyIncrementablePawnPosition, HorizontalPiecePosition, HorizontalWallPosition, IncrementableHorizontalPiecePosition, IncrementableHorizontalWallPosition, IncrementableVerticalPiecePosition, IncrementableVerticalWallPosition, PawnPosition, PlayerMatrix, VerticallyDecrementablePawnPosition, VerticallyIncrementablePawnPosition, VerticalPiecePosition, VerticalWallPosition, WallMatrix, WallPosition } from './types';
+import { DecrementableHorizontalPiecePosition, DecrementableHorizontalWallCoordinate, DecrementableVerticalPiecePosition, DecrementableVerticalWallCoordinate, HorizontallyDecrementablePawnPosition, HorizontallyIncrementablePawnPosition, HorizontalPiecePosition, HorizontalWallCoordinate, IncrementableHorizontalPiecePosition, IncrementableHorizontalWallCoordinate, IncrementableVerticalPiecePosition, IncrementableVerticalWallCoordinate, PawnPosition, PlayerMatrix, VerticallyDecrementablePawnPosition, VerticallyIncrementablePawnPosition, VerticalPiecePosition, VerticalWallCoordinate, WallMatrix, WallPosition } from './types';
 export declare const pawnPositions: PawnPosition[];
 export declare const wallPositions: WallPosition[];
+export declare const isWallPositionMap: Record<string, true | undefined>;
 export declare const pawnAndWallPositions: (PawnPosition | WallPosition)[];
@@ -21,6 +22,6 @@ export declare const initialPlayerMatrix: PlayerMatrix;
 export declare const verticalPiecePositions: number[];
-export declare const decrementedHorizontalWallPositions: Record<DecrementableHorizontalWallPosition, IncrementableHorizontalWallPosition>;
-export declare const incrementedHorizontalWallPositions: Record<IncrementableHorizontalWallPosition, DecrementableHorizontalWallPosition>;
-export declare const decrementedVerticalWallPositions: Record<DecrementableVerticalWallPosition, IncrementableVerticalWallPosition>;
-export declare const incrementedVerticalWallPositions: Record<IncrementableVerticalWallPosition, DecrementableVerticalWallPosition>;
+export declare const decrementedHorizontalWallCoordinates: Record<DecrementableHorizontalWallCoordinate, IncrementableHorizontalWallCoordinate>;
+export declare const incrementedHorizontalWallCoordinates: Record<IncrementableHorizontalWallCoordinate, DecrementableHorizontalWallCoordinate>;
+export declare const decrementedVerticalWallCoordinates: Record<DecrementableVerticalWallCoordinate, IncrementableVerticalWallCoordinate>;
+export declare const incrementedVerticalWallCoordinates: Record<IncrementableVerticalWallCoordinate, DecrementableVerticalWallCoordinate>;
 export declare const decrementedHorizontalPiecePositions: Record<DecrementableHorizontalPiecePosition, IncrementableHorizontalPiecePosition>;
@@ -30,12 +31,12 @@ export declare const decrementedVerticalPiecePositions: Record<DecrementableVerticalPiecePosition, IncrementableVerticalPiecePosition>;
 export declare const incrementedHorizontalPiecePositions: Record<IncrementableHorizontalPiecePosition, DecrementableHorizontalPiecePosition>;
-export declare const isHorizontalWallCoordinateMap: Record<HorizontalPiecePosition | HorizontalWallPosition, boolean>;
-export declare const isVerticalWallCoordinateMap: Record<VerticalPiecePosition | VerticalWallPosition, boolean>;
-export declare const isIncrementableHorizontalWallPositionMap: Record<HorizontalPiecePosition | HorizontalWallPosition, boolean>;
-export declare const isDecrementableHorizontalWallPositionMap: Record<HorizontalPiecePosition | HorizontalWallPosition, boolean>;
-export declare const isIncrementableVerticalWallPositionMap: Record<VerticalPiecePosition | VerticalWallPosition, boolean>;
-export declare const isDecrementableVerticalWallPositionMap: Record<VerticalPiecePosition | VerticalWallPosition, boolean>;
-export declare const isIncrementableHorizontalPiecePositionMap: Record<HorizontalPiecePosition | HorizontalWallPosition, boolean>;
-export declare const isDecrementableHorizontalPiecePositionMap: Record<HorizontalPiecePosition | HorizontalWallPosition, boolean>;
-export declare const isIncrementableVerticalPiecePositionMap: Record<VerticalPiecePosition | VerticalWallPosition, boolean>;
-export declare const isDecrementableVerticalPiecePositionMap: Record<VerticalPiecePosition | VerticalWallPosition, boolean>;
+export declare const isHorizontalWallCoordinateMap: Record<HorizontalPiecePosition | HorizontalWallCoordinate, boolean>;
+export declare const isVerticalWallCoordinateMap: Record<VerticalPiecePosition | VerticalWallCoordinate, boolean>;
+export declare const isIncrementableHorizontalWallCoordinateMap: Record<HorizontalPiecePosition | HorizontalWallCoordinate, boolean>;
+export declare const isDecrementableHorizontalWallCoordinateMap: Record<HorizontalPiecePosition | HorizontalWallCoordinate, boolean>;
+export declare const isIncrementableVerticalWallCoordinateMap: Record<VerticalPiecePosition | VerticalWallCoordinate, boolean>;
+export declare const isDecrementableVerticalWallCoordinateMap: Record<VerticalPiecePosition | VerticalWallCoordinate, boolean>;
+export declare const isIncrementableHorizontalPiecePositionMap: Record<HorizontalPiecePosition | HorizontalWallCoordinate, boolean>;
+export declare const isDecrementableHorizontalPiecePositionMap: Record<HorizontalPiecePosition | HorizontalWallCoordinate, boolean>;
+export declare const isIncrementableVerticalPiecePositionMap: Record<VerticalPiecePosition | VerticalWallCoordinate, boolean>;
+export declare const isDecrementableVerticalPiecePositionMap: Record<VerticalPiecePosition | VerticalWallCoordinate, boolean>;
 export declare const verticallyIncrementedPawnPositions: Record<VerticallyIncrementablePawnPosition, PawnPosition>;
@@ -42,0 +43,0 @@ export declare const isVerticallyIncrementablePawnPositionMap: {

lib/consts.js

@@ -8,3 +8,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHorizontallyDecrementablePawnPositionMap = exports.horizontallyDecrementedPawnPositions = exports.isHorizontallyIncrementablePawnPositionMap = exports.horizontallyIncrementedPawnPositions = exports.isVerticallyDecrementablePawnPositionMap = exports.verticallyDecrementedPawnPositions = exports.isVerticallyIncrementablePawnPositionMap = exports.verticallyIncrementedPawnPositions = exports.isDecrementableVerticalPiecePositionMap = exports.isIncrementableVerticalPiecePositionMap = exports.isDecrementableHorizontalPiecePositionMap = exports.isIncrementableHorizontalPiecePositionMap = exports.isDecrementableVerticalWallPositionMap = exports.isIncrementableVerticalWallPositionMap = exports.isDecrementableHorizontalWallPositionMap = exports.isIncrementableHorizontalWallPositionMap = exports.isVerticalWallCoordinateMap = exports.isHorizontalWallCoordinateMap = exports.incrementedHorizontalPiecePositions = exports.incrementedVerticalPiecePositions = exports.decrementedVerticalPiecePositions = exports.decrementedHorizontalPiecePositions = exports.incrementedVerticalWallPositions = exports.decrementedVerticalWallPositions = exports.incrementedHorizontalWallPositions = exports.decrementedHorizontalWallPositions = exports.verticalPiecePositions = exports.verticallyDecrementableWallPositions = exports.verticallyIncrementableWallPositions = exports.horizontallyDecrementableWallPositions = exports.horizontallyIncrementableWallPositions = exports.possiblyTrappedPositions = exports.horizontalPawnCoordinates = exports.initialWallMatrix = exports.initialPlayerMatrix = exports.pawnAndWallPositions = exports.wallPositions = exports.pawnPositions = void 0;
+exports.isHorizontallyDecrementablePawnPositionMap = exports.horizontallyDecrementedPawnPositions = exports.isHorizontallyIncrementablePawnPositionMap = exports.horizontallyIncrementedPawnPositions = exports.isVerticallyDecrementablePawnPositionMap = exports.verticallyDecrementedPawnPositions = exports.isVerticallyIncrementablePawnPositionMap = exports.verticallyIncrementedPawnPositions = exports.isDecrementableVerticalPiecePositionMap = exports.isIncrementableVerticalPiecePositionMap = exports.isDecrementableHorizontalPiecePositionMap = exports.isIncrementableHorizontalPiecePositionMap = exports.isDecrementableVerticalWallCoordinateMap = exports.isIncrementableVerticalWallCoordinateMap = exports.isDecrementableHorizontalWallCoordinateMap = exports.isIncrementableHorizontalWallCoordinateMap = exports.isVerticalWallCoordinateMap = exports.isHorizontalWallCoordinateMap = exports.incrementedHorizontalPiecePositions = exports.incrementedVerticalPiecePositions = exports.decrementedVerticalPiecePositions = exports.decrementedHorizontalPiecePositions = exports.incrementedVerticalWallCoordinates = exports.decrementedVerticalWallCoordinates = exports.incrementedHorizontalWallCoordinates = exports.decrementedHorizontalWallCoordinates = exports.verticalPiecePositions = exports.verticallyDecrementableWallPositions = exports.verticallyIncrementableWallPositions = exports.horizontallyDecrementableWallPositions = exports.horizontallyIncrementableWallPositions = exports.possiblyTrappedPositions = exports.horizontalPawnCoordinates = exports.initialWallMatrix = exports.initialPlayerMatrix = exports.pawnAndWallPositions = exports.isWallPositionMap = exports.wallPositions = exports.pawnPositions = void 0;
 exports.pawnPositions = [
@@ -223,2 +223,132 @@ 'a1',
 ];
+exports.isWallPositionMap = {
+    a1h: true,
+    a1v: true,
+    a2h: true,
+    a2v: true,
+    a3h: true,
+    a3v: true,
+    a4h: true,
+    a4v: true,
+    a5h: true,
+    a5v: true,
+    a6h: true,
+    a6v: true,
+    a7h: true,
+    a7v: true,
+    a8h: true,
+    a8v: true,
+    b1h: true,
+    b1v: true,
+    b2h: true,
+    b2v: true,
+    b3h: true,
+    b3v: true,
+    b4h: true,
+    b4v: true,
+    b5h: true,
+    b5v: true,
+    b6h: true,
+    b6v: true,
+    b7h: true,
+    b7v: true,
+    b8h: true,
+    b8v: true,
+    c1h: true,
+    c1v: true,
+    c2h: true,
+    c2v: true,
+    c3h: true,
+    c3v: true,
+    c4h: true,
+    c4v: true,
+    c5h: true,
+    c5v: true,
+    c6h: true,
+    c6v: true,
+    c7h: true,
+    c7v: true,
+    c8h: true,
+    c8v: true,
+    d1h: true,
+    d1v: true,
+    d2h: true,
+    d2v: true,
+    d3h: true,
+    d3v: true,
+    d4h: true,
+    d4v: true,
+    d5h: true,
+    d5v: true,
+    d6h: true,
+    d6v: true,
+    d7h: true,
+    d7v: true,
+    d8h: true,
+    d8v: true,
+    e1h: true,
+    e1v: true,
+    e2h: true,
+    e2v: true,
+    e3h: true,
+    e3v: true,
+    e4h: true,
+    e4v: true,
+    e5h: true,
+    e5v: true,
+    e6h: true,
+    e6v: true,
+    e7h: true,
+    e7v: true,
+    e8h: true,
+    e8v: true,
+    f1h: true,
+    f1v: true,
+    f2h: true,
+    f2v: true,
+    f3h: true,
+    f3v: true,
+    f4h: true,
+    f4v: true,
+    f5h: true,
+    f5v: true,
+    f6h: true,
+    f6v: true,
+    f7h: true,
+    f7v: true,
+    f8h: true,
+    f8v: true,
+    g1h: true,
+    g1v: true,
+    g2h: true,
+    g2v: true,
+    g3h: true,
+    g3v: true,
+    g4h: true,
+    g4v: true,
+    g5h: true,
+    g5v: true,
+    g6h: true,
+    g6v: true,
+    g7h: true,
+    g7v: true,
+    g8h: true,
+    g8v: true,
+    h1h: true,
+    h1v: true,
+    h2h: true,
+    h2v: true,
+    h3h: true,
+    h3v: true,
+    h4h: true,
+    h4v: true,
+    h5h: true,
+    h5v: true,
+    h6h: true,
+    h6v: true,
+    h7h: true,
+    h7v: true,
+    h8h: true,
+    h8v: true,
+};
 exports.pawnAndWallPositions = __spreadArray(__spreadArray([], exports.pawnPositions), exports.wallPositions);
@@ -988,3 +1118,3 @@ exports.initialPlayerMatrix = {
 exports.verticalPiecePositions = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-exports.decrementedHorizontalWallPositions = {
+exports.decrementedHorizontalWallCoordinates = {
     b: 'a',
@@ -998,3 +1128,3 @@ c: 'b',
 };
-exports.incrementedHorizontalWallPositions = {
+exports.incrementedHorizontalWallCoordinates = {
     a: 'b',
@@ -1008,3 +1138,3 @@ b: 'c',
 };
-exports.decrementedVerticalWallPositions = {
+exports.decrementedVerticalWallCoordinates = {
     2: 1,
@@ -1018,3 +1148,3 @@ 3: 2,
 };
-exports.incrementedVerticalWallPositions = {
+exports.incrementedVerticalWallCoordinates = {
     1: 2,
@@ -1090,3 +1220,3 @@ 2: 3,
 };
-exports.isIncrementableHorizontalWallPositionMap = {
+exports.isIncrementableHorizontalWallCoordinateMap = {
     a: true,
@@ -1102,3 +1232,3 @@ b: true,
 };
-exports.isDecrementableHorizontalWallPositionMap = {
+exports.isDecrementableHorizontalWallCoordinateMap = {
     a: false,
@@ -1114,3 +1244,3 @@ b: true,
 };
-exports.isIncrementableVerticalWallPositionMap = {
+exports.isIncrementableVerticalWallCoordinateMap = {
     1: true,
@@ -1126,3 +1256,3 @@ 2: true,
 };
-exports.isDecrementableVerticalWallPositionMap = {
+exports.isDecrementableVerticalWallCoordinateMap = {
     1: false,
@@ -1129,0 +1259,0 @@ 2: true,

lib/getUnicodeRepresentation.js

@@ -43,16 +43,16 @@ "use strict";
     board += '│   ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐   │\n';
-    var _loop_1 = function (y) {
+    for (var y = 9; y > 0; y--) {
         var row = "\u2502 " + y + " \u2502";
-        consts_1.horizontalPawnCoordinates.forEach(function (x) {
-            if (game.pieceMatrix["" + x + y] === 0) {
+        for (var _i = 0, horizontalPawnCoordinates_1 = consts_1.horizontalPawnCoordinates; _i < horizontalPawnCoordinates_1.length; _i++) {
+            var x = horizontalPawnCoordinates_1[_i];
+            var pawnPosition = "" + x + y;
+            var verticalWallPosition = "" + x + y + "v";
+            if (game.pieceMatrix[pawnPosition] === 0) {
                 row += '   ';
             }
             else {
-                row += " " + game.pieceMatrix["" + x + y] + " ";
+                row += " " + game.pieceMatrix[pawnPosition] + " ";
             }
-            if (utils_1.isHorizontalWallPosition(x) &&
-                ((utils_1.isVerticalWallPosition(y) &&
-                    game.wallMatrix["" + x + y + "v"]) ||
-                    (utils_1.isDecrementableVerticalWallPosition(y) &&
-                        game.wallMatrix["" + x + utils_1.decrementVerticalWallPosition(y) + "v"]))) {
+            if (utils_1.isWallPosition(verticalWallPosition) &&
+                utils_1.hasWallToTheRight(game, pawnPosition)) {
                 row += '║';
@@ -63,12 +63,11 @@ }
             }
-        });
+        }
         board += row + "   \u2502\n";
         if (y > 1) {
             row = '│   ├';
-            consts_1.horizontalPawnCoordinates.forEach(function (x, index, array) {
-                if (utils_1.isDecrementableVerticalWallPosition(y) &&
-                    ((utils_1.isHorizontalWallPosition(x) &&
-                        game.wallMatrix["" + x + utils_1.decrementVerticalWallPosition(y) + "h"]) ||
-                        (utils_1.isDecrementableHorizontalWallPosition(x) &&
-                            game.wallMatrix["" + utils_1.decrementHorizontalWallPosition(x) + utils_1.decrementVerticalWallPosition(y) + "h"]))) {
+            for (var _a = 0, horizontalPawnCoordinates_2 = consts_1.horizontalPawnCoordinates; _a < horizontalPawnCoordinates_2.length; _a++) {
+                var x = horizontalPawnCoordinates_2[_a];
+                var horizontalWallPosition = "" + x + y + "h";
+                var pawnPosition = "" + x + y;
+                if (utils_1.hasWallBelow(game, pawnPosition)) {
                     row += '═══';
@@ -79,10 +78,12 @@ }
                 }
-                if (utils_1.isHorizontalWallPosition(x)) {
-                    if (utils_1.isDecrementableVerticalWallPosition(y) &&
-                        game.wallMatrix["" + x + utils_1.decrementVerticalWallPosition(y) + "h"]) {
+                if (utils_1.isHorizontalWallCoordinate(x)) {
+                    if (utils_1.isWallPosition(horizontalWallPosition) &&
+                        utils_1.isVerticallyDecrementableWallPosition(horizontalWallPosition) &&
+                        game.wallMatrix[utils_1.moveWallDown(horizontalWallPosition)]) {
                         row += '╪';
                     }
-                    else if (utils_1.isDecrementableVerticalWallPosition(y) &&
-                        game.wallMatrix["" + x + utils_1.decrementVerticalWallPosition(y) + "v"]) {
+                    else if (utils_1.hasWallToTheRight(game, pawnPosition)) {
                         row += '╫';
+                        // Here we don't need to check for horizontal specifically. The x
+                        // coordinate is all that matters.
                     }
@@ -93,9 +94,6 @@ else {
                 }
-            });
+            }
             row += '┤';
             board += row + "   \u2502\n";
         }
-    };
-    for (var y = 9; y > 0; y--) {
-        _loop_1(y);
     }
@@ -102,0 +100,0 @@ board += "\u2502   \u2514\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2518   \u2502\n\u2502   ";

lib/types.d.ts

 export declare type HorizontalPiecePosition = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i';
 export declare type IncrementableHorizontalPiecePosition = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
 export declare type DecrementableHorizontalPiecePosition = 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i';
-export declare type HorizontalWallPosition = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
-export declare type IncrementableHorizontalWallPosition = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g';
-export declare type DecrementableHorizontalWallPosition = 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
+export declare type HorizontalWallCoordinate = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
+export declare type IncrementableHorizontalWallCoordinate = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g';
+export declare type DecrementableHorizontalWallCoordinate = 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
 export declare type VerticalPiecePosition = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 export declare type IncrementableVerticalPiecePosition = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
 export declare type DecrementableVerticalPiecePosition = 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
-export declare type VerticalWallPosition = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
-export declare type IncrementableVerticalWallPosition = 1 | 2 | 3 | 4 | 5 | 6 | 7;
-export declare type DecrementableVerticalWallPosition = 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export declare type VerticalWallCoordinate = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export declare type IncrementableVerticalWallCoordinate = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export declare type DecrementableVerticalWallCoordinate = 2 | 3 | 4 | 5 | 6 | 7 | 8;
 export declare type PiecePosition = {
@@ -23,3 +23,5 @@ x: HorizontalPiecePosition;
 export declare type PawnMove = PawnPosition;
-export declare type WallPosition = 'a1h' | 'a1v' | 'a2h' | 'a2v' | 'a3h' | 'a3v' | 'a4h' | 'a4v' | 'a5h' | 'a5v' | 'a6h' | 'a6v' | 'a7h' | 'a7v' | 'a8h' | 'a8v' | 'b1h' | 'b1v' | 'b2h' | 'b2v' | 'b3h' | 'b3v' | 'b4h' | 'b4v' | 'b5h' | 'b5v' | 'b6h' | 'b6v' | 'b7h' | 'b7v' | 'b8h' | 'b8v' | 'c1h' | 'c1v' | 'c2h' | 'c2v' | 'c3h' | 'c3v' | 'c4h' | 'c4v' | 'c5h' | 'c5v' | 'c6h' | 'c6v' | 'c7h' | 'c7v' | 'c8h' | 'c8v' | 'd1h' | 'd1v' | 'd2h' | 'd2v' | 'd3h' | 'd3v' | 'd4h' | 'd4v' | 'd5h' | 'd5v' | 'd6h' | 'd6v' | 'd7h' | 'd7v' | 'd8h' | 'd8v' | 'e1h' | 'e1v' | 'e2h' | 'e2v' | 'e3h' | 'e3v' | 'e4h' | 'e4v' | 'e5h' | 'e5v' | 'e6h' | 'e6v' | 'e7h' | 'e7v' | 'e8h' | 'e8v' | 'f1h' | 'f1v' | 'f2h' | 'f2v' | 'f3h' | 'f3v' | 'f4h' | 'f4v' | 'f5h' | 'f5v' | 'f6h' | 'f6v' | 'f7h' | 'f7v' | 'f8h' | 'f8v' | 'g1h' | 'g1v' | 'g2h' | 'g2v' | 'g3h' | 'g3v' | 'g4h' | 'g4v' | 'g5h' | 'g5v' | 'g6h' | 'g6v' | 'g7h' | 'g7v' | 'g8h' | 'g8v' | 'h1h' | 'h1v' | 'h2h' | 'h2v' | 'h3h' | 'h3v' | 'h4h' | 'h4v' | 'h5h' | 'h5v' | 'h6h' | 'h6v' | 'h7h' | 'h7v' | 'h8h' | 'h8v';
+export declare type HorizontalWallPosition = 'a1h' | 'a2h' | 'a3h' | 'a4h' | 'a5h' | 'a6h' | 'a7h' | 'a8h' | 'b1h' | 'b2h' | 'b3h' | 'b4h' | 'b5h' | 'b6h' | 'b7h' | 'b8h' | 'c1h' | 'c2h' | 'c3h' | 'c4h' | 'c5h' | 'c6h' | 'c7h' | 'c8h' | 'd1h' | 'd2h' | 'd3h' | 'd4h' | 'd5h' | 'd6h' | 'd7h' | 'd8h' | 'e1h' | 'e2h' | 'e3h' | 'e4h' | 'e5h' | 'e6h' | 'e7h' | 'e8h' | 'f1h' | 'f2h' | 'f3h' | 'f4h' | 'f5h' | 'f6h' | 'f7h' | 'f8h' | 'g1h' | 'g2h' | 'g3h' | 'g4h' | 'g5h' | 'g6h' | 'g7h' | 'g8h' | 'h1h' | 'h2h' | 'h3h' | 'h4h' | 'h5h' | 'h6h' | 'h7h' | 'h8h';
+export declare type VerticalWallPosition = 'a1v' | 'a2v' | 'a3v' | 'a4v' | 'a5v' | 'a6v' | 'a7v' | 'a8v' | 'b1v' | 'b2v' | 'b3v' | 'b4v' | 'b5v' | 'b6v' | 'b7v' | 'b8v' | 'c1v' | 'c2v' | 'c3v' | 'c4v' | 'c5v' | 'c6v' | 'c7v' | 'c8v' | 'd1v' | 'd2v' | 'd3v' | 'd4v' | 'd5v' | 'd6v' | 'd7v' | 'd8v' | 'e1v' | 'e2v' | 'e3v' | 'e4v' | 'e5v' | 'e6v' | 'e7v' | 'e8v' | 'f1v' | 'f2v' | 'f3v' | 'f4v' | 'f5v' | 'f6v' | 'f7v' | 'f8v' | 'g1v' | 'g2v' | 'g3v' | 'g4v' | 'g5v' | 'g6v' | 'g7v' | 'g8v' | 'h1v' | 'h2v' | 'h3v' | 'h4v' | 'h5v' | 'h6v' | 'h7v' | 'h8v';
+export declare type WallPosition = HorizontalWallPosition | VerticalWallPosition;
 export declare type HorizontallyIncrementableWallPosition = 'a1h' | 'a1v' | 'a2h' | 'a2v' | 'a3h' | 'a3v' | 'a4h' | 'a4v' | 'a5h' | 'a5v' | 'a6h' | 'a6v' | 'a7h' | 'a7v' | 'a8h' | 'a8v' | 'b1h' | 'b1v' | 'b2h' | 'b2v' | 'b3h' | 'b3v' | 'b4h' | 'b4v' | 'b5h' | 'b5v' | 'b6h' | 'b6v' | 'b7h' | 'b7v' | 'b8h' | 'b8v' | 'c1h' | 'c1v' | 'c2h' | 'c2v' | 'c3h' | 'c3v' | 'c4h' | 'c4v' | 'c5h' | 'c5v' | 'c6h' | 'c6v' | 'c7h' | 'c7v' | 'c8h' | 'c8v' | 'd1h' | 'd1v' | 'd2h' | 'd2v' | 'd3h' | 'd3v' | 'd4h' | 'd4v' | 'd5h' | 'd5v' | 'd6h' | 'd6v' | 'd7h' | 'd7v' | 'd8h' | 'd8v' | 'e1h' | 'e1v' | 'e2h' | 'e2v' | 'e3h' | 'e3v' | 'e4h' | 'e4v' | 'e5h' | 'e5v' | 'e6h' | 'e6v' | 'e7h' | 'e7v' | 'e8h' | 'e8v' | 'f1h' | 'f1v' | 'f2h' | 'f2v' | 'f3h' | 'f3v' | 'f4h' | 'f4v' | 'f5h' | 'f5v' | 'f6h' | 'f6v' | 'f7h' | 'f7v' | 'f8h' | 'f8v' | 'g1h' | 'g1v' | 'g2h' | 'g2v' | 'g3h' | 'g3v' | 'g4h' | 'g4v' | 'g5h' | 'g5v' | 'g6h' | 'g6v' | 'g7h' | 'g7v' | 'g8h' | 'g8v';
@@ -26,0 +28,0 @@ export declare type HorizontallyDecrementableWallPosition = 'b1h' | 'b1v' | 'b2h' | 'b2v' | 'b3h' | 'b3v' | 'b4h' | 'b4v' | 'b5h' | 'b5v' | 'b6h' | 'b6v' | 'b7h' | 'b7v' | 'b8h' | 'b8v' | 'c1h' | 'c1v' | 'c2h' | 'c2v' | 'c3h' | 'c3v' | 'c4h' | 'c4v' | 'c5h' | 'c5v' | 'c6h' | 'c6v' | 'c7h' | 'c7v' | 'c8h' | 'c8v' | 'd1h' | 'd1v' | 'd2h' | 'd2v' | 'd3h' | 'd3v' | 'd4h' | 'd4v' | 'd5h' | 'd5v' | 'd6h' | 'd6v' | 'd7h' | 'd7v' | 'd8h' | 'd8v' | 'e1h' | 'e1v' | 'e2h' | 'e2v' | 'e3h' | 'e3v' | 'e4h' | 'e4v' | 'e5h' | 'e5v' | 'e6h' | 'e6v' | 'e7h' | 'e7v' | 'e8h' | 'e8v' | 'f1h' | 'f1v' | 'f2h' | 'f2v' | 'f3h' | 'f3v' | 'f4h' | 'f4v' | 'f5h' | 'f5v' | 'f6h' | 'f6v' | 'f7h' | 'f7v' | 'f8h' | 'f8v' | 'g1h' | 'g1v' | 'g2h' | 'g2v' | 'g3h' | 'g3v' | 'g4h' | 'g4v' | 'g5h' | 'g5v' | 'g6h' | 'g6v' | 'g7h' | 'g7v' | 'g8h' | 'g8v' | 'h1h' | 'h1v' | 'h2h' | 'h2v' | 'h3h' | 'h3v' | 'h4h' | 'h4v' | 'h5h' | 'h5v' | 'h6h' | 'h6v' | 'h7h' | 'h7v' | 'h8h' | 'h8v';

lib/utils.d.ts

@@ -1,4 +0,4 @@
-import { DecrementableHorizontalWallPosition, DecrementableVerticalWallPosition, Game, HorizontallyDecrementablePawnPosition, HorizontallyIncrementablePawnPosition, HorizontalPiecePosition, HorizontalWallPosition, IncrementableHorizontalWallPosition, IncrementableVerticalWallPosition, Move, PawnMove, PawnPosition, Player, VerticallyDecrementablePawnPosition, VerticallyIncrementablePawnPosition, VerticalPiecePosition, VerticalWallPosition, WallMove, WallOrientation, WallPosition } from './types';
+import { DecrementableHorizontalWallCoordinate, DecrementableVerticalWallCoordinate, Game, HorizontallyDecrementablePawnPosition, HorizontallyDecrementableWallPosition, HorizontallyIncrementablePawnPosition, HorizontalPiecePosition, HorizontalWallCoordinate, IncrementableHorizontalWallCoordinate, IncrementableVerticalWallCoordinate, PawnMove, PawnPosition, Player, VerticallyDecrementablePawnPosition, VerticallyDecrementableWallPosition, VerticallyIncrementablePawnPosition, VerticalPiecePosition, VerticalWallCoordinate, WallMove, WallOrientation, WallPosition } from './types';
 declare type GetHorizontalCoordinate = {
-    (move: WallPosition): HorizontalWallPosition;
+    (move: WallPosition): HorizontalWallCoordinate;
     (move: PawnPosition): HorizontalPiecePosition;
@@ -8,3 +8,3 @@ };
 declare type GetVerticalCoordinate = {
-    (move: WallPosition): VerticalWallPosition;
+    (move: WallPosition): VerticalWallCoordinate;
     (move: PawnPosition): VerticalPiecePosition;
@@ -14,9 +14,11 @@ };
 export declare const getWallOrientation: (move: WallMove) => WallOrientation;
-export declare const decrementHorizontalWallPosition: (horizontalWallPosition: DecrementableHorizontalWallPosition) => IncrementableHorizontalWallPosition;
-export declare const decrementVerticalWallPosition: (verticalWallPosition: DecrementableVerticalWallPosition) => IncrementableVerticalWallPosition;
+export declare const decrementHorizontalWallCoordinate: (HorizontalWallCoordinate: DecrementableHorizontalWallCoordinate) => IncrementableHorizontalWallCoordinate;
+export declare const decrementVerticalWallCoordinate: (verticalWallPosition: DecrementableVerticalWallCoordinate) => IncrementableVerticalWallCoordinate;
 export declare const isHorizontalWallMove: (move: PawnMove | WallMove) => move is WallPosition;
 export declare const isPawnMove: (move: PawnMove | WallMove) => move is PawnPosition;
 export declare const doesWallMoveOverlapExistingWall: (game: Game, wallMove: WallMove) => boolean;
-export declare const isWallPosition: (move: Move) => move is WallPosition;
+export declare const isWallPosition: (move: string) => move is WallPosition;
 export declare const getOppositePlayer: (player: Player) => 1 | 2;
+export declare const hasWallToTheRight: (game: Game, move: PawnMove) => true | undefined;
+export declare const hasWallBelow: (game: Game, move: PawnMove) => boolean;
 export declare const isValidAStarMove: (game: Game, currentPosition: PawnPosition, move: PawnMove) => boolean;
@@ -35,8 +37,12 @@ export declare const isValidNormalMove: (game: Game, currentPosition: PawnPosition, move: PawnMove) => boolean;
 export declare const getValidPawnMoveArray: (game: Game) => PawnPosition[];
+export declare const moveWallLeft: (wall: HorizontallyDecrementableWallPosition) => WallPosition;
+export declare const moveWallDown: (wall: VerticallyDecrementableWallPosition) => WallPosition;
 export declare const getNumberOfNeighborWalls: (game: Game, wallMove: WallMove) => number;
 export declare const isWallAdjacentToAtLeastOnePawn: (game: Game, wall: WallPosition) => boolean;
-export declare const isHorizontalWallPosition: (horizontalPosition: HorizontalPiecePosition | HorizontalWallPosition) => horizontalPosition is HorizontalWallPosition;
-export declare const isVerticalWallPosition: (verticalPosition: VerticalPiecePosition | VerticalWallPosition) => verticalPosition is VerticalWallPosition;
-export declare const isDecrementableHorizontalWallPosition: (horizontalPosition: HorizontalPiecePosition | HorizontalWallPosition) => horizontalPosition is DecrementableHorizontalWallPosition;
-export declare const isDecrementableVerticalWallPosition: (horizontalPosition: VerticalPiecePosition | VerticalWallPosition) => horizontalPosition is DecrementableVerticalWallPosition;
+export declare const isHorizontalWallCoordinate: (horizontalPosition: HorizontalPiecePosition | HorizontalWallCoordinate) => horizontalPosition is HorizontalWallCoordinate;
+export declare const isVerticalWallCoordinate: (verticalPosition: VerticalPiecePosition | VerticalWallCoordinate) => verticalPosition is VerticalWallCoordinate;
+export declare const isDecrementableHorizontalWallCoordinate: (horizontalPosition: HorizontalPiecePosition | HorizontalWallCoordinate) => horizontalPosition is DecrementableHorizontalWallCoordinate;
+export declare const isDecrementableVerticalWallCoordinate: (horizontalPosition: VerticalPiecePosition | VerticalWallCoordinate) => horizontalPosition is DecrementableVerticalWallCoordinate;
+export declare const isHorizontallyDecrementableWallPosition: (wallPosition: WallPosition) => wallPosition is HorizontallyDecrementableWallPosition;
+export declare const isVerticallyDecrementableWallPosition: (wallPosition: WallPosition) => wallPosition is VerticallyDecrementableWallPosition;
 export declare const overlapsPath: (path: PawnPosition[], wallMove: WallPosition) => boolean;
@@ -43,0 +49,0 @@ export declare const getValidWallMoveArray: (game: Game) => WallPosition[];

lib/utils.js

@@ -8,3 +8,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rest = exports.last = exports.first = exports.butlast = exports.getValidWallMoveArray = exports.overlapsPath = exports.isDecrementableVerticalWallPosition = exports.isDecrementableHorizontalWallPosition = exports.isVerticalWallPosition = exports.isHorizontalWallPosition = exports.isWallAdjacentToAtLeastOnePawn = exports.getNumberOfNeighborWalls = exports.getValidPawnMoveArray = exports.isHorizontallyDecrementablePawnPosition = exports.horizontallyDecrementPawnPosition = exports.isHorizontallyIncrementablePawnPosition = exports.horizontallyIncrementPawnPosition = exports.isVerticallyDecrementablePawnPosition = exports.verticallyDecrementPawnPosition = exports.isVerticallyIncrementablePawnPosition = exports.verticallyIncrementPawnPosition = exports.doesHorizontalWallBlockPlayer = exports.getShortestPathWithNoObstacles = exports.isValidNormalMove = exports.isValidAStarMove = exports.getOppositePlayer = exports.isWallPosition = exports.doesWallMoveOverlapExistingWall = exports.isPawnMove = exports.isHorizontalWallMove = exports.decrementVerticalWallPosition = exports.decrementHorizontalWallPosition = exports.getWallOrientation = exports.getVerticalCoordinate = exports.getHorizontalCoordinate = void 0;
+exports.rest = exports.last = exports.first = exports.butlast = exports.getValidWallMoveArray = exports.overlapsPath = exports.isVerticallyDecrementableWallPosition = exports.isHorizontallyDecrementableWallPosition = exports.isDecrementableVerticalWallCoordinate = exports.isDecrementableHorizontalWallCoordinate = exports.isVerticalWallCoordinate = exports.isHorizontalWallCoordinate = exports.isWallAdjacentToAtLeastOnePawn = exports.getNumberOfNeighborWalls = exports.moveWallDown = exports.moveWallLeft = exports.getValidPawnMoveArray = exports.isHorizontallyDecrementablePawnPosition = exports.horizontallyDecrementPawnPosition = exports.isHorizontallyIncrementablePawnPosition = exports.horizontallyIncrementPawnPosition = exports.isVerticallyDecrementablePawnPosition = exports.verticallyDecrementPawnPosition = exports.isVerticallyIncrementablePawnPosition = exports.verticallyIncrementPawnPosition = exports.doesHorizontalWallBlockPlayer = exports.getShortestPathWithNoObstacles = exports.isValidNormalMove = exports.isValidAStarMove = exports.hasWallBelow = exports.hasWallToTheRight = exports.getOppositePlayer = exports.isWallPosition = exports.doesWallMoveOverlapExistingWall = exports.isPawnMove = exports.isHorizontalWallMove = exports.decrementVerticalWallCoordinate = exports.decrementHorizontalWallCoordinate = exports.getWallOrientation = exports.getVerticalCoordinate = exports.getHorizontalCoordinate = void 0;
 var consts_1 = require("./consts");
@@ -29,11 +29,11 @@ var getShortestPath_1 = require("./getShortestPath");
 };
-var decrementHorizontalWallPosition = function (horizontalWallPosition) {
-    return consts_1.decrementedHorizontalWallPositions[horizontalWallPosition];
+var decrementHorizontalWallCoordinate = function (HorizontalWallCoordinate) {
+    return consts_1.decrementedHorizontalWallCoordinates[HorizontalWallCoordinate];
 };
-exports.decrementHorizontalWallPosition = decrementHorizontalWallPosition;
+exports.decrementHorizontalWallCoordinate = decrementHorizontalWallCoordinate;
 var decrementHorizontalPiecePosition = function (horizontalPiecePosition) {
     return consts_1.decrementedHorizontalPiecePositions[horizontalPiecePosition];
 };
-var incrementHorizontalWallPosition = function (horizontalWallPosition) {
-    return consts_1.incrementedHorizontalWallPositions[horizontalWallPosition];
+var incrementHorizontalWallCoordinate = function (HorizontalWallCoordinate) {
+    return consts_1.incrementedHorizontalWallCoordinates[HorizontalWallCoordinate];
 };
@@ -43,11 +43,11 @@ var incrementHorizontalPiecePosition = function (horizontalPiecePosition) {
 };
-var decrementVerticalWallPosition = function (verticalWallPosition) {
-    return consts_1.decrementedVerticalWallPositions[verticalWallPosition];
+var decrementVerticalWallCoordinate = function (verticalWallPosition) {
+    return consts_1.decrementedVerticalWallCoordinates[verticalWallPosition];
 };
-exports.decrementVerticalWallPosition = decrementVerticalWallPosition;
+exports.decrementVerticalWallCoordinate = decrementVerticalWallCoordinate;
 var decrementVerticalPiecePosition = function (verticalPiecePosition) {
     return consts_1.decrementedVerticalPiecePositions[verticalPiecePosition];
 };
-var incrementVerticalWallPosition = function (verticalWallPosition) {
-    return consts_1.incrementedVerticalWallPositions[verticalWallPosition];
+var incrementVerticalWallCoordinate = function (verticalWallPosition) {
+    return consts_1.incrementedVerticalWallCoordinates[verticalWallPosition];
 };
@@ -74,4 +74,4 @@ var incrementVerticalPiecePosition = function (verticalPiecePosition) {
             game.wallMatrix[rotateWall(wallMove)] ||
-            (isHorizontallyDecrementableWallPosition(wallMove) &&
-                game.wallMatrix[moveWallLeft(wallMove)]) ||
+            (exports.isHorizontallyDecrementableWallPosition(wallMove) &&
+                game.wallMatrix[exports.moveWallLeft(wallMove)]) ||
             (isHorizontallyIncrementableWallPosition(wallMove) &&
@@ -85,4 +85,4 @@ game.wallMatrix[moveWallRight(wallMove)])) {
             game.wallMatrix[rotateWall(wallMove)] ||
-            (isVerticallyDecrementableWallPosition(wallMove) &&
-                game.wallMatrix[moveWallDown(wallMove)]) ||
+            (exports.isVerticallyDecrementableWallPosition(wallMove) &&
+                game.wallMatrix[exports.moveWallDown(wallMove)]) ||
             (isVerticallyIncrementableWallPosition(wallMove) &&
@@ -97,3 +97,3 @@ game.wallMatrix[moveWallUp(wallMove)])) {
 var isWallPosition = function (move) {
-    return move.length === 3;
+    return Boolean(consts_1.isWallPositionMap[move]);
 };
@@ -116,7 +116,7 @@ exports.isWallPosition = isWallPosition;
     var verticalCoordinate = exports.getVerticalCoordinate(move);
-    if ((exports.isHorizontalWallPosition(horizontalCoordinate) &&
-        exports.isVerticalWallPosition(verticalCoordinate) &&
+    if ((exports.isHorizontalWallCoordinate(horizontalCoordinate) &&
+        exports.isVerticalWallCoordinate(verticalCoordinate) &&
         game.wallMatrix["" + horizontalCoordinate + verticalCoordinate + "h"]) ||
         (isDecrementableHorizontalPiecePosition(horizontalCoordinate) &&
-            exports.isVerticalWallPosition(verticalCoordinate) &&
+            exports.isVerticalWallCoordinate(verticalCoordinate) &&
             game.wallMatrix["" + decrementHorizontalPiecePosition(horizontalCoordinate) + verticalCoordinate + "h"])) {
@@ -158,7 +158,7 @@ return true;
     if ((exports.getVerticalCoordinate(move) < 9 &&
-        exports.isHorizontalWallPosition(horizontalCoordinate) &&
-        exports.isVerticalWallPosition(verticalCoordinate) &&
+        exports.isHorizontalWallCoordinate(horizontalCoordinate) &&
+        exports.isVerticalWallCoordinate(verticalCoordinate) &&
         game.wallMatrix["" + horizontalCoordinate + verticalCoordinate + "v"]) ||
         (exports.getVerticalCoordinate(move) > 1 &&
-            exports.isHorizontalWallPosition(horizontalCoordinate) &&
+            exports.isHorizontalWallCoordinate(horizontalCoordinate) &&
             isDecrementableVerticalPiecePosition(verticalCoordinate) &&
@@ -169,2 +169,3 @@ game.wallMatrix["" + horizontalCoordinate + decrementVerticalPiecePosition(verticalCoordinate) + "v"])) {
 };
+exports.hasWallToTheRight = hasWallToTheRight;
 var isUpRightMove = function (currentPosition, move) {
@@ -196,3 +197,3 @@ if (exports.getVerticalCoordinate(currentPosition) - exports.getVerticalCoordinate(move) ===
         isDecrementableHorizontalPiecePosition(horizontalCoordinate) &&
-        exports.isVerticalWallPosition(verticalCoordinate) &&
+        exports.isVerticalWallCoordinate(verticalCoordinate) &&
         game.wallMatrix["" + decrementHorizontalPiecePosition(horizontalCoordinate) + verticalCoordinate + "v"]) ||
@@ -246,3 +247,3 @@ (exports.getVerticalCoordinate(move) > 1 &&
     var verticalCoordinate = exports.getVerticalCoordinate(move);
-    if ((exports.isHorizontalWallPosition(horizontalCoordinate) &&
+    if ((exports.isHorizontalWallCoordinate(horizontalCoordinate) &&
         isDecrementableVerticalPiecePosition(verticalCoordinate) &&
@@ -258,2 +259,3 @@ game.wallMatrix["" + horizontalCoordinate + decrementVerticalPiecePosition(verticalCoordinate) + "h"]) ||
 };
+exports.hasWallBelow = hasWallBelow;
 var isSingleDownMove = function (currentPosition, move) {
@@ -369,7 +371,7 @@ if (exports.getVerticalCoordinate(currentPosition) - exports.getVerticalCoordinate(move) ===
     if (isSingleRightMove(currentPosition, move)) {
-        return !hasWallToTheRight(game, currentPosition);
+        return !exports.hasWallToTheRight(game, currentPosition);
     }
     // If down move
     if (isSingleDownMove(currentPosition, move)) {
-        return !hasWallBelow(game, currentPosition);
+        return !exports.hasWallBelow(game, currentPosition);
     }
@@ -424,3 +426,3 @@ // If left move
         if (exports.isVerticallyIncrementablePawnPosition(currentPosition) &&
-            hasWallToTheRight(game, exports.verticallyIncrementPawnPosition(currentPosition))) {
+            exports.hasWallToTheRight(game, exports.verticallyIncrementPawnPosition(currentPosition))) {
             return false;
@@ -447,3 +449,3 @@ }
     if (isSingleRightMove(currentPosition, move)) {
-        if (hasWallToTheRight(game, currentPosition))
+        if (exports.hasWallToTheRight(game, currentPosition))
             return false;
@@ -454,6 +456,6 @@ return true;
         hasOpponentToTheRight(game, currentPosition)) {
-        if (hasWallToTheRight(game, currentPosition))
+        if (exports.hasWallToTheRight(game, currentPosition))
             return false;
         if (exports.isHorizontallyIncrementablePawnPosition(currentPosition) &&
-            hasWallToTheRight(game, exports.horizontallyIncrementPawnPosition(currentPosition))) {
+            exports.hasWallToTheRight(game, exports.horizontallyIncrementPawnPosition(currentPosition))) {
             return false;
@@ -466,7 +468,7 @@ }
         if (exports.isHorizontallyIncrementablePawnPosition(currentPosition) &&
-            !hasWallToTheRight(game, exports.horizontallyIncrementPawnPosition(currentPosition)) &&
+            !exports.hasWallToTheRight(game, exports.horizontallyIncrementPawnPosition(currentPosition)) &&
             !isOnRightmostRow(exports.horizontallyIncrementPawnPosition(currentPosition))) {
             return false;
         }
-        if (hasWallToTheRight(game, currentPosition))
+        if (exports.hasWallToTheRight(game, currentPosition))
             return false;
@@ -482,10 +484,10 @@ if (exports.isHorizontallyIncrementablePawnPosition(currentPosition) &&
         if (exports.isHorizontallyIncrementablePawnPosition(currentPosition) &&
-            !hasWallToTheRight(game, exports.horizontallyIncrementPawnPosition(currentPosition)) &&
+            !exports.hasWallToTheRight(game, exports.horizontallyIncrementPawnPosition(currentPosition)) &&
             !isOnRightmostRow(exports.horizontallyIncrementPawnPosition(currentPosition))) {
             return false;
         }
-        if (hasWallToTheRight(game, currentPosition))
+        if (exports.hasWallToTheRight(game, currentPosition))
             return false;
         if (exports.isHorizontallyIncrementablePawnPosition(currentPosition) &&
-            hasWallBelow(game, exports.horizontallyIncrementPawnPosition(currentPosition))) {
+            exports.hasWallBelow(game, exports.horizontallyIncrementPawnPosition(currentPosition))) {
             return false;
@@ -497,3 +499,3 @@ }
     if (isSingleDownMove(currentPosition, move)) {
-        if (hasWallBelow(game, currentPosition)) {
+        if (exports.hasWallBelow(game, currentPosition)) {
             return false;
@@ -505,6 +507,6 @@ }
         hasOpponentBelow(game, currentPosition)) {
-        if (hasWallBelow(game, currentPosition))
+        if (exports.hasWallBelow(game, currentPosition))
             return false;
         if (exports.isVerticallyDecrementablePawnPosition(currentPosition) &&
-            hasWallBelow(game, exports.verticallyDecrementPawnPosition(currentPosition))) {
+            exports.hasWallBelow(game, exports.verticallyDecrementPawnPosition(currentPosition))) {
             return false;
@@ -517,10 +519,10 @@ }
         if (exports.isVerticallyDecrementablePawnPosition(currentPosition) &&
-            !hasWallBelow(game, exports.verticallyDecrementPawnPosition(currentPosition)) &&
+            !exports.hasWallBelow(game, exports.verticallyDecrementPawnPosition(currentPosition)) &&
             !isOnBottomRow(exports.verticallyDecrementPawnPosition(currentPosition))) {
             return false;
         }
-        if (hasWallBelow(game, currentPosition))
+        if (exports.hasWallBelow(game, currentPosition))
             return false;
         if (exports.isVerticallyDecrementablePawnPosition(currentPosition) &&
-            hasWallToTheRight(game, exports.verticallyDecrementPawnPosition(currentPosition)) &&
+            exports.hasWallToTheRight(game, exports.verticallyDecrementPawnPosition(currentPosition)) &&
             !isOnBottomRow(exports.verticallyDecrementPawnPosition(currentPosition))) {
@@ -534,7 +536,7 @@ return false;
         if (exports.isVerticallyDecrementablePawnPosition(currentPosition) &&
-            !hasWallBelow(game, exports.verticallyDecrementPawnPosition(currentPosition)) &&
+            !exports.hasWallBelow(game, exports.verticallyDecrementPawnPosition(currentPosition)) &&
             !isOnBottomRow(exports.verticallyDecrementPawnPosition(currentPosition))) {
             return false;
         }
-        if (hasWallBelow(game, currentPosition))
+        if (exports.hasWallBelow(game, currentPosition))
             return false;
@@ -573,3 +575,3 @@ if (exports.isVerticallyDecrementablePawnPosition(currentPosition) &&
         if (exports.isHorizontallyDecrementablePawnPosition(currentPosition) &&
-            hasWallBelow(game, exports.horizontallyDecrementPawnPosition(currentPosition))) {
+            exports.hasWallBelow(game, exports.horizontallyDecrementPawnPosition(currentPosition))) {
             return false;
@@ -612,4 +614,4 @@ }
     var wallOverlapsWithPlayerColumn = playerX === wallX ||
-        (isIncrementableHorizontalWallPosition(wallX) &&
-            playerX === incrementHorizontalWallPosition(wallX));
+        (isIncrementableHorizontalWallCoordinate(wallX) &&
+            playerX === incrementHorizontalWallCoordinate(wallX));
     if (!wallOverlapsWithPlayerColumn)
@@ -755,4 +757,4 @@ return false;
             game.wallMatrix[rotateWall(wallMove)] ||
-            (isHorizontallyDecrementableWallPosition(wallMove) &&
-                game.wallMatrix[moveWallLeft(wallMove)]) ||
+            (exports.isHorizontallyDecrementableWallPosition(wallMove) &&
+                game.wallMatrix[exports.moveWallLeft(wallMove)]) ||
             (isHorizontallyIncrementableWallPosition(wallMove) &&
@@ -766,4 +768,4 @@ game.wallMatrix[moveWallRight(wallMove)])) {
             game.wallMatrix[wallMove] ||
-            (isVerticallyDecrementableWallPosition(wallMove) &&
-                game.wallMatrix[moveWallDown(wallMove)]) ||
+            (exports.isVerticallyDecrementableWallPosition(wallMove) &&
+                game.wallMatrix[exports.moveWallDown(wallMove)]) ||
             (isVerticallyIncrementableWallPosition(wallMove) &&
@@ -778,3 +780,3 @@ game.wallMatrix[moveWallUp(wallMove)])) {
     var x = wall.charAt(0);
-    var newX = incrementHorizontalWallPosition(x);
+    var newX = incrementHorizontalWallCoordinate(x);
     return "" + newX + wall.substring(1);
@@ -784,8 +786,9 @@ };
     var x = wall.charAt(0);
-    var newX = exports.decrementHorizontalWallPosition(x);
+    var newX = exports.decrementHorizontalWallCoordinate(x);
     return "" + newX + wall.substring(1);
 };
+exports.moveWallLeft = moveWallLeft;
 var moveWallUp = function (wall) {
     var y = Number(wall.charAt(1));
-    var newY = incrementVerticalWallPosition(y);
+    var newY = incrementVerticalWallCoordinate(y);
     return "" + wall.charAt(0) + newY + wall.charAt(2);
@@ -795,5 +798,6 @@ };
     var y = Number(wall.charAt(1));
-    var newY = exports.decrementVerticalWallPosition(y);
+    var newY = exports.decrementVerticalWallCoordinate(y);
     return "" + wall.charAt(0) + newY + wall.charAt(2);
 };
+exports.moveWallDown = moveWallDown;
 var rotateWall = function (wall) {
@@ -815,4 +819,4 @@ return "" + wall.substring(0, 2) + (wall.charAt(2) === 'v' ? 'h' : 'v');
     var verticalWallAboveLeft = [wallMove]
-        .filter(isHorizontallyDecrementableWallPosition)
-        .map(moveWallLeft)
+        .filter(exports.isHorizontallyDecrementableWallPosition)
+        .map(exports.moveWallLeft)
         .map(rotateWall)
@@ -830,4 +834,4 @@ .filter(isVerticallyIncrementableWallPosition)
         .map(rotateWall)
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)[0];
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)[0];
     if (!verticalWallBelowRight)
@@ -839,7 +843,7 @@ return false;
     var verticalWallBelowLeft = [wallMove]
-        .filter(isHorizontallyDecrementableWallPosition)
-        .map(moveWallLeft)
+        .filter(exports.isHorizontallyDecrementableWallPosition)
+        .map(exports.moveWallLeft)
         .map(rotateWall)
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)[0];
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)[0];
     if (!verticalWallBelowLeft)
@@ -861,6 +865,6 @@ return false;
     var horizontalWallLeft = [wallMove]
-        .filter(isHorizontallyDecrementableWallPosition)
-        .map(moveWallLeft)
-        .filter(isHorizontallyDecrementableWallPosition)
-        .map(moveWallLeft)[0];
+        .filter(exports.isHorizontallyDecrementableWallPosition)
+        .map(exports.moveWallLeft)
+        .filter(exports.isHorizontallyDecrementableWallPosition)
+        .map(exports.moveWallLeft)[0];
     if (!horizontalWallLeft)
@@ -881,4 +885,4 @@ return false;
     var verticalWallBelow = [wallMove]
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)
         .map(rotateWall)[0];
@@ -902,4 +906,4 @@ if (!verticalWallBelow)
     var horizontalWallAboveLeft = [wallMove]
-        .filter(isHorizontallyDecrementableWallPosition)
-        .map(moveWallLeft)
+        .filter(exports.isHorizontallyDecrementableWallPosition)
+        .map(exports.moveWallLeft)
         .map(rotateWall)
@@ -917,4 +921,4 @@ .filter(isVerticallyIncrementableWallPosition)
         .map(rotateWall)
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)[0];
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)[0];
     if (!horizontalWallBelowRight)
@@ -926,7 +930,7 @@ return false;
     var horizontalWallBelowLeft = [wallMove]
-        .filter(isHorizontallyDecrementableWallPosition)
-        .map(moveWallLeft)
+        .filter(exports.isHorizontallyDecrementableWallPosition)
+        .map(exports.moveWallLeft)
         .map(rotateWall)
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)[0];
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)[0];
     if (!horizontalWallBelowLeft)
@@ -948,6 +952,6 @@ return false;
     var verticalWallBelow = [wallMove]
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)[0];
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)[0];
     if (!verticalWallBelow)
@@ -968,4 +972,4 @@ return false;
     var horizontalWallBelow = [wallMove]
-        .filter(isVerticallyDecrementableWallPosition)
-        .map(moveWallDown)
+        .filter(exports.isVerticallyDecrementableWallPosition)
+        .map(exports.moveWallDown)
         .map(rotateWall)[0];
@@ -1028,6 +1032,6 @@ if (!horizontalWallBelow)
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         wallY === pawnY) {
@@ -1040,4 +1044,4 @@ return true;
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         wallY === pawnY) {
@@ -1051,4 +1055,4 @@ return true;
             [wallX]
-                .filter(exports.isDecrementableHorizontalWallPosition)
-                .map(exports.decrementHorizontalWallPosition)[0] === pawnX &&
+                .filter(exports.isDecrementableHorizontalWallCoordinate)
+                .map(exports.decrementHorizontalWallCoordinate)[0] === pawnX &&
             wallY === pawnY) {
@@ -1064,7 +1068,7 @@ //    ––
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         [wallY]
-            .filter(exports.isDecrementableVerticalWallPosition)
-            .map(exports.decrementVerticalWallPosition)[0] === pawnY) {
+            .filter(exports.isDecrementableVerticalWallCoordinate)
+            .map(exports.decrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1076,4 +1080,4 @@ }
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         wallY === pawnY) {
@@ -1086,7 +1090,7 @@ return true;
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1099,9 +1103,9 @@ }
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1115,4 +1119,4 @@ }
         [wallY]
-            .filter(exports.isDecrementableVerticalWallPosition)
-            .map(exports.decrementVerticalWallPosition)[0] === pawnY) {
+            .filter(exports.isDecrementableVerticalWallCoordinate)
+            .map(exports.decrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1130,4 +1134,4 @@ }
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1141,6 +1145,6 @@ }
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1152,9 +1156,9 @@ }
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1166,7 +1170,7 @@ }
         [wallX]
-            .filter(isIncrementableHorizontalWallPosition)
-            .map(incrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(isIncrementableHorizontalWallCoordinate)
+            .map(incrementHorizontalWallCoordinate)[0] === pawnX &&
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1179,4 +1183,4 @@ }
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1188,7 +1192,7 @@ }
         [wallX]
-            .filter(exports.isDecrementableHorizontalWallPosition)
-            .map(exports.decrementHorizontalWallPosition)[0] === pawnX &&
+            .filter(exports.isDecrementableHorizontalWallCoordinate)
+            .map(exports.decrementHorizontalWallCoordinate)[0] === pawnX &&
         [wallY]
-            .filter(isIncrementableVerticalWallPosition)
-            .map(incrementVerticalWallPosition)[0] === pawnY) {
+            .filter(isIncrementableVerticalWallCoordinate)
+            .map(incrementVerticalWallCoordinate)[0] === pawnY) {
         return true;
@@ -1212,24 +1216,24 @@ }
 };
-var isHorizontalWallPosition = function (horizontalPosition) {
+var isHorizontalWallCoordinate = function (horizontalPosition) {
     return consts_1.isHorizontalWallCoordinateMap[horizontalPosition];
 };
-exports.isHorizontalWallPosition = isHorizontalWallPosition;
-var isVerticalWallPosition = function (verticalPosition) {
+exports.isHorizontalWallCoordinate = isHorizontalWallCoordinate;
+var isVerticalWallCoordinate = function (verticalPosition) {
     return consts_1.isVerticalWallCoordinateMap[verticalPosition];
 };
-exports.isVerticalWallPosition = isVerticalWallPosition;
-var isIncrementableHorizontalWallPosition = function (horizontalPosition) {
-    return consts_1.isIncrementableHorizontalWallPositionMap[horizontalPosition];
+exports.isVerticalWallCoordinate = isVerticalWallCoordinate;
+var isIncrementableHorizontalWallCoordinate = function (horizontalPosition) {
+    return consts_1.isIncrementableHorizontalWallCoordinateMap[horizontalPosition];
 };
-var isDecrementableHorizontalWallPosition = function (horizontalPosition) {
-    return consts_1.isDecrementableHorizontalWallPositionMap[horizontalPosition];
+var isDecrementableHorizontalWallCoordinate = function (horizontalPosition) {
+    return consts_1.isDecrementableHorizontalWallCoordinateMap[horizontalPosition];
 };
-exports.isDecrementableHorizontalWallPosition = isDecrementableHorizontalWallPosition;
-var isIncrementableVerticalWallPosition = function (horizontalPosition) {
-    return consts_1.isIncrementableVerticalWallPositionMap[horizontalPosition];
+exports.isDecrementableHorizontalWallCoordinate = isDecrementableHorizontalWallCoordinate;
+var isIncrementableVerticalWallCoordinate = function (horizontalPosition) {
+    return consts_1.isIncrementableVerticalWallCoordinateMap[horizontalPosition];
 };
-var isDecrementableVerticalWallPosition = function (horizontalPosition) {
-    return consts_1.isDecrementableVerticalWallPositionMap[horizontalPosition];
+var isDecrementableVerticalWallCoordinate = function (horizontalPosition) {
+    return consts_1.isDecrementableVerticalWallCoordinateMap[horizontalPosition];
 };
-exports.isDecrementableVerticalWallPosition = isDecrementableVerticalWallPosition;
+exports.isDecrementableVerticalWallCoordinate = isDecrementableVerticalWallCoordinate;
 var isHorizontallyIncrementableWallPosition = function (wallPosition) {
@@ -1241,2 +1245,3 @@ return consts_1.horizontallyIncrementableWallPositions.includes(wallPosition);
 };
+exports.isHorizontallyDecrementableWallPosition = isHorizontallyDecrementableWallPosition;
 var isVerticallyIncrementableWallPosition = function (wallPosition) {
@@ -1248,2 +1253,3 @@ return consts_1.verticallyIncrementableWallPositions.includes(wallPosition);
 };
+exports.isVerticallyDecrementableWallPosition = isVerticallyDecrementableWallPosition;
 // Piece
@@ -1277,5 +1283,5 @@ var isIncrementableHorizontalPiecePosition = function (horizontalPiecePosition) {
         var horizontalWallCoordinate = exports.getHorizontalCoordinate(wallMove);
-        return (isIncrementableHorizontalWallPosition(horizontalWallCoordinate) &&
+        return (isIncrementableHorizontalWallCoordinate(horizontalWallCoordinate) &&
             exports.getHorizontalCoordinate(pathStep) ===
-                incrementHorizontalWallPosition(horizontalWallCoordinate) &&
+                incrementHorizontalWallCoordinate(horizontalWallCoordinate) &&
             exports.getVerticalCoordinate(pathStep) === exports.getVerticalCoordinate(wallMove));
@@ -1285,5 +1291,5 @@ }) &&
             var horizontalWallCoordinate = exports.getHorizontalCoordinate(wallMove);
-            return (isIncrementableHorizontalWallPosition(horizontalWallCoordinate) &&
+            return (isIncrementableHorizontalWallCoordinate(horizontalWallCoordinate) &&
                 exports.getHorizontalCoordinate(pathStep) ===
-                    incrementHorizontalWallPosition(horizontalWallCoordinate) &&
+                    incrementHorizontalWallCoordinate(horizontalWallCoordinate) &&
                 exports.getVerticalCoordinate(pathStep) === exports.getVerticalCoordinate(wallMove) + 1);
@@ -1300,5 +1306,5 @@ })) {
             var horizontalWallCoordinate = exports.getHorizontalCoordinate(wallMove);
-            return (isIncrementableHorizontalWallPosition(horizontalWallCoordinate) &&
+            return (isIncrementableHorizontalWallCoordinate(horizontalWallCoordinate) &&
                 exports.getHorizontalCoordinate(pathStep) ===
-                    incrementHorizontalWallPosition(horizontalWallCoordinate) &&
+                    incrementHorizontalWallCoordinate(horizontalWallCoordinate) &&
                 exports.getVerticalCoordinate(pathStep) === exports.getVerticalCoordinate(wallMove));
@@ -1315,5 +1321,5 @@ })) {
             var horizontalWallCoordinate = exports.getHorizontalCoordinate(wallMove);
-            return (isIncrementableHorizontalWallPosition(horizontalWallCoordinate) &&
+            return (isIncrementableHorizontalWallCoordinate(horizontalWallCoordinate) &&
                 exports.getHorizontalCoordinate(pathStep) ===
-                    incrementHorizontalWallPosition(horizontalWallCoordinate) &&
+                    incrementHorizontalWallCoordinate(horizontalWallCoordinate) &&
                 exports.getVerticalCoordinate(pathStep) === exports.getVerticalCoordinate(wallMove) + 1);
@@ -1320,0 +1326,0 @@ })) {

package.json

 {
   "name": "quoridor",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "A JavaScipt Quoridor library for move validation etc.",
@@ -5,0 +5,0 @@ "main": "lib/index.js",

No alert changes

Improved metrics

Total package byte prevSize

200907

increased by2.15%

Lines of code

5318

increased by2.78%

No dependency changes