sapphire-chess 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a152a756661a6bba522bd8a75bde7074e7386a5b65c1572225da5976acd86cd8
+  data.tar.gz: 98c2040c722a85e5f5caf9a8dce9ee5caeb2bf1871b1b9dceb1e1d330de52e03
+SHA512:
+  metadata.gz: 108d87f43ba5f8c26f6e7e607dca07cbc57e7ae79ea4675b3649d5272995351b2cc37ca9570bac11651d4694b3978bba502b0ff60a1b52e5c30541ee68d77c41
+  data.tar.gz: 7a035c86043ecec355bb910d834eec02c060f49705067b27ed2c5b9f467e5920e7adbf1bf215a31330fda448911797d4a8ded7e227b417bb96aa39832027bdcb

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    sapphire-chess (1.0.0)
+      paint (~> 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    json (2.6.3)
+    paint (2.3.0)
+    parallel (1.22.1)
+    parser (3.2.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.1)
+    rexml (3.2.5)
+    rubocop (1.43.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.24.1)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (~> 2.4)
+  rake (~> 13.0)
+  rubocop (~> 1.43)
+  sapphire-chess!
+
+BUNDLED WITH
+   2.4.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2023, Lucas Sorribes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# Sapphire Chess v0.9.0
+
+Welcome to Sapphire Chess!
+
+This is a chess game written in pure Ruby v2.7.5. Other versions have not been tested yet.
+
+Please, visit https://medium.com/@lucas.sorribes/nostromo-my-ruby-chess-journey-part-i-7ef544b547a5 for a very detailed account of how I wrote this game.
+
+---
+
+## Current Features
+
+* A beautiful board with easy-to-distinguish colors for white and black pieces.
+* Fully functional AI
+* Two game modes: human vs. computer, human vs. human.
+* Three levels of difficulty.
+* Full chess movement rules implementation, including castling and *en passant*, for both the human and the computer player.
+* Accepts algebraic notation for movements, with human input validation.
+* Material score display.
+* Player's last move display.
+
+## Screenshot
+
+![Game screenshot](./screenshot.png)

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/sapphire-chess

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'sapphire-chess'
+
+Engine.new.play

data/lib/sapphire-chess/ai.rb

@@ -0,0 +1,101 @@
+module AI
+  private
+
+  # Chooses move by best possible outcome:
+  def computer_chooses_move
+    possible_moves = board.generate_moves(color)
+    possible_moves << %i[castle king] if castle_rights?(:king)
+    possible_moves << %i[castle queen] if castle_rights?(:queen)
+
+    best_move(possible_moves)
+  end
+
+  def best_move(possible_moves)
+    evaluations = {}
+    anti_loop_filter(possible_moves)
+
+    possible_moves.each do |move|
+      evaluations[move] = 
+      minimax(move, depth, -Float::INFINITY, Float::INFINITY, maximizing_player?)
+    end
+
+    move_randomizer(evaluations)
+  end
+
+  def minimax(move, depth, alpha, beta, maximizing_player)
+    return board.evaluate if depth.zero?
+
+    move_final_evaluation =
+    board.provisional(move, color) do
+      # This generates possible outcomes (children) for the provisional move:
+      # Each branch represents the next turn (i.e.: if current player is white
+      # [the maximizing player], it generates every possible movement for the
+      # next player, black [the minimizing player], who will choose the best
+      # possible move, and so on. The best (relative to each player) possible
+      # outcome for each move will determine what move is chosen, `best_evaluation`)
+      # See AI#computer_chooses_move
+
+      # The alpha-beta `prunes` the tree: it makes the search more efficient
+      # removing unnecessary branches, resulting in a faster process.
+      move_final_evaluation =
+        if maximizing_player
+          best_minimizing_evaluation = Float::INFINITY
+
+          board.generate_moves(:black).each do |possible_move|
+            evaluation = minimax(possible_move, depth - 1, alpha, beta, false)
+            best_minimizing_evaluation = [best_minimizing_evaluation, evaluation].min
+            beta = [beta, evaluation].min
+            break if beta <= alpha
+          end
+
+          best_minimizing_evaluation
+        else
+          best_maximizing_evaluation = -Float::INFINITY
+
+          board.generate_moves(:white).each do |possible_move|
+            evaluation = minimax(possible_move, depth - 1, alpha, beta, true)
+            best_maximizing_evaluation = [best_maximizing_evaluation, evaluation].max
+            alpha = [alpha, evaluation].max
+            break if beta <= alpha
+          end
+
+          best_maximizing_evaluation
+        end
+    end
+
+    move_final_evaluation
+  end
+
+  # This method randomizes the moves if two or more moves share the best evaluation.
+  # This avoids the Computer to play the same moves every game.
+  def move_randomizer(evaluations)
+    best_evaluation =
+      if color == :white then evaluations.values.max
+      else
+        evaluations.values.min
+      end
+
+    evaluations.select do |_, evaluation|
+      evaluation == best_evaluation
+    end.keys.sample
+  end
+
+  def anti_loop_filter(possible_moves)
+    possible_moves.delete(history[-2]) if possible_moves.include?(history[-2])
+  end
+
+  # For evaluation analysis only:
+  def store_evaluation(move, evaluation)
+    return [move, evaluation] if move.first == :castle
+
+    description = format(
+      '%<piece_class>s %<piece_position>s to %<target_class>s %<target_position>s',
+      piece_class: board[move.first].class,
+      piece_position: move.first,
+      target_class: board[move.last].class,
+      target_position: move.last
+    )
+
+    [description, evaluation]
+  end
+end

data/lib/sapphire-chess/algebraic_conversion.rb

@@ -0,0 +1,89 @@
+module AlgebraicConversion
+  LETTER_RESET_VALUE = 97 # ASCII downcase 'a' numeric value: 'a'.ord
+  ALGEBRAIC_NOTATION_FORMAT = /[a-h]{1}[1-8]{1}/.freeze
+  CASTLING_INPUT_FORMAT = /castle [kq]{1}/.freeze
+
+  private
+
+  def algebraic_input
+    move_input = nil
+    loop do
+      move_input = gets.chomp.strip.downcase
+      break if valid_input_format?(move_input)
+
+      puts 'Please, enter a valid move_input.'
+    end
+
+    convert_algegraic_input(move_input)
+  end
+
+  def valid_input_format?(move_input)
+    (move_input.size == 2 &&
+      move_input.match?(ALGEBRAIC_NOTATION_FORMAT)) ||
+      (move_input.size == 4 &&
+        move_input[0, 2].match?(ALGEBRAIC_NOTATION_FORMAT) &&
+        move_input[2, 2].match?(ALGEBRAIC_NOTATION_FORMAT)) ||
+      move_input.match?(CASTLING_INPUT_FORMAT)
+  end
+
+  def convert_algegraic_input(move_input)
+    case move_input.size
+    when 2 then convert_single_input(move_input)
+    when 4 then convert_double_input(move_input)
+    else convert_castling_input(move_input)
+    end
+  end
+
+  def convert_single_input(move_input)
+    letter = move_input[0]
+    number = move_input[1]
+
+    row = number_to_row(number)
+    column = letter_to_column(letter)
+
+    [row, column]
+  end
+
+  def convert_double_input(move_input)
+    letter = move_input[0]
+    number = move_input[1]
+    letter_end = move_input[2]
+    number_end = move_input[3]
+
+    row = number_to_row(number)
+    column = letter_to_column(letter)
+
+    row_end = number_to_row(number_end)
+    column_end = letter_to_column(letter_end)
+
+    [[row, column], [row_end, column_end]]
+  end
+
+  def number_to_row(number)
+    (number.to_i - Board::SQUARE_ORDER).abs
+  end
+
+  def letter_to_column(letter)
+    letter.ord - LETTER_RESET_VALUE
+  end
+
+  def convert_castling_input(move_input)
+    side = move_input[-1] == 'k' ? :king : :queen
+    [:castle, side]
+  end
+
+  def convert_to_algebraic(square)
+    letter = column_to_letter(square.last)
+    number = row_to_number(square.first)
+
+    "#{letter}#{number}"
+  end
+
+  def column_to_letter(column)
+    (column + LETTER_RESET_VALUE).chr
+  end
+
+  def row_to_number(row)
+    (row - Board::SQUARE_ORDER).abs
+  end
+end

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

@@ -0,0 +1,66 @@
+module BoardAnalysis
+  # This is the total material evaluation (pieces value put together)
+  # when a player keeps just a king, a queen and a few pieces, indicating
+  # that the game is now in its last stage (endgame):
+  LAST_STAND_PIECES_VALUE = 21_500
+
+  def in_check?(color)
+    king_position = find_king(color)
+
+    enemy_pieces(color).each do |piece|
+      return true if piece.available_moves.include?(king_position)
+    end
+
+    false
+  end
+
+  def find_king(color)
+    king_location = pieces.find do |piece|
+      piece.color == color && piece.is_a?(King)
+    end
+
+    king_location&.location
+  end
+
+  def checkmate?(color)
+    return false unless in_check?(color)
+
+    friendly_pieces(color).all? { |piece| piece.safe_moves.empty? }
+  end
+
+  def no_king?(color)
+    find_king(color).nil?
+  end
+
+  def pieces
+    matrix.flatten.reject { |position| position.is_a?(EmptySquare) }
+  end
+
+  def friendly_pieces(color)
+    pieces.select { |piece| piece.color == color }
+  end
+
+  def enemy_pieces(color)
+    pieces.reject { |piece| piece.color == color }
+  end
+
+  def count(type, color)
+    friendly_pieces(color).select { |piece| piece.instance_of?(type) }.size
+  end
+
+  def promoted_pawns(color)
+    friendly_pieces(color).select do |piece|
+      piece.is_a?(Pawn) && piece.promoted?
+    end.size
+  end
+
+  def end_game?
+    (count(Queen, :white).zero? && count(Queen, :black).zero?) ||
+      (last_stand?(:white) || last_stand?(:black))
+  end
+
+  def last_stand?(color)
+    count(Queen, color).positive? &&
+      friendly_pieces(color).map(&:value).sum <= LAST_STAND_PIECES_VALUE
+  end
+end

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

@@ -0,0 +1,25 @@
+module BoardEvaluation
+  def evaluate
+    material_evaluation + piece_location_evaluation
+  end
+
+  def material_evaluation
+    white_evaluation = friendly_pieces(:white).map(&:value).sum
+    black_evaluation = -friendly_pieces(:black).map(&:value).sum
+
+    white_evaluation + black_evaluation
+  end
+
+  def piece_location_evaluation
+    white_evaluation = friendly_pieces(:white).map(&:location_value).sum
+    black_evaluation = -friendly_pieces(:black).map(&:location_value).sum
+
+    white_evaluation + black_evaluation
+  end
+
+  def evaluate_move(move, color)
+    provisional(move, color) do
+      evaluate
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+require_relative '../pieces'
+require_relative '../movement_rules/castling_board_control'
+require_relative '../movement_rules/en_passant_board_control'
+require_relative '../board/board_analysis'
+require_relative '../board/board_evaluation'
+require_relative '../board/board_provisional_moves'
+
+class Board
+  SQUARE_ORDER = 8
+  B_PAWN_ROW = 1
+  W_PAWN_ROW = 6
+  FIRST_ROW = 0
+  LAST_ROW = 7
+  PIECES_SEQUENCE = [
+    Rook, Knight, Bishop, Queen, King, Bishop, Knight, Rook
+  ].freeze
+
+  include BoardAnalysis
+  include BoardEvaluation
+  include ProvisionalMoves
+  include CastlingBoardControl
+  include EnPassantBoardControl
+
+  attr_reader :matrix, :white_player, :black_player, :hard_difficulty
+
+  def self.initialize_board
+    board = new(duplicated: false)
+
+    set_pawns(board)
+    set_pieces(board)
+
+    board
+  end
+
+  class << self
+    private
+
+    def set_pawns(board)
+      [B_PAWN_ROW, W_PAWN_ROW].each do |pawn_row|
+        color = pawn_row == B_PAWN_ROW ? :black : :white
+  
+        SQUARE_ORDER.times do |column|
+          board[[pawn_row, column]] = Pawn.new(board, [pawn_row, column], color)
+        end
+      end
+    end
+
+    def set_pieces(board)
+      [[FIRST_ROW, :black], [LAST_ROW, :white]].each do |(row, color)|
+        PIECES_SEQUENCE.each_with_index do |piece, column|
+          board[[row, column]] = piece.new(board, [row, column], color)
+        end
+      end
+    end
+  end
+
+  def initialize(duplicated: false)
+    @matrix = Array.new(SQUARE_ORDER) { Array.new(SQUARE_ORDER, EmptySquare.instance) }
+    @duplicated = duplicated
+  end
+
+  def add_players!(player1, player2)
+    if player1.color == :white
+      @white_player = player1
+      @black_player = player2
+    else
+      @white_player = player2
+      @black_player = player1
+    end
+  end
+
+  def [](square)
+    row, column = square
+    matrix[row][column]
+  end
+
+  def []=(square, piece)
+    row, column = square
+    matrix[row][column] = piece
+  end
+
+  def within_limits?(square)
+    square.none? { |axis| axis >= SQUARE_ORDER || axis.negative? }
+  end
+
+  def empty_square?(square)
+    row, column = square
+    within_limits?(square) && matrix[row][column].is_a?(EmptySquare)
+  end
+
+  def move_piece!(piece, target_square, permanent: false)
+    mark_moved_piece!(piece) if permanent
+
+    self[piece], self[target_square] = EmptySquare.instance, self[piece]
+
+    self[target_square].location = target_square
+
+    return unless permanent && was_en_passant?(piece, target_square)
+    
+    capture_passed_pawn!(target_square)
+  end
+
+  # Deep duplication of the board for Piece#safe_moves
+  def duplicate
+    pieces.each_with_object(Board.new(duplicated: true)) do |piece, new_board|
+      new_piece = piece.class.new(new_board, piece.location, piece.color)
+
+      new_board[new_piece.location] = new_piece
+    end
+  end
+
+  def generate_moves(color)
+    possible_moves =
+    friendly_pieces(color).each_with_object([]) do |piece, possible_moves|
+      location = piece.location
+
+      piece.available_moves.each do |possible_move|
+        possible_moves << [location, possible_move]
+      end
+    end
+    # sort_moves!(possible_moves, color)
+    possible_moves
+  end
+
+  # This method is avoids checking for availability of en passant
+  # moves in duplicate boards
+  def a_duplicate?
+    @duplicated
+  end
+
+  def set_game_difficulty
+    self.hard_difficulty =
+      [white_player, black_player].find do |player|
+        player.is_a?(Computer)
+      end.depth == 3
+  end
+
+  def hard_difficulty?
+    hard_difficulty
+  end
+
+  private
+
+  attr_writer :hard_difficulty
+  # For testing purposes:
+  def sort_moves!(possible_moves, color)
+    possible_moves.sort! do |a, b|
+      if color == :white
+        evaluate_move(a, color) <=> evaluate_move(b, color)
+      else
+        evaluate_move(b, color) <=> evaluate_move(a, color)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module ProvisionalMoves
+  def provisional(move, color)
+    piece_buffer = self[move.last] unless move.first == :castle
+    make_provisional!(move, color)
+    from_block = block_given? ? yield : raise(ArgumentError, 'No block given to ProvisionalMoves#provisional')
+    unmake_provisional!(piece_buffer, move, color)
+    from_block
+  end
+
+  private
+
+  def make_provisional!(move, color)
+    if move.first == :castle
+      side = move.last
+      castle!(side, color)
+    else
+      start_position, target_position = move
+      move_piece!(start_position, target_position)
+    end
+  end
+
+  def unmake_provisional!(piece_buffer, move, color)
+    if move.first == :castle
+      side = move.last
+      uncastle!(side, color)
+    else
+      start_position, target_position = move
+      move_piece!(target_position, start_position)
+      self[target_position] = piece_buffer
+    end
+  end
+end