sapphire-chess 1.0.0

data/lib/sapphire-chess/board/board_renderer.rb

@@ -0,0 +1,122 @@
+class BoardRenderer
+  LEFT_MARGIN = 4
+  RIGHT_MARGIN = 3
+
+  EMPTY_ROW_0 =       '|        |'
+  EMPTY_ROW_0_WHITE = '|████████|'
+  EMPTY_ROW =         '        |'
+  EMPTY_ROW_WHITE =   '████████|'
+
+  FLOOR_0 =           '+--------+'
+  FLOOR =             '--------+'
+
+  COLUMN_LETTERS = ('a'..'h').to_a.freeze
+  ROW_NUMBERS =    [*('1'..'8')].reverse
+
+  def initialize(board)
+    @board = board
+    @square_order = board.class::SQUARE_ORDER
+  end
+
+  def render
+    print_column_letters
+    print_floor
+
+    print_rows
+
+    new_line
+    print_column_letters
+  end
+
+  private
+
+  attr_reader :board, :square_order
+
+  def print_column_letters
+    COLUMN_LETTERS.each { |letter| print "        #{letter}" }
+    new_line(2)
+  end
+
+  def print_floor
+    puts ' ' * LEFT_MARGIN + FLOOR_0 + FLOOR * (square_order - 1)
+  end
+
+  def print_rows
+    square_order.times do |number|
+      print_row(number)
+      print ROW_NUMBERS[number]
+      print_piece_row(number)
+      puts (' ' * RIGHT_MARGIN) + ROW_NUMBERS[number]
+      print_row(number)
+      print_floor
+    end
+  end
+
+  def print_row(number)
+    puts number.even? ? white_starting_row : black_starting_row
+  end
+
+  def white_starting_row
+    ' ' * LEFT_MARGIN +
+      EMPTY_ROW_0_WHITE +
+      (EMPTY_ROW + EMPTY_ROW_WHITE) * 3 +
+      EMPTY_ROW
+  end
+
+  def black_starting_row
+    ' ' * LEFT_MARGIN +
+      EMPTY_ROW_0 +
+      (EMPTY_ROW_WHITE + EMPTY_ROW) * 3 +
+      EMPTY_ROW_WHITE
+  end
+
+  def print_piece_row(row)
+    square_order.times do |column|
+      square = [row, column]
+
+      if white_square?(square) then print_white_square(square, column)
+      else 
+        print_black_square(square, column)
+      end
+    end
+  end
+
+  def white_square?(square)
+    row = square.first
+    column = square.last
+
+    row.even? && column.even? || row.odd? && column.odd?
+  end
+
+  def print_white_square(square, column)
+    print(
+      if board[square].is_a?(EmptySquare) && column.zero?
+        "   |███#{board[square].white}███|"
+      elsif column.zero?
+        "   |██ #{board[square]}  ██|"
+      elsif board[square].is_a?(EmptySquare)
+        "███#{board[square].white}███|"
+      else
+        "██ #{board[square]}  ██|"
+      end
+    )
+  end
+
+  def print_black_square(square, column)
+    print(
+      if board[square].is_a?(EmptySquare) && column.zero?
+        "   |   #{board[square]}   |"
+      elsif column.zero?
+        "   |   #{board[square]}    |"
+      elsif board[square].is_a?(EmptySquare)
+        "   #{board[square]}   |"
+      else
+        "   #{board[square]}    |"
+      end
+    )
+  end
+
+  def new_line(lines = 1)
+    lines.times { puts '' }
+  end
+end

data/lib/sapphire-chess/board.rb

@@ -0,0 +1,5 @@
+require_relative 'board/board_general'
+require_relative 'board/board_renderer'
+require_relative 'board/board_analysis'
+require_relative 'board/board_evaluation'
+require_relative 'board/board_provisional_moves'

data/lib/sapphire-chess/display.rb

@@ -0,0 +1,140 @@
+module Display
+  def clear_screen
+    system 'clear'
+  end
+
+  def new_line(lines = 1)
+    puts '' * lines
+  end
+
+  def display_welcome
+    clear_screen
+
+    print '♟  ♞  ♝  ♜  ♛  ♚ '
+    print Paint[" 💎  Welcome to Sapphire Chess #{SapphireChess::VERSION}! 💎 ", :green]
+    puts Paint[' ♚  ♛  ♜  ♝  ♞  ♟', :blue]
+    new_line
+  end
+
+  def display_game_modes
+    puts "Please, select the game mode: (1/2)\n\n"\
+      "1) You against the machine.\n\n"\
+      "2) You against a friend using this same computer.\n\n"\
+      "3) Enjoy watching the computer playing against itself.\n\n"
+  end
+
+  def display_difficulty_settings
+    puts "Please, enter the game difficulty:\n"\
+      "[i.e.: \"1\", \"e\" or \"easy\" to select Easy]\n\n"\
+      "1) Easy\n2) Medium\n3) Hard\n\n"\
+      "This setting determines how many turns the computer can think ahead.\n"\
+      'Warning: the "hard" setting is very hard!'
+  end
+
+  def display_move_message
+    puts "What piece do you want to move?\n"\
+         "[Use algebraic notation, i.e.: 'a2a4']\n"\
+         "[To castle, 'castle (k for king side, q for queen side), "\
+         "i.e: 'castle k']\n\n"
+  end
+
+  def display_last_moves
+    new_line
+    return if turn_number < 2
+
+    print Paint['Last moves: ', :green]
+    display_move(:white)
+    display_move(:black)
+    new_line
+  end
+
+  def display_move(color)
+    player = color == :white ? white_player : black_player
+
+    if color == :white
+      print Paint["White #{player.last_move}"]
+      print Paint[' | ', :green]
+    else
+      puts Paint["Black #{player.last_move}", :blue]
+    end
+  end
+
+  def display_turn_number
+    print Paint["   Turn #{turn_number.to_i}    ", nil, :green]
+  end
+
+  def display_player_turn
+    puts Paint[
+      "It's #{current_player.color}'s turn!",
+      nil,
+      current_player.color,
+      :bright
+    ]
+  end
+
+  def display_graphic_score
+    %i[black white].each do |color|
+      message =
+        case color
+        when :white then Paint['White player score', :white, :underline]
+        else
+          Paint['Black player score', :blue, :underline]
+        end
+      print "#{message}: "
+      display_material_score(color)
+      new_line(2)
+    end
+  end
+
+  def display_material_score(color)
+    [Pawn, Knight, Bishop, Rook, Queen, King].each do |type|
+      symbol = piece_symbol(color, type)
+
+      score_line = piece_score(type, color, symbol)
+
+      print score_line unless score_line[-2] == '0'
+    end
+  end
+
+  def piece_symbol(color, type)
+    white = color == :white
+
+    if type == Pawn && white then Paint[type::WHITE.first, :white]
+    elsif type == Pawn && !white then Paint[type::BLACK.first, :blue]
+    elsif type != Pawn && white then Paint[type::WHITE, :white]
+    else
+      Paint[type::BLACK, :blue]
+    end
+  end
+
+  def piece_score(type, color, piece_symbol)
+    if type == Queen
+      "#{piece_symbol} x "\
+      "#{board.count(type, color) + board.promoted_pawns(color)} "
+    elsif type == Pawn
+      "#{piece_symbol} x "\
+      "#{board.count(type, color) - board.promoted_pawns(color)} "
+    else
+      "#{piece_symbol} x #{board.count(type, color)} "
+    end
+  end
+
+  def display_check
+    puts Paint['You are in check!', :red, :bright]
+    new_line
+  end
+
+  def display_checkmate
+    puts Paint['Checkmate!', nil, :red, :bright]
+    new_line
+  end
+
+  def display_winner
+    puts Paint[
+      "#{current_player.color.to_s.capitalize} player wins!",
+      nil,
+      current_player.color
+    ]
+    puts 'Thanks for playing Ruby Chess'
+  end
+end

data/lib/sapphire-chess/engine.rb

@@ -0,0 +1,153 @@
+require_relative 'board/board_general'
+require_relative 'board/board_renderer'
+require_relative 'pieces'
+require_relative 'player'
+require_relative 'display'
+require_relative 'version'
+require_relative 'human_input_validation'
+require_relative 'algebraic_conversion'
+
+require 'bundler/setup'
+require 'paint'
+
+class Engine
+  include Display
+  include HumanInputValidation
+  include AlgebraicConversion
+
+  def initialize
+    @board = Board.initialize_board
+    @renderer = BoardRenderer.new(board)
+    @turn_number = 1
+  end
+
+  def play
+    display_welcome
+    define_players
+    @current_player = white_player
+    board.add_players!(white_player, black_player)
+    if computer_plays?
+      set_difficulty
+      board.set_game_difficulty
+    end
+
+    main_game_loop
+
+    end_game
+  end
+
+  private
+
+  attr_reader :white_player, :black_player, :board, :renderer
+  attr_accessor :current_player, :turn_number
+
+  def define_players
+    mode = prompt_game_mode
+    human_player_color = mode == 1 ? prompt_color : ''
+
+    @white_player, @black_player = initialize_players(human_player_color, mode: mode)
+  end
+
+  def initialize_players(human_player_color, mode: nil)
+    if human_player_color == 'w'
+      [Human.new(:white, board), Computer.new(:black, board)]
+    elsif human_player_color == 'b'
+      [Computer.new(:white, board), Human.new(:black, board)]
+    elsif mode == 2
+      [Human.new(:white, board), Human.new(:black, board)]
+    else
+      [Computer.new(:white, board), Computer.new(:black, board)]
+    end
+  end
+
+  def computer_plays?
+    white_player.is_a?(Computer) || black_player.is_a?(Computer)
+  end
+
+  # See Computer in player.rb, AI#minimax in ai.rb
+  def set_difficulty
+    difficulty_input = prompt_difficulty
+
+    [white_player, black_player].each do |player|
+      player.depth = difficulty_input if player.is_a?(Computer)
+    end
+  end
+
+  def main_game_loop
+    until game_over?
+      clear_screen
+      renderer.render
+      display_game_data
+      perform_move!(player_move_selection)
+      swap_player!
+      update_turn_counter
+    end
+  end
+
+  def display_game_data
+    display_graphic_score
+    display_last_moves
+    display_turn_number
+    display_player_turn
+  end
+
+  def swap_player!
+    self.current_player =
+      current_player == white_player ? black_player : white_player
+  end
+
+  def update_turn_counter
+    self.turn_number += 0.5
+  end
+
+  def player_move_selection
+    if current_player.is_a?(Human)
+      display_check if board.in_check?(current_player.color)
+      prompt_move
+    else
+      puts "\n🤖 I am thinking... 🤖"
+      current_player.select_move
+    end
+  end
+
+  def perform_move!(move_input)
+    piece, target_square = convert_player_input(move_input)
+    store_move!(piece, target_square)
+
+    case piece
+    when :castle then board.castle!(target_square, current_player.color, permanent: true)
+    else
+      board.move_piece!(piece, target_square, permanent: true)
+    end
+  end
+
+  def store_move!(piece, target_square)
+    current_player.history << [piece, target_square]
+
+    current_player.last_move = move_to_string(piece, target_square)
+  end
+
+  def move_to_string(piece, target_square)
+    if piece == :castle
+      "Castle, #{target_square} side"
+    elsif board[target_square].is_a?(Piece)
+      "#{board[piece].class} #{convert_to_algebraic(piece)} "\
+      "to #{board[target_square].class} "\
+      "#{convert_to_algebraic(target_square)}"
+    else
+      "#{board[piece].class} #{convert_to_algebraic(piece)} "\
+      "to #{convert_to_algebraic(target_square)}"
+    end
+  end
+
+  def end_game
+    clear_screen
+    renderer.render
+    swap_player!
+    display_winner
+  end
+
+  def game_over?
+    board.checkmate?(current_player.color) || board.no_king?(current_player.color)
+  end
+end

data/lib/sapphire-chess/human_input_validation.rb

@@ -0,0 +1,123 @@
+module HumanInputValidation
+  def prompt_color
+    puts 'What color would you like to play? ([W]hite/[B]lack)'
+    choice = nil
+    loop do
+      choice = gets.chomp.strip.downcase
+      break if valid_color?(choice)
+
+      puts 'Please, enter a valid color choice.'
+    end
+    choice
+  end
+
+  def valid_color?(choice)
+    %w[white black w b].include?(choice)
+  end
+
+  def prompt_game_mode
+    display_game_modes
+    game_mode = nil
+    loop do
+      game_mode = gets.chomp.strip.to_i
+      break if [1, 2, 3].include?(game_mode)
+
+      puts 'Please, enter a valid game mode.'
+    end
+    new_line
+    game_mode
+  end
+
+  def prompt_difficulty
+    display_difficulty_settings
+    difficulty_input = nil
+    loop do
+      difficulty_input = gets.chomp.strip.downcase
+      break if valid_difficulty?(difficulty_input)
+
+      puts 'Please, enter a valid difficulty setting.'
+    end
+
+    case difficulty_input
+    when 'easy' then 1
+    when 'medium' then 2
+    when 'hard' then 3
+    else difficulty_input.to_i
+    end
+  end
+
+  def valid_difficulty?(difficulty)
+    %w[easy medium hard 1 2 3].include?(difficulty)
+  end
+
+  def prompt_move
+    display_move_message
+
+    player_move_input = nil
+    loop do
+      player_move_input = current_player.select_move
+      break if valid_player_input?(player_move_input)
+
+      puts 'Please, select a valid movement.'
+    end
+
+    player_move_input
+  end
+
+  def prompt_target_square(piece)
+    target_square = nil
+    puts "Where do you want to move the #{board[piece].class}?"
+    loop do
+      target_square = current_player.get_move
+      break if valid_target_square?(piece, target_square)
+
+      puts "The #{board[piece].class} selected can't move to that square."
+    end
+
+    target_square
+  end
+
+  def valid_player_input?(player_move_input)
+    if double_input?(player_move_input)
+      valid_piece_selection?(player_move_input.first) &&
+        valid_target_square?(player_move_input.first, player_move_input.last)
+    elsif player_move_input.first == :castle
+      valid_castling?(player_move_input.last)
+    else
+      valid_piece_selection?(player_move_input)
+    end
+  end
+
+  def double_input?(player_move_input)
+    player_move_input.first.is_a?(Array)
+  end
+
+  def single_input?(player_move_input)
+    player_move_input.first.is_a?(Integer)
+  end
+
+  def valid_piece_selection?(piece)
+    board[piece].is_a?(Piece) &&
+      board[piece].color == current_player.color
+  end
+
+  def valid_target_square?(piece, target_square)
+    board[piece].available_moves.include?(target_square)
+  end
+
+  def valid_castling?(side)
+    current_player.castle_rights?(side)
+  end
+
+  def convert_player_input(player_move_input)
+    if single_input?(player_move_input)
+      piece = player_move_input
+      target_square = prompt_target_square(piece)
+    else
+      piece = player_move_input.first
+      target_square = player_move_input.last
+    end
+
+    [piece, target_square]
+  end
+end

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

@@ -0,0 +1,37 @@
+module CastlingBoardControl
+  # (See Castling, movement.rb::CastlingPieceControl, Rook, King)
+  def mark_moved_piece!(piece)
+    return unless self[piece].is_a?(Rook) || self[piece].is_a?(King)
+
+    self[piece].mark!
+  end
+
+  def castle!(side, color, permanent: false)
+    castling_squares =
+      if color == :white && side == :king then [[7, 4], [7, 6], [7, 7], [7, 5]]
+      elsif color == :white && side == :queen then [[7, 4], [7, 2], [7, 0], [7, 3]]
+      elsif color == :black && side == :king then [[0, 4], [0, 6], [0, 7], [0, 5]]
+      else
+        [[0, 4], [0, 2], [0, 0], [0, 3]]
+      end
+
+    king_start, king_target, rook_start, rook_target = castling_squares
+
+    move_piece!(king_start, king_target, permanent: permanent)
+    move_piece!(rook_start, rook_target, permanent: permanent)
+  end
+
+  def uncastle!(side, color)
+    castling_squares =
+      if color == :white && side == :king then [[7, 6], [7, 4], [7, 5], [7, 7]]
+      elsif color == :white && side == :queen then [[7, 2], [7, 4], [7, 3], [7, 0]]
+      elsif color == :black && side == :king then [[0, 6], [0, 4], [0, 5], [0, 7]]
+      else
+        [[0, 2], [0, 4], [0, 3], [0, 0]]
+      end
+    king_start, king_target, rook_start, rook_target = castling_squares
+
+    move_piece!(king_start, king_target, permanent: false)
+    move_piece!(rook_start, rook_target, permanent: false)
+  end
+end

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

@@ -0,0 +1,9 @@
+module CastlingPieceControl
+  def moved?
+    @moved
+  end
+
+  def mark!
+    @moved = true
+  end
+end

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

@@ -0,0 +1,79 @@
+module CastlingRights
+  def castle_rights?(side)
+    !king_and_rook_moved?(side) &&
+      castling_line_free?(side) &&
+      !board.in_check?(color) &&
+      !results_in_check?(side) &&
+      !king_crosses_attack_line?(side)
+  end
+
+  private
+
+  def king_and_rook_moved?(side)
+    case color
+    when :white
+      king = [7, 4]
+      rook = side == :king ? [7, 7] : [7, 0]
+    else
+      king = [0, 4]
+      rook = side == :king ? [0, 7] : [0, 0]
+    end
+
+    return true unless board[king].is_a?(King) && board[rook].is_a?(Rook)
+
+    board[king].moved? && board[rook].moved?
+  end
+
+  def castling_line_free?(side)
+    if color == :white && side == :king then f1_to_g1_free?
+    elsif color == :white && side == :queen then b1_to_d1_free?
+    elsif color == :black && side == :king then f8_to_g8_free?
+    else 
+      b8_to_d8_free?
+    end
+  end
+
+  def f1_to_g1_free?
+    board.empty_square?([7, 5]) &&
+      board.empty_square?([7, 6])
+  end
+
+  def b1_to_d1_free?
+    board.empty_square?([7, 1]) &&
+      board.empty_square?([7, 2]) &&
+      board.empty_square?([7, 3])
+  end
+
+  def f8_to_g8_free?
+    board.empty_square?([0, 5]) &&
+      board.empty_square?([0, 6])
+  end
+
+  def b8_to_d8_free?
+    board.empty_square?([0, 1]) &&
+      board.empty_square?([0, 2]) &&
+      board.empty_square?([0, 3])
+  end
+
+  def results_in_check?(side)
+    return true if king_and_rook_moved?(side)
+    board.castle!(side, color)
+    in_check = board.in_check?(color)
+    board.uncastle!(side, color)
+
+    in_check
+  end
+
+  def king_crosses_attack_line?(side)
+    hot_square = case color
+                 when :white then side == :king ? [7, 5] : [7, 3]
+                 else side == :king ? [0, 5] : [0, 3]
+                 end
+
+    board.enemy_pieces(color).each do |piece|
+      return true if piece.available_moves.include?(hot_square)
+    end
+
+    false
+  end
+end

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

@@ -0,0 +1,20 @@
+module EnPassantBoardControl
+  def capture_passed_pawn!(target_square)
+    captured_pawn = passed_pawn(target_square)
+
+    self[captured_pawn] = EmptySquare.instance
+  end
+
+  def was_en_passant?(piece, target_square)
+    captured_pawn = passed_pawn(target_square)
+
+    self[target_square].is_a?(Pawn) &&
+      self[target_square].pawn_to_pass(piece).include?(captured_pawn)
+  end
+
+  def passed_pawn(target_square)
+    direction = self[target_square].color == :white ? 1 : -1
+
+    [target_square.first + direction, target_square.last]
+  end
+end