chess_cli 0.9.2

data/lib/console_game/chess/logics/logic.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module ConsoleGame
+  module Chess
+    # Logic module for the game Chess in Console Game
+    # @author Ancient Nimbus
+    # @version 1.3.2
+    module Logic
+      # Default values
+      PRESET = { bound: [8, 8], nil_hash: -> { Hash.new { |h, k| h[k] = nil } } }.freeze
+
+      # A hash of lambda functions for calculating movement in 8 directions on a grid
+      DIRECTIONS = {
+        n: ->(value, step, row) { value + row * step },
+        ne: ->(value, step, row) { value + row * step + step },
+        e: ->(value, step, _row) { value + step },
+        se: ->(value, step, row) { value - row * step + step },
+        s: ->(value, step, row) { value - row * step },
+        sw: ->(value, step, row) { value - row * step - step },
+        w: ->(value, step, _row) { value - step },
+        nw: ->(value, step, row) { value + row * step - step }
+      }.freeze
+
+      private
+
+      # Recursively find the next position depending on direction
+      # @param pos [Integer] start position
+      # @param path [Symbol] see DIRECTIONS for available options. E.g., :e for count from left to right
+      # @param combination [Array<Integer>] default value is an empty array
+      # @param length [Symbol, Integer] :max for maximum range within bound or custom length of the sequence
+      # @param bound [Array<Integer>] grid size `[row, col]`
+      # @return [Array<Integer>] array of numbers
+      def pathfinder(pos = 0, path = :e, combination = nil, length: :max, bound: PRESET[:bound])
+        combination ||= [pos]
+        arr_size = combination.size
+        return combination if arr_size == length
+
+        next_value = DIRECTIONS.fetch(path) do |key|
+          raise ArgumentError, "Invalid path: #{key}"
+        end.call(pos, arr_size, bound[0])
+
+        combination << next_value
+
+        if out_of_bound?(next_value, bound) || not_adjacent?(path, combination)
+          return length == :max ? combination[0..-2] : []
+        end
+
+        pathfinder(pos, path, combination, length:, bound:)
+      end
+
+      # Calculate valid sequence based on positional value
+      # @param movements [Hash] expects a hash with DIRECTION as keys
+      # @param pos [Integer] positional value within a matrix
+      # @param paths [Hash] a hash with `nil` set as default value
+      # @return [Hash<Array<Integer>>] an array of valid directional path within given bound
+      def all_paths(movements, pos, paths: PRESET[:nil_hash].call)
+        movements.each do |path, range|
+          next if range.nil?
+
+          sequence = path(pos, path, range: range)
+          paths[path] = sequence unless sequence.empty?
+        end
+        paths
+      end
+
+      # 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)
+        seq_length = range.is_a?(Integer) ? range + 1 : range
+        path = pathfinder(pos, path, length: seq_length)
+        path.size > 1 ? path : []
+      end
+
+      # Possible movement direction for the given piece
+      # @param directions [Array<Symbol>] possible paths
+      # @param range [Symbol, Integer] movement range of the given piece or :max for furthest possible range
+      # @param movements [Hash] a hash with `nil` set as default value
+      # @return [Hash]
+      def movement_range(directions = [], range: 1, movements: PRESET[:nil_hash].call)
+        DIRECTIONS.each_key { |k| movements[k] }
+        directions.each { |dir| movements[dir] = range }
+        movements
+      end
+
+      # Convert coordinate array to cell position
+      # @param coord [Array<Integer>] `[row, col]`
+      # @param bound [Array<Integer>] `[row, col]`
+      # @return [Integer]
+      def to_pos(coord = [0, 0], bound: PRESET[:bound])
+        row, col = coord
+        grid_width, _grid_height = bound
+        pos_value = (row * grid_width) + col
+
+        raise ArgumentError, "#{coord} is out of bound!" unless pos_value.between?(0, bound.reduce(:*) - 1)
+
+        pos_value
+      end
+
+      # Convert cell position to coordinate array
+      # @param pos [Integer] positional value
+      # @param bound [Array<Integer>] `[row, col]`
+      # @return [Array<Integer>]
+      def to_coord(pos = 0, bound: PRESET[:bound])
+        raise ArgumentError, "#{pos} is out of bound!" unless pos.between?(0, bound.reduce(:*) - 1)
+
+        grid_width, _grid_height = bound
+        pos.divmod(grid_width)
+      end
+
+      # == Pathfinder ==
+
+      # Helper method to check for out of bound cases for top and bottom borders
+      # @param value [Integer]
+      # @param bound [Array<Integer>] grid size `[row, col]`
+      # @return [Boolean]
+      def out_of_bound?(value, bound) = value.negative? || value > bound.reduce(:*) - 1
+
+      # Helper method to check for out of bound cases for left and right borders (Previously: not_one_unit_apart?)
+      # @param path [Symbol] see DIRECTIONS for available options. E.g., :e for count from left to right
+      # @param values_arr [Array<Integer>]
+      # @return [Boolean]
+      def not_adjacent?(path, values_arr)
+        return false unless %i[e w ne nw se sw].include?(path)
+
+        first_col, prev_col, curr_col = [values_arr.first, *values_arr.last(2)].map { |pos| to_coord(pos)[1] }
+
+        wraps_around_edge = ((first_col - curr_col).abs - (values_arr.size - 1)).abs != 0
+        not_adjacent = (prev_col - curr_col).abs != 1
+
+        wraps_around_edge || not_adjacent
+      end
+    end
+  end
+end

data/lib/console_game/chess/logics/moves_simulation.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ConsoleGame
+  module Chess
+    # The Moves Simulation class helps simulate the next possible moves of a chess piece
+    # @author Ancient Nimbus
+    class MovesSimulation
+      # Simulates the next possible moves for a given chess position.
+      # @return [Array<Integer>] good moves
+      def self.simulate_next_moves(...) = new(...).simulate_next_moves
+
+      # @!attribute [r] turn_data
+      #   @return [Array<ChessPiece, String>] complete state of the current turn
+      attr_reader :level, :piece, :turn_data, :i_am_the_king, :king, :smart_moves
+      attr_accessor :good_pos
+
+      # @param level [Level] expects a Chess::Level class object
+      # @param piece [ChessPiece] expects a ChessPiece class objet
+      # @param smart [Boolean] when true, it returns moves that is safe for itself too
+      def initialize(level, piece, smart: false)
+        @level = level
+        @piece = piece
+        @turn_data = level.turn_data
+        @good_pos = []
+        is_king = piece.is_a?(King)
+        @king = is_king ? piece : level.kings[piece.side]
+        @i_am_the_king = is_king
+        @smart_moves = smart
+      end
+
+      # Simulate next move - Find good moves
+      # @return [Set<Integer>] good moves
+      def simulate_next_moves
+        current_pos = piece.curr_pos
+        turn_data[current_pos] = ""
+        piece.possible_moves.each { |new_pos| simulate_move(new_pos) }
+        restore_previous_state(current_pos)
+        good_pos.compact.to_set
+      end
+
+      private
+
+      # Simulation helper: find a good move
+      # @param new_pos [Integer]
+      def simulate_move(new_pos)
+        tile = turn_data[new_pos]
+        turn_data[new_pos] = piece
+        piece.curr_pos = new_pos
+        level.update_board_state
+        good_pos.push(new_pos) if good_move?
+        turn_data[new_pos] = tile
+      end
+
+      # Helper to determine good move
+      def good_move? = !(i_am_the_king ? am_i_in_danger? : hows_the_king?)
+
+      # Determine check conditions based on smart_moves
+      def hows_the_king? = smart_moves ? (am_i_in_danger? && king_in_danger?) : king_in_danger?
+
+      # Check yourself
+      def am_i_in_danger? = piece.under_threat?
+
+      # Check the king
+      def king_in_danger? = king.under_threat?
+
+      # Simulation helper: restore pre simulation state
+      # @param current_pos [Integer]
+      def restore_previous_state(current_pos)
+        piece.curr_pos = current_pos
+        turn_data[current_pos] = piece
+        level.update_board_state
+      end
+    end
+  end
+end

data/lib/console_game/chess/logics/piece_analysis.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ConsoleGame
+  module Chess
+    # The Piece Analysis class calculates the overall state of the chessboard
+    # @author Ancient Nimbus
+    class PieceAnalysis
+      class << self
+        # Analyse the board
+        # @return [Hash] Board analysis data
+        #   @option return [Hash<Symbol, Set<Integer>>] :threats_map Threatened squares by side
+        #   @option return [Hash<Symbol, Array<String>>] :usable_pieces Movable piece positions by side
+        def board_analysis(...) = new(...).board_analysis
+
+        # Returns a hash with :white and :black keys to nil.
+        # @return [Hash<nil>]
+        def bw_nil_hash = { white: nil, black: nil }
+
+        # Returns a Hash with default values as empty arrays, and initial keys :white and :black set to empty arrays.
+        # @return [Hash<Array>]
+        def bw_arr_hash = Hash.new { |h, k| h[k] = [] }.merge({ white: [], black: [] })
+      end
+
+      # @!attribute [r] all_pieces
+      #   @return [Array<ChessPiece>] All the ChessPiece that's currently on the board
+      attr_reader :all_pieces
+
+      # @param all_pieces [Array<ChessPiece>]
+      def initialize(all_pieces)
+        @all_pieces = all_pieces
+      end
+
+      # Analyse the board
+      # usable_pieces: usable pieces of the given turn
+      # threats_map: all blunder tile for each side
+      # @return [Hash] Board analysis data
+      def board_analysis
+        threats_map, usable_pieces = Array.new(2) { PieceAnalysis.bw_arr_hash }
+        pieces_group.each do |side, pieces|
+          threats_map[side] = add_pos_to_blunder_tracker(pieces)
+          usable_pieces[side] = pieces.map { |piece| piece.info unless piece.possible_moves.empty? }.compact
+        end
+        { threats_map:, usable_pieces: }
+      end
+
+      private
+
+      # Split chess pieces into two group
+      # @return [Hash]
+      def pieces_group
+        grouped_pieces = PieceAnalysis.bw_nil_hash
+        grouped_pieces[:white], grouped_pieces[:black] = all_pieces.partition { |piece| piece.side == :white }
+        grouped_pieces
+      end
+
+      # Helper: add blunder tiles to session variable
+      # @param pieces [ChessPiece]
+      # @return [Set<Integer>]
+      def add_pos_to_blunder_tracker(pieces)
+        pawns, back_row = pieces.partition { |piece| piece.is_a?(Pawn) }
+        bad_moves = pawns_threat(pawns) + back_rows_threat(back_row)
+        bad_moves.flatten.sort.to_set
+      end
+
+      # Helper: Add pawn pieces's threat to map
+      # @param pawns [Pawn]
+      # @return [Array<Integer>]
+      def pawns_threat(pawns) = pawns.map { |unit| unit.sights + unit.targets.values.compact }
+
+      # Helper: Add back row pieces's threat to map
+      # @param back_row [King, Queen, Bishop, Knight, Rook]
+      # @return [Array<Integer>]
+      def back_rows_threat(back_row) = back_row.map { |unit| unit.sights + unit.possible_moves.compact }
+    end
+  end
+end

data/lib/console_game/chess/logics/piece_lookup.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../utilities/chess_utils"
+
+module ConsoleGame
+  module Chess
+    # The Piece lookup class handles various piece fetching tasks
+    # @author Ancient Nimbus
+    class PieceLookup
+      include ChessUtils
+      # @!attribute [r] level
+      #   @return [Level] current level
+      # @!attribute [r] turn_data
+      #   @return [Array<ChessPiece, String>] complete state of the current turn
+      # @!attribute [r] player
+      #   @return [ChessPlayer, ChessComputer] player of the current turn
+      attr_reader :level, :turn_data, :player
+
+      # @param level [Level] expects a Chess::Level class object
+      def initialize(level)
+        @level = level
+        @turn_data = level.turn_data
+        @player = level.player
+      end
+
+      # Fetch a single chess piece
+      # @param query [String] algebraic notation `"e4"`
+      # @param bypass [Boolean] for internal use only, use this to bypass user-end validation
+      # @return [ChessPiece]
+      def fetch_piece(query, bypass: true)
+        return nil unless bypass || choices.include?(query)
+
+        turn_data[to_1d_pos(query)]
+      end
+
+      # Fetch a group of pieces notation from turn_data based on algebraic notation
+      # @param query [Array<String>]
+      # @return [Array<Array<ChessPiece>, Array<String>>]
+      def group_fetch(query)
+        pieces = []
+        notations = query.flatten.map do |alg_pos|
+          pieces << (piece = fetch_piece(alg_pos))
+          piece.notation
+        end
+        [pieces, notations]
+      end
+
+      # Grab all pieces, only whites or only blacks
+      # @param side [Symbol] expects :all, :white or :black
+      # @param type [ChessPiece, King, Queen, Rook, Bishop, Knight, Pawn] limit selection
+      # @return [Array<ChessPiece>] a list of chess pieces
+      def fetch_all(side = :all, type: ChessPiece)
+        turn_data.select { |tile| tile.is_a?(type) && (SIDES_SYM.include?(side) ? tile.side == side : true) }
+      end
+
+      # Lookup a piece based on its possible move position
+      # @param side [Symbol] :black or :white
+      # @param type [Symbol] expects a notation
+      # @param target [String] expects a algebraic notation
+      # @param file_rank [String] expects a file rank data
+      # @return [ChessPiece, nil]
+      def reverse_lookup(side, type, target, file_rank = nil)
+        type = Chess.const_get(ALG_REF.dig(type, :class))
+        result = refined_lookup(fetch_all(side, type:), side, to_1d_pos(target), file_rank)
+        result.size > 1 ? nil : result[0]
+      end
+
+      private
+
+      # Helper: Filter pieces by checking whether it is usable at the current term with file info for extra measure
+      # @param filtered_pieces [Array<ChessPiece>]
+      # @param side [Symbol] :black or :white
+      # @param new_pos [Integer] expects a positional value
+      # @param file_rank [String] expects a file rank data
+      # @return [Array<ChessPiece>]
+      def refined_lookup(filtered_pieces, side, new_pos, file_rank)
+        filtered_pieces.select do |piece|
+          next unless usable_pieces[side].include?(piece.info)
+
+          piece.possible_moves.include?(new_pos) && (file_rank.nil? || piece.info.include?(file_rank))
+        end
+      end
+
+      # Helper: fetch latest usable piece
+      # @return [Hash{Symbol => Array<String>}]
+      def usable_pieces = level.usable_pieces
+
+      # Helper: fetch latest player choices
+      # @return [Array<String>]
+      def choices = usable_pieces[player.side]
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "chess_piece"
+
+module ConsoleGame
+  module Chess
+    # Bishop is a sub-class of ChessPiece for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class Bishop < 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 = :c1, side = :white, level: nil)
+        super(alg_pos, side, :b, movements: %i[ne se sw nw], range: :max, level:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "../logics/logic"
+require_relative "../logics/display"
+require_relative "../utilities/fen_import"
+require_relative "../utilities/chess_utils"
+
+module ConsoleGame
+  module Chess
+    # Chess Piece is a parent class for the game Chess in Console Game
+    # @author Ancient Nimbus
+    class ChessPiece
+      include ChessUtils
+      include Logic
+      include Display
+
+      # Points system for chess pieces
+      PTS_VALUES = { k: 100, q: 9, r: 5, b: 5, n: 3, p: 1 }.freeze
+
+      attr_accessor :at_start, :curr_pos, :targets, :sights, :color, :moved, :last_move, :possible_moves
+      attr_reader :level, :notation, :name, :icon, :pts, :movements, :start_pos, :side, :captured,
+                  :std_color, :highlight
+
+      # @param alg_pos [Symbol] expects board position in Algebraic notation
+      # @param side [Symbol] specify unit side :black or :white
+      # @param notation [Symbol] expects a chess notation of a specific piece, e.g., Knight = :n
+      # @param movements [Hash] expects compass direction
+      # @param range [Integer, Symbol] unit movement range
+      # @param level [Chess::Level] chess level object
+      # @param at_start [Boolean] determine if the piece is at its start location
+      def initialize(alg_pos = :e1, side = :white, notation = :k, movements: DIRECTIONS.keys, range: 1, level: nil,
+                     at_start: true)
+        @level = level
+        @side = side
+        @pts = PTS_VALUES[notation]
+        piece_styling(notation)
+        @start_pos = alg_pos.is_a?(Symbol) ? alg_map[alg_pos] : alg_pos
+        @curr_pos = start_pos
+        @at_start = at_start.nil? ? false : at_start # @todo Better logic??
+        movements_trackers(movements, range)
+      end
+
+      # == Public methods ==
+
+      # 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)
+        old_pos = curr_pos
+        new_pos = new_alg_pos.is_a?(Integer) ? new_alg_pos : alg_map[new_alg_pos.to_sym]
+        return self.moved = false unless possible_moves.include?(new_pos)
+
+        process_movement(level.turn_data, old_pos, new_pos)
+        self.moved = true
+      end
+
+      # Query and update possible_moves
+      # @param limiter [Array] limit piece movement when player is checked
+      def query_moves(limiter = [])
+        validate_moves(level.turn_data, curr_pos).map { |pos| alg_map.key(pos) }
+        @possible_moves = possible_moves & limiter unless limiter.empty?
+        threat_response
+      end
+
+      # Returns the algebraic notation of current position
+      # @return [String] full algebraic position
+      def info = to_alg_pos(curr_pos)
+
+      # Returns the file of current position
+      # @return [String] file of the piece
+      def file = info[0]
+
+      # Returns the rank of current position
+      # @return [String] file of the piece
+      def rank = info[1]
+
+      # Determine if a piece is currently under threats
+      # @return [Boolean]
+      def under_threat? = level.threats_map[opposite_of(side)].include?(curr_pos)
+
+      private
+
+      # == Setup ==
+
+      # Initialize piece styling
+      # @param notation [Symbol] expects a chess notation of a specific piece, e.g., Knight = :n
+      def piece_styling(notation)
+        @notation, @name, @icon = PIECES[notation].slice(:notation, :name, :style1).values
+        @std_color, @highlight = THEME[:classic].slice(side, :highlight).values
+        @color = std_color
+      end
+
+      # Initialize piece movements trackers
+      # @param movements [Array]
+      # @param range [Integer, Symbol]
+      def movements_trackers(movements, range)
+        @movements = movement_range(movements, range: range)
+        @targets = movement_range(movements, range: nil)
+        @sights, @captured = Array.new(2) { [] }
+        @moved = false
+      end
+
+      # == Move logic ==
+
+      # Process movement
+      # @param turn_data [Array<ChessPiece, String>]
+      # @param old_pos [Integer]
+      # @param new_pos [Integer]
+      # @return [Integer] new location's positional value
+      def process_movement(turn_data, old_pos, new_pos)
+        self.at_start = false
+        self.curr_pos = new_pos
+        new_tile = turn_data[new_pos]
+
+        turn_data[old_pos] = ""
+        turn_data[new_pos] = self
+        @last_move = store_last_move(:move, old_pos:)
+        return curr_pos if new_tile.is_a?(String)
+
+        captured << new_tile
+        @last_move = store_last_move(:capture, old_pos:)
+        curr_pos
+      end
+
+      # 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:)
+        alg_notation = notation.to_s.upcase
+        move = "#{alg_notation}#{info}"
+        if event == :capture
+          move.insert(1, "x")
+          move.insert(1, to_alg_pos(old_pos, :f))
+        end
+        move
+      end
+
+      # Valid movement
+      # @param pos1 [Integer] original board positional value
+      # @param pos2 [Integer] new board positional value
+      # @return [Boolean]
+      # def valid_moves?(pos1, pos2); end
+
+      # == Threat Query ==
+
+      # Handle events when the opposite active piece can capture self in the upcoming turn
+      # Switch color when under threat
+      def threat_response = self.color = under_threat_by?(level.active_piece) ? highlight : std_color
+
+      # Determine if a piece might get attacked by multiple pieces, similar to #under_threat? but more specific
+      # @param attacker [ChessPiece]
+      # @return [Boolean]
+      def under_threat_by?(attacker)
+        return false unless attacker.is_a?(ChessPiece) && attacker.side != side
+
+        attacker.targets.value?(curr_pos) && attacker.possible_moves.include?(curr_pos)
+      end
+
+      # Returns the path of an attacking chess piece based on the current position of self
+      # @param attacker [ChessPiece]
+      # @return [Array<Integer>]
+      def find_attacker_path(attacker)
+        atk_direction = attacker.targets.key(curr_pos)
+        opt = %i[n s].include?(atk_direction) ? 0 : 1
+        length = (to_coord(attacker.curr_pos)[opt] - to_coord(curr_pos)[opt]).abs
+        pathfinder(attacker.curr_pos, atk_direction, length:)
+      end
+
+      # == Pathfinder related ==
+
+      # Store all valid placement
+      # @param pos [Integer] positional value within a matrix
+      def validate_moves(turn_data, pos = curr_pos)
+        self.sights = []
+        targets.transform_values! { |_| nil }
+        possible_moves = all_paths(movements, pos)
+        possible_moves.each do |path, positions|
+          # remove blocked spot and onwards
+          possible_moves[path] = detect_occupied_tiles(path, turn_data, positions)
+        end
+        @possible_moves = (possible_moves.values.flatten + targets.values).compact.to_set
+      end
+
+      # 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 = positions[1..]
+        positions.each_with_index do |pos, idx|
+          tile = turn_data[pos]
+          next unless tile != self && tile.is_a?(ChessPiece)
+
+          tile.side == side ? sights.push(pos) : targets[path] = pos
+          # p "#{side} #{name} at #{alg_map.key(curr_pos)} is watching over #{sights}"
+          new_positions = positions[1...idx]
+          break
+        end
+        new_positions
+      end
+    end
+  end
+end