chess_tui 0.41.4

data/lib/chess/pieces/king.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # King
+    class King < Piece
+      include Chess::Save::FenCodeFromBoard
+
+      attr_accessor :in_check
+
+      def initialize(color)
+        super
+        @in_check = false
+      end
+
+      # all possible_moves of Bishop
+      #
+      # @param board [Chess::Board]
+      # @return [Array] possible_moves_arr
+      def possible_moves(board)
+        file = @pos[0]
+        rank = @pos[1]
+        moves = []
+        moves += one_step_all_direction_moves(board, file, rank)
+        moves += castling_moves(board)
+        moves
+      end
+
+      # gets one step possible move in all direction for king
+      #
+      # @param board [Chess::Board]
+      # @param file [String]
+      # @param rank [Integer]
+      # @return [Array] all_dir_possible_moves_arr
+      def one_step_all_direction_moves(board, file, rank)
+        north = board.north_pos(file, rank)
+        south = board.south_pos(file, rank)
+        west = board.west_pos(file, rank)
+        east = board.east_pos(file, rank)
+        north_west = board.north_west_pos(file, rank)
+        south_east = board.south_east_pos(file, rank)
+        south_west = board.south_west_pos(file, rank)
+        north_east = board.north_east_pos(file, rank)
+        directions = north, south, west, east, north_west, south_east, south_west, north_east
+
+        get_moves_on_direction(board, directions)
+      end
+
+      # helper method for {#one_step_all_direction_moves}
+      #
+      # @param board [Chess::Board]
+      # @param directions [Array]
+      # @return [Array] all_dir_possible_moves_arr
+      def get_moves_on_direction(board, directions)
+        moves = []
+        directions.each do |direction|
+          if board.pos_in_range?(direction) && (board.empty_at?(*direction) || board.enemy_at?(*direction))
+            moves << direction
+          end
+        end
+        moves
+      end
+
+      # finds possible castling moves
+      #
+      # @param board [Chess::Board]
+      # @return [Array] castling_moves_arr
+      def castling_moves(board)
+        moves = []
+        if valid_castling_rights?(board)
+          if white?
+            moves += white_castling_moves(board)
+          elsif black?
+            moves += black_castling_moves(board)
+          end
+        end
+        moves
+      end
+
+      # check if valid_castling_rights exits
+      #
+      # @param board [Chess::Board]
+      def valid_castling_rights?(board)
+        return false if board.castling_rights == '-'
+
+        board.castling_rights.include?('K') ||
+          board.castling_rights.include?('Q') ||
+          board.castling_rights.include?('k') ||
+          board.castling_rights.include?('q')
+      end
+
+      # helper method for {#castling_moves}
+      # @param (see #castling_moves)
+      # @return (see #castling_moves)
+      def white_castling_moves(board)
+        moves = []
+        moves << ['g', 0] if board.castling_rights.include?('K') && can_castle?(board, 'K')
+        moves << ['c', 0] if board.castling_rights.include?('Q') && can_castle?(board, 'Q')
+        moves
+      end
+
+      # helper method for {#castling_moves}
+      # @param (see #castling_moves)
+      # @return (see #castling_moves)
+      def black_castling_moves(board)
+        moves = []
+        moves << ['g', 7] if board.castling_rights.include?('k') && can_castle?(board, 'k')
+        moves << ['c', 7] if board.castling_rights.include?('q') && can_castle?(board, 'q')
+        moves
+      end
+
+      # check if can castle(no_piece_in_between) for the given castling_right
+      #
+      # @param board [Chess::Board]
+      # @param castling_right [String]
+      def can_castle?(board, castling_right)
+        case castling_right
+        when 'Q'
+          no_piece_in_between?(board, ['a', 0], ['e', 0])
+        when 'K'
+          no_piece_in_between?(board, ['e', 0], ['h', 0])
+        when 'q'
+          no_piece_in_between?(board, ['a', 7], ['e', 7])
+        when 'k'
+          no_piece_in_between?(board, ['e', 7], ['h', 7])
+        end
+      end
+
+      # checks if no piece in between start and finish
+      # helper method for {#can_castle?}
+      #
+      # @param board [Chess::Board]
+      # @param start [Array]
+      # @param finish [Array]
+      def no_piece_in_between?(board, start, finish)
+        curr_file = start.first
+        rank = start.last
+        pieces = []
+        loop do
+          curr_file = (curr_file.ord + 1).chr
+          break if curr_file == finish.first
+
+          pieces << board.piece_at(curr_file, rank)
+        end
+        pieces.all?('')
+      end
+
+      # checks if king is in check by one or more opponent_piece
+      #
+      # @param board [Chess::Board]
+      # @param opponent_pieces [Chess::Board#white_pieces, Chess::Board#black_pieces]
+      def in_check?(board, opponent_pieces)
+        @in_check = false
+        opponent_pieces.each do |piece|
+          break if @in_check
+
+          possible_moves = piece.possible_moves(board)
+          @in_check = true if possible_moves.include?(@pos)
+        end
+        @in_check
+      end
+    end
+  end
+end

data/lib/chess/pieces/knight.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # Knight
+    class Knight < Piece
+      # all possible_moves of Knight
+      #
+      # @param board [Chess::Board]
+      # @return [Array] possible_moves_arr
+      def possible_moves(board)
+        file = @pos[0]
+        rank = @pos[1]
+        moves = []
+        moves += north_moves(board, file, rank)
+        moves += south_moves(board, file, rank)
+        moves += west_moves(board, file, rank)
+        moves += east_moves(board, file, rank)
+        moves
+      end
+
+      def north_moves(board, file, rank)
+        moves = []
+        north_steps = 2
+        two_step_north = [file, rank + north_steps]
+
+        east = board.east_pos(*two_step_north)
+        west = board.west_pos(*two_step_north)
+        moves << east if board.pos_in_range?(east) && (board.empty_at?(*east) || board.enemy_at?(*east))
+        moves << west if board.pos_in_range?(west) && (board.empty_at?(*west) || board.enemy_at?(*west))
+        moves
+      end
+
+      def south_moves(board, file, rank)
+        moves = []
+        south_steps = 2
+        two_step_south = [file, rank - south_steps]
+
+        return moves unless board.pos_in_range?(two_step_south)
+
+        east = board.east_pos(*two_step_south)
+        west = board.west_pos(*two_step_south)
+        [east, west].each do |pos|
+          moves << pos if board.pos_in_range?(pos) && (board.empty_at?(*pos) || board.enemy_at?(*pos))
+        end
+        moves
+      end
+
+      def west_moves(board, file, rank)
+        moves = []
+        west_steps = 2
+        two_step_west = [(file.ord - west_steps).chr, rank]
+
+        return moves unless board.pos_in_range?(two_step_west)
+
+        north = board.north_pos(*two_step_west)
+        south = board.south_pos(*two_step_west)
+        [north, south].each do |pos|
+          moves << pos if board.pos_in_range?(pos) && (board.empty_at?(*pos) || board.enemy_at?(*pos))
+        end
+        moves
+      end
+
+      def east_moves(board, file, rank)
+        moves = []
+        east_steps = 2
+        two_step_east = [(file.ord + east_steps).chr, rank]
+        north = board.north_pos(*two_step_east)
+        south = board.south_pos(*two_step_east)
+        [north, south].each do |pos|
+          moves << pos if board.pos_in_range?(pos) && (board.empty_at?(*pos) || board.enemy_at?(*pos))
+        end
+        moves
+      end
+    end
+  end
+end

data/lib/chess/pieces/pawn.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # Pawn
+    class Pawn < Piece
+      # possible_moves of the pawn
+      # @param board [Chess::Board]
+      # @return [Array] moves
+      def possible_moves(board)
+        moves = []
+        file = @pos[0]
+        rank = @pos[1]
+        moves += pawn_moves_by_color(board, file, rank)
+        moves
+      end
+
+      # checks if it's first move of pawn
+      # @param rank [Integer]
+      def first_move?(rank)
+        (rank == 1 && white?) || (rank == 6 && black?)
+      end
+
+      # creates all the possible first moves
+      # @param board [Chess::Board]
+      # @param file [String]
+      # @param rank [Integer]
+      # @return [Array] moves
+      def pawn_moves_by_color(board, file, rank)
+        moves = []
+        moves += one_step_forward(board, file, rank)
+        moves += two_step_forward(board, file, rank) if first_move?(rank)
+        moves += attack_en_passant(board, file, rank) unless first_move?(rank)
+        moves += cross_side_attack(board, file, rank)
+        moves.reject!(&:empty?)
+        moves
+      end
+
+      # one step move of pawn
+      # @param board [Chess::Board]
+      # @param file [String]
+      # @param rank [Integer]
+      # @return [Array] moves
+      def one_step_forward(board, file, rank)
+        moves = []
+        if white?
+          north = board.north_pos(file, rank)
+          moves << north if board.empty_at?(*north)
+        else
+          south = board.south_pos(file, rank)
+          moves << south if board.empty_at?(*south) && board.pos_in_range?(south)
+        end
+        moves
+      end
+
+      # two step move of pawn
+      # @param board [Chess::Board]
+      # @param file [String]
+      # @param rank [Integer]
+      # @return [Array] moves
+      def two_step_forward(board, file, rank)
+        moves = []
+        moves << if white?
+                   north_two_step(board, file, rank)
+                 else
+                   south_two_step(board, file, rank)
+                 end
+        moves
+      end
+
+      # helper method for {#two_step_forward}
+      # @param (see #two_step_forward)
+      # @return (see #two_step_forward)
+      def north_two_step(board, file, rank)
+        north_one_step = board.north_pos(file, rank)
+        north_two_step = board.north_pos(*north_one_step)
+        return [] unless board.empty_at?(*north_one_step) && board.empty_at?(*north_two_step)
+
+        north_two_step
+      end
+
+      # helper method for {#two_step_forward}
+      # @param (see #two_step_forward)
+      # @return (see #two_step_forward)
+      def south_two_step(board, file, rank)
+        south_one_step = board.south_pos(file, rank)
+        south_two_step = board.south_pos(*south_one_step)
+        unless board.empty_at?(*south_one_step) && board.empty_at?(*south_two_step) &&
+               board.pos_in_range?(south_one_step) && board.pos_in_range?(south_two_step)
+
+          return []
+        end
+
+        south_two_step
+      end
+
+      # cross attack moves of pawn
+      # @param board [Chess::Board]
+      # @param file [String]
+      # @param rank [Integer]
+      # @return [Array] moves
+      def cross_side_attack(board, file, rank)
+        moves = []
+        moves += if white?
+                   north_attack(board, file, rank)
+                 else
+                   south_attack(board, file, rank)
+                 end
+        moves
+      end
+
+      # helper method for {#cross_side_attack}
+      # @param (see #cross_side_attack)
+      # @return (see #cross_side_attack)
+      def north_attack(board, file, rank)
+        moves = []
+        north_east = board.north_east_pos(file, rank)
+        north_west = board.north_west_pos(file, rank)
+        [north_east, north_west].each do |pos|
+          moves << pos if !(board.empty_at?(*pos) || board.pos_nil?(pos)) && board.piece_at(*pos).black?
+        end
+        moves
+      end
+
+      # helper method for {#cross_side_attack}
+      # @param (see #cross_side_attack)
+      # @return (see #cross_side_attack)
+      def south_attack(board, file, rank)
+        moves = []
+        south_east = board.south_east_pos(file, rank)
+        south_west = board.south_west_pos(file, rank)
+        [south_east, south_west].each do |pos|
+          moves << pos if !(board.empty_at?(*pos) || board.pos_nil?(pos)) &&
+                          board.piece_at(*pos).white? &&
+                          board.pos_in_range?(pos)
+        end
+        moves
+      end
+
+      # moves for attacking an pawn which is a {Chess::Board#possible_en_passant_target}
+      #
+      # @param (see #cross_side_attack)
+      # @return (see #cross_side_attack)
+      def attack_en_passant(board, file, rank) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        moves = []
+        if white?
+          north_east = board.north_east_pos(file, rank)
+          moves << north_east if (north_east.first + north_east.last.to_s) == board.possible_en_passant_target
+          north_west = board.north_west_pos(file, rank)
+          moves << north_west if (north_west.first + north_west.last.to_s) == board.possible_en_passant_target
+        else
+          south_east = board.south_east_pos(file, rank)
+          moves << south_east if (south_east.first + south_east.last.to_s) == board.possible_en_passant_target
+          south_west = board.south_west_pos(file, rank)
+          moves << south_west if (south_west.first + south_west.last.to_s) == board.possible_en_passant_target
+        end
+        moves
+      end
+    end
+  end
+end

data/lib/chess/pieces/piece.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # Piece
+    class Piece
+      attr_reader :color
+      attr_accessor :pos, :valid_moves
+
+      def initialize(color)
+        @color = color
+        @pos = []
+        @valid_moves = []
+      end
+
+      # checks if piece color is black
+      def black?
+        @color == 'black'
+      end
+
+      # checks if piece color is white
+      def white?
+        @color == 'white'
+      end
+    end
+  end
+end

data/lib/chess/pieces/queen.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # Queen
+    class Queen < Piece
+      include RookMoves
+      include BishopMoves
+
+      # all possible_moves of Queen
+      #
+      # @param board [Chess::Board]
+      # @return [Array] possible_moves_arr
+      def possible_moves(board)
+        file = @pos[0]
+        rank = @pos[1]
+        moves = []
+        moves += rook_moves(board, file, rank)
+        moves += bishop_moves(board, file, rank)
+        moves
+      end
+
+      def rook_moves(board, file, rank)
+        moves = []
+        moves += north_moves(board, file, rank)
+        moves += south_moves(board, file, rank)
+        moves += west_moves(board, file, rank)
+        moves += east_moves(board, file, rank)
+        moves
+      end
+
+      def bishop_moves(board, file, rank)
+        moves = []
+        moves += north_west_moves(board, file, rank)
+        moves += north_east_moves(board, file, rank)
+        moves += south_west_moves(board, file, rank)
+        moves += south_east_moves(board, file, rank)
+        moves
+      end
+    end
+  end
+end

data/lib/chess/pieces/rook.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # RookMoves
+    module RookMoves
+      def north_moves(board, file, rank)
+        north = board.north_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*north)
+          moves << north if board.pos_in_range?(north)
+          north = board.north_pos(*north)
+        end
+        moves << north if board.pos_in_range?(north) && board.enemy_at?(*north)
+        moves
+      end
+
+      def south_moves(board, file, rank)
+        south = board.south_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*south)
+          moves << south if board.pos_in_range?(south)
+          south = board.south_pos(*south)
+        end
+        moves << south if board.pos_in_range?(south) && board.enemy_at?(*south)
+        moves
+      end
+
+      def east_moves(board, file, rank)
+        east = board.east_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*east)
+          moves << east if board.pos_in_range?(east)
+          east = board.east_pos(*east)
+        end
+        moves << east if board.pos_in_range?(east) && board.enemy_at?(*east)
+        moves
+      end
+
+      def west_moves(board, file, rank)
+        west = board.west_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*west)
+          moves << west if board.pos_in_range?(west)
+          west = board.west_pos(*west)
+        end
+        moves << west if board.pos_in_range?(west) && board.enemy_at?(*west)
+        moves
+      end
+    end
+
+    # Rook
+    class Rook < Piece
+      include RookMoves
+
+      # all possible_moves of Rook
+      #
+      # @param board [Chess::Board]
+      # @return [Array] possible_moves_arr
+      def possible_moves(board)
+        file = @pos[0]
+        rank = @pos[1]
+        moves = []
+        moves += north_moves(board, file, rank)
+        moves += south_moves(board, file, rank)
+        moves += west_moves(board, file, rank)
+        moves += east_moves(board, file, rank)
+        moves
+      end
+    end
+  end
+end

data/lib/chess/play_game.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# This is a script file handling procedular stuff of this game.
+
+# Starts a Chess Game
+#
+# see {Chess::Display#prompt_start_choices} for start choices.
+#
+# @return [void]
+def start_game
+  game = Chess::Game.new
+
+  choice = game.prompt_start_choices
+  case choice
+  when 1 then load_game_with_code(
+    game,
+    'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
+  ) # new game FEN code
+  when 2 then select_save(game)
+  when 3 then enter_code(game)
+  else start_game end
+end
+
+# choice to resume a saved game.
+#
+# {Chess::Save#read} is used to read the file data
+# @param game [Chess::Game]
+# @return [void]
+def select_save(game)
+  fen_code = game.prompt_select_save(game.read)
+  load_game_with_code(game, fen_code)
+end
+
+# choice to start a game using FEN code
+#
+# {Chess::Display#prompt_enter_code} is used for prompting user.
+# @param game [Chess::Game]
+# @return [void]
+def enter_code(game)
+  fen_code = game.prompt_enter_code
+  load_game_with_code(game, fen_code)
+end
+
+# loads a game with given code
+#
+# @param game [Chess::Game]
+# @param fen_code [String] Fen notation for chess board.
+# @return [void]
+def load_game_with_code(game, fen_code)
+  board = Chess::Board.new(fen_code)
+  system 'clear'
+  game.display_board(board.data)
+  game.display_buttons
+  game.start_mouse_input(board)
+end

data/lib/chess/play_moves/play_king_moves.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # PlayKingMoves
+  module PlayKingMoves
+    # plays the given castling move or normal move for king
+    #
+    # @param piece [Chess::Pieces::King]
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @return [void]
+    def play_king_move(piece, board, move_pos)
+      if castling_move?(piece, board, move_pos)
+        play_castling_move(piece, board, move_pos)
+      else
+        play_normal_move(piece, board, move_pos)
+      end
+    end
+
+    # check if move is a castling_move
+    #
+    # @param (see #play_king_move)
+    def castling_move?(piece, board, move_pos)
+      castling_moves = piece.castling_moves(board)
+      castling_moves.include?(move_pos)
+    end
+
+    # plays the castling move (a special move which moves 2 pieces a king and a rook)
+    #
+    # @param (see #play_king_move)
+    # @return [void]
+    def play_castling_move(piece, board, move_pos)
+      play_normal_move(piece, board, move_pos)
+      play_rook_jump_move(piece, board, move_pos)
+    end
+
+    # plays the move of jumping rook over to the other side of king
+    #
+    # @param piece [Chess::Pieces::King]
+    # @param board [Chess::Board]
+    # @param rook_move_pos [Array]
+    # @return [void]
+    def play_rook_jump_move(piece, board, rook_move_pos) # rubocop:disable Metrics/MethodLength
+      king_file = piece.pos.first
+      king_rank = piece.pos.last
+      if king_file == 'c'
+        rook = board.piece_at('a', king_rank)
+        rook_move_pos = ['d', king_rank]
+        play_normal_move(rook, board, rook_move_pos)
+      elsif king_file == 'g'
+        rook = board.piece_at('h', king_rank)
+        rook_move_pos = ['f', king_rank]
+        play_normal_move(rook, board, rook_move_pos)
+      end
+    end
+  end
+end