Feature: move implementation

src/board.test.ts

@@ -142,4 +142,15 @@ describe('board', () => {
 		});
 	});
 
+	describe('removePieceAt', () => {
+		it('should export a function removePieceAt', () => {
+			expect(typeof removePieceAt).toBe('function');
+		});
+
+		it('should remove the piece at the specified location', () => {
+			const pieces: Piece[] = [{x: 'd', y: '2', type: PieceType.KNIGHT, color: Color.BLACK}];
+
+			expect(removePieceAt({x: 'd', y: '2'}, pieces)).toEqual([]);
+		});
+	});
 });

src/board.ts

@@ -1,6 +1,7 @@
 import {Piece, PieceType} from './pieces';
 import {numberToLetter} from './utils';
 import {Color} from './color';
+import {Position} from './position';
 
 
 interface Board {
@@ -86,4 +87,12 @@ const appendInitialPosition = (piece: Piece, index: number) => {
 const findPiece = (x: string, y: string, board: Board) : Piece =>
 	board.pieces.find((piece: Piece) => piece.x === x && piece.y === y);
 
-export {createBoard, findPiece, Board};
+const removePieceAt = (position: Position, pieces: Piece[]) => {
+	const index = pieces.findIndex((piece: Piece) => position.x === piece.x && position.y === piece.y);
+
+	return index >= 0
+		? [...pieces.slice(0, index), ...pieces.slice(index + 1)]
+		: pieces;
+};
+
+export {Board, createBoard, findPiece, removePieceAt};

src/error.ts

@@ -0,0 +1,4 @@
+export interface Error {
+	message: string;
+
+}

src/game.test.ts

@@ -25,4 +25,47 @@ describe('game', () => {
 			expect(game.player2).toBe(p2);
 		});
 	});
+
+	describe('move', () => {
+		const p1: Player = createPlayer('id-1', Color.WHITE);
+		const p2: Player = createPlayer('id-2', Color.BLACK);
+		const game: Game = createGame(p1, p2);
+
+		it('should export a function move', () => {
+			expect(typeof move).toBe('function');
+		});
+
+		it('should return a game object', (done) => {
+			move(createMove({x: 'd', y: '2'}, {x: 'd', y: '4'}), game).then((g: Game) => {
+				expect(findPiece('d', '4', g.board)).toEqual({type: PieceType.PAWN, color: Color.WHITE, x: 'd', y:'4'});
+				done();
+			});
+		});
+
+		it('should remove a piece that has been killed', (done) => {
+			move(createMove({x: 'd', y: '2'}, {x: 'd', y: '4'}), game).then((g: Game) => {
+				move(createMove({x: 'e', y: '7'}, {x: 'e', y: '5'}), g).then((g: Game) => {
+					move(createMove({x: 'd', y: '4'}, {x: 'e', y: '5'}), g).then((g: Game) => {
+						expect(findPiece('e', '5', g.board)).toEqual({type: PieceType.PAWN, color: Color.WHITE, x: 'e', y:'5'});
+						done();
+					});
+				});
+			});
+		});
+
+		it('should should store the previous board in the undo array', (done) => {
+			move(createMove({x: 'd', y: '2'}, {x: 'd', y: '4'}), game).then((g: Game) => {
+				expect(g.undo[0]).toBe(game.board);
+				done();
+			});
+		});
+
+		it('should return an error WRONG_PLAAYER when the first piece to move is black', (done) => {
+			const wrongGame: Game = createGame(p2, p1);
+			move(createMove({x: 'd', y: '7'}, {x: 'd', y: '5'}), wrongGame).catch((e: Error) => {
+				expect(e).toEqual(Error('WRONG_PLAYER'));
+				done();
+			});
+		});
+	});
 });

src/game.ts

@@ -1,5 +1,10 @@
-import {Board, createBoard} from './board';
-import {Player, makePlayer} from './player';
+import {Board, createBoard, findPiece, removePieceAt} from './board';
+import {Player} from './player';
+import {Piece} from './pieces';
+import {Move} from './move';
+import {Position} from './position';
+import {Color} from './color';
+import {compose, concat} from './utils';
 
 interface Game {
 	board: Board;
@@ -17,4 +22,28 @@ const createGame = (player1: Player, player2: Player): Game => ({
 	redo: [],
 });
 
-export {createGame, Game};
+const move = (m: Move, game: Game): Promise<Game> => {
+	const pieceAtDestination = findPiece(m.to.x, m.to.y, game.board);
+	const pieceToMove = findPiece(m.from.x, m.from.y, game.board);
+
+	return new Promise((resolve, reject) => {
+		if (game.undo.length % 2 === 0 && pieceToMove.color !== Color.WHITE) {
+			reject(Error('WRONG_PLAYER'));
+		} else {
+			resolve({
+				board: {
+					pieces: compose(cConcat({...pieceToMove, x: m.to.x, y: m.to.y}), cRemovePieceAt(m.from), cRemovePieceAt(m.to))(game.board.pieces),
+				},
+				undo: concat(game.board, game.undo),
+				redo: game.redo,
+				player1: game.player1,
+				player2: game.player2,
+			});
+		}
+	});
+};
+
+const cRemovePieceAt =  (position: Position) => (pieces: Piece[]) => removePieceAt(position, pieces);
+const cConcat = (value: any) => (arr: any[]) => concat(value, arr);
+
+export {createGame, Game, move};

src/index.test.ts

@@ -0,0 +1,5 @@
+describe('Chess Engine', () => {
+	it('should work', () => {
+
+	});
+});

src/index.ts

@@ -0,0 +1 @@
+export {createBoard} from './board';

src/move.test.ts

@@ -0,0 +1,19 @@
+import {Move, createMove} from './move';
+import {createPosition} from './position';
+
+describe('move', () => {
+	describe('createMove', () => {
+		it('should export a function createMove', () => {
+			expect(typeof createMove).toBe('function');
+		});
+
+		it('should return a corresponding Move object', () => {
+			const move: Move = createMove({x:'d', y: '2'}, {x: 'd', y: '4'});
+
+			expect(move.from.x).toBe('d');
+			expect(move.from.y).toBe('2');
+			expect(move.to.x).toBe('d');
+			expect(move.to.y).toBe('4');
+		});
+	});
+});

src/move.ts

@@ -0,0 +1,10 @@
+import {Position} from './position';
+
+interface Move {
+	from: Position;
+	to: Position;
+}
+
+const createMove = (from: Position, to: Position) => ({from, to});
+
+export {Move, createMove};

src/utils.ts

@@ -15,4 +15,8 @@ const getDeltaX = (x1: string, x2: string): number => getDelta(letterToNumber(x1
 
 const getDeltaY = (x1: string, x2: string): number => getDelta(parseInt(x1), parseInt(x2));
 
-export {numberToLetter, letterToNumber, positionToVector, getDelta, getDeltaX, getDeltaY};
+const compose = (...fns: Function[]) => fns.reduce((f, g) => (...args: any[]) => f(g(...args)));
+
+const concat = (value: any, arr: any[]) => arr.concat(value);
+
+export {numberToLetter, letterToNumber, positionToVector, getDelta, getDeltaX, getDeltaY, compose, concat};