From 748c9c17bd0a42a633515c6f1540156186880c9c Mon Sep 17 00:00:00 2001
From: Wilhelm <E197362z@eta.univ-nantes.fr>
Date: Fri, 10 Apr 2020 14:10:15 +0200
Subject: [PATCH] ajout_des_dossiers
---
README.adoc | 19 +-
package.json | 60 +-
src/main/ts/move-validation.ts | 728 ++++++++++++++++++-
src/main/ts/position.ts | 14 +-
src/test/ts/camel-move-validation.spec.ts | 163 ++++-
src/test/ts/empress-move-validation.spec.ts | 180 ++++-
src/test/ts/king-move-validation.spec.ts | 150 +++-
src/test/ts/princess-move-validation.spec.ts | 140 +++-
src/test/ts/queen-move-validation.spec.ts | 115 +++
tsconfig.json | 2 +-
10 files changed, 1453 insertions(+), 118 deletions(-)
diff --git a/README.adoc b/README.adoc
index 249f087..f90d2b5 100644
--- a/README.adoc
+++ b/README.adoc
@@ -15,7 +15,7 @@ Dans notre cas, notre jeu aura les pièces suivantes:
- *Roi*, *Reine* et *Pion* des échecs traditionnels.
- Le *Chameau* à la place du Chevalier. Le Chameau se déplace comme un cavalier mais avec une case supplémentaire. Il saute de trois cases horizontalement et d'une case verticalement ou de trois cases verticalement et d'une case horizontalement.
- La *Princesse* Ã la place du Fou. La Princesse combine les mouvements d'un Cavalier et d'un Fou.
-- L'*Impératrice* à la place de la Tour. L'Impératrice combine les mouvements d'une Tout et d'un Fou.
+- L'*Impératrice* à la place de la Tour. L'Impératrice combine les mouvements d'une Tour et d'un Chevalier.
== Préparation
@@ -77,6 +77,23 @@ npm install
** `tsconfig.json` est le fichier de configuration de *TypeScript*. Vous n'avez pas besoin de le modifier.
+=== Mise à jour du projet
+
+Les erreurs ou manques de précision du projet seront corrigées dès que possible.
+Cela impliquera la mise à jour des vos divergences pour récupérer les changements.
+Pour cela, vous devez faire:
+
+```sh
+git remote add upstream https://gitlab.univ-nantes.fr/naomod/idl/projet-2019.git
+git fetch upstream
+git rebase upstream/master
+```
+
+* La première ligne ajoute le dépot originel et le nomme "upstream"
+* La deuxième ligne récupère les changements, sans les fusionner
+* La troisième ligne fusione les changements avec votre divergence
+
+
== Test et lancement
* Le projet utilise l'outil de construction et de gestion de modules *npm*.
diff --git a/package.json b/package.json
index f4fac23..08a1586 100644
--- a/package.json
+++ b/package.json
@@ -1,32 +1,32 @@
{
- "name": "chess",
- "description": "Ce projet consiste à déployer une application web de jeu d'échecs jouable en multijoueur.",
- "version": "1.0.0",
- "main": "build/main.js",
- "scripts": {
- "build": "tsc",
- "dev": "ts-node-dev --respawn --transpileOnly ./src/main/ts/main.ts",
- "serve": "tsc && node ./build/main.js",
- "test": "alsatian './src/test/ts/**/*.spec.ts' "
- },
- "keywords": [],
- "author": "Gerson Sunyé",
- "license": "MIT",
- "dependencies": {
- "@types/express": "^4.16.1",
- "body-parser": "^1.18.3",
- "ejs": "^2.6.1",
- "express": "^4.16.4",
- "ts-node": "^8.0.2",
- "ts-node-dev": "^1.0.0-pre.32",
- "typescript": "^3.3.3"
- },
- "devDependencies": {
- "alsatian": "^3.2.1",
- "typescript": "^3.7.5"
- },
- "repository": {
- "type": "git",
- "url": "git@gitlab.univ-nantes.fr:naomod/idl/projet-2019.git"
- }
+ "name": "chess",
+ "description": "Ce projet consiste à déployer une application web de jeu d'échecs jouable en multijoueur.",
+ "version": "1.0.0",
+ "main": "build/main.js",
+ "scripts": {
+ "build": "tsc",
+ "dev": "ts-node-dev --respawn --transpileOnly ./src/main/ts/main.ts",
+ "serve": "tsc && node ./build/main.js",
+ "test": "./node_modules/.bin/alsatian ./src/test/ts/*.spec.ts || true"
+ },
+ "keywords": [],
+ "author": "Gerson Sunyé",
+ "license": "MIT",
+ "dependencies": {
+ "@types/express": "^4.16.1",
+ "body-parser": "^1.18.3",
+ "ejs": "^2.6.1",
+ "express": "^4.16.4",
+ "ts-node": "^8.0.2",
+ "ts-node-dev": "^1.0.0-pre.32",
+ "typescript": "^3.3.3"
+ },
+ "devDependencies": {
+ "alsatian": "^3.2.1",
+ "typescript": "^3.7.5"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git@gitlab.univ-nantes.fr:naomod/idl/projet-2019.git"
+ }
}
diff --git a/src/main/ts/move-validation.ts b/src/main/ts/move-validation.ts
index 4dc1850..ae2ea96 100644
--- a/src/main/ts/move-validation.ts
+++ b/src/main/ts/move-validation.ts
@@ -1,6 +1,8 @@
import { Chessboard, isEmpty, Square, squareAtPosition } from "./chessboard";
import { Move } from "./movements";
-import { equals, left, right, top, bottom } from "./position";
+import { equals, left, right, top, bottom, Position, position } from "./position";
+import { checkServerIdentity } from "tls";
+
/**
* Checks whether a Black Pawn can perform a given move.
@@ -10,25 +12,43 @@ import { equals, left, right, top, bottom } from "./position";
* diagram); or the pawn can capture an opponent's piece on a square diagonally
* in front of it on an adjacent file, by moving to that square (black "x"s).
*
- * A pawn has two special moves: the en passant capture and promotion.
*
* @param board The chessboard of the current game
* @param move
*/
-export function blackPawnMove(board: Chessboard, move: Move): boolean {
- // #TODO: Manage special 'En passant' move.
+export function blackPawnMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
- if (equals(move.to!, bottom(move.from!))) {
+ if (equals(move.to!, bottom(move.from!)))
+ {
//console.log("Single forward");
return isEmpty(board, move.to!);
}
- if (move.from!.rank === 6 && equals(move.to!, bottom(bottom(move.from!)))) {
+ if (move.from!.rank === 6 && equals(move.to!, bottom(bottom(move.from!))))
+ {
//console.log("Double forward");
return isEmpty(board, bottom(move.from!)) && isEmpty(board, move.to!);
}
- if (equals(move.to!, left(bottom(move.from!))) || equals(move.to!, right(bottom(move.from!)))) {
+ if (equals(move.to!, left(bottom(move.from!))) || equals(move.to!, right(bottom(move.from!))))
+ {
let destination: Square = squareAtPosition(board, move.to!);
return !(destination.isEmpty || !destination.piece!.isWhite)
}
@@ -43,23 +63,41 @@ export function blackPawnMove(board: Chessboard, move: Move): boolean {
* the diagram); or the pawn can capture an opponent's piece on a square diagonally
* in front of it on an adjacent file, by moving to that square (black "x"s).
*
- * A pawn has two special moves: the en passant capture and promotion.
*
* @param board The chessboard of the current game
* @param move
*/
-export function whitePawnMove(board: Chessboard, move: Move): boolean {
- // #TODO: Manage special 'En passant' move.
+export function whitePawnMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
- if (equals(move.to!, top(move.from!))) {
+ if (equals(move.to!, top(move.from!)))
+ {
return isEmpty(board, move.to!);
}
- if (move.from!.rank === 1 && equals(move.to!, top(top(move.from!)))) {
+ if (move.from!.rank === 1 && equals(move.to!, top(top(move.from!))))
+ {
return isEmpty(board, top(move.from!)) && isEmpty(board, move.to!);
}
- if (equals(move.to!, left(top(move.from!))) || equals(move.to!, right(top(move.from!)))) {
+ if (equals(move.to!, left(top(move.from!))) || equals(move.to!, right(top(move.from!))))
+ {
let destination: Square = squareAtPosition(board, move.to!);
return !(destination.isEmpty || destination.piece!.isWhite)
}
@@ -74,9 +112,49 @@ export function whitePawnMove(board: Chessboard, move: Move): boolean {
* @param board The chessboard of the current game
* @param move
*/
-export function kingMove(board: Chessboard, move: Move): boolean {
- // #TODO: Implement this function
- return true;
+export function kingMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+
+ if (equals(move.to!, top(move.from!)) || equals(move.to!, bottom(move.from!)) || equals(move.to!, left(move.from!)) || equals(move.to!, right(move.from!)) || equals(move.to!, top(left(move.from!))) || equals(move.to!, top(right(move.from!))) || equals(move.to!, bottom(left(move.from!))) || equals(move.to!, bottom(right(move.from!))) )
+ {
+ if( isEmpty(board, move.to!))
+ {
+ console.log("Square is empty")
+ return true
+ }
+ else if (squareAtPosition(board, move.from!).piece!.isWhite != squareAtPosition(board, move.to!).piece!.isWhite)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else if (squareAtPosition(board, move.from!).piece!.isWhite == squareAtPosition(board, move.to!).piece!.isWhite)
+ {
+ console.log("Can't capture piece of the same color.")
+ return false
+ }
+ else
+ {
+ console.log("Square not empty")
+ return false
+ }
+ }
+ return false;
}
/**
@@ -87,22 +165,82 @@ export function kingMove(board: Chessboard, move: Move): boolean {
* @param board The chessboard of the current game
* @param move
*/
-export function queenMove(board: Chessboard, move: Move): boolean {
- // #TODO: Implement this function
- return true;
+export function queenMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+ /**
+ * Checks if the movement correspond to the movement of a bishop.
+ */
+ if (bishopMove(board, move))
+ {
+ return true
+ }
+ /**
+ * Checks if the movement correspond to the movement of a rook.
+ */
+ else if(rookMove(board, move))
+ {
+ return true
+ }
+ /**
+ * The movement isn't corresponding to neither bishop's or rook's movement, movement isn't possible.
+ */
+ else return false
}
-/**
- * Checks whether a Empress can perform a given move.
- * An empress can move any number of squares along a rank or file,
- * but cannot leap over other pieces.
- *
- * @param board The chessboard of the current game
- * @param move
- */
-export function empressMove(board: Chessboard, move: Move): boolean {
- // #TODO: Implement this function
- return true;
+
+export function empressMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+
+ /**
+ * Checks if the movement correspond to the movement of a knight.
+ */
+ if (knightMove(board, move))
+ {
+ return true
+ }
+ /**
+ * Checks if the movement correspond to the movement of a rook.
+ */
+ else if(rookMove(board, move))
+ {
+ return true
+ }
+ /**
+ * The movement isn't corresponding to neither knight's or rook's movement, movement isn't possible.
+ */
+ else return false
}
/**
@@ -117,9 +255,42 @@ export function empressMove(board: Chessboard, move: Move): boolean {
* @param board The chessboard of the current game
* @param move
*/
-export function princessMove(board: Chessboard, move: Move): boolean {
- // #TODO: Implement this function
- return true;
+export function princessMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+ /**
+ * Checks if the movement correspond to the movement of a bishop.
+ */
+ if (bishopMove(board, move))
+ {
+ return true
+ }
+ /**
+ * Checks if the movement correspond to the movement of a knight.
+ */
+ else if(knightMove(board, move))
+ {
+ return true
+ }
+ /**
+ * The movement isn't corresponding to neither bishop's or knight's movement, movement isn't possible.
+ */
+ else return false
}
/**
@@ -128,12 +299,493 @@ export function princessMove(board: Chessboard, move: Move): boolean {
* three squares vertically and one square horizontally, or three
* squares horizontally and one square vertically.)
*
- * The camel is the only piece that can leap over other pieces.
+ * The camel can leap over other pieces.
+ *
+ * @param board The chessboard of the current game
+ * @param move
+ */
+export function camelMove(board: Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+
+ let fromSquare : Square = squareAtPosition(board, move.from!)
+ let toSquare : Square = squareAtPosition(board, move.to!)
+
+ let verticalMove : number = Math.abs(move.to!.file - move.from!.file)
+ let horizontalMove : number = Math.abs(move.to!.rank - move.from!.rank)
+
+ let fromPieceIsWhite : boolean = fromSquare.piece!.isWhite
+
+ if ( ( verticalMove == 3 && horizontalMove == 1) || (verticalMove == 1 && horizontalMove == 3) )
+ {
+ if( isEmpty(board, move.to!))
+ {
+ console.log("Square is empty")
+ return true
+ }
+ else if ( fromPieceIsWhite != toSquare.piece!.isWhite )
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else if ( fromPieceIsWhite == toSquare.piece!.isWhite)
+ {
+ console.log("Can't capture piece of the same color.")
+ return false
+ }
+ else
+ {
+ console.log("Square not empty")
+ return false
+ }
+ }
+ else
+ {
+ return false;
+ }
+}
+
+export function knightMove(board:Chessboard, move: Move): boolean
+{
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+
+ if ((Math.abs(move.to!.file-move.from!.file) == 2 && Math.abs(move.to!.rank- move.from!.rank) == 1) || (Math.abs(move.to!.file-move.from!.file) == 1 && Math.abs(move.to!.rank- move.from!.rank) == 2))
+ {
+ if( isEmpty(board, move.to!))
+ {
+ console.log("Square is empty")
+ return true
+ }
+ else if (squareAtPosition(board, move.from!).piece!.isWhite != squareAtPosition(board, move.to!).piece!.isWhite)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else if (squareAtPosition(board, move.from!).piece!.isWhite == squareAtPosition(board, move.to!).piece!.isWhite)
+ {
+ console.log("Can't capture piece of the same color.")
+ return false
+ }
+ else
+ {
+ console.log("Square not empty")
+ return false
+ }
+ }
+ else
+ {
+ return false;
+ }
+}
+
+/**
+ * Checks whether a rook can perform a given move.
+ * A rook can move any number of squares along a rank or file,
+ * but cannot leap over other pieces.
+ * A rook can also move to any of the closest squares that are not on the
+ * same rank, file, or diagonal. (Thus the move forms an "L"-shape:
+ * two squares vertically and one square horizontally, or two
+ * squares horizontally and one square vertically.)
*
* @param board The chessboard of the current game
* @param move
*/
-export function camelMove(board: Chessboard, move: Move): boolean {
- // #TODO: Implement this function
- return true;
-}
\ No newline at end of file
+export function rookMove(board: Chessboard, move: Move): boolean
+{
+ /**
+ * We can't modify the core of the project, so I choose value more understable for us to work with.
+ */
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+
+ let fromSquare : Square = squareAtPosition(board, move.from!)
+ let toSquare : Square = squareAtPosition(board, move.to!)
+
+ let rookIsWhite : boolean = (fromSquare.piece!.isWhite)
+ let pieceAtDestinationIsWhite : boolean
+
+ if (!(toSquare.isEmpty))
+ {
+ pieceAtDestinationIsWhite = toSquare.piece!.isWhite
+ }
+
+ /**
+ * Check if the movement isn't on itself.
+ */
+ if((fromRow != toRow) || (fromColumn != toColumn))
+ {
+ /**
+ * Check if the movement is either horizontal or vertical. (Rook movements)
+ */
+ if ((fromRow == toRow) || (fromColumn == toColumn))
+ {
+ /**
+ * The movement is a rook alike movement.
+ * The program is going to check the path of the rook to make sure there is no pieces on the path.
+ * Checks if the movement is horizontal
+ */
+ if (fromRow == toRow)
+ {
+ /**
+ * The movement is horizontal, so we need to know in which directions the rook is going.
+ * Check if the ending position is greater than the starting position
+ */
+ if (fromColumn > toColumn)
+ {
+ /**
+ * The ending position is greater, that means we need to check for x squares on the left,
+ * x = the difference between ending and starting pos.
+ */
+ console.log("Checking left...")
+ let checkPos = move.from!
+ for(let i = 0; i < (fromColumn - toColumn); i++)
+ {
+ checkPos = left(checkPos)
+ console.log("Checking : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if ( equals(checkPos,move.to!) )
+ {
+ if (rookIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+
+ } else return false
+ }
+ }
+ console.log("Path is empty")
+ return true
+ } else if (fromColumn < toColumn)
+ {
+ /**
+ * The starting position is greater, that means we need to check for x squares on the right.
+ * x = the difference between ending and starting pos.
+ */
+ console.log("Checking right...")
+ let checkPos = move.from!
+ for(let i = 0; i < (toColumn - fromColumn); i++)
+ {
+ checkPos = right(checkPos)
+ console.log("Checking : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if(equals(checkPos,move.to!))
+ {
+ if (rookIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+ } else return false
+ }
+ }
+ return true
+ }
+ }
+ else if (fromColumn == toColumn)
+ {
+ /**
+ * The movement is vertical, so we need to know in which directions the rook is going.
+ * Check if the ending position is greater than the starting position
+ */
+ if (fromRow < toRow)
+ {
+ /**
+ * The starting position is greater, that means we need to check for x squares on the top.
+ * x = the difference between ending and starting pos.
+ */
+ console.log("Checking top...")
+ let checkPos = move.from!
+ for(let i = 0; i < (toRow - fromRow); i++)
+ {
+ checkPos = top(checkPos)
+ console.log("Checking at : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if(equals(checkPos,move.to!))
+ {
+ if (rookIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+ } else return false
+
+ }
+ }
+ console.log("Path is empty")
+ return true
+ }else if (fromRow > toRow)
+ {
+ /**
+ * The starting position is greater, that means we need to check for x squares on the bottom.
+ * x = the difference between ending and starting pos.
+ */
+ console.log("Checking bottom...")
+ let checkPos = move.from!
+ for(let i = 0; i < (fromRow - toRow); i++)
+ {
+ checkPos = bottom(checkPos)
+ console.log("Checking at : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if(equals(checkPos,move.to!))
+ {
+ if (rookIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+ } else return false
+ }
+ }
+ console.log("Path is empty")
+ return true
+ }
+ }
+ }
+ } else return false
+
+ /**
+ * Trying to move on itself, move impossible.
+ */
+ return false
+}
+
+export function bishopMove(board: Chessboard, move: Move): boolean
+{
+ /**
+ * We can't modify the core of the project, so I choose value more understable for us to work with.
+ */
+ // Logging -- FROM HERE
+ // Logging -- Declaration of values
+ let fromColumn : number = move.from!.file
+ let toColumn : number = move.to!.file
+ let fromRow : number = move.from!.rank
+ let toRow : number = move.to!.rank
+ /*
+ // Logging -- Print values
+ console.log("NEW MOVEMENT ENTERED : ")
+ console.log("You are moving :", JSON.stringify(squareAtPosition(board, move.from!).piece!))
+ console.log("fromRow : ",fromRow )
+ console.log("fromColumn : ",fromColumn )
+ console.log("toRow : ",toRow )
+ console.log("toColumn : ",toColumn )
+ */
+ // Logging -- TO HERE
+
+ let fromSquare : Square = squareAtPosition(board, move.from!)
+ let toSquare : Square = squareAtPosition(board, move.to!)
+ let bishopIsWhite : boolean = (fromSquare.piece!.isWhite)
+ let pieceAtDestinationIsWhite : boolean
+
+ if (!(toSquare.isEmpty))
+ {
+ pieceAtDestinationIsWhite = toSquare.piece!.isWhite
+ }
+
+
+ if((fromRow != toRow) && (fromColumn != toColumn))
+ {
+
+ if (fromRow < toRow)
+ {
+ if ((fromColumn < toColumn)&&(toColumn-fromColumn == toRow-fromRow))
+ {
+
+ console.log("Checking top right...")
+ let checkPos = move.from!
+ for(let i = 0; i < (toColumn - fromColumn); i++)
+ {
+ checkPos = top(right(checkPos))
+ console.log("Checking : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if(equals(checkPos,move.to!))
+ {
+ if (bishopIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+ } else return false
+ }
+ }
+ return true
+ }
+ else if ((fromColumn > toColumn)&&(fromColumn-toColumn == toRow-fromRow))
+ {
+
+ console.log("Checking top left...")
+ let checkPos = move.from!
+ for(let i = 0; i < (fromColumn - toColumn); i++)
+ {
+ checkPos = top(left(checkPos))
+ console.log("Checking : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if ( equals(checkPos,move.to!) )
+ {
+ if (bishopIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+
+ } else return false
+ }
+ }
+ console.log("Path is empty")
+ return true
+ }
+ }
+ else if (fromRow > toRow)
+ {
+ if ((fromColumn < toColumn)&&(toColumn-fromColumn == fromRow-toRow))
+ {
+
+ console.log("Checking bottom right...")
+ let checkPos = move.from!
+ for(let i = 0; i < (toColumn - fromColumn); i++)
+ {
+ checkPos = bottom(right(checkPos))
+ console.log("Checking : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if(equals(checkPos,move.to!))
+ {
+ if (bishopIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+ } else return false
+ }
+ }
+ return true
+ } else if ((fromColumn > toColumn)&&(fromColumn-toColumn == fromRow-toRow))
+ {
+ console.log("Checking bottom left...")
+ let checkPos = move.from!
+ for(let i = 0; i < (fromColumn - toColumn); i++)
+ {
+ checkPos = bottom(left(checkPos))
+ console.log("Checking : ", checkPos)
+ if (!(isEmpty(board,checkPos)))
+ {
+ console.log("Square not empty at :", checkPos)
+ if ( equals(checkPos,move.to!) )
+ {
+ if (bishopIsWhite != pieceAtDestinationIsWhite!)
+ {
+ console.log("Captured it.")
+ return true
+ }
+ else
+ {
+ console.log("Can't capture piece of the same color.");
+ return false
+ }
+
+ } else return false
+ }
+ }
+ console.log("Path is empty")
+ return true
+ }
+ }
+ } else return false
+
+ /**
+ * Trying to move on itself, move impossible.
+ */
+ return false
+}
\ No newline at end of file
diff --git a/src/main/ts/position.ts b/src/main/ts/position.ts
index 15de0c1..1c47db5 100644
--- a/src/main/ts/position.ts
+++ b/src/main/ts/position.ts
@@ -12,38 +12,38 @@ export interface Position {
}
/**
- * Creates a new Posistion from two numbers, representing
+ * Creates a new Position from two numbers, representing
* the new position's file and rank.
*
* @param rank this position rank, from 0..7
* @param file this position file, from 0..7
*/
-export function position(file:number, rank: number): Position {
+export function position(file : number, rank : number): Position {
let position: Position = {rank: rank, file: file};
return position;
}
-export function bottom(pos: Position) : Position {
+export function bottom(pos : Position) : Position {
let bottomPosition = {file: pos.file, rank: pos.rank - 1};
return bottomPosition;
}
-export function top(pos: Position) : Position {
+export function top(pos : Position) : Position {
let topPosition = {file: pos.file, rank: pos.rank + 1};
return topPosition;
}
-export function left(pos: Position) : Position {
+export function left(pos : Position) : Position {
let leftPosition = {file: pos.file - 1, rank: pos.rank};
return leftPosition;
}
-export function right(pos: Position) : Position {
+export function right(pos : Position) : Position {
let rightPosition = {file: pos.file + 1, rank: pos.rank};
return rightPosition;
}
-export function equals(one: Position, other: Position) : boolean {
+export function equals(one : Position, other : Position) : boolean {
//console.log("Equals: " + JSON.stringify(one) + ", " + JSON.stringify(other));
return one.rank === other.rank && one.file === other.file;
diff --git a/src/test/ts/camel-move-validation.spec.ts b/src/test/ts/camel-move-validation.spec.ts
index 478abe0..9e80b8f 100644
--- a/src/test/ts/camel-move-validation.spec.ts
+++ b/src/test/ts/camel-move-validation.spec.ts
@@ -1,52 +1,195 @@
import { Expect, Test, Setup} from "alsatian";
import { Chessboard, createEmptyChessboard, putPiece } from '../../main/ts/chessboard';
+import { whiteCamel, whitePawn, blackPawn} from "../../main/ts/piece";
+import { Move, move } from '../../main/ts/movements';
+import { Position, position } from '../../main/ts/position';
+import * as isPossible from "../../main/ts/move-validation"
let chessboard : Chessboard;
-export class TestCamelMoves {
+const positionA4 : Position = position(0, 3) // A4
+const positionA5 : Position = position(0, 4) // A5
+const positionA6 : Position = position(0, 5) // A6
+const positionA7 : Position = position(0, 6) // A7
+const positionA8 : Position = position(0, 7) // A8
+
+const positionB1 : Position = position(1, 0) // B1
+const positionB2 : Position = position(1, 1) // B2
+const positionB3 : Position = position(1, 2) // B3
+const positionB5 : Position = position(1, 4) // B5
+const positionB6 : Position = position(1, 5) // B6
+
+const positionC3 : Position = position(2, 1) // C3
+const positionC4 : Position = position(2, 3) // C4
+const positionC5 : Position = position(2, 4) // C5
+const positionC6 : Position = position(2, 5) // C6
+const positionC7 : Position = position(2, 6) // C7
+
+const positionD1 : Position = position(3, 0) // D1
+const positionD2 : Position = position(3, 1) // D2
+const positionD3 : Position = position(3, 2) // D3
+const positionD4 : Position = position(3, 3) // D4
+const positionD5 : Position = position(3, 4) // D5
+const positionD6 : Position = position(3, 5) // D6
+const positionD7 : Position = position(3, 6) // D7
+
+
+const positionE1 : Position = position(4, 0) // E1
+const positionE3 : Position = position(4, 2) // E3
+const positionE4 : Position = position(4, 3) // E4
+const positionE5 : Position = position(4, 4) // E5
+const positionE8 : Position = position(4, 7) // E8
+
+const positionF1 : Position = position(5, 0) // F1
+const positionF2 : Position = position(5, 1) // F2
+const positionF4 : Position = position(5, 3) // F4
+const positionF6 : Position = position(5, 5) // F6
+const positionF7 : Position = position(5, 6) // F7
+const positionG3 : Position = position(6, 2) // G3
+const positionG5 : Position = position(6, 4) // G5
+
+const positionH1 : Position = position(7, 0) // H1
+const positionH3 : Position = position(7, 2) // H3
+const positionH4 : Position = position(7, 3) // H4
+const positionH5 : Position = position(7, 4) // H5
+const positionH7 : Position = position(7, 6) // H7
+
+// Horizontal moves
+const moveE4_H4 : Move = move(positionE4, positionH4);
+const moveE4_A4 : Move = move(positionE4, positionA4);
+
+// Vertical moves
+const moveE4_E1 : Move = move(positionE4, positionE1);
+const moveE4_E8 : Move = move(positionE4, positionE8);
+
+// Diagonal moves
+const moveE4_A8 : Move = move(positionE4, positionA8);
+const moveE4_B1 : Move = move(positionE4, positionB1);
+const moveE4_H7 : Move = move(positionE4, positionH7);
+const moveE4_H1 : Move = move(positionE4, positionH1);
+
+// Camel moves
+const moveE4_F7 : Move = move(positionE4, positionF7);
+const moveE4_H5 : Move = move(positionE4, positionH5);
+const moveE4_F1 : Move = move(positionE4, positionF1);
+const moveE4_H3 : Move = move(positionE4, positionH3);
+const moveE4_D1 : Move = move(positionE4, positionD1);
+const moveE4_B3 : Move = move(positionE4, positionB3);
+const moveE4_B5 : Move = move(positionE4, positionB5);
+const moveE4_D7 : Move = move(positionE4, positionD7);
+
+// Impossible moves
+const moveE4_C7 : Move = move(positionE4, positionC7);
+const moveE4_B2 : Move = move(positionE4, positionB2);
+
+// On the same pos
+const moveE4_E4 : Move = move(positionE4, positionE4)
+
+// Two Horizontal and one Vertical
+const moveE4_G3 : Move = move(positionE4, positionG3)
+const moveE4_G5 : Move = move(positionE4, positionG5)
+const moveE4_C3 : Move = move(positionE4, positionC3)
+const moveE4_C5 : Move = move(positionE4, positionC5)
+
+// Two Vertical and one Horizontal
+const moveE4_F2 : Move = move(positionE4, positionF2)
+const moveE4_F6 : Move = move(positionE4, positionF6)
+const moveE4_D2 : Move = move(positionE4, positionD2)
+const moveE4_D6 : Move = move(positionE4, positionD6)
+
+
+
+
+export class TestCamelMoves
+{
@Setup
- beforeEach() {
+ beforeEach()
+ {
// TODO:
// Initialize an empty chessboard
+ // Place a white Camel on E4
+ chessboard = createEmptyChessboard()
+ putPiece(chessboard, positionE4, whiteCamel)
}
@Test("A Camel can move three squares horizontally and one square vertically")
- testCanMoveThreeHorizontalAndOneVertical() {
+ testCanMoveThreeHorizontalAndOneVertical()
+ {
// TODO:
+ // Check the following moves are possible:
+ // - moveE4_H3
+ // - moveE4_H5
+ // - moveE4_B3
+ // - moveE4_B5
+ Expect(isPossible.camelMove(chessboard,moveE4_H3)).toBeTruthy()
+ Expect(isPossible.camelMove(chessboard,moveE4_H5)).toBeTruthy()
+ Expect(isPossible.camelMove(chessboard,moveE4_B3)).toBeTruthy()
+ Expect(isPossible.camelMove(chessboard,moveE4_B5)).toBeTruthy()
+
}
@Test("A Camel can move three squares vertically and one square horizontally")
- testCanMoveThreeVerticalAndOneHorizontal() {
+ testCanMoveThreeVerticalAndOneHorizontal()
+ {
// TODO:
+ // Check the following moves are possible:
+ // - moveE4_F1
+ // - moveE4_F7
+ // - moveE4_D1
+ // - moveE4_D7
+ Expect(isPossible.camelMove(chessboard,moveE4_F1)).toBeTruthy()
+ Expect(isPossible.camelMove(chessboard,moveE4_F7)).toBeTruthy()
+ Expect(isPossible.camelMove(chessboard,moveE4_D1)).toBeTruthy()
+ Expect(isPossible.camelMove(chessboard,moveE4_D7)).toBeTruthy()
}
@Test("A Camel can leap other pieces")
- testCanLeapOtherPieces() {
+ testCanLeapOtherPieces()
+ {
+ putPiece(chessboard, positionE5, whitePawn)
+ Expect(isPossible.camelMove(chessboard,moveE4_F7)).toBeTruthy()
// TODO:
}
@Test("A Camel cannot move diagonally")
- testCannotMoveDiagonally() {
+ testCannotMoveDiagonally()
+ {
+ Expect(isPossible.camelMove(chessboard, moveE4_A8)).not.toBeTruthy()
+ Expect(isPossible.camelMove(chessboard, moveE4_B1)).not.toBeTruthy()
+ Expect(isPossible.camelMove(chessboard, moveE4_H7)).not.toBeTruthy()
+ Expect(isPossible.camelMove(chessboard, moveE4_H1)).not.toBeTruthy()
// TODO:
}
@Test("A Camel cannot move horizontally")
- testCannotMoveHorizontally() {
+ testCannotMoveHorizontally()
+ {
+ Expect(isPossible.camelMove(chessboard, moveE4_H4)).not.toBeTruthy()
+ Expect(isPossible.camelMove(chessboard, moveE4_A4)).not.toBeTruthy()
// TODO:
}
@Test("A Camel cannot move vertically")
- testCannotMoveVertically() {
+ testCannotMoveVertically()
+ {
+ Expect(isPossible.camelMove(chessboard, moveE4_E1)).not.toBeTruthy()
+ Expect(isPossible.camelMove(chessboard, moveE4_E8)).not.toBeTruthy()
// TODO:
}
@Test("A Camel can capture a piece from another color")
- testCanCaptureAnotherColor() {
+ testCanCaptureAnotherColor()
+ {
+ putPiece(chessboard, positionF7, blackPawn)
+ Expect(isPossible.camelMove(chessboard, moveE4_F7)).toBeTruthy
// TODO:
}
@Test("A Camel cannot capture a piece from the same color")
- testCannotCaptureSameColor() {
+ testCannotCaptureSameColor()
+ {
+ putPiece(chessboard, positionF7, whitePawn)
+ Expect(isPossible.camelMove(chessboard, moveE4_F7)).not.toBeTruthy
// TODO:
}
}
diff --git a/src/test/ts/empress-move-validation.spec.ts b/src/test/ts/empress-move-validation.spec.ts
index fc8c0ff..0190fa5 100644
--- a/src/test/ts/empress-move-validation.spec.ts
+++ b/src/test/ts/empress-move-validation.spec.ts
@@ -1,53 +1,181 @@
import { Expect, Test, Setup} from "alsatian";
import { Chessboard, createEmptyChessboard, putPiece } from '../../main/ts/chessboard';
+import * as isPossible from "../../main/ts/move-validation"
+import { Position, position } from '../../main/ts/position';
+import { Move, move } from '../../main/ts/movements';
+import { whitePawn, blackPawn, whiteEmpress } from "../../main/ts/piece";
+
+// Creating chessboards for tests.
let chessboard : Chessboard;
+const positionA4 : Position = position(0, 3) // A4
+const positionA5 : Position = position(0, 4) // A5
+const positionA6 : Position = position(0, 5) // A6
+const positionA7 : Position = position(0, 6) // A7
+const positionA8 : Position = position(0, 7) // A8
+
+const positionB1 : Position = position(1, 0) // B1
+const positionB2 : Position = position(1, 1) // B2
+const positionB3 : Position = position(1, 2) // B3
+const positionB5 : Position = position(1, 4) // B5
+const positionB6 : Position = position(1, 5) // B6
+
+const positionC3 : Position = position(2, 2) // C3
+const positionC4 : Position = position(2, 3) // C4
+const positionC5 : Position = position(2, 4) // C5
+const positionC6 : Position = position(2, 5) // C6
+const positionC7 : Position = position(2, 6) // C7
+
+const positionD1 : Position = position(3, 0) // D1
+const positionD2 : Position = position(3, 1) // D2
+const positionD3 : Position = position(3, 2) // D3
+const positionD4 : Position = position(3, 3) // D4
+const positionD5 : Position = position(3, 4) // D5
+const positionD6 : Position = position(3, 5) // D6
+const positionD7 : Position = position(3, 6) // D7
+
+
+const positionE1 : Position = position(4, 0) // E1
+const positionE3 : Position = position(4, 2) // E3
+const positionE4 : Position = position(4, 3) // E4
+const positionE8 : Position = position(4, 7) // E8
+
+const positionF1 : Position = position(5, 0) // F1
+const positionF2 : Position = position(5, 1) // F2
+const positionF4 : Position = position(5, 3) // F4
+const positionF6 : Position = position(5, 5) // F6
+const positionF7 : Position = position(5, 6) // F7
+const positionG3 : Position = position(6, 2) // G3
+const positionG5 : Position = position(6, 4) // G5
+
+const positionH1 : Position = position(7, 0) // H1
+const positionH3 : Position = position(7, 2) // H3
+const positionH4 : Position = position(7, 3) // H4
+const positionH5 : Position = position(7, 4) // H5
+const positionH7 : Position = position(7, 6) // H7
+
+// Horizontal moves
+const moveE4_H4 : Move = move(positionE4, positionH4);
+const moveE4_A4 : Move = move(positionE4, positionA4);
+
+// Vertical moves
+const moveE4_E1 : Move = move(positionE4, positionE1);
+const moveE4_E8 : Move = move(positionE4, positionE8);
+
+// Diagonal moves
+const moveE4_A8 : Move = move(positionE4, positionA8);
+const moveE4_B1 : Move = move(positionE4, positionB1);
+const moveE4_H7 : Move = move(positionE4, positionH7);
+const moveE4_H1 : Move = move(positionE4, positionH1);
+
+// Camel moves
+const moveE4_F7 : Move = move(positionE4, positionF7);
+const moveE4_H5 : Move = move(positionE4, positionH5);
+const moveE4_F1 : Move = move(positionE4, positionF1);
+const moveE4_H3 : Move = move(positionE4, positionH3);
+const moveE4_D1 : Move = move(positionE4, positionD1);
+const moveE4_B3 : Move = move(positionE4, positionB3);
+const moveE4_B5 : Move = move(positionE4, positionB5);
+const moveE4_D7 : Move = move(positionE4, positionD7);
+
+// Impossible moves
+const moveE4_C7 : Move = move(positionE4, positionC7);
+const moveE4_B2 : Move = move(positionE4, positionB2);
+
+// On the same pos
+const moveE4_E4 : Move = move(positionE4, positionE4)
+
+// Two Horizontal and one Vertical
+const moveE4_G3 : Move = move(positionE4, positionG3)
+const moveE4_G5 : Move = move(positionE4, positionG5)
+const moveE4_C3 : Move = move(positionE4, positionC3)
+const moveE4_C5 : Move = move(positionE4, positionC5)
+
+// Two Vertical and one Horizontal
+const moveE4_F2 : Move = move(positionE4, positionF2)
+const moveE4_F6 : Move = move(positionE4, positionF6)
+const moveE4_D2 : Move = move(positionE4, positionD2)
+const moveE4_D6 : Move = move(positionE4, positionD6)
+
export class TestEmpressMoves {
@Setup
- beforeEach() {
- // TODO:
- // Initialize an empty chessboard
- // Place a white Empress on E4
+ beforeEach()
+ {
+ chessboard = createEmptyChessboard()
+ putPiece(chessboard, positionE4, whiteEmpress)
}
- @Test("A Empress can move horizontally")
- testCanMoveHorizontally() {
- // TODO:
- // Check the following moves are possible: moveE4_H4, moveE4_A4
+ @Test("An Empress can move horizontally")
+ testCanMoveHorizontally()
+ {
+
+ Expect(isPossible.empressMove(chessboard, moveE4_H4)).toBeTruthy();
+ Expect(isPossible.empressMove(chessboard, moveE4_A4)).toBeTruthy();
+ // Should be possible
}
@Test("A Empress can move vertically")
testCanMoveVertically() {
- // TODO:
- // Check the following moves are possible: moveE4_E1, moveE4_E8
+
+ Expect(isPossible.empressMove(chessboard, moveE4_E8)).toBeTruthy();
+ Expect(isPossible.empressMove(chessboard, moveE4_E1)).toBeTruthy();
+ // Should be possible
}
- @Test("A Empress can move diagonally")
- testCanMoveDiagonally() {
- // TODO:
- // Check the following moves are possible:
- // moveE4_A8, moveE4_B1, moveE4_H7, moveE4_H1
+ @Test("An Empress can move two squares horizontally and one square vertically")
+ testCanMoveTwoHorizontalAndOneVertical() {
+
+ Expect(isPossible.empressMove(chessboard,moveE4_G3)).toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_G5)).toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_C3)).toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_C5)).toBeTruthy()
+ // Should be possible
}
+ @Test("An Empress can move two squares vertically and one square horizontally")
+ testCanMoveTwoVerticalAndOneHorizontal() {
+
+ Expect(isPossible.empressMove(chessboard,moveE4_F2)).toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_F6)).toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_D2)).toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_D6)).toBeTruthy()
+ // Should be possible
+ }
+
+
+ @Test("A Empress cannot move diagonally")
+ testCannotMoveDiagonally() {
+
+ Expect(isPossible.empressMove(chessboard,moveE4_A8)).not.toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_B1)).not.toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_H7)).not.toBeTruthy()
+ Expect(isPossible.empressMove(chessboard,moveE4_H1)).not.toBeTruthy()
+ // Should not be possible
+ }
@Test("A Empress can capture a piece from different color")
testCanCaptureDifferentColor() {
- // TODO:
- // Place a black Pawn on H4
- // Check the move moveE4_H4 is possible
+ putPiece(chessboard,positionH4,blackPawn)
+ Expect(isPossible.empressMove(chessboard , moveE4_H4)).toBeTruthy()
+ // Should be possible
}
@Test("A Empress cannot capture a piece from the same color")
testCannotCaptureSameColor() {
- // TODO:
- // Place a white Pawn on H4
- // Check the move moveE4_H4 is impossible
+ putPiece(chessboard,positionH4,whitePawn)
+ Expect(isPossible.empressMove(chessboard, moveE4_H4)).not.toBeTruthy()
+ // Shouldn't be possible
+ }
+
+ @Test("A Empress cannot leap other pieces, when moving horizontally")
+ testCannotLeapHorizontally() {
+ putPiece(chessboard,positionF4,blackPawn)
+ Expect(isPossible.empressMove(chessboard, moveE4_H4)).not.toBeTruthy()
}
- @Test("A Empress cannot leap other pieces")
- testCannotLeap() {
- // TODO:
- // Place a black Pawn on F4
- // Check the move moveE4_H4 is impossible
+ @Test("A Empress cannot leap other pieces, when moving horizontally")
+ testCannotLeapvertically() {
+ putPiece(chessboard,positionE3,blackPawn)
+ Expect(isPossible.empressMove(chessboard, moveE4_E1)).not.toBeTruthy()
}
}
diff --git a/src/test/ts/king-move-validation.spec.ts b/src/test/ts/king-move-validation.spec.ts
index 168f9b6..958b60a 100644
--- a/src/test/ts/king-move-validation.spec.ts
+++ b/src/test/ts/king-move-validation.spec.ts
@@ -1,41 +1,189 @@
import { Expect, Test, Setup} from "alsatian";
import { Chessboard, createEmptyChessboard, putPiece } from '../../main/ts/chessboard';
+import {position, Position} from '../../main/ts/position'
+import { Move, move } from '../../main/ts/movements';
+import * as isPossible from "../../main/ts/move-validation"
+import { whitePawn, blackPawn, whiteKing, blackKing} from "../../main/ts/piece";
let chessboard : Chessboard;
+const positionA4 : Position = position(0, 3) // A4
+const positionA5 : Position = position(0, 4) // A5
+const positionA6 : Position = position(0, 5) // A6
+const positionA7 : Position = position(0, 6) // A7
+const positionA8 : Position = position(0, 7) // A8
+
+const positionB1 : Position = position(1, 0) // B1
+const positionB2 : Position = position(1, 1) // B2
+const positionB3 : Position = position(1, 2) // B3
+const positionB5 : Position = position(1, 4) // B5
+const positionB6 : Position = position(1, 5) // B6
+
+const positionC2 : Position = position(2, 1) // C2
+const positionC3 : Position = position(2, 2) // C3
+const positionC4 : Position = position(2, 3) // C4
+const positionC5 : Position = position(2, 4) // C5
+const positionC6 : Position = position(2, 5) // C6
+const positionC7 : Position = position(2, 6) // C7
+
+const positionD1 : Position = position(3, 0) // D1
+const positionD2 : Position = position(3, 1) // D2
+const positionD3 : Position = position(3, 2) // D3
+const positionD4 : Position = position(3, 3) // D4
+const positionD5 : Position = position(3, 4) // D5
+const positionD6 : Position = position(3, 5) // D6
+const positionD7 : Position = position(3, 6) // D7
+
+
+const positionE1 : Position = position(4, 0) // E1
+const positionE2 : Position = position(4, 1) // E5
+const positionE3 : Position = position(4, 2) // E3
+const positionE4 : Position = position(4, 3) // E4
+const positionE5 : Position = position(4, 4) // E5
+const positionE6 : Position = position(4, 5) // E6
+const positionE8 : Position = position(4, 7) // E8
+
+const positionF1 : Position = position(5, 0) // F1
+const positionF2 : Position = position(5, 1) // F2
+const positionF3 : Position = position(5, 2) // F3
+const positionF4 : Position = position(5, 3) // F4
+const positionF5 : Position = position(5, 4) // F5
+const positionF6 : Position = position(5, 5) // F6
+const positionF7 : Position = position(5, 6) // F7
+
+const positionG2 : Position = position(6, 1) // G3
+const positionG3 : Position = position(6, 2) // G3
+const positionG4 : Position = position(6, 3) // G3
+const positionG5 : Position = position(6, 4) // G5
+const positionG6 : Position = position(6, 5) // G5
+
+
+const positionH1 : Position = position(7, 0) // H1
+const positionH3 : Position = position(7, 2) // H3
+const positionH4 : Position = position(7, 3) // H4
+const positionH5 : Position = position(7, 4) // H5
+const positionH7 : Position = position(7, 6) // H7
+
+// Horizontal moves
+const moveE4_H4 : Move = move(positionE4, positionH4);
+const moveE4_A4 : Move = move(positionE4, positionA4);
+
+// Vertical moves
+const moveE4_E1 : Move = move(positionE4, positionE1);
+const moveE4_E8 : Move = move(positionE4, positionE8);
+
+// Diagonal moves
+const moveE4_A8 : Move = move(positionE4, positionA8);
+const moveE4_B1 : Move = move(positionE4, positionB1);
+const moveE4_H7 : Move = move(positionE4, positionH7);
+const moveE4_H1 : Move = move(positionE4, positionH1);
+
+// Camel moves
+const moveE4_F7 : Move = move(positionE4, positionF7);
+const moveE4_H5 : Move = move(positionE4, positionH5);
+const moveE4_F1 : Move = move(positionE4, positionF1);
+const moveE4_H3 : Move = move(positionE4, positionH3);
+const moveE4_D1 : Move = move(positionE4, positionD1);
+const moveE4_B3 : Move = move(positionE4, positionB3);
+const moveE4_B5 : Move = move(positionE4, positionB5);
+const moveE4_D7 : Move = move(positionE4, positionD7);
+
+// Impossible moves
+const moveE4_C7 : Move = move(positionE4, positionC7);
+const moveE4_B2 : Move = move(positionE4, positionB2);
+
+// On the same pos
+const moveE4_E4 : Move = move(positionE4, positionE4)
+
+// Two Horizontal and one Vertical
+const moveE4_G3 : Move = move(positionE4, positionG3)
+const moveE4_G5 : Move = move(positionE4, positionG5)
+const moveE4_C3 : Move = move(positionE4, positionC3)
+const moveE4_C5 : Move = move(positionE4, positionC5)
+
+// Two Vertical and one Horizontal
+const moveE4_F2 : Move = move(positionE4, positionF2)
+const moveE4_F6 : Move = move(positionE4, positionF6)
+const moveE4_D2 : Move = move(positionE4, positionD2)
+const moveE4_D6 : Move = move(positionE4, positionD6)
+
+//One square arround E4
+const moveE4_E3 : Move = move(positionE4, positionE3)
+const moveE4_D3 : Move = move(positionE4, positionD3)
+const moveE4_D4 : Move = move(positionE4, positionD4)
+const moveE4_D5 : Move = move(positionE4, positionD5)
+const moveE4_E5 : Move = move(positionE4, positionE5)
+const moveE4_F5 : Move = move(positionE4, positionF5)
+const moveE4_F4 : Move = move(positionE4, positionF4)
+const moveE4_F3 : Move = move(positionE4, positionF3)
+
+//Two squares arround E4
+const moveE4_C2 : Move = move(positionE4, positionC2)
+const moveE4_C4 : Move = move(positionE4, positionC4)
+const moveE4_C6 : Move = move(positionE4, positionC6)
+const moveE4_E6 : Move = move(positionE4, positionE6)
+const moveE4_E2 : Move = move(positionE4, positionE2)
+const moveE4_G2 : Move = move(positionE4, positionG2)
+const moveE4_G4 : Move = move(positionE4, positionG4)
+const moveE4_G6 : Move = move(positionE4, positionG6)
+
export class TestKingMoves {
@Setup
beforeEach() {
// TODO:
+ chessboard = createEmptyChessboard();
// Initialize an empty chessboard
+ putPiece(chessboard,positionE4, blackKing)
// Place a black King on E4
}
@Test("A King can move 1 square in all directions")
testCanMoveOneSquare() {
// TODO:
+ Expect(isPossible.kingMove(chessboard, moveE4_D3)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_D4)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_D5)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_E3)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_E5)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_F3)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_F4)).toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_F5)).toBeTruthy();
// Check it can move to squares D3, D4, D5, E3, E5, F3, F4, and F5
}
@Test("A King cannot move more than 1 square")
testCannotMoveMoreThanOneSquare() {
// TODO:
- // Check it cannot move to squares C2, C3, C4, C6, D4, and F4
+ Expect(isPossible.kingMove(chessboard, moveE4_C2)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_C3)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_C4)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_C6)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_E2)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_E6)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_G2)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_G4)).not.toBeTruthy();
+ Expect(isPossible.kingMove(chessboard, moveE4_G6)).not.toBeTruthy();
+
+ // Check it cannot move to squares C2, C3, C4, C6, E2, E6, G2, G4, and G6
}
@Test("A King cannot capure pieces from the same color")
testCannotCaptureSameColor() {
// TODO:
+ putPiece(chessboard, positionE5, blackPawn)
// Place a black Pawn on E5
+ Expect(isPossible.kingMove(chessboard, moveE4_E5)).not.toBeTruthy()
// Check the King cannot move to E5.
}
@Test("A King can capure pieces from a different color")
testCanCaptureSameColor() {
// TODO:
+ putPiece(chessboard, positionE5, whitePawn)
// Place a white Pawn on E5
+ Expect(isPossible.kingMove(chessboard, moveE4_E5)).toBeTruthy()
// Check the King can move to E5.
}
}
\ No newline at end of file
diff --git a/src/test/ts/princess-move-validation.spec.ts b/src/test/ts/princess-move-validation.spec.ts
index bc32170..34b02cd 100644
--- a/src/test/ts/princess-move-validation.spec.ts
+++ b/src/test/ts/princess-move-validation.spec.ts
@@ -1,13 +1,117 @@
import { Expect, Test, Setup} from "alsatian";
import { Chessboard, createEmptyChessboard, putPiece } from '../../main/ts/chessboard';
+import * as isPossible from "../../main/ts/move-validation"
+import { Position, position } from '../../main/ts/position';
+import { Move, move } from '../../main/ts/movements';
+import { whitePawn, blackPawn, whitePrincess, blackPrincess } from "../../main/ts/piece";
let chessboard : Chessboard;
+const positionA4 : Position = position(0, 3) // A4
+const positionA5 : Position = position(0, 4) // A5
+const positionA6 : Position = position(0, 5) // A6
+const positionA7 : Position = position(0, 6) // A7
+const positionA8 : Position = position(0, 7) // A8
+
+const positionB1 : Position = position(1, 0) // B1
+const positionB2 : Position = position(1, 1) // B2
+const positionB3 : Position = position(1, 2) // B3
+const positionB5 : Position = position(1, 4) // B5
+const positionB6 : Position = position(1, 5) // B6
+
+const positionC3 : Position = position(2, 1) // C3
+const positionC4 : Position = position(2, 3) // C4
+const positionC5 : Position = position(2, 4) // C5
+const positionC6 : Position = position(2, 5) // C6
+const positionC7 : Position = position(2, 6) // C7
+
+const positionD1 : Position = position(3, 0) // D1
+const positionD2 : Position = position(3, 1) // D2
+const positionD3 : Position = position(3, 2) // D3
+const positionD4 : Position = position(3, 3) // D4
+const positionD5 : Position = position(3, 4) // D5
+const positionD6 : Position = position(3, 5) // D6
+const positionD7 : Position = position(3, 6) // D7
+
+
+const positionE1 : Position = position(4, 0) // E1
+const positionE3 : Position = position(4, 2) // E3
+const positionE4 : Position = position(4, 3) // E4
+const positionE5 : Position = position(4, 4) // E5
+const positionE8 : Position = position(4, 7) // E8
+
+const positionF1 : Position = position(5, 0) // F1
+const positionF2 : Position = position(5, 1) // F2
+const positionF4 : Position = position(5, 3) // F4
+const positionF6 : Position = position(5, 5) // F6
+const positionF7 : Position = position(5, 6) // F7
+const positionG3 : Position = position(6, 2) // G3
+const positionG5 : Position = position(6, 4) // G5
+
+const positionH1 : Position = position(7, 0) // H1
+const positionH3 : Position = position(7, 2) // H3
+const positionH4 : Position = position(7, 3) // H4
+const positionH5 : Position = position(7, 4) // H5
+const positionH7 : Position = position(7, 6) // H7
+
+// Horizontal moves
+const moveE4_H4 : Move = move(positionE4, positionH4);
+const moveE4_A4 : Move = move(positionE4, positionA4);
+
+// Vertical moves
+const moveE4_E1 : Move = move(positionE4, positionE1);
+const moveE4_E8 : Move = move(positionE4, positionE8);
+
+// Diagonal moves
+const moveE4_A8 : Move = move(positionE4, positionA8);
+const moveE4_B1 : Move = move(positionE4, positionB1);
+const moveE4_H7 : Move = move(positionE4, positionH7);
+const moveE4_H1 : Move = move(positionE4, positionH1);
+
+// Camel moves
+const moveE4_F7 : Move = move(positionE4, positionF7);
+const moveE4_H5 : Move = move(positionE4, positionH5);
+const moveE4_F1 : Move = move(positionE4, positionF1);
+const moveE4_H3 : Move = move(positionE4, positionH3);
+const moveE4_D1 : Move = move(positionE4, positionD1);
+const moveE4_B3 : Move = move(positionE4, positionB3);
+const moveE4_B5 : Move = move(positionE4, positionB5);
+const moveE4_D7 : Move = move(positionE4, positionD7);
+
+// Impossible moves
+const moveE4_C7 : Move = move(positionE4, positionC7);
+const moveE4_B2 : Move = move(positionE4, positionB2);
+
+// On the same pos
+const moveE4_E4 : Move = move(positionE4, positionE4)
+
+// Two Horizontal and one Vertical
+const moveE4_G3 : Move = move(positionE4, positionG3)
+const moveE4_G5 : Move = move(positionE4, positionG5)
+const moveE4_C3 : Move = move(positionE4, positionC3)
+const moveE4_C5 : Move = move(positionE4, positionC5)
+
+// Two Vertical and one Horizontal
+const moveE4_F2 : Move = move(positionE4, positionF2)
+const moveE4_F6 : Move = move(positionE4, positionF6)
+const moveE4_D2 : Move = move(positionE4, positionD2)
+const moveE4_D6 : Move = move(positionE4, positionD6)
+
+//One square arround E4
+const moveE4_E3 : Move = move(positionE4, positionE3)
+const moveE4_D3 : Move = move(positionE4, positionD3)
+const moveE4_D4 : Move = move(positionE4, positionD4)
+const moveE4_D5 : Move = move(positionE4, positionD5)
+const moveE4_E5 : Move = move(positionE4, positionE5)
+const moveE4_F4 : Move = move(positionE4, positionF4)
+
export class TestPrincessMoves {
@Setup
beforeEach() {
// TODO:
+ chessboard = createEmptyChessboard();
// Initialize an empty chessboard
+ putPiece(chessboard, positionE4, blackPrincess)
// Place a black Princess on E4
}
@@ -15,54 +119,82 @@ export class TestPrincessMoves {
testCanMoveDiagonally() {
// TODO:
// Check the following moves are possible:
+ Expect(isPossible.princessMove(chessboard, moveE4_A8)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_B1)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_H7)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_H1)).toBeTruthy()
// moveE4_A8, moveE4_B1, moveE4_H7, moveE4_H1
}
- @Test("A Princess can move three squares horizontally and one square vertically")
+ @Test("A Princess can move two squares horizontally and one square vertically")
testCanMoveTwoHorizontalAndOneVertical() {
+ Expect(isPossible.princessMove(chessboard, moveE4_C3)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_G3)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_C5)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_G5)).toBeTruthy()
+
// TODO
}
- @Test("A Princess can move three squares vertically and one square horizontally")
+ @Test("A Princess can move two squares vertically and one square horizontally")
testCanMoveTwoVerticalAndOneHorizontal() {
+ Expect(isPossible.princessMove(chessboard, moveE4_D6)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_F6)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_D2)).toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_F2)).toBeTruthy()
// TODO
}
@Test("A Princess cannot move horizontally")
testCannotMoveHorizontally() {
// TODO:
+ Expect(isPossible.princessMove(chessboard, moveE4_H4)).not.toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_A4)).not.toBeTruthy()
// Check the following moves are impossible: moveE4_H4, moveE4_A4
}
@Test("A Princess cannot move vertically")
testCannotMoveVertically() {
// TODO:
+ Expect(isPossible.princessMove(chessboard, moveE4_E1)).not.toBeTruthy()
+ Expect(isPossible.princessMove(chessboard, moveE4_E8)).not.toBeTruthy()
// Check the following moves are impossible: moveE4_E1, moveE4_E8
}
@Test("A Princess can capture a piece from another color")
testCanCaptureDifferentColor() {
// TODO:
+ putPiece(chessboard, positionA8, whitePawn)
// Place a white Pawn on A8
+ Expect(isPossible.princessMove(chessboard, moveE4_A8)).toBeTruthy()
+
// Check the move moveE4_A8 is possible
}
@Test("A Princess cannot capture a piece from the same color")
testCannotCaptureSameColor() {
// TODO:
+ putPiece(chessboard, positionA8, blackPawn)
// Place a black Pawn on A8
+ Expect(isPossible.princessMove(chessboard, moveE4_A8)).not.toBeTruthy()
// Check the move moveE4_A8 is impossible
}
@Test("A Princess cannot leap other pieces")
testCannotLeapDiagonally() {
// TODO:
+ putPiece(chessboard, positionC6, whitePawn)
// Place a white Pawn on C6
+ Expect(isPossible.princessMove(chessboard, moveE4_A8)).not.toBeTruthy()
// Check the move moveE4_A8 is impossible
}
-
+
@Test("A Princess can leap other pieces when moving in L ")
testCanLeapOtherPiecesWhenMovingInL() {
- // TODO:
+
+ putPiece(chessboard, positionE5, whitePawn)
+
+ Expect(isPossible.princessMove(chessboard, moveE4_F6)).toBeTruthy()
+
}
}
diff --git a/src/test/ts/queen-move-validation.spec.ts b/src/test/ts/queen-move-validation.spec.ts
index 549e344..3fa30c3 100644
--- a/src/test/ts/queen-move-validation.spec.ts
+++ b/src/test/ts/queen-move-validation.spec.ts
@@ -1,13 +1,109 @@
import { Expect, Test, Setup} from "alsatian";
import { Chessboard, createEmptyChessboard, putPiece } from '../../main/ts/chessboard';
+import * as isPossible from "../../main/ts/move-validation"
+import { Position, position } from '../../main/ts/position';
+import { Move, move } from '../../main/ts/movements';
+import { whitePawn, blackPawn, whitePrincess, whiteQueen } from "../../main/ts/piece";
let chessboard : Chessboard;
+const positionA4 : Position = position(0, 3) // A4
+const positionA5 : Position = position(0, 4) // A5
+const positionA6 : Position = position(0, 5) // A6
+const positionA7 : Position = position(0, 6) // A7
+const positionA8 : Position = position(0, 7) // A8
+
+const positionB1 : Position = position(1, 0) // B1
+const positionB2 : Position = position(1, 1) // B2
+const positionB3 : Position = position(1, 2) // B3
+const positionB5 : Position = position(1, 4) // B5
+const positionB6 : Position = position(1, 5) // B6
+
+const positionC3 : Position = position(2, 1) // C3
+const positionC4 : Position = position(2, 3) // C4
+const positionC5 : Position = position(2, 4) // C5
+const positionC6 : Position = position(2, 5) // C6
+const positionC7 : Position = position(2, 6) // C7
+
+const positionD1 : Position = position(3, 0) // D1
+const positionD2 : Position = position(3, 1) // D2
+const positionD3 : Position = position(3, 2) // D3
+const positionD4 : Position = position(3, 3) // D4
+const positionD5 : Position = position(3, 4) // D5
+const positionD6 : Position = position(3, 5) // D6
+const positionD7 : Position = position(3, 6) // D7
+
+
+const positionE1 : Position = position(4, 0) // E1
+const positionE3 : Position = position(4, 2) // E3
+const positionE4 : Position = position(4, 3) // E4
+const positionE5 : Position = position(4, 4) // E5
+const positionE8 : Position = position(4, 7) // E8
+
+const positionF1 : Position = position(5, 0) // F1
+const positionF2 : Position = position(5, 1) // F2
+const positionF4 : Position = position(5, 3) // F4
+const positionF6 : Position = position(5, 5) // F6
+const positionF7 : Position = position(5, 6) // F7
+const positionG3 : Position = position(6, 2) // G3
+const positionG5 : Position = position(6, 4) // G5
+
+const positionH1 : Position = position(7, 0) // H1
+const positionH3 : Position = position(7, 2) // H3
+const positionH4 : Position = position(7, 3) // H4
+const positionH5 : Position = position(7, 4) // H5
+const positionH7 : Position = position(7, 6) // H7
+
+// Horizontal moves
+const moveE4_H4 : Move = move(positionE4, positionH4);
+const moveE4_A4 : Move = move(positionE4, positionA4);
+
+// Vertical moves
+const moveE4_E1 : Move = move(positionE4, positionE1);
+const moveE4_E8 : Move = move(positionE4, positionE8);
+
+// Diagonal moves
+const moveE4_A8 : Move = move(positionE4, positionA8);
+const moveE4_B1 : Move = move(positionE4, positionB1);
+const moveE4_H7 : Move = move(positionE4, positionH7);
+const moveE4_H1 : Move = move(positionE4, positionH1);
+
+// Camel moves
+const moveE4_F7 : Move = move(positionE4, positionF7);
+const moveE4_H5 : Move = move(positionE4, positionH5);
+const moveE4_F1 : Move = move(positionE4, positionF1);
+const moveE4_H3 : Move = move(positionE4, positionH3);
+const moveE4_D1 : Move = move(positionE4, positionD1);
+const moveE4_B3 : Move = move(positionE4, positionB3);
+const moveE4_B5 : Move = move(positionE4, positionB5);
+const moveE4_D7 : Move = move(positionE4, positionD7);
+
+// Impossible moves
+const moveE4_C7 : Move = move(positionE4, positionC7);
+const moveE4_B2 : Move = move(positionE4, positionB2);
+
+// On the same pos
+const moveE4_E4 : Move = move(positionE4, positionE4)
+
+// Two Horizontal and one Vertical
+const moveE4_G3 : Move = move(positionE4, positionG3)
+const moveE4_G5 : Move = move(positionE4, positionG5)
+const moveE4_C3 : Move = move(positionE4, positionC3)
+const moveE4_C5 : Move = move(positionE4, positionC5)
+
+// Two Vertical and one Horizontal
+const moveE4_F2 : Move = move(positionE4, positionF2)
+const moveE4_F6 : Move = move(positionE4, positionF6)
+const moveE4_D2 : Move = move(positionE4, positionD2)
+const moveE4_D6 : Move = move(positionE4, positionD6)
+
export class TestQueenMoves {
@Setup
beforeEach() {
// TODO:
+ chessboard = createEmptyChessboard()
// Initialize an empty chessboard
+ putPiece(chessboard, positionE4, whiteQueen)
// Place a white Queen on E4
}
@@ -15,45 +111,64 @@ export class TestQueenMoves {
testCanMoveDiagonally() {
// TODO:
// Check the following moves are possible:
+ Expect(isPossible.queenMove(chessboard, moveE4_A8)).toBeTruthy()
+ Expect(isPossible.queenMove(chessboard, moveE4_B1)).toBeTruthy()
+ Expect(isPossible.queenMove(chessboard, moveE4_H7)).toBeTruthy()
+ Expect(isPossible.queenMove(chessboard, moveE4_H1)).toBeTruthy()
// moveE4_A8, moveE4_B1, moveE4_H7, moveE4_H1
}
@Test("A Queen can move horizontally")
testCanMoveHorizontally() {
// TODO:
+ Expect(isPossible.queenMove(chessboard, moveE4_H4)).toBeTruthy()
+ Expect(isPossible.queenMove(chessboard, moveE4_A4)).toBeTruthy()
// Check the following moves are possible: moveE4_H4, moveE4_A4
}
@Test("A Queen can move vertically")
testCanMoveVertically() {
// TODO:
+ Expect(isPossible.queenMove(chessboard, moveE4_E1)).toBeTruthy()
+ Expect(isPossible.queenMove(chessboard, moveE4_E8)).toBeTruthy()
// Check the following moves are possible: moveE4_E1, moveE4_E8
}
@Test("A Queen can only move horizontally, vertically, and diagonally")
testForbiddenMoves() {
// TODO:
+ Expect(isPossible.queenMove(chessboard, moveE4_C7)).not.toBeTruthy()
+ Expect(isPossible.queenMove(chessboard, moveE4_B2)).not.toBeTruthy()
// Check the following moves are impossible: moveE4_C7, moveE4_B2
}
@Test("A Queen cannot leap other pieces")
testCannotLeap() {
// TODO:
+ putPiece(chessboard, positionC6, whitePawn)
+ putPiece(chessboard, positionF4, blackPawn)
+
// Place a white Pawn on C6 and a black Pawn on F4
+ Expect(isPossible.queenMove(chessboard, moveE4_H4)).not.toBeTruthy
+ Expect(isPossible.queenMove(chessboard, moveE4_A8)).not.toBeTruthy
// Check the moves moveE4_A8 and moveE4_H4 are impossible
}
@Test("A Queen cannot capure pieces from the same color")
testCannotCaptureSameColor() {
// TODO:
+ putPiece(chessboard, positionH4, whitePawn)
// Place a white Pawn on H4
+ Expect(isPossible.queenMove(chessboard, moveE4_H4)).not.toBeTruthy
// Check the move moveE4_H4 is impossible
}
@Test("A Queen can capure pieces from a different color")
testCanCaptureDifferentColor() {
// TODO:
+ putPiece(chessboard, positionH4, blackPawn)
// Place a black Pawn on H4
+ Expect(isPossible.queenMove(chessboard, moveE4_H4)).toBeTruthy
// Check the move moveE4_H4 is possible
}
}
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
index 859fd97..0748fdb 100755
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -14,6 +14,6 @@
"node_modules"
],
"include": [
- "src/main/ts/**/*"
+ "src/**/*"
]
}
--
GitLab