pgn2 1.5.0 → 2.0.1

data/lib/pgn/pgn_parser.rb

@@ -8,7 +8,7 @@ require 'racc/parser.rb'
 module PGN
   class PgnParser < Racc::Parser
 
-module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 97)
+module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 96)
 
   def parse(input)
     @lexer = PGN::Lexer.new(input)
@@ -71,37 +71,37 @@ racc_action_table = [
     21,    25,    31 ]
 
 racc_action_check = [
-     1,    28,     2,    28,    17,    28,     5,    17,     6,     1,
-    28,     9,     9,     9,    24,     9,    11,    24,    15,    18,
-    20,    23,    29 ]
+     1,    28,     2,    28,    17,    28,     4,    17,     6,     1,
+    28,    10,    10,    10,    24,    10,    11,    24,    15,    18,
+    19,    23,    29 ]
 
 racc_action_pointer = [
-   nil,     0,     2,   nil,   nil,    -3,     0,   nil,   nil,     8,
-   nil,    14,   nil,   nil,   nil,     7,   nil,     1,     9,   nil,
-     9,   nil,   nil,    15,    11,   nil,   nil,   nil,    -2,    16,
+   nil,     0,     2,   nil,    -3,   nil,     0,   nil,   nil,   nil,
+     8,    14,   nil,   nil,   nil,     7,   nil,     1,     9,     9,
+   nil,   nil,   nil,    15,    11,   nil,   nil,   nil,    -2,    16,
    nil,   nil,   nil ]
 
 racc_action_default = [
-    -1,   -25,   -25,    -2,    -8,    -4,   -25,    33,    -3,   -25,
-    -5,   -25,    -7,    -9,   -10,   -11,   -13,   -14,   -25,   -12,
+    -1,   -25,   -25,    -2,    -8,    -4,   -25,    33,    -3,    -5,
+   -25,   -25,    -7,    -9,   -10,   -11,   -13,   -14,   -25,   -12,
    -22,    -8,   -15,   -16,   -17,   -20,    -6,   -23,   -25,   -19,
    -18,   -21,   -24 ]
 
 racc_goto_table = [
-     9,    24,     4,    19,     1,     3,    10,    29,    27,     8,
-    22,   nil,   nil,   nil,   nil,   nil,   nil,    28 ]
+    10,    24,    20,     1,     3,     5,    27,    29,     9,     4,
+     8,    19,    22,   nil,   nil,   nil,   nil,    28 ]
 
 racc_goto_check = [
-     6,    11,     3,     9,     1,     2,     3,    11,     9,     4,
-    10,   nil,   nil,   nil,   nil,   nil,   nil,     6 ]
+     6,    11,    12,     1,     2,     5,    12,    11,     5,     3,
+     4,     9,    10,   nil,   nil,   nil,   nil,     6 ]
 
 racc_goto_pointer = [
-   nil,     4,     4,     1,     5,   nil,    -4,   nil,   nil,   -12,
-    -7,   -16,   nil ]
+   nil,     3,     3,     8,     6,     4,    -4,   nil,   nil,    -4,
+    -5,   -16,   -13 ]
 
 racc_goto_default = [
-   nil,   nil,   nil,   nil,   nil,     5,   nil,    13,    15,   nil,
-   nil,   nil,    20 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    13,    15,   nil,
+   nil,   nil,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
@@ -223,7 +223,7 @@ module_eval(<<'.,.,', 'pgn_parser.y', 15)
   def _reduce_3(val, _values, result)
             result = val[1].pop
         result = {
-          tags:    val[0],
+          tags:    val[0].reverse_each.with_object({}) { |pair, h| h.merge!(pair) },
           result:  result,
           moves:   val[1],
           pgn:     nil,
@@ -236,18 +236,18 @@ module_eval(<<'.,.,', 'pgn_parser.y', 15)
 
 module_eval(<<'.,.,', 'pgn_parser.y', 26)
   def _reduce_4(val, _values, result)
-     result = val[0]
+     result = [val[0]]
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'pgn_parser.y', 29)
   def _reduce_5(val, _values, result)
-            # Right-recursive with section.merge(pair) reproduces the legacy
-        # whittle parser's tag semantics exactly: reverse source insertion
-        # order, and first-occurrence-wins on duplicate keys. This keeps
-        # serialized tag order byte-compatible with the legacy behavior.
-        result = val[1].merge(val[0])
+            # Left-recursive; the source-order array is reduced to the legacy
+        # tag semantics in {pgn_game} (reverse, then merge with
+        # first-occurrence-wins) so the whittle-order compatibility quirk is
+        # a single explicit line instead of implicit in recursion direction.
+        result = val[0] << val[1]
 
     result
   end
@@ -294,7 +294,7 @@ module_eval(<<'.,.,', 'pgn_parser.y', 50)
 module_eval(<<'.,.,', 'pgn_parser.y', 54)
   def _reduce_12(val, _values, result)
             result = val[0]
-        result.variations = val[1]
+        result.variations = val[1].reverse
         result
 
     result
@@ -377,17 +377,16 @@ module_eval(<<'.,.,', 'pgn_parser.y', 82)
 
 module_eval(<<'.,.,', 'pgn_parser.y', 85)
   def _reduce_23(val, _values, result)
-            # Right-recursive prepend reproduces the legacy whittle parser's
-        # variation-order reversal on every parse. This keeps parsed-game
-        # serialization byte-compatible with the legacy behavior; the quirk
-        # can be fixed in a separate change.
-        result = val[1] << val[0]
+            # Left-recursive; the legacy variation-order reversal is applied as
+        # a single explicit `.reverse` where the list is consumed in
+        # {element}, instead of being implicit in recursion direction.
+        result = val[0] << val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 93)
+module_eval(<<'.,.,', 'pgn_parser.y', 92)
   def _reduce_24(val, _values, result)
      result = val[1]
     result

data/lib/pgn/pgn_parser.y

@@ -15,7 +15,7 @@ rule
       {
         result = val[1].pop
         result = {
-          tags:    val[0],
+          tags:    val[0].reverse_each.with_object({}) { |pair, h| h.merge!(pair) },
           result:  result,
           moves:   val[1],
           pgn:     nil,
@@ -24,14 +24,14 @@ rule
       }
 
   tag_section:
-      tag_pair                            { result = val[0] }
-    | tag_pair tag_section
+      tag_pair                            { result = [val[0]] }
+    | tag_section tag_pair
       {
-        # Right-recursive with section.merge(pair) reproduces the legacy
-        # whittle parser's tag semantics exactly: reverse source insertion
-        # order, and first-occurrence-wins on duplicate keys. This keeps
-        # serialized tag order byte-compatible with the legacy behavior.
-        result = val[1].merge(val[0])
+        # Left-recursive; the source-order array is reduced to the legacy
+        # tag semantics in {pgn_game} (reverse, then merge with
+        # first-occurrence-wins) so the whittle-order compatibility quirk is
+        # a single explicit line instead of implicit in recursion direction.
+        result = val[0] << val[1]
       }
 
   tag_pair:
@@ -53,7 +53,7 @@ rule
     | san_move_annotated variation_list
       {
         result = val[0]
-        result.variations = val[1]
+        result.variations = val[1].reverse
         result
       }
     | COMMENT
@@ -81,13 +81,12 @@ rule
 
   variation_list:
       variation                           { result = [val[0]] }
-    | variation variation_list
+    | variation_list variation
       {
-        # Right-recursive prepend reproduces the legacy whittle parser's
-        # variation-order reversal on every parse. This keeps parsed-game
-        # serialization byte-compatible with the legacy behavior; the quirk
-        # can be fixed in a separate change.
-        result = val[1] << val[0]
+        # Left-recursive; the legacy variation-order reversal is applied as
+        # a single explicit `.reverse` where the list is consumed in
+        # {element}, instead of being implicit in recursion direction.
+        result = val[0] << val[1]
       }
 
   variation:

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,153 @@ 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
+
+    # All legal moves from this position as sorted SAN strings, computed
+    # by delegating the native engine's UCI move list through
+    # {PGN::Notation.san}. Requires the compiled native extension; raises
+    # NameError if it is absent.
+    #
+    # @return [Array<String>] sorted lexicographically
+    #
+    def legal_moves_san
+      engine = PGN::Bitboard::Engine.new(to_fen.to_s)
+      engine.legal_moves.map { |uci| uci_to_san(uci) }.sort
+    end
+
+    # Whether +move+ is legal. Accepts SAN ("Nf3", "e4", "O-O", "a8=Q",
+    # "Qxf7#") or UCI ("g1f3", "e2e4", "e1g1", "a7a8q"). Requires the
+    # compiled native extension; raises NameError if it is absent.
+    #
+    # UCI is handed straight to the engine. SAN is resolved against the
+    # engine's legal move list: a SAN string is legal only when it points
+    # at exactly one legal move (so an ambiguous "Nd2" with two knights
+    # is rejected, while "Nbd2"/"Nfd2" are accepted). The engine remains
+    # the single source of truth for legality (king safety, pins, etc.).
+    #
+    # @param move [String] SAN or UCI
+    # @return [Boolean]
+    def legal?(move)
+      engine = PGN::Bitboard::Engine.new(to_fen.to_s)
+      return engine.legal?(move) if uci?(move)
+
+      parsed = PGN::Move.new(move, player)
+      return false if parsed.destination.nil? && parsed.castle.nil?
+
+      candidates = engine.legal_moves.select { |uci| matches_san?(uci, parsed) }
+      candidates.size == 1
+    rescue StandardError
+      false
+    end
+
     def inspect
-      "\n" + board.inspect
+      "\n#{board.inspect}"
+    end
+
+    # The color string for the side to move ('w'/'b').
+    def mover_color
+      player == :white ? 'w' : 'b'
+    end
+
+    # The color string for the opponent of the side to move ('w'/'b').
+    def opponent_color
+      player == :white ? 'b' : 'w'
+    end
+
+    # Whether the side to move's king is currently in check.
+    #
+    # @return [Boolean]
+    def in_check?
+      king = PGN::Attack.king_idx(board, mover_color)
+      !king.nil? && PGN::Attack.attacked?(board, king, opponent_color)
+    end
+
+    # The algebraic squares of every piece of the given color that attacks
+    # +square+ (algebraic, e.g. "e4"). Defaults to the side to move's
+    # opponent, which is useful for check detection.
+    #
+    # @param square [String] e.g. "e4"
+    # @param color [String, nil] 'w' or 'b'; defaults to the opponent color
+    # @return [Array<String>] squares attacking +square+
+    def attackers(square, color = opponent_color)
+      PGN::Attack.attackers(board, board.index_of(square), color)
+    end
+
+    # Whether the side to move has been checkmated (in check and no legal
+    # move). Requires the native extension for legal-move enumeration.
+    #
+    # @return [Boolean]
+    def checkmate?
+      in_check? && legal_moves.empty?
+    end
+
+    # Whether the side to move has been stalemated (not in check and no
+    # legal move). Requires the native extension.
+    #
+    # @return [Boolean]
+    def stalemate?
+      !in_check? && legal_moves.empty?
+    end
+
+    # Whether the position has insufficient material to mate. Covers K vs K,
+    # K + one minor vs K, and same-colored bishops only.
+    #
+    # @return [Boolean]
+    def insufficient_material?
+      non_king = (0...128).each_with_object([]) do |idx, acc|
+        next if idx.anybits?(0x88)
+
+        piece = board.at_index(idx)
+        acc << [piece, idx] if piece && piece.upcase != 'K'
+      end
+      return true if non_king.empty?
+      return true if non_king.size == 1 && %w[B N].include?(non_king.first.first.upcase)
+
+      bishops_same_color?(non_king)
+    end
+
+    # Whether the 50-move rule applies (100 halfmoves since the last pawn
+    # move or capture).
+    #
+    # @return [Boolean]
+    def fifty_move?
+      halfmove >= 100
+    end
+
+    # The terminal status of this position: :checkmate, :stalemate, or :draw
+    # (insufficient material or 50-move rule). nil if the position is still
+    # in progress. Threefold repetition requires game history and is
+    # answered by {PGN::Game#outcome}.
+    #
+    # @return [Symbol, nil]
+    def outcome
+      return :checkmate if checkmate?
+      return :stalemate if stalemate?
+      return :draw if insufficient_material? || fifty_move?
+
+      nil
     end
 
     # @return [PGN::FEN] a {PGN::FEN} object representing the current position
@@ -120,11 +255,108 @@ 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
+
+    private
+
+    # True when +move+ looks like a UCI coordinate string ("e2e4",
+    # "e1g1", "a7a8q"), so it can be handed straight to the engine.
+    def uci?(move)
+      move.is_a?(String) && move.match?(/\A[a-h][1-8][a-h][1-8][qrbn]?\z/)
+    end
+
+    # Convert a UCI string to SAN using the current position, for
+    # {#legal_moves_san}. Promotion (if present) is passed as the letter.
+    def uci_to_san(uci)
+      from = uci[0, 2]
+      to = uci[2, 2]
+      promo = uci[4]
+      PGN::Notation.san(self, from, to, promo)
+    end
+
+    # Map a castling side letter from {PGN::Move#castle} to the king's
+    # from/to UCI squares for the side to move.
+    CASTLE_UCI = {
+      'K' => 'e1g1',
+      'Q' => 'e1c1',
+      'k' => 'e8g8',
+      'q' => 'e8c8'
+    }.freeze
+    private_constant :CASTLE_UCI
+
+    # Does the legal UCI move +uci+ match the parsed SAN +move+? A move
+    # matches when destination, piece, promotion, and castling all agree,
+    # and the origin square satisfies +move+'s disambiguation (if any).
+    def matches_san?(uci, move)
+      return uci == CASTLE_UCI[move.castle] if move.castle
+
+      to = uci[2, 2]
+      return false if move.destination != to
+
+      from_idx = board.index_of(uci[0, 2])
+      return false if board.at_index(from_idx) != move.piece
+
+      promo = uci[4]
+      return false if move.promotion&.downcase != promo
+
+      disambiguation_matches?(move.disambiguation, from_idx)
+    end
+
+    # Whether the disambiguation string from SAN (a file, a rank, or a full
+    # square) describes the origin square at +from_idx+. nil disambiguation
+    # matches any origin (ambiguity is handled by the caller counting matches).
+    def disambiguation_matches?(disambiguation, from_idx)
+      return true if disambiguation.nil? || disambiguation.empty?
+
+      file = Board::INDEX_TO_FILE[from_idx & 0x0F]
+      rank = Board::INDEX_TO_RANK[from_idx >> 4]
+      case disambiguation
+      when /\A[a-h]\z/ then file == disambiguation
+      when /\A[1-8]\z/ then rank == disambiguation
+      else file + rank == disambiguation
+      end
+    end
+
+    # Whether +non_king+ is all bishops on squares of the same color (a known
+    # insufficient-material draw, e.g. KB vs KB with same-colored bishops).
+    def bishops_same_color?(non_king)
+      return false unless non_king.all? { |piece, _| piece.upcase == 'B' }
+      return false if non_king.size > 2
+
+      colors = non_king.map { |_piece, idx| ((idx & 0x0F) + (idx >> 4)) % 2 }
+      colors.uniq.size == 1
+    end
   end
 end

data/lib/pgn/serializer.rb

@@ -17,7 +17,7 @@ module PGN
 
     # @return [String] a canonical PGN string ending with a trailing newline
     def to_s
-      tag_section + "\n\n" + movetext_section + "\n"
+      "#{tag_section}\n\n#{movetext_section}\n"
     end
 
     private
@@ -39,18 +39,16 @@ module PGN
     # result, all joined by spaces.
     def movetext_section
       tokens = []
-      if @game.comment && !@game.comment.empty?
-        tokens << "{ #{escape_comment(@game.comment)} }"
-      end
+      tokens << "{ #{escape_comment(@game.comment)} }" if @game.comment && !@game.comment.empty?
       line = emit_line(@game.moves, starting_fullmove, starting_player)
       tokens << line unless line.empty?
       tokens << result_token
-      tokens.join(" ")
+      tokens.join(' ')
     end
 
     # The result token: the game's result if present and non-empty, else "*".
     def result_token
-      (@game.result.nil? || @game.result.empty?) ? "*" : @game.result
+      @game.result.nil? || @game.result.empty? ? '*' : @game.result
     end
 
     # Emit a single line (mainline or variation) of movetext, tracking the
@@ -63,12 +61,11 @@ module PGN
       moves.each do |move|
         if player == :white
           tokens << "#{fullmove}."
-          tokens << move_token(move, fullmove, player)
         else # black
           need_number = prev_player.nil? || prev_had_extras || prev_player != :white
           tokens << "#{fullmove}..." if need_number
-          tokens << move_token(move, fullmove, player)
         end
+        tokens << move_token(move, fullmove, player)
 
         prev_player = player
         prev_had_extras = has_extras?(move)
@@ -76,7 +73,7 @@ module PGN
         player = opposite(player)
       end
 
-      tokens.join(" ")
+      tokens.join(' ')
     end
 
     # A move token: notation plus trailing extras (annotation, comment,
@@ -85,13 +82,11 @@ module PGN
     def move_token(move, fullmove, player)
       parts = [move.notation]
       (move.annotation || []).each { |a| parts << a }
-      if move.comment && !move.comment.empty?
-        parts << "{ #{escape_comment(move.comment)} }"
-      end
+      parts << "{ #{escape_comment(move.comment)} }" if move.comment && !move.comment.empty?
       (move.variations || []).each do |variation|
         parts << "(#{emit_line(variation, fullmove, player)})"
       end
-      parts.join(" ")
+      parts.join(' ')
     end
 
     # Whether a move carries any annotation, comment, or variation.
@@ -118,8 +113,8 @@ module PGN
     # string replacement would otherwise re-interpret backslashes).
     def escape_tag(value)
       value.to_s
-           .gsub("\\") { "\\\\" }
-           .gsub('"') { "\\\"" }
+           .gsub('\\') { '\\\\' }
+           .gsub('"') { '\"' }
     end
 
     # Escape backslashes and braces for a comment body (block form, so the
@@ -133,9 +128,9 @@ module PGN
     # acknowledged v1 limitation.
     def escape_comment(text)
       text.to_s
-          .gsub("\\") { "\\\\" }
-          .gsub("{") { "\\{" }
-          .gsub("}") { "\\}" }
+          .gsub('\\') { '\\\\' }
+          .gsub('{') { '\\{' }
+          .gsub('}') { '\\}' }
     end
   end
 end

data/lib/pgn/version.rb

@@ -1,3 +1,3 @@
 module PGN
-  VERSION = '1.5.0'.freeze
+  VERSION = '2.0.1'.freeze
 end

data/lib/pgn/zobrist.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PGN
+  # Zobrist hashing keys for incremental position hashing. All keys are
+  # fixed 64-bit pseudo-random Integers generated once at load time from a
+  # frozen seed so hashes are stable for the life of the process.
+  #
+  # Indexing is by 0x88 square index (0..127); off-board indices are
+  # allocated but never read.
+  module Zobrist
+    SEED = 0x1234_5678_9abc_def1
+
+    # Deterministic pseudo-random generator so hashes are stable per
+    # process and across machines (no Kernel#rand).
+    def self.gen
+      @gen ||= Random.new(SEED)
+    end
+    private_class_method :gen
+
+    def self.rand64
+      gen.rand(1 << 64)
+    end
+    private_class_method :rand64
+
+    PIECES = %w[P N B R Q K p n b r q k].freeze
+
+    TABLE = PIECES.to_h { |piece| [piece, Array.new(128) { rand64 }] }.freeze
+
+    SIDE = rand64
+    CASTLING = { 'K' => rand64, 'Q' => rand64, 'k' => rand64, 'q' => rand64 }.freeze
+    EP_FILE = Array.new(8) { rand64 }.freeze
+
+    # @param board [PGN::Board]
+    # @param player [Symbol] :white or :black
+    # @param castling [Array<String>] e.g. %w[K Q k q]
+    # @param en_passant [String, nil] e.g. "e3" or nil
+    # @return [Integer] the Zobrist hash of the position
+    def self.seed(board, player, castling, en_passant)
+      h = 0
+      0.upto(7) do |rank|
+        0.upto(7) do |file|
+          idx = board.index_for(file, rank)
+          piece = board.at_index(idx)
+          h ^= TABLE[piece][idx] if piece
+        end
+      end
+      h ^= SIDE if player == :black
+      castling.to_a.each { |right| h ^= CASTLING[right] if CASTLING.key?(right) }
+      h ^= EP_FILE[Board::FILE_TO_INDEX[en_passant[0]]] if en_passant && !en_passant.empty?
+      h
+    end
+  end
+end

data/lib/pgn.rb

@@ -1,15 +1,20 @@
 require 'pgn/board'
 require 'pgn/fen'
+require 'pgn/epd'
 require 'pgn/game'
+require 'pgn/node'
 require 'pgn/move'
 require 'pgn/move_calculator'
 require 'pgn/lexer'
 require 'pgn/notation'
+require 'pgn/attack'
+require 'pgn/zobrist'
 require 'pgn/pgn_parser'
 require 'pgn/parser'
 require 'pgn/position'
 require 'pgn/serializer'
 require 'pgn/version'
+require 'pgn/bitboard'
 
 module PGN
   # @param pgn [String] a pgn representation of one or more chess games