rb_chess 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 04be0bab3ec8dd8abbb014e44d3a209cf727c52973752bb371d46cc9f40d19f0
+  data.tar.gz: 077b182bb41c50319c21dbba238d51d36f7d7f8760722168a24cb8d4ae675661
+SHA512:
+  metadata.gz: 79dbefdc24671860bc959442bcfcaf62c77329db1e879a2d34a56551cf557a499f8e22e1a5baa413a1dee4c05be93f82376781d28a970636d770d21012137514
+  data.tar.gz: 7bbfc032021fc78f66dd6c0727d06cbc4d89ae10addc092c72e5f8a2a3a1dd721bddd558a8b92ce231814465d37f5ea1550fa80f7d9174d19519d15f2aaf82c6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Peter Abah
+
+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,68 @@
+# rb_chess
+A chess library written in ruby. It provides all a representation of a chess game with all rules and serialization. It also provides a command line interface for playing the game
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'just_chess'
+```
+
+And then run:
+```
+$ bundle
+```
+
+Or install it yourself as:
+```
+$ gem install rb_chess
+```
+
+## Features
+- Supports all chess moves including:
+  + En passant.
+  + Castling.
+  + Pawn promotion.
+- The game detects and declares:
+  + Checkmate.
+  + Stalemate.
+  + Insufficient material.
+  + Fivefold repetition
+  + Seventy five moves rule
+- Move generation.
+- Move validation.
+- Serializing (json and binary).
+
+## Usage
+
+The code below plays a random game of chess:
+
+```ruby
+require 'rb_chess'
+
+game = RbChess::Game.new
+
+until game.game_over?
+  puts game.board.ascii
+  game.make_move(game.all_moves.sample)
+end
+
+puts game.board.to_fen
+```
+
+You can find the full example of using this library in the [RbChess::CLI](lib/rb_chess/cli/cli.rb) class in lib/rb_chess/cli/cli.rb.
+
+## Playing
+- To start run ``` rb_chess ```.
+- Moves are made by typing in coordinate system i.e `e2e4`.
+- Castling moves are made by typing `0-0` for kingside and `0-0-0` for queenside.
+- Promotion moves are made by typing the move with the promotion piece after it e.g `a7a8Q`.
+- To save type `save` or `s`.
+- To quit the game type `exit`.
+
+## To do
+- Support for PGN.
+- Support for SAN move format.
+
+## License
+Distributed under the MIT License. See LICENSE for more information.

data/bin/rb_chess

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rb_chess/cli/cli'
+
+RbChess::CLI.new.start

data/lib/rb_chess/board.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'require_all'
+
+require_relative 'fen_parser'
+require_relative 'position'
+require_relative 'errors'
+require_relative 'letter_display'
+require_rel 'pieces/pawn', 'pieces/piece_constants'
+
+# A class to represent a chess board
+module RbChess
+  class Board
+    include LetterDisplay
+    include PieceConstants
+
+    attr_reader :pieces, :active_color, :en_passant_square, :halfmove_clock, :fullmove_no, :castling_rights
+
+    def initialize(fen_notation: nil, segments: nil)
+      segments ||= fen_notation ? FENParser.new(fen_notation).parse : FENParser.new.parse
+      @pieces = segments[:pieces].freeze
+      @active_color = segments[:active_color]
+      @castling_rights = segments[:castling_rights]
+      @en_passant_square = segments[:en_passant_square]
+      @halfmove_clock = segments[:halfmove_clock]
+      @fullmove_no = segments[:fullmove_no]
+    end
+
+    def make_move(move)
+      segments = {
+        pieces: update_pieces(move),
+        active_color: active_color == :white ? :black : :white,
+        castling_rights: update_castling_rights(move),
+        en_passant_square: update_en_passant_square(move),
+        halfmove_clock: update_halfmove_clock(move),
+        fullmove_no: active_color == :black ? fullmove_no + 1 : fullmove_no
+      }
+
+      self.class.new(segments: segments)
+    end
+
+    def player_pieces(color)
+      pieces.select { |piece| piece.color == color }
+    end
+
+    def opponent_color
+      active_color == :white ? :black : :white
+    end
+
+    def piece_at(pos, pieces_n: pieces)
+      pos = Position.parse(pos) unless pos.is_a? Position
+
+      pieces_n.find { |piece| piece.position == pos }
+    end
+
+    def can_castle_kingside?(color)
+      castling_rights.kingside[color]
+    end
+
+    def can_castle_queenside?(color)
+      castling_rights.queenside[color]
+    end
+
+    def to_fen
+      FENParser.board_to_fen self
+    end
+
+    def to_s
+      to_fen
+    end
+
+    private
+
+    def update_castling_rights(move)
+      new_castling_rights = castling_rights.dup
+
+      new_castling_rights.kingside[:white] = invalidate_kingside_castling(move, :white)
+      new_castling_rights.queenside[:white] = invalidate_queenside_castling(move, :white)
+
+      new_castling_rights.kingside[:black] = invalidate_kingside_castling(move, :black)
+      new_castling_rights.queenside[:black] = invalidate_queenside_castling(move, :black)
+
+      new_castling_rights
+    end
+
+    def invalidate_kingside_castling(move, color)
+      invalidate = move.moved.all? do |hash|
+        if color == active_color
+          hash[:from].king_pos?(color) || hash[:from].kingside_rook_pos?(color)
+        elsif move.removed
+          move.removed.kingside_rook_pos?(color)
+        end
+      end
+
+      castling_rights.kingside[color] && !invalidate
+    end
+
+    def invalidate_queenside_castling(move, color)
+      invalidate = move.moved.all? do |hash|
+        if color == active_color
+          hash[:from].king_pos?(color) || hash[:from].queenside_rook_pos?(color)
+        elsif move.removed
+          move.removed.queenside_rook_pos?(color)
+        end
+      end
+
+      castling_rights.queenside[color] && !invalidate
+    end
+
+    def update_pieces(move)
+      pieces = remove_piece(move)
+      move_pieces(pieces, move)
+    end
+
+    def update_en_passant_square(move)
+      move.moved.reduce('-') do |res, hash|
+        if en_passant_possible?(hash)
+          direction = piece_at(hash[:from]).direction
+          return hash[:to].increment(y: -direction)
+        end
+
+        res
+      end
+    end
+
+    def update_halfmove_clock(move)
+      reset_clock = move.moved.reduce(false) do |res, hash|
+        piece = piece_at(hash[:from])
+        piece.is_a?(Pawn) ? true : res
+      end
+
+      move.removed || reset_clock ? 0 : halfmove_clock + 1
+    end
+
+    def en_passant_possible?(hash)
+      piece = piece_at(hash[:from])
+
+      piece.is_a?(Pawn) && hash[:from].starting_pawn_rank?(piece.color) &&
+        hash[:to].en_passant_rank?(piece.color)
+    end
+
+    def remove_piece(move)
+      return pieces.dup unless move.removed
+      raise ChessError, 'Cannot remove your own piece' if piece_at(move.removed).color == active_color
+
+      pieces.reject { |piece| piece.position == move.removed }
+    end
+
+    def move_pieces(pieces, move)
+      move.moved.reduce(pieces) do |res, hash|
+        piece = move_piece(res, hash)
+        piece = promote_piece(pieces, hash, move.promotion) if move.promotion
+        res = res.reject { |piece| piece.position == hash[:from] }
+        res.push(piece)
+      end
+    end
+
+    def move_piece(pieces, hash)
+      piece = piece_at(hash[:from], pieces_n: pieces)
+      raise ChessError, 'Can only move your own piece' unless piece.color == active_color
+
+      piece.update_position(hash[:to])
+    end
+
+    def promote_piece(pieces, hash, piece_letter)
+      piece_class = LETTER_TO_PIECE_CLASS[piece_letter.downcase.to_sym]
+      color = piece_at(hash[:from], pieces_n: pieces).color
+      piece_class.new(color, hash[:to])
+    end
+  end
+end

data/lib/rb_chess/castling_rights.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RbChess
+  class CastlingRights
+    attr_reader :kingside, :queenside
+
+    def initialize(kingside: nil, queenside: nil)
+      @kingside = kingside || { white: false, black: false }
+      @queenside = queenside || { white: false, black: false }
+    end
+
+    def to_s
+      res = ''
+
+      res += 'K' if kingside[:white]
+      res += 'Q' if queenside[:white]
+      res += 'k' if kingside[:black]
+      res += 'q' if queenside[:black]
+
+      res = '-' if res.empty?
+
+      res
+    end
+
+    def dup
+      new_kingside = kingside.dup
+      new_queenside = queenside.dup
+      CastlingRights.new(kingside: new_kingside, queenside: new_queenside)
+    end
+  end
+end

data/lib/rb_chess/cli/cli.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'require_all'
+
+require_relative '../game'
+require_rel '.'
+
+module RbChess
+  class CLI
+    def initialize
+      @game_saver = GameSaver.new
+    end
+
+    def start
+      welcome
+      @game, @players = game_option == :new ? new_game : load_game
+      play_game
+    end
+
+    def welcome
+      puts 'Welcome to Chess.'
+      help
+      puts 'Enjoy the game.'
+    end
+
+    def game_option
+      choice = -1
+      until choice.between?(1, 2)
+        puts <<~HEREDOC
+          ---------------------
+          1 - New game
+          2 - Load saved game
+        HEREDOC
+
+        choice = gets.chomp.to_i
+      end
+
+      choice == 1 ? :new : :load
+    end
+
+    def new_game
+      players = get_players
+      [Game.new, players]
+    end
+
+    def load_game
+      files = @game_saver.saved_games
+      if files.empty?
+        puts 'No Games to load. Starting new game'
+        return new_game
+      end
+
+      choice = -1
+      until choice.between?(0, files.size - 1)
+        display_list(files)
+        puts 'Choose game to load. (Enter number)'
+        choice = gets.chomp.to_i - 1
+      end
+
+      @game_saver.load(files[choice])
+    end
+
+    def play_game
+      game_loop until @game.game_over?
+
+      puts @game.board.ascii
+      puts end_game_msg
+      play_again? && start
+    end
+
+    def game_loop
+      puts @game.board.ascii
+      puts "#{player.name} in check!" if @game.check?
+      input = player_input
+
+      if commands[input.to_sym]
+        commands[input.to_sym].call
+      elsif pos? input
+        show_pos_moves input
+      elsif @game.valid_move? input
+        @game.make_move input
+      else
+        puts 'Invalid move or command!'
+      end
+    end
+
+    def player
+      @players.find { |p| p.color == @game.current_player }
+    end
+
+    def end_game_msg
+      player = @players.find { |p| p.color == @game.winner }
+
+      if @game.checkmate?
+        "Checkmate #{player.name} wins!"
+      elsif @game.stalemate?
+        'Draw by stalemate!'
+      elsif @game.fivefold?
+        'Draw by fivefold repetition!'
+      elsif @game.seventy_five_moves?
+        'Draw by seventy five moves rule (No pawn move or capture in last seventy five moves)'
+      elsif @game.insufficient_material?
+        'Draw by insufficient material'
+      else
+        'Game over!'
+      end
+    end
+
+    def play_again?
+      p 'Do you want to play again?(Y|N default is N): '
+      choice = gets.chomp.downcase
+      choice == 'y'
+    end
+
+    def player_input
+      return player.move(@game) if player.is_a? ComputerPlayer
+
+      puts "#{player.name} Enter move"
+      gets.chomp.downcase
+    end
+
+    def help
+      puts <<~HEREDOC
+        Moves are in coordinate system format e.g e2e4 with exception of castling moves
+        which are 0-0 for kingside and 0-0-0 for queenside.
+
+        You can also enter a piece position e.g b1.
+        If the piece has legal moves available, the game will display them or the the
+        player must choose another piece.
+
+        For promotion moves append the promotion piece (Q, R, B, N) after the move
+        e.g a2a1R
+
+        If a player is in check, they can only select pieces with moves that take them
+        out of check.
+
+        Enter [moves] or [m] to view all available moves.
+
+        Enter [save] or [s] at any time to save the game.
+
+        Enter [exit] at any time to end the game
+
+        Enter [help] or [h] to view this guide again
+
+        The game ends by checkmate or draw (stalemate, fivefold repetition,
+        insufficient material or seventy five turns without a capture or pawn move)
+      HEREDOC
+    end
+
+    def moves
+      display_list(@game.all_moves)
+    end
+
+    def save
+      filename = ''
+      while filename.empty?
+        puts 'Enter filename: '
+        filename = gets.chomp
+      end
+
+      @game_saver.save(@game, @players, filename)
+    end
+
+    def get_players
+      mode = get_mode
+      return [Player.new(:white), Player.new(:black)] if mode == :human
+
+      color = get_color
+      computer_color = color == :white ? :black : :white
+      [Player.new(color), RandomAI.new(computer_color)]
+    end
+
+    def get_mode
+      choice = -1
+      until choice.between?(1, 2)
+        puts <<~HEREDOC
+          -------------
+          Choose mode
+          -------------
+          1 - vs Human
+          2 - vs Computer (just random moves)
+        HEREDOC
+        choice = gets.chomp.to_i
+      end
+
+      choice == 1 ? :human : :computer
+    end
+
+    def get_color
+      choice = -1
+      until choice.between?(1, 2)
+        puts <<~HEREDOC
+          -------------
+          Choose color
+          -------------
+          1 - White
+          2 - Black
+        HEREDOC
+        choice = gets.chomp.to_i
+      end
+
+      choice == 1 ? :white : :black
+    end
+
+    def commands
+      @commands ||= {
+        help: method(:help),
+        h: method(:help),
+        moves: method(:moves),
+        m: method(:moves),
+        exit: method(:exit),
+        save: method(:save),
+        s: method(:save)
+      }
+    end
+
+    def pos?(pos)
+      /^[a-h][1-8]$/.match pos
+    end
+
+    def show_pos_moves(pos)
+      moves = @game.moves_at pos
+      if moves.empty?
+        puts "No moves at #{pos}"
+        return
+      end
+
+      display_list(moves)
+    end
+
+    def display_list(list)
+      list.each_with_index do |data, i|
+        puts "#{i + 1} - #{data}"
+      end
+    end
+  end
+end

data/lib/rb_chess/cli/game_saver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RbChess
+  class GameSaver
+    def initialize
+      Dir.exist?(dirname) || FileUtils.mkdir_p(dirname)
+    end
+
+    def saved_games
+      files = Dir.entries(dirname).reject { |f| ['.', '..'].include?(f) }
+    end
+
+    def save(game, players, filename)
+      filename = File.join(dirname, filename)
+      data = Marshal.dump([game, players])
+      File.open(filename, 'wb') { |f| f.write(data) }
+      puts 'Game saved'
+    end
+
+    def load(filename)
+      filename = File.join(dirname, filename)
+      data = File.open(filename, 'rb') { |f| f.read }
+
+      Marshal.load(data)
+    end
+
+    def dirname
+      File.join(Dir.home, '.rb_chess/saved')
+    end
+  end
+end

data/lib/rb_chess/cli/players.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RbChess
+  class Player
+    attr_reader :color, :name
+
+    def initialize(color)
+      @color = color
+      @name = color.to_s.capitalize
+    end
+  end
+
+  class ComputerPlayer < Player; end
+
+  class RandomAI < ComputerPlayer
+    def move(game)
+      game.all_moves.sample
+    end
+  end
+end

data/lib/rb_chess/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RbChess
+  class ChessError < StandardError; end
+end