chess_cli 0.9.2

data/lib/console_game/chess/pieces/king.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "chess_piece"
+
+module ConsoleGame
+  module Chess
+    # King is a sub-class of ChessPiece for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class King < ChessPiece
+      attr_accessor :checked
+      attr_reader :checked_status, :castle_dirs, :castle_config, :castle_key
+
+      # @param alg_pos [Symbol] expects board position in Algebraic notation
+      # @param side [Symbol] specify unit side :black or :white
+      # @param level [Level] Chess::Level object
+      def initialize(alg_pos = :e1, side = :white, level: nil)
+        super(alg_pos, side, :k, level:)
+        @castle_dirs = %i[e w]
+        @checked = false
+        @checked_status = { checked:, attackers: [] }
+      end
+
+      # Override move
+      # Move the chess piece to a new valid location
+      # @param new_alg_pos [Symbol] expects board position in Algebraic notation, e.g., :e3
+      def move(new_alg_pos)
+        old_pos = curr_pos
+        disable_castling
+        super(new_alg_pos)
+
+        castling_event(old_pos)
+      end
+
+      # Override query_moves
+      # Query and update possible_moves
+      def query_moves
+        king_to_the_table
+        setup_castle
+        super
+      end
+
+      # == King specific logics ==
+
+      # Determine if the King is in a checkmate position
+      # @return [Boolean] true if it is a checkmate
+      def checkmate?
+        return false unless in_check?
+
+        level.simulate_next_moves(self)
+        allies = level.fetch_all(side).select { |ally| ally unless ally.is_a?(King) }
+        checked_status[:attackers].each { |attacker| return false if any_saviours?(allies, attacker) }
+        crown_has_fallen?
+      end
+
+      private
+
+      # Add king reference to level
+      def king_to_the_table
+        return unless level.kings[side].nil?
+
+        level.kings[side] = self
+      end
+
+      # Determine if the King can perform castling
+      def setup_castle
+        return unless can_castle?
+
+        @castle_key ||= side == :white ? %i[K Q] : %i[k q]
+        @castle_config ||= castle_key.zip(castle_dirs)
+        castle_config.each do |set|
+          key, dir = set
+          castle_dirs.delete(dir) if level.castling_states[key] == false
+        end
+      end
+
+      # Determine if the King can perform castling
+      # @return [Boolean]
+      def can_castle? = at_start && !checked
+
+      # Process castling event
+      # @param old_pos [Integer] previous position
+      def castling_event(old_pos)
+        distance = curr_pos - old_pos
+        return unless distance.abs == 2
+
+        rook_pos, @last_move = castling_config
+        summon_the_rook(distance.positive? ? "h#{rank}" : "a#{rank}", rook_pos)
+
+        print_castling_msg
+      end
+
+      # Castling config assignment
+      # @return [Array<Integer, String>] returns rook target position and algebraic move
+      def castling_config = file == "g" ? [curr_pos - 1, "O-O"] : [curr_pos + 1, "O-O-O"]
+
+      # Print castling message
+      def print_castling_msg = level.board.print_after_cb("level.castle", { info: })
+
+      # Search the rook
+      # @param rook_to_summon [String] expects algebraic notation
+      # @param rook_pos [Integer] expects grid position of the target rook
+      def summon_the_rook(rook_to_summon, rook_pos) = level.fetch_piece(rook_to_summon, bypass: true).move(rook_pos)
+
+      # disable castling
+      def disable_castling
+        return unless at_start
+
+        castle_key.each { |key| level.castling_states[key] = false }
+      end
+
+      # Override validate_moves
+      # Store all valid placement
+      # @param turn_data [Array] turn data from level object
+      # @param pos [Integer] positional value within a matrix
+      def validate_moves(turn_data, pos = curr_pos)
+        super(turn_data, pos)
+        @possible_moves = possible_moves - level.threats_map[opposite_of(side)]
+      end
+
+      # Override path
+      # Path via Pathfinder
+      # @param pos [Integer] board positional value
+      # @param path [Symbol] compass direction
+      # @param range [Symbol, Integer] movement range of the given piece or :max for furthest possible range
+      # @return [Array<Integer>]
+      def path(pos = 0, path = :e, range: 1)
+        range = 2 if can_castle? && castle_dirs.include?(path)
+        super(pos, path, range: range)
+      end
+
+      # == Checkmate event flow ==
+
+      # Determine if there are any saviour
+      # @param king_allies [Array<ChessPiece>] expects an array of King's army
+      # @param attacker [ChessPiece]
+      # @return [Boolean] true if someone can come save the King
+      def any_saviours?(king_allies, attacker)
+        attack_path = find_attacker_path(attacker)
+        saviours = find_saviours(king_allies, attack_path)
+        limit_saviours_movements(saviours, attack_path)
+        add_saviours(saviours)
+        !saviours.empty?
+      end
+
+      # Helper for any_saviours?, find all saviours
+      # @param king_allies [Array<ChessPiece>] expects an array of King's army
+      # @param attack_path [Array<Integer>]
+      # @return [Array<ChessPiece>]
+      def find_saviours(king_allies, attack_path)
+        king_allies.map { |ally| ally unless (ally.possible_moves & attack_path).empty? }.compact
+      end
+
+      # Helper for any_saviours?, Update and limits saviours path to attacker's path
+      # @param saviours [Array<ChessPiece>] expects an array of King's saviours
+      # @param attack_path [Array<Integer>]
+      def limit_saviours_movements(saviours, attack_path)
+        saviours.each do |ally|
+          ally.query_moves(attack_path)
+          ally.targets.compact.each_value { |pos| level.turn_data[pos].query_moves }
+        end
+      end
+
+      # Helper for any_saviours?, add saviours and King to the usable pieces if King still move
+      # @param saviours [Array<ChessPiece>] expects an array of King's saviours
+      def add_saviours(saviours)
+        saviours.push(self) unless possible_moves.empty?
+        level.usable_pieces[side] = saviours.map(&:info)
+      end
+
+      # Determine if there are no escape route for the King
+      # @return [Boolean] true if King cannot escape
+      def crown_has_fallen? = (possible_moves - level.threats_map[opposite_of(side)]).empty?
+
+      # == Check event flow ==
+
+      # Determine if the King is checked
+      # @return [Boolean] true if the king is checked
+      def in_check?
+        checked_status.transform_values! { |_| [] }
+        self.checked = under_threat?
+        checked_event if checked
+        checked
+      end
+
+      # Process the checked event
+      def checked_event
+        find_checking_pieces
+        sub = { type: checked_status[:attackers].map(&:name).join(", "), king_side: side.capitalize }
+        level.event_msgs << level.board.s("level.check", sub)
+      end
+
+      # Find the pieces that is checking the King
+      def find_checking_pieces
+        level.fetch_all(opposite_of(side)).select do |piece|
+          checked_status[:attackers] << piece if piece.targets.value?(curr_pos)
+        end
+      end
+    end
+  end
+end

data/lib/console_game/chess/pieces/knight.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "chess_piece"
+
+module ConsoleGame
+  module Chess
+    # Knight is a sub-class of ChessPiece for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class Knight < ChessPiece
+      # @param alg_pos [Symbol] expects board position in Algebraic notation
+      # @param side [Symbol] specify unit side :black or :white
+      # @param level [Level] Chess::Level object
+      def initialize(alg_pos = :b1, side = :white, level: nil) = super(alg_pos, side, :n, level:)
+
+      private
+
+      # Override path
+      # Knight Movement via pathfinder
+      # @param pos [Integer] board positional value
+      # @param path [Symbol] compass direction
+      # @param range [Symbol, Integer] movement range of the given piece
+      # @return [Array<Integer>]
+      def path(pos = 0, path = :e, range: 1)
+        dirs_keys = DIRECTIONS.keys
+        offset_dirs = dirs_keys.rotate(1)
+        offset_pos = super(pos, offset_dirs[dirs_keys.index(path)], range: range).last
+        return [] if offset_pos.nil?
+
+        next_pos = super(offset_pos, path, range: range).last
+        return [] if next_pos.nil?
+
+        valid_moves?(pos, next_pos) ? [pos, next_pos] : []
+      end
+
+      # Valid movement for Knight
+      # @param pos1 [Integer] original board positional value
+      # @param pos2 [Integer] new board positional value
+      # @return [Boolean]
+      def valid_moves?(pos1, pos2)
+        r1, c1, r2, c2 = [pos1, pos2].map { |pos| to_coord(pos) }.flatten
+
+        ((r1 - r2).abs == 2 && (c1 - c2).abs == 1) || ((r1 - r2).abs == 1 && (c1 - c2).abs == 2)
+      end
+    end
+  end
+end

data/lib/console_game/chess/pieces/pawn.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "chess_piece"
+
+module ConsoleGame
+  module Chess
+    # Pawn is a sub-class of ChessPiece for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class Pawn < ChessPiece
+      attr_reader :at_end
+
+      # @param alg_pos [Symbol] expects board position in Algebraic notation
+      # @param side [Symbol] specify unit side :black or :white
+      # @param level [Level] Chess::Level object
+      def initialize(alg_pos = :a2, side = :white, level: nil)
+        movements = side == :white ? %i[n ne nw] : %i[s se sw]
+        super(alg_pos, side, :p, movements:, level:)
+        self.at_start = at_rank?(%i[a2 h2], %i[a7 h7])
+        at_end?
+      end
+
+      # Override move
+      # Move the chess piece to a new valid location
+      # @param new_alg_pos [Symbol] expects board position in Algebraic notation, e.g., :e3
+      # @param notation [String]
+      def move(new_alg_pos, notation = nil)
+        old_pos = curr_pos
+        super(new_alg_pos)
+
+        en_passant_reg if (old_pos - curr_pos).abs == 16
+        en_passant_capture unless level.en_passant.nil?
+
+        return unless at_end?
+
+        notation = notation.nil? ? level.promote_opts : notation
+        promote_to(notation.to_sym)
+      end
+
+      private
+
+      # Handle En Passant detection event
+      def en_passant_reg
+        tiles_to_query = fetch_adjacent_tiles
+
+        ghost_pos = side == :white ? curr_pos - 8 : curr_pos + 8
+        level.en_passant = [self, ghost_pos] unless tiles_to_query.empty?
+      end
+
+      # Handle En Passant capture event
+      def en_passant_capture
+        captured_pawn, ghost_pos = level.en_passant
+        return unless curr_pos == ghost_pos
+
+        level.turn_data[captured_pawn.curr_pos] = ""
+        level.en_passant = nil
+      end
+
+      # Helper: Return valid adjacent tiles
+      def fetch_adjacent_tiles
+        tiles_to_query = [curr_pos - 1, curr_pos + 1].map { |pos| level.turn_data.fetch(pos) }
+        tiles_to_query.select { |tile| tile.is_a?(Pawn) && tile.rank == rank && tile.side != side }
+      end
+
+      # Perform pawn promotion
+      # @param notation [Symbol]
+      def promote_to(notation = :q)
+        return unless %i[q r b n].include?(notation)
+
+        class_name = ALG_REF.dig(notation, :class)
+        new_unit = Chess.const_get(class_name).new(curr_pos, side, level:)
+        level.turn_data[curr_pos] = new_unit
+
+        last_move_is_promotion(notation)
+        print_promo_msg(new_unit)
+      end
+
+      # Print Promotion message
+      # @param piece [ChessPiece]
+      def print_promo_msg(piece) = level.board.print_after_cb("level.promo", { new_name: piece.name, info: })
+
+      # Check if the pawn is at the other end of the board
+      def at_end? = @at_end = at_rank?(%i[a8 h8], %i[a1 h1])
+
+      # Parallel query to check if pawn is at a certain rank
+      # @param white_range [Array<Symbol>] `[:a2, :h2]`
+      # @param black_range [Array<Symbol>] `[:a7, :h7]`
+      # @return [Boolean]
+      def at_rank?(white_range = %i[a2 h2], black_range = %i[a7 h7])
+        w_min, w_max, b_min, b_max = [white_range, black_range].flatten.map { |alg| alg_map[alg] }
+        case side
+        when :white then return true if [*w_min..w_max].any?(curr_pos)
+        when :black then return true if [*b_min..b_max].any?(curr_pos)
+        end
+        false
+      end
+
+      # Override store_last_move
+      # Last move formatted as algebraic notation
+      # @param event [Symbol] expects the following key: :move, :capture
+      # @param old_pos [Integer] original position
+      # @return [String]
+      def store_last_move(event = :move, old_pos:) = super.sub("P", "")
+
+      # Add promotion notation to last move
+      # @param notation [Symbol]
+      def last_move_is_promotion(notation) = self.last_move += "=#{notation.upcase}"
+
+      # Override detect_occupied_tiles
+      # Detect blocked tile based on the given positions
+      # @param path [Symbol]
+      # @param turn_data [Array] board data array
+      # @param positions [Array] rank array
+      # @return [Array]
+      def detect_occupied_tiles(path, turn_data, positions)
+        new_positions = super(path, turn_data, positions)
+        tile_data = new_positions.empty? ? nil : turn_data[new_positions.first]
+        if %i[n s].include?(path)
+          new_positions = [] if tile_data.is_a?(ChessPiece)
+          targets[path] = nil
+        elsif tile_data.is_a?(String)
+          sights.push(*new_positions)
+          new_positions = []
+        end
+        new_positions.push(en_passant_add)
+      end
+
+      # Helper: add en passant capture position to possible moves
+      def en_passant_add = level.en_passant.nil? ? nil : level.en_passant[1]
+
+      # Override path
+      # Path via Pathfinder
+      # @param pos [Integer] board positional value
+      # @param path [Symbol] compass direction
+      # @param range [Symbol, Integer] movement range of the given piece or :max for furthest possible range
+      # @return [Array<Integer>]
+      def path(pos = 0, path = :e, range: 1)
+        range = 2 if at_start && %i[n s].include?(path)
+        super(pos, path, range: range)
+      end
+    end
+  end
+end

data/lib/console_game/chess/pieces/queen.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "chess_piece"
+
+module ConsoleGame
+  module Chess
+    # Queen is a sub-class of ChessPiece for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class Queen < ChessPiece
+      # @param alg_pos [Symbol] expects board position in Algebraic notation
+      # @param side [Symbol] specify unit side :black or :white
+      # @param level [Level] Chess::Level object
+      def initialize(alg_pos = :d1, side = :white, level: nil) = super(alg_pos, side, :q, range: :max, level:)
+    end
+  end
+end

data/lib/console_game/chess/pieces/rook.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "chess_piece"
+
+module ConsoleGame
+  module Chess
+    # Rook is a sub-class of ChessPiece for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class Rook < ChessPiece
+      # @param alg_pos [Symbol] expects board position in Algebraic notation
+      # @param side [Symbol] specify unit side :black or :white
+      # @param level [Level] Chess::Level object
+      def initialize(alg_pos = :a1, side = :white, level: nil)
+        super(alg_pos, side, :r, movements: %i[n e s w], range: :max, level:)
+      end
+
+      # Move the chess piece to a new valid location
+      # @param new_alg_pos [Symbol, Integer] expects board position in Algebraic notation, e.g., :e3
+      def move(new_alg_pos)
+        disable_castling
+        super
+      end
+
+      private
+
+      # disable castling
+      def disable_castling
+        return unless at_start
+
+        kingside = file == "h"
+        query = kingside ? :k : :q
+        query = query.upcase if side == :white
+        level.castling_states[query] = false
+      end
+    end
+  end
+end

data/lib/console_game/chess/player/chess_computer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "chess_player"
+
+module ConsoleGame
+  module Chess
+    # Chess computer player class
+    class ChessComputer < ChessPlayer
+      def initialize(name = "", controller = nil, color = nil, m_history: [])
+        super
+      end
+
+      # Process player action
+      # Computer player's move
+      def play_turn
+        selection = level.usable_pieces[side].sample
+
+        assign_piece(selection)
+        target = piece_at_hand.possible_moves.to_a.sample
+
+        move_piece(target)
+      end
+    end
+  end
+end

data/lib/console_game/chess/player/chess_player.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative "../../player"
+require_relative "../utilities/chess_utils"
+
+module ConsoleGame
+  module Chess
+    # ChessPlayer is the Player object for the game Chess and it is a subclass of Player.
+    class ChessPlayer < Player
+      include ChessUtils
+      # @!attribute [w] piece_at_hand
+      #   @return [ChessPiece]
+      attr_accessor :side, :piece_at_hand
+      # @!attribute [r] controller
+      #   @return [ChessInput]
+      attr_reader :level, :board, :controller, :moves_history, :session_id, :cmd_usage_cp
+
+      # @param name [String]
+      # @param controller [ChessInput]
+      # @param color [Symbol] :black or :white
+      # @param m_history [Array<String>]
+      def initialize(name = "", controller = nil, color = nil, m_history: [])
+        super(name, controller)
+        @side = color
+        # @type [ChessPiece, nil]
+        @piece_at_hand = nil
+        @moves_history = m_history
+
+        store_cmd_usage
+      end
+
+      # Override: Initialise player save data
+      def init_data
+        @data = Hash.new do |hash, key|
+          hash[key] =
+            { event: nil, site: nil, date: nil, round: nil, white: nil, black: nil, result: nil, mode: nil, moves: {},
+              white_moves: [], black_moves: [], fens: [] }
+        end
+      end
+
+      # Register session data
+      # @param id [Integer] session id
+      # @param [Hash] metadata fields for PGN style data
+      # @see SessionBuilder #build_session
+      # @return [Hash] session data
+      def register_session(id, **metadata)
+        @session_id = id
+        metadata.each { |k, v| write_metadata(k, v) }
+        data[id]
+      end
+
+      # Store active level
+      # @param active_level [Level]
+      def link_level(active_level)
+        return if level == active_level
+
+        @level = active_level
+        @board = active_level.board
+      end
+
+      # == Game Logic ==
+
+      # Play a turn in chess as a human player, input action is handled by ChessInput
+      # Placeholder method for ChessComputer
+      def play_turn; end
+
+      # Preview a move, display the moves indictor
+      # Prompt player to enter move value when preview mode is used
+      # @param curr_alg_pos [String] algebraic position
+      # @return [Boolean] true if the operation is a success
+      def preview_move(curr_alg_pos)
+        return false unless assign_piece(curr_alg_pos)
+
+        level.event_msgs << board.s("level.preview", move_msg_bundle)
+        board.print_turn(level.event_msgs)
+
+        # Second prompt to complete the turn
+        controller.make_a_move(self)
+        true
+      end
+
+      # Chain with #preview_move, enables player make a move after previewing possible moves
+      # @param new_alg_pos [String] algebraic position
+      # @return [Boolean] true if the operation is a success
+      def move_piece(new_alg_pos)
+        piece_at_hand.move(new_alg_pos)
+        return false unless piece_at_hand.moved
+
+        msg = piece_at_hand.last_move.include?("x") ? "capture" : "move"
+        level.event_msgs << board.s("level.#{msg}", move_msg_bundle.merge(atk_msg_bundle))
+
+        turn_end
+      end
+
+      # Assign a piece and make a move on the same prompt
+      # @param curr_alg_pos [String] algebraic position
+      # @param new_alg_pos [String] algebraic position
+      # @return [Boolean] true if the operation is a success
+      def direct_move(curr_alg_pos, new_alg_pos)
+        assign_piece(curr_alg_pos) && move_piece(new_alg_pos)
+      end
+
+      # Pawn specific: Promote the pawn when it reaches the other end of the board
+      # @param curr_alg_pos [String] algebraic position
+      # @param new_alg_pos [String] algebraic position
+      # @param notation [Symbol] algebraic notation
+      # @return [Boolean] true if the operation is a success
+      def direct_promote(curr_alg_pos, new_alg_pos, notation)
+        return false unless assign_piece(curr_alg_pos) && piece_at_hand.is_a?(Pawn)
+
+        piece_at_hand.move(new_alg_pos, notation)
+        return false unless piece_at_hand.moved
+
+        turn_end
+      end
+
+      # Pawn specific: Present a list of option when player can promote a pawn
+      def indirect_promote
+        piece_at_hand.query_moves
+        level.refresh
+        level.event_msgs << board.s("level.promo_opt")
+        controller.promote_a_pawn
+      end
+
+      # Fetch and move
+      # @param side [Symbol]
+      # @param type [Symbol]
+      # @param target [String]
+      def fetch_and_move(side, type, target, file_rank = nil)
+        piece = level.reverse_lookup(side, type, target, file_rank)
+
+        return board.print_after_cb("level.err.notation") if invalid_assignment?(piece)
+
+        store_active_piece(piece)
+        move_piece(target)
+      end
+
+      # Invalid input
+      def invalid_input(input)
+        return false unless cmd_usage_cp != controller.command_usage.slice(:alg, :smith)
+
+        store_cmd_usage
+        board.print_after_cb("cmd.input.done", { input: })
+        false
+      end
+
+      private
+
+      # Fetch and copy command usage data from input
+      def store_cmd_usage = @cmd_usage_cp = controller.command_usage.slice(:alg, :smith)
+
+      # Move action message bundle for Paint
+      # @return [Hash]
+      def move_msg_bundle = { player: name, name: [piece_at_hand.name, board.type_hl],
+                              info: [piece_at_hand.info, board.alg_pos_hl] }
+
+      # Capture action message bundle for Paint
+      # @return [Hash]
+      def atk_msg_bundle = { side: opposite_of(side).capitalize,
+                             def: [piece_at_hand.captured.last&.name, board.type_hl] }
+
+      # Handling piece assignment
+      # @param alg_pos [String] algebraic notation
+      # @return [ChessPiece]
+      def assign_piece(alg_pos)
+        put_piece_down
+        piece = level.fetch_piece(alg_pos, bypass: false)
+
+        return board.print_after_cb("level.err.notation") if invalid_assignment?(piece)
+
+        store_active_piece(piece)
+      end
+
+      # Assignment validation
+      # @param piece [nil, ChessPiece]
+      # @return [Boolean]
+      def invalid_assignment?(piece) = piece.nil? || level.simulate_next_moves(piece).empty?
+
+      # Unassign active piece
+      def put_piece_down
+        level.active_piece = nil
+        self.piece_at_hand = nil
+      end
+
+      # store active piece
+      # @param piece [ChessPiece]
+      # @param current_level [Level]
+      # @return [ChessPiece]
+      def store_active_piece(piece, current_level = level)
+        self.piece_at_hand = piece
+        current_level.active_piece = piece_at_hand
+        level.update_board_state
+        level.game_end_check
+        piece_at_hand
+      end
+
+      # States that player action has ended
+      # @return [Boolean]
+      def turn_end
+        piece_at_hand.is_a?(Pawn) ? level.half_move = 0 : level.half_move += 1
+        moves_history << piece_at_hand.last_move
+        level.reset_en_passant
+        put_piece_down
+        true
+      end
+
+      # Access player session keys
+      def write_metadata(key, value) = data[session_id][key] = value.is_a?(String) ? Paint.unpaint(value) : value
+    end
+  end
+end