terminal_chess 0.1.2 → 0.2.0

data/lib/printer.rb

@@ -1,77 +1,152 @@
 #!/usr/bin/env ruby
 
-module PRINTER
+module Printer
 
-  VERSION ||= "0.1.0"
-  COLS ||= ['A','B','C','D','E','F','G','H']
-  @@n = 0
-  @@print_count = 1
+  # TODO : Replace text pieces with unicode symbols
+  PIECE_TO_UNICODE_MAPPING ||= {
+    "pa": "♙",
+    "ro": "♖",
+    "bi": "♗",
+    "kn": "♘",
+    "ki": "♔",
+    "qu": "♕"
+  }
+  COLS ||= ('A'..'H')
 
+  @@subrow = 0        # Reference to current row within a cell
+  @@cell_number = 1   # Reference to the current cell
 
-  # Prints the board to terminal, based on layout defined by piece_locations
-  def printer
-    
-    # Clear and reset counters
-    @@print_count = 1
+
+  def print_header
+    # Print chess board Header (Title and then Column Labels A to H)
+    print "\n\t>> Welcome to Terminal Chess v#{TerminalChess::VERSION}\n\n"
+    print "\s\s\s" # cell padding
+
+    COLS.each { |c| print "  #{c}   " }
+    puts
+  end
+
+  def print_footer
+    # Print chess board footer (Column Labels A to H)
+    print "\s\s\s" # cell padding
+
+    COLS.each { |c| print "  #{c}   " }
+    puts
+  end
+
+  def print_start_of_row(row_num)
+    # Pad the start of each row with spacing or the row numbers 1..8
+    if row_num
+      print " #{row_num} "
+    else
+      print " " * 3
+    end
+  end
+
+  def print_end_of_row(row_num)
+    # Print row number 1...8 at end of each row
+    if (@@subrow == 1 || @@subrow == 4) && row_num
+      print " #{row_num}"
+    end
+  end
+
+  def clear_all
+    # Reset counters and clear terminal
+    @@cell_number = 1
     system "clear" or system "cls"
+  end
 
-    # Header (title & column labels)
-    print "\n\t>> Welcome to Terminal Chess v#{VERSION}\n\n\s\s\s"
-    COLS.each { |c| print " _#{c}__ " }
-    puts "\n"
 
-    # Print Cells (use printer block and pass cell styling in loop below)
+  def printer
+    # Prints the board to terminal, based on layout defined by piece_locations
+
+    clear_all
+    print_header
+
+    # Print first cell of each row, with row number
     (1..8).each do |row|
-      yield "|    |"
-      yield "| XX |", "#{row}"
-      yield "|____|"
+      yield "      "
+      yield "  XX  ", "#{row}"
+      yield "      "
     end
 
-    # Footer (print column labels)
-    print "\s\s\s"
-    COLS.each { |c| print "  #{c}   " }
-    puts ""
+    print_footer
   end
 
+  def substitute_pieces(text, index, color, background_color, piece_locations)
+    piece = piece_to_string(piece_locations[index][:type])
+
+    piece.upcase! unless piece == "pa"
+    piece = piece.colorize(color)
+
+    if background_color == :white
+      text.gsub("XX", piece).on_light_white
+    else
+      text.gsub("XX", piece).on_light_black
+    end
+  end
+
+  def piece_to_string(piece_name)
+    # Print pieces as two characters
+    #   "pawn" -> "pa" , "bishop" -> "BI" , "king" -> "KI" , ...
+    #   print nil as "  " so it takes up a two character width on the printed board
+    piece_name == nil ? "  " : piece_name[0..1]
+  end
 
   def print_board(piece_locations)
-    printer { |i, j|
-
-      # Print preceeding row index (1...8) if applicable
-      if j then print " #{j} " else print "   " end
-      if @@n < 3
-        # Print cell (4 characters wide, 3 characters tall)
-        4.times do
-          color = piece_locations[@@print_count]["color"] || "black"
-          next_color = piece_locations[@@print_count+1]["color"] || "black"
-          print "#{i}".gsub("XX", piece_locations[@@print_count]["type"][0..1].upcase).colorize(:"#{color}").on_light_white
-          print "#{i}".gsub("XX", piece_locations[@@print_count+1]["type"][0..1].upcase).colorize(:"#{next_color}").on_light_black
-          if "#{i}".include? "XX"
-            # Incremenet print_count, unless last cell is being printed, to avoid an out of range error
-            @@print_count += 2 unless @@print_count == 63
-          end
+    printer do |tile_text, row_num|
+
+      print_start_of_row(row_num)
+
+      4.times do
+
+        # Print cell and next neighboring cell,
+        # then loop until 4 pairs of 2 cells have been printed, completing row
+        color      = piece_locations[@@cell_number][:color]     || :black
+        next_color = piece_locations[@@cell_number + 1][:color] || :black
+
+        # Print two rows at a time as every two rows repeat
+        #  alternating tile colors
+        #    ________________________
+        #   |   ###   ###   ###   ###| -> subrow 0
+        #   |   ###   ###   ###   ###| -> subrow 1
+        #   |   ###   ###   ###   ###| -> subrow 2
+        #   |###   ###   ###   ###   | -> subrow 3
+        #   |###   ###   ###   ###   | -> subrow 4
+        #   |###   ###   ###   ###   | -> subrow 5
+        #
+
+        if @@subrow < 3
+          print substitute_pieces(
+            tile_text, @@cell_number, color, :white, piece_locations
+          )
+          print substitute_pieces(
+            tile_text, @@cell_number + 1, next_color, :black, piece_locations
+          )
+        else
+          print substitute_pieces(
+            tile_text, @@cell_number, color, :black, piece_locations
+          )
+          print substitute_pieces(
+            tile_text, @@cell_number + 1, next_color, :white, piece_locations
+          )
         end
-      else
-        # Print cell starting with alternative color (4 characters wide, 3 characters tall)
-        4.times do
-          color = piece_locations[@@print_count]["color"] || "black"
-          next_color = piece_locations[@@print_count+1]["color"] || "black"
-          print "#{i}".gsub("XX", piece_locations[@@print_count]["type"][0..1].upcase).colorize(:"#{color}").on_light_black
-          print "#{i}".gsub("XX", piece_locations[@@print_count+1]["type"][0..1].upcase).colorize(:"#{next_color}").on_light_white
-          if "#{i}".include? "XX"
-            @@print_count += 2 unless @@print_count == 63
-          end
+
+        if tile_text.include? "XX"
+          # Incremenet cell_number unless last cell is being printed
+          # to avoid an out of range error
+          @@cell_number += 2 unless @@cell_number == 63
         end
       end
 
-      # Print succeeding row index (1...8) if applicable
-      if (@@n == 1 || @@n == 4) && j then print " #{j}" end
+      print_end_of_row(row_num)
 
-      # Incriment row index. Reset once n reaches 6 (i.e., two complete cell rows have been printed - the pattern to repeat)
-      @@n += 1
-      if @@n == 6 then @@n = 0 end
-      puts ""
-    }
+      # Incriment row index.
+      # Reset once n reaches 6 (i.e., two complete cell rows have been printed - the pattern to repeat)
+      @@subrow += 1
+      @@subrow = 0 if @@subrow == 6
+      puts
+    end
   end
 
 end

data/lib/server.rb

@@ -0,0 +1,65 @@
+require 'em-websocket'
+
+EventMachine.run do
+
+  clients = []
+  game_ongoing = false
+  p [:start, "Waiting for clients to connect..."]
+
+  EM::WebSocket.start(:host => '0.0.0.0', :port => '4567') do |ws|
+
+    ws.onopen do |handshake|
+      p [:open]
+      if @game_ongoing 
+        ws.send "Game already in progress"
+        ws.close
+      else
+        puts "Now connected to client"
+      end
+      
+      if clients.length == 0
+        puts "Waiting for second client"
+        clients << ws
+        ws.send "INFO: Player now connected to #{handshake.path}"
+        ws.send "INFO: Awaiting second player..."
+      
+      elsif clients.length == 1
+        clients << ws
+        puts "Starting Game..."
+        ws.send "INFO: Player now connected to server at #{handshake.path}"
+
+        clients.each_with_index do |client, idx|
+          client.send "INFO: Connected to remote player"
+          client.send "SETUP: You are player #{idx+1}"
+        end
+      end
+    end
+
+    ws.onmessage do |msg|
+      p [:message, msg]
+      opposing_player = (clients - [ws]).first
+
+      # Send opposing player the new move
+      opposing_player.send msg
+    end
+
+    ws.onerror do |err|
+      p [:error, err]
+    end
+
+    ws.onclose do
+      clients.each do |client|
+        client.send "INFO: Player has left the game"
+        client.close unless client.state == :closed
+      end
+
+      p [:close, "Client disconnected. Disconnecting all players"]
+
+      # End session for all clients
+      clients = []
+      game_ongoing = false
+    end
+
+  end
+end
+

data/lib/terminal_chess.rb

@@ -1,32 +1,13 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH << '.'
+$LOAD_PATH << __FILE__ # '.'
 
-require_relative "terminal_chess/version"
-require_relative "printer.rb"
-require_relative "move.rb"
-require_relative "board.rb"
+require_relative 'local_chess_client'
+require_relative 'network_chess_client'
 
-# Setup
-board = Board.new; 
-board.setup_board; 
-board.board_refresh
-
-# Gameplay
-loop do
-
-  print "\nPiece to Move [#{board.player_turn.capitalize}]: "
-  from = gets.chomp.upcase
-  
-  begin
-    print "Valid destinations: #{board.valid_destinations(from).join(", ")}"
-  
-    print "\nLocation: "
-    to = gets.chomp.upcase
-    board.move(from, to)
-
-  rescue Exception => e
-    puts "Invalid selection #{e if !ENV["DEV"].nil?}"
-  end
+if ENV["NGROK"]
+  NetworkChessClient.new(ENV["NGROK"])
+else
+  LocalChessClient.new
 end
 

data/lib/terminal_chess/messages.rb

@@ -0,0 +1,27 @@
+class Messages
+
+  @red_turn   = "It is red's turn. Please move a red piece."
+  @black_turn = "It is black's turn. Please move a black piece."
+
+  @red_in_check   = "Please move red king out of check to continue"
+  @black_in_check = "Please move black king out of check to continue"
+  @red_winner     = "Checkmate! Red Player Wins!"
+  @black_winner   = "Checkmate! Black Player Wins!"
+  @invalid        = "Invalid Selection"
+
+  @piece_moved    = "Piece moved"
+
+  class << self
+    attr_reader(
+      :red_turn,
+      :black_turn,
+      :red_in_check,
+      :black_in_check,
+      :red_winner,
+      :black_winner,
+      :checkmate,
+      :invalid,
+      :piece_moved
+    )
+  end
+end

data/lib/terminal_chess/version.rb

@@ -1,3 +1,3 @@
 module TerminalChess
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/terminal_chess.gemspec

@@ -6,7 +6,7 @@ require 'terminal_chess/version'
 Gem::Specification.new do |s|
   s.name        = 'terminal_chess'
   s.version     = TerminalChess::VERSION
-  s.date        = '2015-03-03'
+  s.date        = '2017-12-12'
   s.summary     = "Chess game playable via the terminal"
   s.description = "Two player chess game through the terminal"
   s.authors     = ["Jason Willems"]
@@ -19,6 +19,10 @@ Gem::Specification.new do |s|
   s.executables << 'terminal_chess'
 
   s.add_runtime_dependency "colorize"
+  s.add_runtime_dependency "em-websocket"
+  s.add_runtime_dependency "eventmachine"
+  s.add_runtime_dependency "faye-websocket"
   s.add_development_dependency "bundler", "~> 1.7"
   s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "minitest"
 end

data/test/test_terminal_chess.rb

@@ -1,30 +1,37 @@
-#require 'test/unit'
 require 'minitest/autorun'
 require "./lib/terminal_chess/version"
+require "./lib/terminal_chess/messages"
 require "printer.rb"
 require "move.rb"
 require "board.rb"
 
 class MyIO
-  def gets 
+  def gets
     "Q\n"
   end
 end
 
-class TestBoard < MiniTest::Unit::TestCase
-  
+<<CHESSBOARD
+Tile Positions:
+
+   A,B,C,D,E,F,G,H
+  1   1-8
+  2   9-16
+  3   17-24
+  4   25-32
+  5   33-40
+  6   41-48
+  7   49-56
+  8   57-64
+CHESSBOARD
+
+class TestBoard < MiniTest::Test
+
   def setup
-   
-    @columns        = %w[A B C D E F G H]
-    @invalid_msg    = "Invalid selection"
-    @red_turn_msg   = "It is red's turn. Please move a red piece."
-    @black_turn_msg = "It is black's turn. Please move a black piece."
-    @red_in_check   = "Please move red king out of check to continue"
-    @black_in_check = "Please move black king out of check to continue"
 
+    @columns = %w[A B C D E F G H]
     @board = Board.new
-    @board.setup_board 
-    @board.board_refresh    
+    @board.display_board
 
     def valid_piece_movement(from)
       @board.valid_destinations(from)
@@ -37,33 +44,42 @@ class TestBoard < MiniTest::Unit::TestCase
     def get_board
       @board.piece_manifest
     end
- 
+
     def piece_quantity(piece)
       all_tiles = get_board
       count = 0
       all_tiles.each do |num, details|
-        count += 1 if details.fetch("type") == piece
+        count += 1 if details.fetch(:type) == piece
       end
+
       count
     end
 
     def tile_empty(lowerbound, upperbound)
       all_tiles = get_board
       empty = true
+
       all_tiles.each do |num, details|
         if num >= lowerbound && num <= upperbound
-          empty = empty && details.fetch("type") == "  "
+          empty = empty && details.fetch(:type).nil? # == "  "
         end
       end
+
       empty
     end
-  
+
     def type_on_tile(index)
       all_tiles = get_board
       all_tiles.each do |num, details|
-        return details.fetch("type") if num == index
+        return details.fetch(:type) if num == index
       end
     end
+
+    def normalized_tile_name(indexes)
+      # 13 -> A3 , 24 -> B4 , etc
+      first, second = indexes.to_s.split("")
+      Hash[("1".."8").zip("A".."H")][first] + second
+    end
   end
 
 
@@ -74,36 +90,51 @@ class TestBoard < MiniTest::Unit::TestCase
 
 
   def test_red_cannot_move_out_of_turn
-    assert_equal(@black_turn_msg, @board.move("C7", "C5"))
+    assert_equal(Messages.black_turn, @board.move("C7", "C5"))
   end
 
   def test_turn_does_not_change_after_invalid_move
-    move_piece("H2", "H9")  # Error moving black pawn
+    # Error moving black pawn (invalid)
+    move_piece("H2", "H9")
     assert_equal(false, tile_empty(16, 16))
+
+    # Success moving black pawn
     move_piece("H2", "H3")
     assert_equal(true, tile_empty(16, 16))
   end
 
   def test_unmoved_pawns_can_move_one_space
-    assert_equal(piece_quantity("pawn"), 16)
+    assert_equal(piece_quantity(:pawn), 16)
+
     @columns.each do |c|
       move_piece("#{c}2", "#{c}3")
       move_piece("#{c}7", "#{c}6")
     end
-    assert_equal(16, piece_quantity("pawn"), "There are no longer 16 pawns on the board")
-    assert_equal(true, tile_empty(9,16), "Tiles 9 - 16 are still occupied")
-    assert_equal(true, tile_empty(49, 56), "Tiles 49 - 58 are still occupied")
+
+    assert_equal(16, piece_quantity(:pawn), "There are no longer 16 pawns on the board")
+
+    assert_equal(true,  tile_empty(9, 16),  "Pawns failed to move out of their starting positions")
+    assert_equal(false, tile_empty(17, 24), "Pawns failed to move forward to positions one tile forward (tiles 17-24)")
+
+    assert_equal(false, tile_empty(41, 48), "Pawns failed to move forward to positions one tile forward")
+    assert_equal(true,  tile_empty(49, 56), "Pawns failed to move out of their starting positions (tiles 49-56)")
   end
 
   def test_unmoved_pawns_can_move_two_spaces
-    assert_equal(piece_quantity("pawn"), 16)
+    assert_equal(piece_quantity(:pawn), 16)
+
     @columns.each do |c|
       move_piece("#{c}2", "#{c}4")
       move_piece("#{c}7", "#{c}5")
     end
-    assert_equal(16, piece_quantity("pawn"), "There are no longer 16 pawns on the board")
-    assert_equal(true, tile_empty(9, 24), "Tiles 9 - 24 are still occupied")
-    assert_equal(true, tile_empty(41, 56), "Tiles 41 - 56 are still occupied")
+
+    assert_equal(16, piece_quantity(:pawn), "There are no longer 16 pawns on the board")
+
+    assert_equal(true,  tile_empty(9, 24),  "Pawns are still in their initial starting positions (tiles 9-24)")
+    assert_equal(false, tile_empty(25, 32), "Pawns failed to move forward two positions")
+
+    assert_equal(false, tile_empty(33, 40), "Pawns failed to move forward two positions")
+    assert_equal(true,  tile_empty(41, 56), "Pawns are still in their initial starting position (tiles 41-56)")
   end
 
   def test_pawns_only_attack_diagonal
@@ -113,8 +144,19 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("G5", "G4")
     move_piece("B5", "B6")
     move_piece("G4", "G3")
+
     assert_equal(["A7", "C7"], valid_piece_movement("B6"), "black pawn should only attack diagonally")
-    assert_equal(["F2", "H2"], valid_piece_movement("G3"), "red pawn should only attack diagonally") 
+    assert_equal(["F2", "H2"], valid_piece_movement("G3"), "red pawn should only attack diagonally")
+  end
+
+  def test_bishops_can_move_over_pawns
+    # Black
+    assert_equal(["A3", "C3"], valid_piece_movement("B1"), "bishop should be able to jump over pawns")
+    assert_equal(["F3", "H3"], valid_piece_movement("G1"), "bishop should be able to jump over pawns")
+
+    # Red
+    assert_equal(["A6", "C6"], valid_piece_movement("B8"), "bishop should be able to jump over pawns")
+    assert_equal(["F6", "H6"], valid_piece_movement("G8"), "bishop should be able to jump over pawns")
   end
 
   def test_king_cannot_castle_through_check_to_right
@@ -127,11 +169,12 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("G4", "G5")  # black pawn
     move_piece("G6", "G5")  # red rook
     assert_equal(["F1"], valid_piece_movement("E1"), "King should only be allowed to move right one tile")
+
     move_piece("A2", "A3")  # black pawn
     move_piece("G5", "G2")  # red rook
     move_piece("A3", "A4")  # black pawn
     move_piece("G2", "F2")  # red rook
-    assert_equal(@black_in_check, move_piece("E1", "F1"), "King should not be allowed to move into check")
+    assert_equal(Messages.black_in_check, move_piece("E1", "F1"), "King should not be allowed to move into check")
   end
 
   def test_king_cannot_castle_through_check_to_left
@@ -144,9 +187,11 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("D1", "D2")  # black queen
     move_piece("B6", "B2")  # black pawn
     assert_equal(["C1", "D1"], valid_piece_movement("E1"), "King should only be allowed to move left one or two tiles")
+
     move_piece("F4", "G5")  # black bishop
     move_piece("B2", "C2")  # red rook
     assert_equal(["D1"], valid_piece_movement("E1"), "King should only be allowed to move left one tile (or it's traversing check)")
+
     move_piece("G5", "H5")  # black bishop
     move_piece("C2", "D2")  # red rook
     assert_equal(["D1"], valid_piece_movement("E1"), "King should only be allowed to move left one tile (or it's traversing check)")
@@ -174,6 +219,80 @@ class TestBoard < MiniTest::Unit::TestCase
     assert_equal(["C1", "D1"], valid_piece_movement("E1"), "King should be allowed to move left one or two tiles")
   end
 
+  def test_king_cannot_castle_to_right_after_king_has_moved
+    move_piece("G2", "G4")  # black pawn
+    move_piece("A7", "A5")  # red pawn
+    move_piece("F1", "H3")  # black bishop
+    move_piece("A8", "A6")  # red rook
+    move_piece("G1", "F3")  # black knight
+    move_piece("A5", "A4")  # red pawn
+    move_piece("E1", "F1")  # move king right one
+    move_piece("H7", "H6")  # red pawn
+    move_piece("F1", "E1")  # move king back to its original position
+    assert_equal(["F1"], valid_piece_movement("E1"), "King should not be allowed to castle right after moving")
+  end
+
+  def test_king_cannot_castle_to_left_after_king_has_moved
+    move_piece("B1", "A3")  #
+    move_piece("A7", "A6")  #
+    move_piece("D2", "D4")  #
+    move_piece("B7", "B6")  #
+    move_piece("C1", "F4")  #
+    move_piece("C7", "C6")  #
+    move_piece("D1", "D2")  #
+    move_piece("D7", "D6")  #
+    move_piece("E1", "D1")  # Move king left one position
+    move_piece("H7", "H6")  # red pawn
+    move_piece("D1", "E1")  # Move king back to original position
+    assert_equal(["D1"], valid_piece_movement("E1"), "King should not be allowed to castle left after moving")
+  end
+
+  def test_king_cannot_castle_to_right_after_right_rook_has_moved
+    move_piece("G2", "G4")  # black pawn
+    move_piece("A7", "A5")  # red pawn
+    move_piece("F1", "H3")  # black bishop
+    move_piece("A8", "A6")  # red rook
+    move_piece("G1", "F3")  # black knight
+    move_piece("A5", "A4")  # red pawn
+    move_piece("H1", "G1")  # move right rook left one position
+    move_piece("H7", "H6")  # red pawn
+    move_piece("G1", "H1")  # move right rook back to its original position
+    assert_equal(["F1"], valid_piece_movement("E1"), "King should not be allowed to castle right after right rook has moved")
+  end
+
+  def test_king_cannot_castle_to_left_after_left_rook_has_moved
+    move_piece("B1", "A3")  #
+    move_piece("A7", "A6")  #
+    move_piece("D2", "D4")  #
+    move_piece("B7", "B6")  #
+    move_piece("C1", "F4")  #
+    move_piece("C7", "C6")  #
+    move_piece("D1", "D2")  #
+    move_piece("D7", "D6")  #
+    move_piece("A1", "B1")  # Move left rook right one position
+    move_piece("H7", "H6")  # red pawn
+    move_piece("B1", "A1")  # Move left rook back to original position
+    assert_equal(["D1"], valid_piece_movement("E1"), "King should not be allowed to castle left after left rook has moved")
+  end
+
+  def test_king_can_castle_to_left_or_right_when_both_moves_valid
+    move_piece("B1", "A3")  # black knight
+    move_piece("A7", "A6")  # red pawn
+    move_piece("D2", "D4")  # black pawn
+    move_piece("B7", "B6")  # red pawn
+    move_piece("C1", "F4")  # black bishop
+    move_piece("C7", "C6")  # red pawn
+    move_piece("D1", "D3")  # black queen  #=> castle left now valid
+    move_piece("D7", "D6")  # red pawn
+    move_piece("G1", "H3")  # black knight
+    move_piece("E7", "E6")  # red pawn
+    move_piece("G2", "G4")  # black pawn
+    move_piece("F7", "F6")  # red pawn
+    move_piece("F1", "G2")  # black bishop  #=> castle right now valid
+    move_piece("G7", "G6")  # red pawn
+    assert_equal(["C1", "D1", "D2", "F1", "G1"], valid_piece_movement("E1"), "King should be allowed to castle left and right if both moves are valid")
+  end
+
   def test_king_can_kill_check_attacker
     move_piece("A2", "A3")  # Error moving black pawn
     move_piece("A7", "A5")  # Error moving red pawn
@@ -183,8 +302,9 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("A6", "E6")  # Error moving red rook
     move_piece("B3", "B4")  # Error moving black pawn
     move_piece("E6", "E2")  # Error moving red rook
-    assert_equal(@black_in_check, move_piece("B4", "B5"))
+    assert_equal(Messages.black_in_check, move_piece("B4", "B5"))
     assert_equal(false, tile_empty(5, 5))
+
     move_piece("E1", "E2")  # Error moving black king
     assert_equal(true, tile_empty(5, 5))
   end
@@ -198,8 +318,9 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("A6", "E6")    # red rook
     move_piece("B3", "B4")    # black pawn
     move_piece("E6", "E2")    # red rook
-    assert_equal(@black_in_check, move_piece("B4", "B5"))
+    assert_equal(Messages.black_in_check, move_piece("B4", "B5"))
     assert_equal(false, tile_empty(4, 4))
+
     move_piece("D1", "E2")
     assert_equal(true, tile_empty(4, 4))
   end
@@ -213,8 +334,9 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("A6", "E6")  # red rook
     move_piece("G4", "G5")  # black pawn
     move_piece("E6", "E2")  # red rook
-    assert_equal(@black_in_check, move_piece("G5", "G6"))
+    assert_equal(Messages.black_in_check, move_piece("G5", "G6"))
     assert_equal(false, tile_empty(4, 4))
+
     move_piece("E1", "F1")
     assert_equal(true, tile_empty(5,5))
   end
@@ -230,7 +352,7 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("H4", "H3")
     $stdin = MyIO.new
     move_piece("B7", "C8")
-    assert_equal("queen", type_on_tile(59))
+    assert_equal(:queen, type_on_tile(59))
   end
 
   def test_pawn_cannot_be_promoted_out_of_turn
@@ -241,8 +363,8 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("A5", "A6")
     move_piece("H5", "H4")
     move_piece("A6", "B7")
-    $stdin = MyIO.new
-    assert_equal(@red_turn_msg, move_piece("B7", "C8"))
+    $stdin = MyIO.new       # send 'Q' to stdin for pawn promotion
+    assert_equal(Messages.red_turn, move_piece("B7", "C8"))
   end
 
   def test_pawn_cannot_be_promoted_while_check
@@ -254,12 +376,89 @@ class TestBoard < MiniTest::Unit::TestCase
     move_piece("H6", "E6")
     move_piece("A6", "B7")
     move_piece("E6", "E2")
-    assert_equal(@black_in_check, move_piece("B7", "C8"))
-    assert_equal("pawn", type_on_tile(50))
-    assert_equal("bishop", type_on_tile(59))
+    assert_equal(Messages.black_in_check, move_piece("B7", "C8"), "Should not be able to promote pawn while it's in check")
+    assert_equal(:pawn,   type_on_tile(50))
+    assert_equal(:bishop, type_on_tile(59))
+  end
+
+  def test_checkmate_smothered_mate_kings_pawn
+    move_piece("E2", "E4")
+    move_piece("E7", "E5")
+    move_piece("G1", "E2")
+    move_piece("B8", "C6")
+    move_piece("B1", "C3")
+    move_piece("C6", "D4")
+    move_piece("G2", "G3")
+    assert_equal(Messages.red_winner, move_piece("D4", "F3"), "Checkmate. Red should be victorious!")
+  end
+
+  def test_checkmate_fools_mate
+    move_piece("F2", "F3")
+    move_piece("E7", "E5")
+    move_piece("G2", "G4")
+    assert_equal(Messages.red_winner, move_piece("D8", "H4"), "Game should have ended as black is in checkmate")
+  end
+
+  def test_not_checkmate_when_piece_can_remove_checker
+    # Black Rook should be able to take red bishop that has black king in check
+    # hence piece is not in checkmate
+    move_piece("F2", "F3")  # black pawn
+    move_piece("E7", "E5")  # red pawn
+    move_piece("G2", "G4")  # black pawn
+    move_piece("A7", "A6")  # red pawn
+    move_piece("H2", "H4")  # black pawn
+    move_piece("A6", "A5")  # red pawn
+    move_piece("H4", "H5")  # black pawn
+    move_piece("D8", "H4")  # Check (from red queen)
+    move_piece("H1", "H4")  # Take queen -> no longer in check
+    assert_equal(:rook, type_on_tile(32)) #H5
   end
 
-  def test_invalid_moves_not_accepted
-    # TODO
+  def test_not_checkmate_when_piece_can_block_check_path
+    move_piece("F2", "F3")  # black pawn
+    move_piece("E7", "E5")  # red pawn
+    move_piece("G2", "G4")  # black pawn
+    move_piece("A7", "A6")  # red pawn
+    move_piece("H2", "H4")  # black pawn
+    move_piece("A6", "A5")  # red pawn
+    move_piece("H4", "H5")  # black pawn
+    move_piece("A5", "A4")  # red pawn
+    move_piece("H1", "H2")  # black rook (will be able to block check path)
+    move_piece("D8", "H4")  # red queen (black now in check)
+    assert_equal(Messages.black_in_check, move_piece("A2", "A3"), "Should only be able to move out of check for next move")
+    move_piece("H2", "F2")  # black rook (check now blocked)
+    move_piece("H4", "G3")  # red queen
+    move_piece("B1", "A3")  # verify black is no longer in check and can move any piece
   end
+
+  def test_invalid_pawn_moves_not_accepted
+    piece_to_move    = (9.. 16).to_a.sample # piece from black pawn row
+    piece_type       = type_on_tile(piece_to_move)
+    invalid_location = ((1..8).to_a + (33..64).to_a).sample # rows outside of scope
+    location_type    = type_on_tile(invalid_location)
+
+    from = normalized_tile_name(Board.new.get_rowcol_from_index(piece_to_move))
+    to   = normalized_tile_name(Board.new.get_rowcol_from_index(invalid_location))
+
+    move_piece(from, to)
+
+    assert_equal(location_type, type_on_tile(invalid_location))
+    assert_equal(piece_type, type_on_tile(piece_to_move))
+  end
+
+  def test_non_knights_can_not_move_over_populated_pawn_row
+    piece_to_move    = ((1..8).to_a - [2, 7]).sample   # first row without knights
+    piece_type       = type_on_tile(piece_to_move)
+    invalid_location = ((17..64).to_a).sample          # rows outside of scope
+    location_type    = type_on_tile(invalid_location)
+
+    from = normalized_tile_name(Board.new.get_rowcol_from_index(piece_to_move))
+    to   = normalized_tile_name(Board.new.get_rowcol_from_index(invalid_location))
+
+    move_piece(from, to)
+
+    assert_equal(location_type, type_on_tile(invalid_location))
+    assert_equal(piece_type, type_on_tile(piece_to_move))
+  end
+
 end