schachnovelle 1.0.0-beta-6 → 1.1.0

package/ui/Game.js

@@ -1,18 +1,17 @@
-const readline = require('readline')
-const Side = require('./Side')
-const Board = require('./Board')
-const Printer = require('./Printer')
-const Utils = require('./Utils')
-const controller = require('../tests/controller')
+const readline = require("readline")
+const Side = require("./Side")
+const Board = require("./Board")
+const Printer = require("./Printer")
+const Utils = require("./Utils")
 
-const { prompt } = require('enquirer');
+const Enquirer = require("enquirer")
 
 class Game {
-  constructor (options) {
-    this.white = new Side('white')
-    this.black = new Side('black')
+  constructor(options) {
+    this.white = new Side("white")
+    this.black = new Side("black")
     this.playingAs = options.playingAs
-    this.toMove = 'white'
+    this.toMove = "white"
 
     this.moveIndex = 0
     this.history = []
@@ -21,12 +20,13 @@ class Game {
 
     // Initialize the board
     this.board = new Board(this.white, this.black, {
-      mode: 'pieces', // possibly add text mode
+      mode: "pieces", // possibly add text mode
       orientation: this.playingAs,
       spacing: options.spacing,
-      mode: options.mode
+      mode: options.mode,
     })
 
+    this.enquirer = new Enquirer()
     this.printer = new Printer(options.spacing)
     this.utils = new Utils()
   }
@@ -36,21 +36,21 @@ class Game {
    * 2. Sets that as the selected piece
    */
   async promptPieceSelection() {
-    this.printer.print(`${this.toMove} to move.`)
-    this.printer.addSpace('y')
-    const response = await prompt([
-      {
-        type: 'select',
-        name: 'piece',
-        message: 'Piece',
-        choices: this.listAvailablePieces(),
-        result: (result) => {
-          this.setSelectedPiece(result)
-          return result
-        }
-      }
-    ]).catch(console.error);
-    
+    const response = await this.enquirer
+      .prompt([
+        {
+          type: "select",
+          name: "piece",
+          message: "Piece",
+          choices: this.listAvailablePieces(),
+          result: result => {
+            this.setSelectedPiece(result)
+            return result
+          },
+        },
+      ])
+      .catch(console.error)
+
     /**
      * Only do something if the await has been fulfilled
      */
@@ -64,24 +64,35 @@ class Game {
    * 3. Asks for the new coordinates of that piece
    */
   async promptFileSelection() {
-    const response = await prompt([
-      {
-        type: 'select',
-        name: 'file',
-        message: 'File:',
-        choices: this.possibleFiles(),
-        result: (result) => {
-          this.setSelectedFile(result)
-          return result
-        }
-      }
-    ]).catch(console.error);
-    
+    const backToPiece = "... piece selection"
+    const response = await this.enquirer
+      .prompt([
+        {
+          type: "select",
+          name: "file",
+          message: "File:",
+          choices: this.possibleFiles().concat(backToPiece),
+          result: result => {
+            if (result === backToPiece) {
+              return result
+            } else {
+              this.setSelectedFile(result)
+              return result
+            }
+          },
+        },
+      ])
+      .catch(console.error)
+
     /**
      * Only do something if the await has been fulfilled
      */
     if (response) {
-      this.promptRankSelection()
+      if (response.file === backToPiece) {
+        this.promptPieceSelection()
+      } else {
+        this.promptRankSelection()
+      }
     }
   }
 
@@ -90,126 +101,494 @@ class Game {
    * 3. Asks for the new coordinates of that piece
    */
   async promptRankSelection() {
-    const response = await prompt([
-      {
-        type: 'select',
-        name: 'rank',
-        message: 'Rank:',
-        choices: this.possibleRanks(),
-        result: (result) => {
-          this.setSelectedRank(Number(result))
-          return Number(result)
-        }
-      }
-    ]).catch(console.error);
-    
+    const backToFile = "... file selection"
+    const response = await this.enquirer
+      .prompt([
+        {
+          type: "select",
+          name: "rank",
+          message: "Rank:",
+          choices: this.possibleRanks().concat(backToFile),
+          result: result => {
+            if (result === backToFile) {
+              return result
+            } else {
+              this.setSelectedRank(Number(result))
+              return Number(result)
+            }
+          },
+        },
+      ])
+      .catch(console.error)
+
     /**
      * Only do something if the await has been fulfilled
      */
     if (response) {
-      this.validateMove()
+      if (response.rank === backToFile) {
+        this.promptFileSelection()
+      } else {
+        this.validateMove()
+      }
     }
   }
 
-  allMoves () {
-    let moves = []
-    for (const file of this.board.files) {
-      for (const rank of this.board.ranks) {
-        if (this.movePotential([file, rank], false) !== 'blocked') { moves.push([file, rank]) }
-      }
-    }
-    return moves
+  /**
+   * For the given color, return all possible moves
+   */
+  allPossibleMoves(color) {
+    let all = []
+    this.board[color].pieces
+      .filter(p => !p.captured)
+      .forEach(p => {
+        this.possibleMoves(p, color)
+          .forEach(m => all.push(m))
+      })
+    return all
+  }
+
+  /**
+   * Return all possible checks
+   * @param {*} color
+   * @returns
+   */
+  allPossibleChecks(color) {
+    // Moves
+    const moves = this.allPossibleMoves(color)
+
+    const allChecks = moves.filter(m => m[2] === 'check')
+
+    return allChecks
   }
 
   /**
    * Return the possible moves for the selected piece
    * Returns an object with all possible moves split into file, and rank
    */
-  possibleMoves (piece) {
+  possibleMoves(piece, color) {
+    // TODO: If the current color is in check, 
+    // then limit the possible moves to the ones that get you out of it
+
     // Start with the selected piece. First of all, it can't move to it's own square
-    // console.log(this.getSelectedPiece())
     switch (piece.type) {
-      case ('Pawn'):
-        return this.possiblePawnMoves(piece)
-      case ('Knight'):
-        return this.allMoves()
-      case ('Bishop'):
-        return this.allMoves()
-      case ('Rook'):
-        return this.allMoves()
-      case ('Queen'):
-        return this.allMoves()
-      case ('King'):
-        return this.allMoves()
+      case "Pawn":
+        return this.possiblePawnMoves(piece, color)
+      case "Knight":
+        return this.possibleKnightMoves(piece, color)
+      case "Bishop":
+        return this.possibleBishopMoves(piece, color)
+      case "Rook":
+        return this.possibleRookMoves(piece, color)
+      case "Queen":
+        return this.possibleQueenMoves(piece, color)
+      case "King":
+        return this.possibleKingMoves(piece, color)
     }
   }
 
   /**
    * Returns all possible moves for a pawn
    */
-  possiblePawnMoves (pawn) {
+  possiblePawnMoves (pawn, color) {
     const possible = []
     const positions = []
-    const nextRank = this.toMove === 'white' ? pawn.pos[1] + 1 : pawn.pos[1] - 1
-    const secondNextRank = this.toMove === 'white' ? pawn.pos[1] + 2 : pawn.pos[1] - 2
+    const direction = this.playingAs === color ? 1 : -1
+
+    const nextRank = pawn.pos[1] + direction
+    const secondNextRank = pawn.pos[1] + (direction * 2)
     // If it's on the starting rank, allow two moves
-    if (pawn.pos[1] === 2 && this.toMove === 'white') {
-      positions.push(
-        [pawn.pos[0], nextRank],
-        [pawn.pos[0], secondNextRank]
-      )
-    } else if (pawn.pos[1] === 7 && this.toMove === 'black') {
-      positions.push(
-        [pawn.pos[0], nextRank],
-        [pawn.pos[0], secondNextRank]
-      )
-    } else if (this.toMove === 'white') {
-      positions.push(
-        [pawn.pos[0], nextRank]
-      )
+    if (pawn.pos[1] === 2 && color === "white") {
+      positions.push([pawn.pos[0], nextRank], [pawn.pos[0], secondNextRank])
+    } else if (pawn.pos[1] === 7 && color === "black") {
+      positions.push([pawn.pos[0], nextRank], [pawn.pos[0], secondNextRank])
+    } else if (color === "white") {
+      positions.push([pawn.pos[0], nextRank])
     } else {
-      positions.push(
-        [pawn.pos[0], nextRank]
-      )
+      positions.push([pawn.pos[0], nextRank])
     }
     // Captures
     const fileIndex = this.board.files.indexOf(pawn.pos[0])
     const positionsToCapture = []
     switch (fileIndex) {
-      case (0):
-        const posXL = [ this.board.files[fileIndex + 1], nextRank]
+      case 0:
+        const posXL = [this.board.files[fileIndex + 1], nextRank]
         positionsToCapture.push(posXL)
         break
-      case (7):
-        const posXR = [ this.board.files[fileIndex - 1], nextRank ]
+      case 7:
+        const posXR = [this.board.files[fileIndex - 1], nextRank]
         positionsToCapture.push(posXR)
         break
       default:
-        const posL = [ this.board.files[fileIndex + 1], nextRank ]
-        const posR = [ this.board.files[fileIndex - 1], nextRank ]
+        const posL = [this.board.files[fileIndex + 1], nextRank]
+        const posR = [this.board.files[fileIndex - 1], nextRank]
         positionsToCapture.push(posL, posR)
         break
     }
     for (const pos of positions) {
-      if (this.movePotential(pos, false) !== 'blocked') {
+      if (this.movePotential(pos, color, false) !== "blocked") {
         possible.push(pos)
       }
     }
     for (const pos of positionsToCapture) {
-      if (this.movePotential(pos, true) === 'capture') {
+      if (this.movePotential(pos, color, true) === "capture") {
+        possible.push(pos)
+      } else if (this.movePotential(pos, color, true) === "check") {
+        pos.push('check')
         possible.push(pos)
       }
     }
     // TODO: en passant (depends on a history)
-    // convert to queen / rook / bishop / knight
+    return possible
+  }
+
+  /**
+   * Just returns the candidate positions a knight could move to
+   * @param {Integer} fileIndex
+   * @param {Integer} rankIndex
+   */
+  knightCandidateMoves(fileIndex, rankIndex) {
+    return [
+      // Two up, one left
+      [this.board.files[fileIndex - 1], this.board.ranks[rankIndex + 2]],
+      // Two up, one right
+      [this.board.files[fileIndex + 1], this.board.ranks[rankIndex + 2]],
+      // Two right, one up
+      [this.board.files[fileIndex + 2], this.board.ranks[rankIndex + 1]],
+      // Two right, one down
+      [this.board.files[fileIndex + 2], this.board.ranks[rankIndex - 1]],
+      // Two down, one right
+      [this.board.files[fileIndex + 1], this.board.ranks[rankIndex - 2]],
+      // Two down, one left
+      [this.board.files[fileIndex - 1], this.board.ranks[rankIndex - 2]],
+      // Two left, one down
+      [this.board.files[fileIndex - 2], this.board.ranks[rankIndex - 1]],
+      // Two left, one up
+      [this.board.files[fileIndex - 2], this.board.ranks[rankIndex + 1]],
+    ]
+  }
+
+  /**
+   * Returns the possible moves for a knight
+   */
+  possibleKnightMoves(knight, color) {
+    const fileIndex = this.board.files.indexOf(knight.pos[0])
+    const rankIndex = this.board.ranks.indexOf(knight.pos[1])
+    // From the starting square, draw a plus in each direction and then go one diagonal from there
+    // Take the starting file and go left and right
+    const candidates = this.knightCandidateMoves(fileIndex, rankIndex)
+
+    const possible = candidates.filter(move => {
+      if (move[0] !== undefined && move[1] !== undefined) {
+        if (this.movePotential(move, color, true) === "check") {
+          move.push('check')
+          return move
+        } else if (this.movePotential(move, color, true) !== "blocked") {
+          return move
+        }
+      }
+    })
+    return possible
+  }
+
+  /**
+   * Returns the possible moves for a bishop
+   */
+  possibleBishopMoves(bishop, color) {
+    // go into all diagonal directions until there's no place or there's a capture or there's a block
+    const fileIndex = this.board.files.indexOf(bishop.pos[0])
+    const rankIndex = this.board.ranks.indexOf(bishop.pos[1])
+
+    const fU = this.forwardAndUp(fileIndex, rankIndex, color)
+    const fD = this.forwardAndDown(fileIndex, rankIndex, color, false)
+    const bU = this.backwardAndUp(fileIndex, rankIndex, color, false)
+    const bD = this.backwardAndDown(fileIndex, rankIndex, color, false)
+
+    return [...fU, ...fD, ...bU, ...bD]
+  }
+
+  /**
+   * Returns the possible moves for a rook
+   */
+  possibleRookMoves(rook, color) {
+    // go into all diagonal directions until there's no place or there's a capture or there's a block
+    const fileIndex = this.board.files.indexOf(rook.pos[0])
+    const rankIndex = this.board.ranks.indexOf(rook.pos[1])
+
+    const u = this.up(fileIndex, rankIndex, color, false)
+    const d = this.down(fileIndex, rankIndex, color, false)
+    const l = this.left(fileIndex, rankIndex, color, false)
+    const r = this.right(fileIndex, rankIndex, color, false)
+
+    return [...u, ...d, ...l, ...r]
+  }
+
+  /**
+   * Returns the possible moves for a queen
+   */
+  possibleQueenMoves(queen, color) {
+    // go into all diagonal directions until there's no place or there's a capture or there's a block
+    const fileIndex = this.board.files.indexOf(queen.pos[0])
+    const rankIndex = this.board.ranks.indexOf(queen.pos[1])
+
+    const u = this.up(fileIndex, rankIndex, color, false)
+    const d = this.down(fileIndex, rankIndex, color, false)
+    const l = this.left(fileIndex, rankIndex, color, false)
+    const r = this.right(fileIndex, rankIndex, color, false)
+    const fU = this.forwardAndUp(fileIndex, rankIndex, color, false)
+    const fD = this.forwardAndDown(fileIndex, rankIndex, color, false)
+    const bU = this.backwardAndUp(fileIndex, rankIndex, color, false)
+    const bD = this.backwardAndDown(fileIndex, rankIndex, color, false)
+
+    return [...u, ...d, ...l, ...r, ...fU, ...fD, ...bU, ...bD]
+  }
+
+  /**
+   * Returns the possible moves for a queen
+   */
+  possibleKingMoves(king, color) {
+    // go into all diagonal directions until there's no place or there's a capture or there's a block
+    const fileIndex = this.board.files.indexOf(king.pos[0])
+    const rankIndex = this.board.ranks.indexOf(king.pos[1])
+
+    const u = this.up(fileIndex, rankIndex, color, true)
+    const d = this.down(fileIndex, rankIndex, color, true)
+    const l = this.left(fileIndex, rankIndex, color, true)
+    const r = this.right(fileIndex, rankIndex, color, true)
+    const fU = this.forwardAndUp(fileIndex, rankIndex, color, true)
+    const fD = this.forwardAndDown(fileIndex, rankIndex, color, true)
+    const bU = this.backwardAndUp(fileIndex, rankIndex, color, true)
+    const bD = this.backwardAndDown(fileIndex, rankIndex, color, true)
+
+    return [...u, ...d, ...l, ...r, ...fU, ...fD, ...bU, ...bD]
+  }
+
+  /**
+   * Returns the possible moves on a diagonal going right and up
+   * This function is used in two contexts;
+   * 1. To determine the next moves for a person playing
+   * 2. To check if the next move will be checking the opponent's king
+   */
+  forwardAndUp(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let fi = fileIndex + 1
+    let ri = rankIndex + 1
+
+    let nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      fi++
+      ri++
+      nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+    }
+
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a diagonal going right and down
+   */
+  forwardAndDown(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let fi = fileIndex + 1
+    let ri = rankIndex + -1
+
+    let nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      fi++
+      ri--
+      nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+    }
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a diagonal going left and up
+   */
+  backwardAndUp(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let fi = fileIndex - 1
+    let ri = rankIndex + 1
+
+    let nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      fi--
+      ri++
+      nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+    }
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a diagonal going left and down
+   */
+  backwardAndDown(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let fi = fileIndex - 1
+    let ri = rankIndex - 1
+
+    let nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      fi--
+      ri--
+      nextPosition = [this.board.files[fi], this.board.ranks[ri]]
+    }
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a file going up
+   */
+  up(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let ri = rankIndex + 1
+
+    let nextPosition = [this.board.files[fileIndex], this.board.ranks[ri]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      ri++
+      nextPosition = [this.board.files[fileIndex], this.board.ranks[ri]]
+    }
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a file going down
+   */
+  down(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let ri = rankIndex - 1
+
+    let nextPosition = [this.board.files[fileIndex], this.board.ranks[ri]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      ri--
+      nextPosition = [this.board.files[fileIndex], this.board.ranks[ri]]
+    }
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a rank going left
+   */
+  left(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let fi = fileIndex - 1
+
+    let nextPosition = [this.board.files[fi], this.board.ranks[rankIndex]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      fi--
+      nextPosition = [this.board.files[fi], this.board.ranks[rankIndex]]
+    }
+    return possible
+  }
+
+  /**
+   * Returns the possible moves on a rank going right
+   */
+  right(fileIndex, rankIndex, color, king) {
+    const possible = []
+    let fi = fileIndex + 1
+
+    let nextPosition = [this.board.files[fi], this.board.ranks[rankIndex]]
+
+    while (
+      this.movePotential(nextPosition, color, true) !== "blocked" &&
+      this.movePotential(nextPosition, color, true) !== "impossible"
+    ) {
+      if (this.movePotential(nextPosition, color, true) === "check") {
+        nextPosition.push('check')
+        possible.push(nextPosition)
+        break
+      }
+      possible.push(nextPosition)
+      if (this.movePotential(nextPosition, color, true) === "capture" || king) break
+      fi++
+      nextPosition = [this.board.files[fi], this.board.ranks[rankIndex]]
+    }
     return possible
   }
 
   /**
    * Returns the possible ranks from the possiblemoves function
    */
-  possibleFiles () {
-    const possible = this.possibleMoves(this.selectedPiece).map((pos) => { return pos[0] })
+  possibleFiles() {
+    const possible = this.possibleMoves(this.selectedPiece, this.toMove).map(pos => {
+      return pos[0]
+    })
     /** Filter unique */
     return [...new Set(possible)]
   }
@@ -217,52 +596,70 @@ class Game {
   /**
    * Returns the possible ranks from the possiblemoves function
    */
-  possibleRanks () {
-    const possible = this.possibleMoves(this.selectedPiece).filter((move) => {
-      if (move[0] === this.selectedFile) { return move[1] }
-    }).map((pos) => {
-      return pos[1].toString()
-    })
+  possibleRanks() {
+    const possible = this.possibleMoves(this.selectedPiece, this.toMove)
+      .filter(move => {
+        if (move[0] === this.selectedFile) {
+          return move[1]
+        }
+      })
+      .map(pos => {
+        return pos[1].toString()
+      })
     /** Filter unique */
     return [...new Set(possible)]
   }
 
   /**
-   * TODO: Checks if it is a legal move
-   * If all is well, commits the move
+   * 1. Process captures
+   * 2. TODO: Check check
+   * 3. TODO: Check checkmate
    */
-  validateMove () {
-    const legal = true
-    // somehow find out if it's a legal move. Then;
-    if (legal) {
-      // Commit the move to update the board
-      this.processCapture()
-      this.commitMove()
-      // Opponent to move
-    } else {
-      // retry
-      console.error('Not a legal move. Try again')
-      this.runPrompt()
-    }
+  async validateMove() {
+    // Commit the move to update the board
+    this.processCapture()
+    await this.promptPromotion()
+    this.commitMove()
   }
 
   /**
    * Allowed configures the check to consider if a capture may be made
+   * If it is true,
    * Returns 'capture' if there is an opposing piece at the given position
+   * Returns 'check' if the opposing piece at the given position is a king
    * Returns 'blocked' if there is an own piece or 'possible' for no piece at the given position
    */
-  movePotential (pos, allowed) {
-    const opponentsPieces = this.board[this.utils.opponentColor(this.toMove)].pieces
-    const ownPiece = this.board[this.toMove].pieces.find((piece) => {
+  movePotential(pos, color, allowed) {
+    if (pos[0] === undefined || pos[1] === undefined) {
+      return "impossible"
+    }
+
+    const opponentsPieces =
+      this.board[this.utils.opposingColor(color)].pieces
+
+    const ownPiece = this.board[color].pieces.find(piece => {
       return piece.pos[0] === pos[0] && piece.pos[1] === pos[1]
     })
-    const opponentsPiece = opponentsPieces.find((piece) => {
+    const opponentsPiece = opponentsPieces.find(piece => {
       return piece.pos[0] === pos[0] && piece.pos[1] === pos[1]
     })
 
-    if (opponentsPiece && allowed) { return 'capture' }
-    if (ownPiece || opponentsPiece && !allowed) { return 'blocked' }
-    if (!ownPiece && !opponentsPiece) { return 'possible' }
+    if (opponentsPiece && allowed) {
+      if (opponentsPiece.type === "King") {
+        return "check"
+      } else {
+        return "capture"
+      }
+    }
+    if (ownPiece && allowed) {
+      return "blocked"
+    }
+    if (ownPiece || (opponentsPiece && !allowed)) {
+      return "blocked"
+    }
+    if (!ownPiece && !opponentsPiece) {
+      return "possible"
+    }
   }
 
   /**
@@ -270,16 +667,84 @@ class Game {
    * 1. Checks for capture
    * 2. If capture, set the piece status to captured
    */
-  processCapture () {
-    const opponentsPieces = this.board[this.utils.opponentColor(this.toMove)].pieces
-    const capturedPiece = opponentsPieces.find((piece) => {
-      return piece.pos[0] === this.selectedFile && piece.pos[1] === this.selectedRank
+  processCapture() {
+    const opponentsPieces =
+      this.board[this.utils.opposingColor(this.toMove)].pieces
+    const capturedPiece = opponentsPieces.find(piece => {
+      return (
+        piece.pos[0] === this.selectedFile && piece.pos[1] === this.selectedRank
+      )
     })
     if (capturedPiece) {
       capturedPiece.captured = true
     }
   }
 
+  /**
+   * Prompt promotion
+   * 1. Asks user which piece to promote to
+   * 2. Sets said piece to its new values
+   */
+  async promptPromotion() {
+    if (
+      (this.selectedPiece.type === "Pawn" &&
+        this.toMove === "white" &&
+        this.selectedRank === 8) ||
+      (this.selectedPiece.type === "Pawn" &&
+        this.toMove === "black" &&
+        this.selectedRank === 1)
+    ) {
+      await this.enquirer
+        .prompt({
+          type: "select",
+          name: "promotion",
+          message: "Promote to:",
+          choices: this.board[this.toMove].promotionChoices.map(choice => {
+            return choice.piece
+          }),
+          result: piece => {
+            const promotionChoice = this.board[
+              this.toMove
+            ].promotionChoices.find(choice => {
+              return choice.piece === piece
+            })
+            const selectedPiece = this.getSelectedPiece()
+            selectedPiece.piece = piece
+            selectedPiece.type = promotionChoice.type
+            selectedPiece.prefix = promotionChoice.prefix
+            selectedPiece.value = promotionChoice.piece
+            return selectedPiece
+          },
+        })
+        .catch(console.error)
+    }
+  }
+
+  /**
+   * Check master function. Is run right before passTurn and board.render
+   */
+  checkForCheck() {
+    // If the opponent's checks length is > 0, that means you're in check
+    const opponent = this.utils.opposingColor(this.toMove)
+    const opponentsChecks = this.allPossibleChecks(opponent)
+
+    if (opponentsChecks.length > 0) {
+      this.board[this.toMove].inCheck = true
+    } else {
+      this.board[this.toMove].inCheck = false
+      this.board[opponent].inCheck = false
+    }
+  }
+
+  /**
+   * Passes the turn to the other player by setting the toMove var and prompting the next move
+   */
+  passTurn() {
+    this.toMove = this.toMove === "white" ? "black" : "white"
+    this.checkForCheck()
+    this.promptPieceSelection()
+  }
+
   /**
    * Commits the given move
    * 1. Sets the position of the selected piece
@@ -287,53 +752,37 @@ class Game {
    * 3. Passes the turn to the other player
    * 4. Renders the board
    */
-  commitMove () {
+  commitMove() {
     this.getSelectedPiece().pos = [this.selectedFile, this.selectedRank]
     this.commitToHistory()
     this.passTurn()
+    this.board.clear()
     this.board.render()
   }
 
-  /**
-   * Passes the turn to the other player by setting the toMove var and prompting the next move
-   */
-  passTurn () {
-    this.toMove === 'white' ? this.toMove = 'black' : this.toMove = 'white'
-    this.promptPieceSelection()
-  }
-
   /**
    * Pushes move to history
    */
-  commitToHistory () {
-    console.log(`${this.selectedPiece.piece} to ${this.selectedFile}${this.selectedRank}`)
-    // if (this.toMove === 'white') {
-    //   this.history.push({
-    //     turn: this.moveIndex + 1,
-    //     move: move
-    //   })
-    // } else {
-    //   this.history[this.moveIndex].move += `, ${move}`
-    //   this.moveIndex++
-    // }
-  }
+  commitToHistory() {}
 
   /**
    * Returns a list of available pieces for the prompt
    */
-  listAvailablePieces () {
-    return this.board[this.toMove].pieces.filter((piece) => {
-      return !piece.captured && this.possibleMoves(piece).length > 0
-    }).map((piece) => {
-      return `${piece.piece} (${piece.pos})`
-    })
+  listAvailablePieces() {
+    return this.board[this.toMove].pieces
+      .filter(piece => {
+        return !piece.captured && this.possibleMoves(piece, this.toMove).length > 0
+      })
+      .map(piece => {
+        return `${piece.piece} (${piece.pos})`
+      })
   }
 
   /**
    * Sets the given piece as selected for this move
    */
-  setSelectedPiece (piece) {
-    const selection = this.board[this.toMove].pieces.find((p) => {
+  setSelectedPiece(piece) {
+    const selection = this.board[this.toMove].pieces.find(p => {
       return p.pos[0] === piece[3] && p.pos[1] === Number(piece[5])
     })
     this.selectedPiece = selection
@@ -342,31 +791,54 @@ class Game {
   /**
    * Sets the given file as selected for this move
    */
-  setSelectedFile (file) {
+  setSelectedFile(file) {
     this.selectedFile = file
   }
 
   /**
    * Sets the given rank as selected for this move
    */
-  setSelectedRank (rank) {
+  setSelectedRank(rank) {
     this.selectedRank = rank
   }
 
+  /**
+   * Get the current player's piece
+   */
+  getPiece(type) {
+    return this.board[this.toMove].pieces.find(piece => {
+      return piece.type === type
+    })
+  }
+
+  /**
+   * Get the opponent's piece
+   */
+  getOpponentsPiece(type) {
+    return this.board[this.utils.opposingColor(this.toMove)].pieces.find(
+      piece => {
+        return piece.type === type
+      }
+    )
+  }
+
   /**
    * returns the selected piece for this move
    */
-  getSelectedPiece () {
-    return this.board[this.toMove].pieces.find(piece => { return piece === this.selectedPiece })
+  getSelectedPiece() {
+    return this.board[this.toMove].pieces.find(piece => {
+      return piece === this.selectedPiece
+    })
   }
 
   /**
    * Um Gottes Wille, nicht!
    */
-  init () {
+  init() {
+    this.board.clear()
     this.board.render()
     this.promptPieceSelection()
   }
 }
 
-module.exports = Game
+module.exports = Game