sapphire-chess 1.0.0

data/lib/sapphire-chess/movement_rules/en_passant_piece_control.rb

@@ -0,0 +1,36 @@
+module EnPassantPieceControl
+  def add_en_passant_movement!(moves)
+    adyacent_enemy_pawn = pawn_to_pass.first
+    return if adyacent_enemy_pawn.nil?
+
+    moves << en_passant_target_square(adyacent_enemy_pawn)
+  end
+
+  def pawn_to_pass(current_square = location)
+    # See Piece#safe_moves, Board#is_a_duplicate?
+    return [] if board.a_duplicate?
+
+    left_square = [current_square.first, current_square.last - 1]
+    right_square = [current_square.first, current_square.last + 1]
+
+    [left_square, right_square].select do |square|
+      board[square].is_a?(Pawn) && pawn_just_moved_two?(square)
+    end
+  end
+
+  def pawn_just_moved_two?(square)
+    if color == :white
+      board.black_player.history.last ==
+        [[square.first - 2, square.last], square]
+    else
+      board.white_player.history.last ==
+        [[square.first + 2, square.last], square]
+    end
+  end
+
+  def en_passant_target_square(adyacent_enemy_pawn)
+    direction = color == :white ? -1 : 1
+
+    [adyacent_enemy_pawn.first + direction, adyacent_enemy_pawn.last]
+  end
+end

data/lib/sapphire-chess/movement_rules/move_slide_pattern.rb

@@ -0,0 +1,23 @@
+module SlidePattern
+  def available_moves
+    move_directions.each_with_object([]) do |(row_direction, column_direction), moves|
+      current_row, current_column = location
+
+      loop do
+        current_row += row_direction
+        current_column += column_direction
+        possible_location = [current_row, current_column]
+
+        break unless board.within_limits?(possible_location)
+        break if friend_in?(possible_location)
+
+        moves << possible_location if board.empty_square?(possible_location)
+
+        if enemy_in?(possible_location)
+          moves << possible_location
+          break
+        end
+      end
+    end
+  end
+end

data/lib/sapphire-chess/movement_rules/move_step_pattern.rb

@@ -0,0 +1,17 @@
+module StepPattern
+  def available_moves
+    move_directions.each_with_object([]) do |(row_direction, column_direction), moves|
+      current_row, current_column = location
+
+      current_row += row_direction
+      current_column += column_direction
+      possible_location = [current_row, current_column]
+
+      next unless board.within_limits?(possible_location)
+
+      if board.empty_square?(possible_location) || enemy_in?(possible_location)
+        moves << possible_location
+      end
+    end
+  end
+end

data/lib/sapphire-chess/movement_rules/pawn_movement_and_promotion.rb

@@ -0,0 +1,71 @@
+module PawnMovementAndPromotion
+  def available_moves
+    if promoted? then SlidePattern::available_moves
+    else
+      moves = []
+      add_one_square_movement!(moves)
+      add_two_square_movement!(moves)
+      add_diagonal_movement!(moves)
+      add_en_passant_movement!(moves)
+
+      moves.select { |move| board.within_limits?(move) }
+    end
+  end
+
+  def promoted?
+    @promoted
+  end
+
+  private
+
+  attr_writer :promoted
+
+  def promote
+    self.promoted = true if location.first == opposite_row
+  end
+
+  def opposite_row
+    case color
+    when :white then self.class::W_OPPOSITE_ROW
+    else self.class::B_OPPOSITE_ROW
+    end
+  end
+
+  def at_start?
+    start_row = (color == :white ? Board::W_PAWN_ROW : Board::B_PAWN_ROW)
+
+    current_row == start_row
+  end
+
+  def forward_direction
+    color == :white ? -1 : 1
+  end
+
+  def add_one_square_movement!(moves)
+    current_row, current_column = location
+
+    one_forward = [current_row + forward_direction, current_column]
+    moves << one_forward if board.empty_square?(one_forward)
+  end
+
+  def add_two_square_movement!(moves)
+    current_row, current_column = location
+
+    one_forward = [current_row + forward_direction, current_column]
+    two_forward = [current_row + (forward_direction * 2), current_column]
+    if board.empty_square?(two_forward) &&
+       board.empty_square?(one_forward) &&
+       at_start?
+      moves << two_forward
+    end
+  end
+
+  def add_diagonal_movement!(moves)
+    current_row, current_column = location
+
+    diagonal_left = [current_row + forward_direction, current_column + 1]
+    diagonal_right = [current_row + forward_direction, current_column - 1]
+    moves << diagonal_left if enemy_in?(diagonal_left)
+    moves << diagonal_right if enemy_in?(diagonal_right)
+  end
+end

data/lib/sapphire-chess/movement_rules.rb

@@ -0,0 +1,7 @@
+require_relative 'movement_rules/castling_board_control'
+require_relative 'movement_rules/castling_piece_control'
+require_relative 'movement_rules/castling_rights'
+require_relative 'movement_rules/en_passant_board_control'
+require_relative 'movement_rules/en_passant_piece_control'
+require_relative 'movement_rules/move_slide_pattern'
+require_relative 'movement_rules/move_step_pattern'

data/lib/sapphire-chess/pieces/bishop.rb

@@ -0,0 +1,56 @@
+class Bishop < Piece
+  MOVE_DIRECTIONS = [
+    [1, 1], [1, -1], [-1, 1], [-1, -1]
+  ].freeze
+
+  BLACK = '♝'
+  WHITE = '♗'
+
+  VALUE = 330
+
+  WHITE_LOCATION_VALUE = [
+    [-20, -10, -10, -10, -10, -10, -10, -20],
+    [-10, 0, 0, 0, 0, 0, 0, -10],
+    [-10, 0, 5, 10, 10, 5, 0, -10],
+    [-10, 5, 5, 10, 10, 5, 5, -10],
+    [-10, 0, 10, 10, 10, 10, 0, -10],
+    [-10, 10, 10, 10, 10, 10, 10, -10],
+    [-10, 5, 0, 0, 0, 0, 5, -10],
+    [-20, -10, -10, -10, -10, -10, -10, -20]
+  ].freeze
+
+  BLACK_LOCATION_VALUE = [
+    [-20, -10, -10, -10, -10, -10, -10, -20],
+    [-10, 5, 0, 0, 0, 0, 5, -10],
+    [-10, 10, 10, 10, 10, 10, 10, -10],
+    [-10, 0, 10, 10, 10, 10, 0, -10],
+    [-10, 5, 5, 10, 10, 5, 5, -10],
+    [-10, 0, 5, 10, 10, 5, 0, -10],
+    [-10, 0, 0, 0, 0, 0, 0, -10],
+    [-20, -10, -10, -10, -10, -10, -10, -20]
+  ].freeze
+
+  WHITE_LOCATION_VALUE_EASY = [
+    [-20, -10, -10, -10, -10, -10, -10, -20],
+    [-10, 0, 0, 0, 0, 0, 0, -10],
+    [-10, 0, 5, 15, 15, 5, 0, -10],
+    [-10, 5, 5, 20, 20, 5, 5, -10],
+    [-10, 0, 15, 20, 20, 15, 0, -10],
+    [-10, 10, 15, 20, 20, 15, 10, -10],
+    [-10, 5, 0, 0, 0, 0, 5, -10],
+    [-20, -10, -10, -10, -10, -10, -10, -20]
+  ].freeze
+
+  BLACK_LOCATION_VALUE_EASY = [
+    [-20, -10, -10, -10, -10, -10, -10, -20],
+    [-10, 5, 0, 0, 0, 0, 5, -10],
+    [-10, 10, 15, 20, 20, 15, 10, -10],
+    [-10, 0, 15, 20, 20, 15, 0, -10],
+    [-10, 5, 5, 20, 20, 5, 5, -10],
+    [-10, 0, 5, 15, 15, 5, 0, -10],
+    [-10, 0, 0, 0, 0, 0, 0, -10],
+    [-20, -10, -10, -10, -10, -10, -10, -20]
+  ].freeze
+
+  include SlidePattern
+end

data/lib/sapphire-chess/pieces/empty_square.rb

@@ -0,0 +1,13 @@
+require 'singleton'
+
+class EmptySquare
+  include Singleton
+
+  def to_s
+    '  '
+  end
+
+  def white
+    '██'
+  end
+end

data/lib/sapphire-chess/pieces/king.rb

@@ -0,0 +1,77 @@
+class King < Piece
+  MOVE_DIRECTIONS = [
+    [0, 1], [1, 1], [1, 0], [0, -1],
+    [1, -1], [-1, 1], [-1, -1], [-1, 0]
+  ].freeze
+
+  BLACK = '♚'
+  WHITE = '♔'
+
+  VALUE = 20_000
+
+  WHITE_LOCATION_VALUE = [
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-20, -30, -30, -40, -40, -30, -30, -20],
+    [-10, -20, -20, -20, -20, -20, -20, -10],
+    [20, 20,  0,  0,  0,  0, 20, 20],
+    [20, 30, 10,  0,  0, 10, 30, 20]
+  ].freeze
+
+  BLACK_LOCATION_VALUE = [
+    [20, 30, 10, 0, 0, 10, 30, 20],
+    [20, 20, 0, 0, 0, 0, 20, 20],
+    [-10, -20, -20, -20, -20, -20, -20, -10],
+    [-20, -30, -30, -40, -40, -30, -30, -20],
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-30, -40, -40, -50, -50, -40, -40, -30],
+    [-30, -40, -40, -50, -50, -40, -40, -30]
+  ].freeze
+
+  WHITE_LOCATION_VALUE_END = [
+    [-50, -40, -30, -20, -20, -30, -40, -50],
+    [-30, -20, -10, 0,  0, -10, -20, -30],
+    [-30, -10, 20, 30, 30, 20, -10, -30],
+    [-30, -10, 30, 40, 40, 30, -10, -30],
+    [-30, -10, 30, 40, 40, 30, -10, -30],
+    [-30, -10, 20, 30, 30, 20, -10, -30],
+    [-30, -30,  0,  0,  0,  0, -30, -30],
+    [-50, -30, -30, -30, -30, -30, -30, -50]
+  ].freeze
+
+  BLACK_LOCATION_VALUE_END = [
+    [-50, -30, -30, -30, -30, -30, -30, -50],
+    [-30, -30, 0, 0, 0, 0, -30, -30],
+    [-30, -10, 20, 30, 30, 20, -10, -30],
+    [-30, -10, 30, 40, 40, 30, -10, -30],
+    [-30, -10, 30, 40, 40, 30, -10, -30],
+    [-30, -10, 20, 30, 30, 20, -10, -30],
+    [-30, -20, -10, 0, 0, -10, -20, -30],
+    [-50, -40, -30, -20, -20, -30, -40, -50]
+  ].freeze
+
+  include StepPattern
+  include CastlingPieceControl
+
+  def initialize(board, location, color)
+    super
+    @moved = false
+  end
+
+  def location_value
+    row, column = location
+
+    location_value_table =
+      if board.end_game? && color == :white then self.class::WHITE_LOCATION_VALUE_END
+      elsif board.end_game? && color == :black then self.class::BLACK_LOCATION_VALUE_END
+      elsif !board.end_game? && color == :white then self.class::WHITE_LOCATION_VALUE
+      else
+        self.class::BLACK_LOCATION_VALUE
+      end
+
+    location_value_table[row][column]
+  end
+end

data/lib/sapphire-chess/pieces/knight.rb

@@ -0,0 +1,57 @@
+class Knight < Piece
+  MOVE_DIRECTIONS = [
+    [1, 2], [2, 1], [-1, 2], [-2, 1],
+    [1, -2], [2, -1], [-1, -2], [-2, -1]
+  ].freeze
+
+  BLACK = '♞'
+  WHITE = '♘'
+
+  VALUE = 320
+
+  WHITE_LOCATION_VALUE = [
+    [-50, -40, -30, -30, -30, -30, -40, -50],
+    [-40, -20, 0, 0, 0, 0, -20, -40],
+    [-30, 0, 10, 15, 15, 10, 0, -30],
+    [-30, 5, 15, 20, 20, 15, 5, -30],
+    [-30, 0, 15, 20, 20, 15, 0, -30],
+    [-30, 5, 10, 15, 15, 10, 5, -30],
+    [-40, -20, 0, 5, 5, 0, -20, -40],
+    [-50, -40, -30, -30, -30, -30, -40, -50]
+  ].freeze
+
+  BLACK_LOCATION_VALUE = [
+    [-50, -40, -30, -30, -30, -30, -40, -50],
+    [-40, -20, 0, 5, 5, 0, -20, -40],
+    [-30, 5, 10, 15, 15, 10, 5, -30],
+    [-30, 0, 15, 20, 20, 15, 0, -30],
+    [-30, 5, 15, 20, 20, 15, 5, -30],
+    [-30, 0, 10, 15, 15, 10, 0, -30],
+    [-40, -20, 0, 0, 0, 0, -20, -40],
+    [-50, -40, -30, -30, -30, -30, -40, -50]
+  ].freeze
+
+  WHITE_LOCATION_VALUE_EASY = [
+    [-50, -40, -30, -30, -30, -30, -40, -50],
+    [-40, -20, 0, 0, 0, 0, -20, -40],
+    [-30, 0, 20, 25, 25, 20, 0, -30],
+    [-30, 5, 25, 40, 40, 25, 5, -30],
+    [-30, 0, 25, 40, 40, 25, 0, -30],
+    [-30, 5, 20, 25, 25, 20, 5, -30],
+    [-40, -20, 0, 5, 5, 0, -20, -40],
+    [-50, -40, -30, -30, -30, -30, -40, -50]
+  ].freeze
+
+  BLACK_LOCATION_VALUE_EASY = [
+    [-50, -40, -30, -30, -30, -30, -40, -50],
+    [-40, -20, 0, 5, 5, 0, -20, -40],
+    [-30, 0, 20, 25, 25, 20, 0, -30],
+    [-30, 5, 25, 40, 40, 25, 5, -30],
+    [-30, 0, 25, 40, 40, 25, 0, -30],
+    [-30, 5, 20, 25, 25, 20, 5, -30],
+    [-40, -20, 0, 0, 0, 0, -20, -40],
+    [-50, -40, -30, -30, -30, -30, -40, -50]
+  ].freeze
+
+  include StepPattern
+end

data/lib/sapphire-chess/pieces/pawn.rb

@@ -0,0 +1,82 @@
+require_relative '../movement_rules/en_passant_piece_control'
+require_relative '../movement_rules/pawn_movement_and_promotion'
+
+class Pawn < Piece
+  BLACK = ['♟', '♛'].freeze
+  WHITE = ['♙', '♕'].freeze
+
+  B_OPPOSITE_ROW = 7
+  W_OPPOSITE_ROW = 0
+
+  MOVE_DIRECTIONS = [
+    [0, 1], [0, -1], [1, 0], [-1, 0],
+    [1, 1], [1, -1], [-1, 1], [-1, -1]
+  ].freeze
+
+  VALUE = 100
+
+  WHITE_LOCATION_VALUE = [
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [50, 50, 50, 50, 50, 50, 50, 50],
+    [10, 10, 20, 30, 30, 20, 10, 10],
+    [5, 5, 10, 25, 25, 10, 5, 5],
+    [0, 0, 0, 20, 20, 0, 0, 0],
+    [5, -5, -10, 0, 0, -10, -5, 5],
+    [5, 10, 10, -20, -20, 10, 10, 5],
+    [0, 0, 0, 0, 0, 0, 0, 0]
+  ].freeze
+
+  BLACK_LOCATION_VALUE = [
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [5, 10, 10, -20, -20, 10, 10, 5],
+    [5, -5, -10, 0, 0, -10, -5, 5],
+    [0, 0, 0, 20, 20, 0, 0, 0],
+    [5, 5, 10, 25, 25, 10, 5, 5],
+    [10, 10, 20, 30, 30, 20, 10, 10],
+    [50, 50, 50, 50, 50, 50, 50, 50],
+    [0, 0, 0, 0, 0, 0, 0, 0]
+  ].freeze
+
+  WHITE_LOCATION_VALUE_EASY = [
+    [100, 100, 100, 100, 100, 100, 100, 100],
+    [60, 60, 60, 60, 60, 60, 60, 60],
+    [50, 50, 60, 60, 60, 60, 50, 50],
+    [50, 50, 60, 60, 60, 60, 50, 50],
+    [50, 50, 60, 0, 0, 60, 50, 50],
+    [50, 50, 10, 0, 0, 10, 50, 50],
+    [5, 10, 10, -20, -20, 10, 10, 5],
+    [0, 0, 0, 0, 0, 0, 0, 0]
+  ].freeze
+
+  BLACK_LOCATION_VALUE_EASY = [
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [5, 10, 10, -20, -20, 10, 10, 5],
+    [50, 50, 10, 0, 0, 10, 50, 50],
+    [50, 50, 60, 0, 0, 60, 50, 50],
+    [50, 50, 60, 60, 60, 60, 50, 50],
+    [50, 50, 60, 60, 60, 60, 50, 50],
+    [60, 60, 60, 60, 60, 60, 60, 60],
+    [100, 100, 100, 100, 100, 100, 100, 100]
+  ].freeze
+
+  include SlidePattern
+  include EnPassantPieceControl
+  include PawnMovementAndPromotion
+
+  def initialize(board, location, color)
+    super(board, location, color)
+    @promoted = false
+  end
+
+  def to_s
+    promote unless promoted?
+
+    white = color == :white
+    if promoted? && white then Paint[self.class::WHITE.last, :white, :bright]
+    elsif promoted? && !white then Paint[self.class::BLACK.last, :blue, :bright]
+    elsif !promoted? && white then Paint[self.class::WHITE.first, :white]
+    else
+      Paint[self.class::BLACK.first, :blue]
+    end
+  end
+end

data/lib/sapphire-chess/pieces/piece.rb

@@ -0,0 +1,77 @@
+require_relative '../board'
+require_relative '../movement_rules/castling_piece_control'
+require_relative '../movement_rules/move_slide_pattern'
+require_relative '../movement_rules/move_step_pattern'
+
+require 'bundler/setup'
+require 'paint'
+
+class Piece
+  attr_reader :color, :board
+  attr_accessor :location
+
+  def initialize(board, location, color)
+    @board = board
+    @color = color
+    @location = location
+  end
+
+  def to_s
+    case color
+    when :white then Paint[self.class::WHITE, :white]
+    else Paint[self.class::BLACK, :blue]
+    end
+  end
+
+  # Available moves that don't move us into check
+  def safe_moves
+    available_moves.each_with_object([]) do |move, moves|
+      new_board = board.duplicate
+
+      new_board.move_piece!(location, move)
+      moves << move unless new_board.in_check?(color)
+    end
+  end
+
+  def value
+    self.class::VALUE
+  end
+
+  def location_value
+    row, column = location
+    white = color == :white
+    if board.hard_difficulty? && white
+      self.class::WHITE_LOCATION_VALUE[row][column]
+    elsif board.hard_difficulty? && !white
+      self.class::BLACK_LOCATION_VALUE[row][column]
+    elsif !board.hard_difficulty? && white
+      self.class::WHITE_LOCATION_VALUE_EASY[row][column]
+    else
+      self.class::BLACK_LOCATION_VALUE_EASY[row][column]
+    end
+  end
+
+  private
+
+  def current_row
+    location.first
+  end
+
+  def current_column
+    location.last
+  end
+
+  def move_directions
+    self.class::MOVE_DIRECTIONS
+  end
+
+  def enemy_in?(location)
+    board.within_limits?(location) &&
+      board[location].is_a?(Piece) &&
+      board[location].color != color
+  end
+
+  def friend_in?(location)
+    board[location].is_a?(Piece) && board[location].color == color
+  end
+end

data/lib/sapphire-chess/pieces/queen.rb

@@ -0,0 +1,44 @@
+class Queen < Piece
+  MOVE_DIRECTIONS = [
+    [0, 1], [0, -1], [1, 0], [-1, 0],
+    [1, 1], [1, -1], [-1, 1], [-1, -1]
+  ].freeze
+
+  BLACK = '♛'
+  WHITE = '♕'
+
+  VALUE = 900
+
+  WHITE_LOCATION_VALUE = [
+    [-20, -10, -10, -5, -5, -10, -10, -20],
+    [-10, 0, 0, 0, 0, 0, 0, -10],
+    [-10, 0, 5, 5, 5, 5, 0, -10],
+    [-5, 0, 5, 5, 5, 5, 0, -5],
+    [0, 0, 5, 5, 5, 5, 0, -5],
+    [-10, 5, 5, 5, 5, 5, 0, -10],
+    [-10, 0, 5, 0, 0, 0, 0, -10],
+    [-20, -10, -10, -5, -5, -10, -10, -20]
+  ].freeze
+
+  BLACK_LOCATION_VALUE = [
+    [-20, -10, -10, -5, -5, -10, -10, -20],
+    [-10, 0, 0, 0, 0, 5, 0, -10],
+    [-10, 0, 5, 5, 5, 5, 5, -10],
+    [-5, 0, 5, 5, 5, 5, 0, 0],
+    [-5, 0, 5, 5, 5, 5, 0, -5],
+    [-10, 0, 5, 5, 5, 5, 0, -10],
+    [-10, 0, 0, 0, 0, 0, 0, -10],
+    [-20, -10, -10, -5, -5, -10, -10, -20]
+  ].freeze
+
+  include SlidePattern
+
+  def location_value
+    row, column = location
+
+    case color
+    when :white then self.class::WHITE_LOCATION_VALUE[row][column]
+    else self.class::BLACK_LOCATION_VALUE[row][column]
+    end
+  end
+end

data/lib/sapphire-chess/pieces/rook.rb

@@ -0,0 +1,62 @@
+class Rook < Piece
+  MOVE_DIRECTIONS = [
+    [0, 1], [0, -1], [1, 0], [-1, 0]
+  ].freeze
+
+  BLACK = '♜'
+  WHITE = '♖'
+
+  VALUE = 500
+
+  WHITE_LOCATION_VALUE = [
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [5, 10, 10, 10, 10, 10, 10, 5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [0, 0, 0, 5, 5, 0, 0, 0]
+  ].freeze
+
+  BLACK_LOCATION_VALUE = [
+    [0, 0, 0, 5, 5, 0, 0, 0],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [5, 10, 10, 10, 10, 10, 10, 5],
+    [0, 0, 0, 0, 0, 0, 0, 0]
+  ].freeze
+
+  WHITE_LOCATION_VALUE_EASY = [
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [5, 10, 10, 10, 10, 10, 10, 5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [0, 0, 0, 5, 5, 0, 0, 0]
+  ].freeze
+
+  BLACK_LOCATION_VALUE_EASY = [
+    [0, 0, 0, 5, 5, 0, 0, 0],
+    [-5, 0, 0, 0, 0, 0, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [-5, 0, 10, 10, 10, 10, 0, -5],
+    [5, 10, 10, 10, 10, 10, 10, 5],
+    [0, 0, 0, 0, 0, 0, 0, 0]
+  ].freeze
+
+  include SlidePattern
+  include CastlingPieceControl
+
+  def initialize(board, location, color)
+    super
+    @moved = false
+  end
+end

data/lib/sapphire-chess/pieces.rb

@@ -0,0 +1,8 @@
+require_relative 'pieces/empty_square.rb'
+require_relative 'pieces/piece.rb'
+require_relative 'pieces/pawn.rb'
+require_relative 'pieces/knight.rb'
+require_relative 'pieces/bishop.rb'
+require_relative 'pieces/rook.rb'
+require_relative 'pieces/queen.rb'
+require_relative 'pieces/king.rb'

data/lib/sapphire-chess/player.rb

@@ -0,0 +1,43 @@
+require_relative 'ai'
+require_relative 'algebraic_conversion'
+require_relative 'movement_rules/castling_rights'
+
+class Player
+  include CastlingRights
+
+  attr_accessor :last_move
+  attr_reader :color, :board, :history
+
+  def initialize(color, board)
+    @color = color
+    @board = board
+    @history = []
+  end
+
+  private
+
+  def maximizing_player?
+    color == :white
+  end
+end
+
+class Computer < Player
+  include AI
+
+  # depth: Levels of AI#minimax recursion.
+  # Deeper means harder (computer can think `depth` turns ahead)
+  # See Engine#set_difficulty
+  attr_accessor :depth
+
+  def select_move
+    computer_chooses_move
+  end
+end
+
+class Human < Player
+  include AlgebraicConversion
+
+  def select_move
+    algebraic_input
+  end
+end

data/lib/sapphire-chess/version.rb

@@ -0,0 +1,3 @@
+module SapphireChess
+  VERSION ||= '1.0.0'
+end