implemented a method to make moves

Author: ratkosolar

src/chess.js

@@ -1,7 +1,22 @@
-import { GAME_ONGOING, WHITE, DEFAULT_FEN } from './constants';
+import {
+  GAME_ONGOING,
+  WHITE,
+  DEFAULT_FEN,
+  CASTLE_QUEENSIDE,
+  CASTLE_KINGSIDE,
+  PAWN,
+  BLACK
+} from './constants';
 import FenParser from './fen-parser';
 import Board from './board/board';
-import { getPieceColor } from './utils';
+import {
+  getPieceColor,
+  parseBoardPosition,
+  buildPieceString,
+  getBoardPieceAt,
+  updatePiecePosition,
+  stringifyBoardPosition
+} from './utils';
 
 class Chess {
   constructor(fen = null) {
@@ -21,6 +36,8 @@ class Chess {
     this.halfMoves = 0;
     this.fullMoves = 1;
 
+    this.deadPieces = [];
+
     this.loadFen(fen || DEFAULT_FEN);
   }
 
@@ -80,11 +97,85 @@ class Chess {
     );
   }
 
-  move() {}
+  move(piece, to) {
+    const color = getPieceColor(piece);
+    if (color !== this.activeColor) {
+      throw new Error(`Not ${color} turn`);
+    }
+
+    const board = this.getBoard();
+    const legalMove = this.board
+      .getLegalMovesForPiece(piece, board, this.enPassantTarget, this.castling)
+      .find(move => move.to === to);
+
+    if (!legalMove) {
+      throw new Error('Move not legal');
+    }
+
+    // Move the piece
+    const fromPos = parseBoardPosition(legalMove.from);
+    const toPos = parseBoardPosition(legalMove.to);
+    board[fromPos.y][fromPos.x] = null;
+    board[toPos.y][toPos.x] = buildPieceString(legalMove.piece, color, legalMove.to);
+
+    if (legalMove.capture) {
+      this.deadPieces.push(legalMove.capturedPiece);
+    }
+
+    // Move castling rook
+    if (legalMove.castle) {
+      const castleRookY = color === WHITE ? 7 : 0;
+
+      if (legalMove.castle === CASTLE_QUEENSIDE) {
+        const castleRookX = 0;
+        const castleRook = getBoardPieceAt(board, castleRookX, castleRookY);
+        const newRookPosition = stringifyBoardPosition(castleRookX + 3, castleRookY);
+        board[castleRookY][castleRookX] = null;
+        board[castleRookY][castleRookX + 3] = updatePiecePosition(castleRook, newRookPosition);
+      } else if (legalMove.castle === CASTLE_KINGSIDE) {
+        const castleRookX = 7;
+        const castleRook = getBoardPieceAt(board, 7, castleRookY);
+        const newRookPosition = stringifyBoardPosition(castleRookX - 2, castleRookY);
+        board[castleRookY][castleRookX] = null;
+        board[castleRookY][castleRookX - 2] = updatePiecePosition(castleRook, newRookPosition);
+      }
+    }
+
+    // En passant target (if a pawn does a 2 step move)
+    if (legalMove.piece === PAWN && Math.abs(fromPos.y - toPos.y) === 2) {
+      const enPassantTargetY = color === WHITE ? fromPos.y - 1 : fromPos.y + 1;
+      this.enPassantTarget = stringifyBoardPosition(fromPos.x, enPassantTargetY);
+    } else {
+      this.enPassantTarget = null;
+    }
+
+    this.board = new Board(board);
+    this.fullMoves += 1;
+    this.halfMoves = Math.floor((this.fullMoves + 1) / 2);
+    this.activeColor = color === WHITE ? BLACK : WHITE;
+  }
 
   isCheck() {}
 
   isCheckmate() {}
+
+  isDone() {
+    const board = this.getBoard();
+    const legalMoves = this.board.getAllLegalMoves(
+      board,
+      this.activeColor,
+      this.enPassantTarget,
+      this.castling
+    );
+    if (legalMoves.length === 0) {
+      return true;
+    }
+    return false;
+  }
+
+  getBoard() {
+    return this.board.getBoard();
+  }
 }
 
 export default Chess;

src/chess.test.js

@@ -10,4 +10,78 @@ describe('Chess class instance', () => {
     chess.loadFen('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
     expect(chess.castling).toEqual({ K: true, Q: true, k: true, q: true });
   });
+
+  describe('chess moves', () => {
+    it('should prevent black from making a first move', () => {
+      expect(() => chess.move('p@D7', 'D5')).toThrowError();
+    });
+    it('should allow white to make only 1 move', () => {
+      expect(() => chess.move('P@D2', 'D4')).not.toThrowError();
+      expect(() => chess.move('P@E2', 'E3')).toThrowError('Not w turn');
+    });
+    it('should record en passant target when 2 step pawn move', () => {
+      chess.move('P@D2', 'D4');
+      expect(chess.enPassantTarget).toBe('D3');
+      chess.move('p@D7', 'D5');
+      expect(chess.enPassantTarget).toBe('D6');
+      chess.move('P@C2', 'C3');
+      expect(chess.enPassantTarget).toBe(null);
+    });
+    it('should move rooks when castling queen side', () => {
+      chess.move('P@D2', 'D4');
+      chess.move('p@D7', 'D5');
+      chess.move('P@B2', 'B3');
+      chess.move('p@B7', 'B6');
+      chess.move('B@C1', 'B2');
+      chess.move('b@C8', 'B7');
+      chess.move('N@B1', 'C3');
+      chess.move('n@B8', 'C6');
+      chess.move('Q@D1', 'D2');
+      chess.move('q@D8', 'D7');
+
+      // white queen side castle
+      chess.move('K@E1', 'C1');
+      let board = chess.getBoard();
+      expect(board[7][0]).toBe(null);
+      expect(board[7][3]).toBe('R@D1');
+
+      // black queen side castle
+      chess.move('k@E8', 'C8');
+      board = chess.getBoard();
+      expect(board[0][0]).toBe(null);
+      expect(board[0][3]).toBe('r@D8');
+    });
+    it('should move rooks when castling king side', () => {
+      chess.move('P@E2', 'E4');
+      chess.move('p@E7', 'E5');
+      chess.move('P@G2', 'G3');
+      chess.move('p@G7', 'G6');
+      chess.move('B@F1', 'G2');
+      chess.move('b@F8', 'G7');
+      chess.move('N@G1', 'F3');
+      chess.move('n@G8', 'F6');
+
+      // white king side castle
+      chess.move('K@E1', 'G1');
+      let board = chess.getBoard();
+      expect(board[7][7]).toBe(null);
+      expect(board[7][5]).toBe('R@F1');
+
+      // black king side castle
+      chess.move('k@E8', 'G8');
+      board = chess.getBoard();
+      expect(board[0][7]).toBe(null);
+      expect(board[0][5]).toBe('r@F8');
+    });
+    it('should mark game as done if checkmate', () => {
+      chess.move('P@E2', 'E4');
+      chess.move('p@E7', 'E5');
+      chess.move('B@F1', 'C4');
+      chess.move('p@D7', 'D6');
+      chess.move('Q@D1', 'F3');
+      chess.move('n@B8', 'C6');
+      chess.move('Q@F3', 'F7');
+      expect(chess.isDone()).toBe(true);
+    });
+  });
 });

src/pieces/piece.js

@@ -99,7 +99,7 @@ class Piece {
             piece: this.type,
             color: this.color,
             capture: isCapture,
-            capturePiece: isCapture ? occupiedPiece : null,
+            capturedPiece: isCapture ? occupiedPiece : null,
             enPassant: isEnPassant,
             castle: isCastle ? move.type : null
           };

src/pieces/piece.test.js

@@ -63,7 +63,7 @@ describe('Chess piece class', () => {
     expect(setPieceColor(null)).toThrowError();
   });
 
-  it('should should validate piece position', () => {
+  it('should validate piece position', () => {
     expect(setPiecePosition('A4')).not.toThrowError();
     expect(setPiecePosition('H8')).not.toThrowError();
     expect(setPiecePosition('F7')).not.toThrowError();