pgn2 1.5.0 → 2.0.0

data/lib/pgn/board.rb

@@ -32,6 +32,31 @@ module PGN
     RANK_TO_INDEX = ('1'..'8').each_with_index.to_h
     INDEX_TO_RANK = RANK_TO_INDEX.invert
 
+    # 0x88 knight offsets (a1 + 33 = b3, etc.).
+    KNIGHT_OFFS = [33, 31, -31, -33, 18, 14, -14, -18].freeze
+    KING_OFFS = [-1, 1, -16, 16, -15, 15, -17, 17].freeze
+
+    # Precomputed on-board attack masks: entry `idx` is the frozen Array of
+    # on-board 0x88 target indices reachable from `idx` by that piece. Built
+    # once at load time so the per-call offset + off-board test is replaced by
+    # a direct array iteration.
+    KNIGHT_ATTACKS = Array.new(128) do |idx|
+      next nil if (idx & 0x88) != 0 # rubocop:disable Style/BitwisePredicate
+
+      KNIGHT_OFFS.each_with_object([]) do |off, a|
+        t = idx + off
+        a << t if (t & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+      end.freeze
+    end.freeze
+    KING_ATTACKS = Array.new(128) do |idx|
+      next nil if (idx & 0x88) != 0 # rubocop:disable Style/BitwisePredicate
+
+      KING_OFFS.each_with_object([]) do |off, a|
+        t = idx + off
+        a << t if (t & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+      end.freeze
+    end.freeze
+
     # algebraic to unicode piece lookup
     #
     UNICODE_PIECES = {
@@ -264,6 +289,45 @@ module PGN
       INDEX_TO_FILE[idx & 0x0F] + INDEX_TO_RANK[idx >> 4]
     end
 
+    # Serializes the board to the FEN board-string portion (ranks 8→1,
+    # files a→h, runs of empty squares collapsed to a digit) by walking
+    # the 0x88 `@cells` array directly. This avoids rebuilding the 8x8
+    # `squares` array on every FEN generation.
+    #
+    # @return [String] e.g. "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
+    def fen_board_string
+      rows = []
+      7.downto(0) do |rank|
+        s = String.new
+        run = 0
+        0.upto(7) do |file|
+          piece = @cells[(rank * 16) + file]
+          if piece.nil?
+            run += 1
+          else
+            s << run.to_s if run.positive?
+            run = 0
+            s << piece
+          end
+        end
+        s << run.to_s if run.positive?
+        rows << s
+      end
+      rows.join('/')
+    end
+
+    # Boards are equal when every cell holds the same piece (or is
+    # empty), including off-board padding, which is always nil on both.
+    def eql?(other)
+      other.is_a?(Board) && cells == other.cells
+    end
+
+    alias == eql?
+
+    protected
+
+    attr_reader :cells
+
     private
 
     def file_of(square)

data/lib/pgn/fen.rb

@@ -37,9 +37,13 @@ module PGN
   class FEN
     # The FEN string representing the starting position in chess
     #
-    INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    INITIAL = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'.freeze
 
-    attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove
+    attr_accessor :board, :active, :halfmove, :fullmove
+    # `castling` and `en_passant` have custom writers below (normalize nil/empty
+    # to '-'), so expose readers here and define the writers explicitly to avoid
+    # redefining the accessors generated by attr_accessor (Lint/DuplicateMethods).
+    attr_reader :castling, :en_passant
 
     # @return [PGN::FEN] a {PGN::FEN} object representing the starting
     #   position
@@ -61,22 +65,22 @@ module PGN
     # @param fen_string [String] a string in Forsyth-Edwards Notation
     #
     def initialize(fen_string = nil)
-      if fen_string
-        self.board_string,
-          self.active,
-          self.castling,
-          self.en_passant,
-          self.halfmove,
-          self.fullmove = fen_string.split
-      end
+      return unless fen_string
+
+      self.board_string,
+        self.active,
+        self.castling,
+        self.en_passant,
+        self.halfmove,
+        self.fullmove = fen_string.split
     end
 
     def en_passant=(val)
-      @en_passant = val.nil? ? "-" : val
+      @en_passant = val.nil? ? '-' : val
     end
 
     def castling=(val)
-      @castling = (val.nil? || val.empty?) ? "-" : val
+      @castling = val.nil? || val.empty? ? '-' : val
     end
 
     # @param board_fen [String] the fen representation of the board
@@ -84,10 +88,10 @@ module PGN
     #   fen.board_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
     #
     def board_string=(board_fen)
-      squares = board_fen.gsub(/\d/) {|match| "_" * match.to_i }
-                         .split("/")
-                         .map {|row| row.split('') }
-                         .map {|row| row.map {|e| e == "_" ? nil : e } }
+      squares = board_fen.gsub(/\d/) { |match| '_' * match.to_i }
+                         .split('/')
+                         .map(&:chars)
+                         .map { |row| row.map { |e| e == '_' ? nil : e } }
                          .reverse
                          .transpose
       self.board = PGN::Board.new(squares)
@@ -98,39 +102,24 @@ module PGN
     #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
     #
     def board_string
-      rows = self.board.squares.transpose.reverse
-      rows.map do |row|
-        s = +""
-        run = 0
-        row.each do |e|
-          if e.nil?
-            run += 1
-          else
-            s << run.to_s if run > 0
-            run = 0
-            s << e
-          end
-        end
-        s << run.to_s if run > 0
-        s
-      end.join("/")
+      board.fen_board_string
     end
 
     # @return [PGN::Position] a {PGN::Position} representing the current
     #   position
     #
     def to_position
-      player     = self.active == 'w' ? :white : :black
-      castling   = self.castling.split('') - ['-']
-      en_passant = self.en_passant == '-' ? nil : en_passant
+      player     = active == 'w' ? :white : :black
+      castling   = self.castling.chars - ['-']
+      en_passant = nil if self.en_passant == '-'
 
       PGN::Position.new(
-        self.board,
+        board,
         player,
         castling,
         en_passant,
-        self.halfmove.to_i,
-        self.fullmove.to_i,
+        halfmove.to_i,
+        fullmove.to_i
       )
     end
 
@@ -140,17 +129,17 @@ module PGN
     #
     def to_s
       [
-        self.board_string,
-        self.active,
-        self.castling,
-        self.en_passant,
-        self.halfmove,
-        self.fullmove,
-      ].join(" ")
+        board_string,
+        active,
+        castling,
+        en_passant,
+        halfmove,
+        fullmove
+      ].join(' ')
     end
 
     def inspect
-      self.to_s
+      to_s
     end
   end
 end

data/lib/pgn/game.rb

@@ -30,7 +30,9 @@ module PGN
     end
 
     def clean_text(text)
-      text&.gsub(/{(.*)}/, '\1')&.gsub(/\s+/, ' ')&.strip
+      return unless text
+
+      text.gsub(/{(.*)}/, '\1').gsub(/\s+/, ' ').strip
     end
   end
 
@@ -106,16 +108,25 @@ module PGN
     # @return [Array<PGN::Position>] list of the {PGN::Position}s in the game
     #
     def positions
-      @positions ||= begin
-        position = starting_position
-        arr = [position]
-        moves.each do |move|
-          new_pos = position.move(move.notation)
-          arr << new_pos
-          position = new_pos
-        end
-        arr
+      @positions ||= each_position.to_a
+    end
+
+    # @return [Enumerator, self] with a block: yields each {PGN::Position}
+    #   in order (starting position, then one per move) and returns self.
+    #   Without a block: returns an Enumerator that yields the same.
+    #
+    # The replay loop is shared with {#positions} so eager and lazy paths
+    # produce identical position objects in identical order.
+    def each_position
+      return enum_for(:each_position) unless block_given?
+
+      position = starting_position
+      yield position
+      moves.each do |move|
+        position = position.move(move.notation)
+        yield position
       end
+      self
     end
 
     # @return [Array<String>] list of the fen representations of the positions
@@ -158,9 +169,7 @@ module PGN
       return MoveText.new(entry.include?('0') ? entry.gsub('0', 'O') : entry) if entry.is_a?(String)
 
       notation = entry.notation.include?('0') ? entry.notation.gsub('0', 'O') : entry.notation
-      if notation.equal?(entry.notation) && (entry.comment.nil? || !entry.comment.include?('{'))
-        return entry
-      end
+      return entry if notation.equal?(entry.notation) && (entry.comment.nil? || !entry.comment.include?('{'))
 
       MoveText.new(notation, entry.annotation, entry.comment, entry.variations)
     end

data/lib/pgn/move.rb

@@ -57,8 +57,12 @@ module PGN
   #
 
   class Move
-    attr_accessor :san, :player
-    attr_accessor :piece, :destination, :promotion, :check, :capture, :disambiguation, :castle
+    attr_accessor :san, :player, :destination, :check
+    # piece/promotion/capture/disambiguation/castle have custom writers below
+    # (color normalization, nil-coalescing, etc.), so expose only readers here
+    # to avoid redefining attr_accessor setters (Lint/DuplicateMethods).
+    attr_reader :piece, :promotion, :capture, :disambiguation, :castle
+
     # A regular expression for matching moves in standard algebraic
     # notation
     #
@@ -70,7 +74,7 @@ module PGN
       (?<capture>        x            ){0}
       (?<disambiguation> [a-h]?[1-8]? ){0}
 
-      (?<castle>         O-O(-O)?     ){0}
+      (?<castle>         O-O(?:-O)?    ){0}
 
       (?<normal>
         \g<piece>?
@@ -80,8 +84,8 @@ module PGN
         \g<promotion>?
       ){0}
 
-      \A (\g<castle> | \g<normal>) \g<check>? \z
-    /x.freeze
+      \A (?:\g<castle> | \g<normal>) \g<check>? \z
+    /x
 
     # @param move [String] the move in SAN
     # @param player [Symbol] the player making the move
@@ -115,10 +119,10 @@ module PGN
     end
 
     def promotion=(val)
-      if val
-        val.downcase! if black?
-        @promotion = val.delete('=')
-      end
+      return unless val
+
+      val.downcase! if black?
+      @promotion = val.delete('=')
     end
 
     def capture=(val)
@@ -130,11 +134,11 @@ module PGN
     end
 
     def castle=(val)
-      if val
-        @castle = 'K' if val == 'O-O'
-        @castle = 'Q' if val == 'O-O-O'
-        @castle.downcase! if black?
-      end
+      return unless val
+
+      @castle = 'K' if val == 'O-O'
+      @castle = 'Q' if val == 'O-O-O'
+      @castle.downcase! if black?
     end
 
     # @return [Boolean] whether the move results in check
@@ -164,7 +168,7 @@ module PGN
     # @return [Boolean] whether the piece being moved is a pawn
     #
     def pawn?
-      piece == 'P' || piece == 'p'
+      %w[P p].include?(piece)
     end
   end
 end

data/lib/pgn/move_calculator.rb

@@ -191,7 +191,7 @@ module PGN
 
       possibilities = case move.piece
                       when 'B', 'R', 'Q', 'b', 'r', 'q' then direction_origins
-                      when 'K', 'N', 'k', 'n' then move_origins
+                      when 'K', 'N', 'k', 'n' then leaper_origins
                       when 'P', 'p' then pawn_origins
                       else # don't care move, used in variations
                         return nil
@@ -237,6 +237,18 @@ module PGN
       possibilities
     end
 
+    # Knight/king origins use the precomputed on-board attack masks on
+    # {PGN::Board}, skipping the per-call off-board test.
+    def leaper_origins
+      dest  = dest_idx
+      mask  = move.piece.upcase == 'N' ? Board::KNIGHT_ATTACKS[dest] : Board::KING_ATTACKS[dest]
+      piece = move.piece
+
+      possibilities = []
+      mask.each { |t| possibilities << t if board.at_index(t) == piece }
+      possibilities
+    end
+
     # Computes the possible pawn origins based on the destination square
     # and whether or not the move is a capture.
     #

data/lib/pgn/notation.rb

@@ -133,7 +133,7 @@ module PGN
     # Other squares holding `piece` whose move to `to_idx` is legal.
     def same_type_legals(piece, from_idx, to_idx)
       (0...128).each_with_object([]) do |idx, acc|
-        next if (idx & 0x88) != 0
+        next if idx.anybits?(0x88)
         next if idx == from_idx
         next unless @board.at_index(idx) == piece
 
@@ -230,9 +230,9 @@ module PGN
 
       case piece.upcase
       when 'N'
-        KNIGHT_OFFS.any? { |o| (from_idx + o) == to_idx }
+        Board::KNIGHT_ATTACKS[from_idx].include?(to_idx)
       when 'K'
-        KING_OFFS.any? { |o| (from_idx + o) == to_idx }
+        Board::KING_ATTACKS[from_idx].include?(to_idx)
       when 'B', 'R', 'Q'
         slider_reaches?(piece.upcase, from_idx, to_idx)
       else
@@ -243,7 +243,7 @@ module PGN
     def slider_reaches?(piece_up, from_idx, to_idx)
       slider_dirs(piece_up).any? do |off|
         i = from_idx + off
-        while (i & 0x88).zero?
+        while i.nobits?(0x88)
           return true if i == to_idx
           break if @board.at_index(i)
 
@@ -264,7 +264,7 @@ module PGN
     end
 
     def own?(piece, color)
-      color == 'w' ? piece == piece.upcase : piece == piece.downcase
+      piece == (color == 'w' ? piece.upcase : piece.downcase)
     end
 
     # Slider ray directions for a piece letter ('B'/'R'/'Q').
@@ -281,7 +281,7 @@ module PGN
     def king_idx(board, color)
       king = color == 'w' ? 'K' : 'k'
       (0...128).each do |idx|
-        next if (idx & 0x88) != 0
+        next if idx.anybits?(0x88)
 
         return idx if board.at_index(idx) == king
       end
@@ -301,24 +301,18 @@ module PGN
       pawn = color == 'w' ? 'P' : 'p'
       offs.any? do |off|
         i = target + off
-        (i & 0x88).zero? && board.at_index(i) == pawn
+        i.nobits?(0x88) && board.at_index(i) == pawn
       end
     end
 
     def knight_attacked?(board, target, color)
       knight = color == 'w' ? 'N' : 'n'
-      KNIGHT_OFFS.any? do |off|
-        i = target + off
-        (i & 0x88).zero? && board.at_index(i) == knight
-      end
+      Board::KNIGHT_ATTACKS[target].any? { |i| board.at_index(i) == knight }
     end
 
     def king_attacked?(board, target, color)
       king = color == 'w' ? 'K' : 'k'
-      KING_OFFS.any? do |off|
-        i = target + off
-        (i & 0x88).zero? && board.at_index(i) == king
-      end
+      Board::KING_ATTACKS[target].any? { |i| board.at_index(i) == king }
     end
 
     def slider_attacked?(board, target, color)
@@ -332,10 +326,11 @@ module PGN
     def ray_hit?(board, target, dirs)
       dirs.each do |off|
         i = target + off
-        while (i & 0x88).zero?
+        while i.nobits?(0x88)
           piece = board.at_index(i)
           if piece
             return true if yield(piece)
+
             break
           end
           i += off
@@ -352,7 +347,7 @@ module PGN
       ep_idx = ep_target_idx(position, board)
 
       (0...128).any? do |idx|
-        next if (idx & 0x88) != 0
+        next if idx.anybits?(0x88)
 
         piece = board.at_index(idx)
         piece && own?(piece, color) && move_from?(board, idx, piece, color, ep_idx)
@@ -370,8 +365,8 @@ module PGN
     def move_from?(board, idx, piece, color, ep_idx)
       up = piece.upcase
       case up
-      when 'N' then leaper_moves?(board, idx, piece, color, KNIGHT_OFFS)
-      when 'K' then leaper_moves?(board, idx, piece, color, KING_OFFS)
+      when 'N' then leaper_moves?(board, idx, piece, color, Board::KNIGHT_ATTACKS[idx])
+      when 'K' then leaper_moves?(board, idx, piece, color, Board::KING_ATTACKS[idx])
       when 'B', 'R', 'Q'
         slider_moves?(board, idx, piece, color, slider_dirs(up))
       when 'P'
@@ -381,22 +376,22 @@ module PGN
       end
     end
 
-    def leaper_moves?(board, idx, piece, color, offs)
-      offs.any? do |off|
-        t = idx + off
-        (t & 0x88).zero? && landable?(board, t, color) && safe?(board, idx, t, piece, nil)
+    def leaper_moves?(board, idx, piece, color, targets)
+      targets.any? do |t|
+        landable?(board, t, color) && safe?(board, idx, t, piece, nil)
       end
     end
 
     def slider_moves?(board, idx, piece, color, dirs)
       dirs.any? do |off|
         t = idx + off
-        while (t & 0x88).zero?
+        while t.nobits?(0x88)
           tp = board.at_index(t)
           if tp.nil?
             return true if safe?(board, idx, t, piece, nil)
           else
             return true if !own?(tp, color) && safe?(board, idx, t, piece, nil)
+
             break
           end
           t += off
@@ -416,24 +411,24 @@ module PGN
       promo_rank = color == 'w' ? 7 : 0
 
       t = idx + dir
-      return false unless (t & 0x88).zero? && board.at_index(t).nil?
+      return false unless t.nobits?(0x88) && board.at_index(t).nil?
 
-      promo = (t >> 4 == promo_rank) ? 'Q' : nil
+      promo = t >> 4 == promo_rank ? 'Q' : nil
       return true if safe?(board, idx, t, piece, promo)
 
       t2 = idx + (dir * 2)
       (idx >> 4) == start_rank && board.at_index(t2).nil? && safe?(board, idx, t2, piece, nil)
     end
 
-    def pawn_captures?(board, idx, piece, color, ep_idx) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def pawn_captures?(board, idx, piece, color, ep_idx)
       promo_rank = color == 'w' ? 7 : 0
       caps = color == 'w' ? [15, 17] : [-15, -17]
       caps.any? do |off|
         t = idx + off
-        next false unless (t & 0x88).zero?
+        next false unless t.nobits?(0x88)
 
         tp = board.at_index(t)
-        promo = (t >> 4 == promo_rank) ? 'Q' : nil
+        promo = t >> 4 == promo_rank ? 'Q' : nil
         if tp && !own?(tp, color)
           safe?(board, idx, t, piece, promo)
         elsif tp.nil? && t == ep_idx

data/lib/pgn/position.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PGN
   # {PGN::Position} encapsulates all of the information necessary to
   # completely understand a chess position. It can be turned into a FEN string
@@ -31,12 +33,7 @@ module PGN
     PLAYERS  = %i[white black].freeze
     CASTLING = %w[K Q k q].freeze
 
-    attr_accessor :board
-    attr_accessor :player
-    attr_accessor :castling
-    attr_accessor :en_passant
-    attr_accessor :halfmove
-    attr_accessor :fullmove
+    attr_accessor :board, :player, :castling, :en_passant, :halfmove, :fullmove
 
     # @return [PGN::Position] the starting position of a chess game
     #
@@ -83,17 +80,10 @@ module PGN
 
       restrictions = calculator.castling_restrictions
       new_castling = restrictions.empty? ? castling : castling - restrictions
-      new_halfmove = if calculator.increment_halfmove?
-                       halfmove + 1
-                     else
-                       0
-                     end
-      new_fullmove = if calculator.increment_fullmove?
-                       fullmove + 1
-                     else
-                       fullmove
-                     end
-      no_move = str == '--'
+      new_halfmove = calculator.increment_halfmove? ? halfmove + 1 : 0
+      new_fullmove = calculator.increment_fullmove? ? fullmove + 1 : fullmove
+      no_move      = str == '--'
+
       PGN::Position.new(
         no_move ? board : calculator.result_board,
         next_player,
@@ -110,8 +100,32 @@ module PGN
       player == :white ? :black : :white
     end
 
+    # The perft node count at +depth+ from this position, computed by the
+    # native bitboard engine via a FEN round-trip. Requires the compiled
+    # native extension (the shipped gem); raises NameError if it is absent.
+    #
+    # @param depth [Integer] search depth, >= 0
+    # @return [Integer]
+    #
+    def perft(depth)
+      raise ArgumentError, 'depth must be a non-negative Integer' unless depth.is_a?(Integer) && depth >= 0
+
+      PGN::Bitboard::Engine.new(to_fen.to_s).perft(depth)
+    end
+
+    # All legal moves from this position as sorted UCI strings
+    # (e.g. "e2e4", "e1g1" for castling, "e7e8q" for promotion), computed
+    # by the native bitboard engine via a FEN round-trip. Requires the
+    # compiled native extension; raises NameError if it is absent.
+    #
+    # @return [Array<String>] sorted lexicographically
+    #
+    def legal_moves
+      PGN::Bitboard::Engine.new(to_fen.to_s).legal_moves
+    end
+
     def inspect
-      "\n" + board.inspect
+      "\n#{board.inspect}"
     end
 
     # @return [PGN::FEN] a {PGN::FEN} object representing the current position
@@ -120,11 +134,38 @@ module PGN
       PGN::FEN.from_attributes(
         board: board,
         active: player == :white ? 'w' : 'b',
-        castling: castling.join(''),
+        castling: castling.join,
         en_passant: en_passant,
         halfmove: halfmove.to_s,
         fullmove: fullmove.to_s
       )
     end
+
+    # Positions are equal when their board, side to move, castling rights,
+    # and en-passant square match. Halfmove/fullmove counters are ignored
+    # (matching threefold-repetition semantics).
+    def eql?(other)
+      other.is_a?(PGN::Position) &&
+        player == other.player &&
+        castling == other.castling &&
+        en_passant == other.en_passant &&
+        zobrist == other.zobrist &&
+        board == other.board
+    end
+
+    alias == eql?
+
+    def hash
+      zobrist
+    end
+
+    # The Zobrist hash of the position. Computed lazily on first access and
+    # cached, so the replay hot path (which never asks for the hash) pays
+    # nothing; consumers like threefold-repetition checks pay one full seed.
+    #
+    # @return [Integer]
+    def zobrist
+      @zobrist ||= Zobrist.seed(board, player, castling, en_passant)
+    end
   end
 end