Class: PGN::FEN

Inherits:
Object
  • Object
show all
Defined in:
lib/pgn/fen.rb

Overview

FEN is responsible for translating between strings in FEN notation and an internal representation of the board.

See Also:

Constant Summary collapse

INITIAL =

The FEN string representing the starting position in chess

"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(fen_string = nil) ⇒ FEN

Returns a new instance of FEN.

Parameters:

  • fen_string (String) (defaults to: nil) —

    a string in Forsyth-Edwards Notation



63
64
65
66
67
68
69
70
71
72
 
# File 'lib/pgn/fen.rb', line 63

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
end

Instance Attribute Details

#active ⇒ 'w', 't'

Returns the current player.

Returns:

  • ('w', 't') —

    the current player



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pgn/fen.rb', line 37

class FEN
  # The FEN string representing the starting position in chess
  #
  INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

  attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove

  # @return [PGN::FEN] a {PGN::FEN} object representing the starting
  #   position
  #
  def self.start
    PGN::FEN.new(INITIAL)
  end

  # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
  #
  def self.from_attributes(attrs)
    fen = PGN::FEN.new
    attrs.each do |key, val|
      fen.send("#{key}=", val)
    end
    fen
  end

  # @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
  end

  def en_passant=(val)
    @en_passant = val.nil? ? "-" : val
  end

  def castling=(val)
    @castling = (val.nil? || val.empty?) ? "-" : val
  end

  # @param board_fen [String] the fen representation of the board
  # @example
  #   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 } }
                       .reverse
                       .transpose
    self.board = PGN::Board.new(squares)
  end

  # @return [String] the fen representation of the board
  # @example
  #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
  #
  def board_string
    self.board
        .squares
        .transpose
        .reverse
        .map {|row| row.map {|e| e.nil? ? "_" : e } }
        .map {|row| row.join }
        .join("/")
        .gsub(/_+/) {|match| match.length }
  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

    PGN::Position.new(
      self.board,
      player,
      castling,
      en_passant,
      self.halfmove.to_i,
      self.fullmove.to_i,
    )
  end

  # @return [String] the FEN string
  # @example
  #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  #
  def to_s
    [
      self.board_string,
      self.active,
      self.castling,
      self.en_passant,
      self.halfmove,
      self.fullmove,
    ].join(" ")
  end

  def inspect
    self.to_s
  end
end

#board ⇒ PGN::Board

Returns a Board object for the current board state.

Returns:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pgn/fen.rb', line 37

class FEN
  # The FEN string representing the starting position in chess
  #
  INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

  attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove

  # @return [PGN::FEN] a {PGN::FEN} object representing the starting
  #   position
  #
  def self.start
    PGN::FEN.new(INITIAL)
  end

  # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
  #
  def self.from_attributes(attrs)
    fen = PGN::FEN.new
    attrs.each do |key, val|
      fen.send("#{key}=", val)
    end
    fen
  end

  # @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
  end

  def en_passant=(val)
    @en_passant = val.nil? ? "-" : val
  end

  def castling=(val)
    @castling = (val.nil? || val.empty?) ? "-" : val
  end

  # @param board_fen [String] the fen representation of the board
  # @example
  #   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 } }
                       .reverse
                       .transpose
    self.board = PGN::Board.new(squares)
  end

  # @return [String] the fen representation of the board
  # @example
  #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
  #
  def board_string
    self.board
        .squares
        .transpose
        .reverse
        .map {|row| row.map {|e| e.nil? ? "_" : e } }
        .map {|row| row.join }
        .join("/")
        .gsub(/_+/) {|match| match.length }
  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

    PGN::Position.new(
      self.board,
      player,
      castling,
      en_passant,
      self.halfmove.to_i,
      self.fullmove.to_i,
    )
  end

  # @return [String] the FEN string
  # @example
  #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  #
  def to_s
    [
      self.board_string,
      self.active,
      self.castling,
      self.en_passant,
      self.halfmove,
      self.fullmove,
    ].join(" ")
  end

  def inspect
    self.to_s
  end
end

#castling ⇒ String

Returns the castling availability.

Examples:

"Kq" # white can castle kingside and black queenside
"-"  # no one can castle

Returns:

  • (String) —

    the castling availability



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pgn/fen.rb', line 37

class FEN
  # The FEN string representing the starting position in chess
  #
  INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

  attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove

  # @return [PGN::FEN] a {PGN::FEN} object representing the starting
  #   position
  #
  def self.start
    PGN::FEN.new(INITIAL)
  end

  # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
  #
  def self.from_attributes(attrs)
    fen = PGN::FEN.new
    attrs.each do |key, val|
      fen.send("#{key}=", val)
    end
    fen
  end

  # @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
  end

  def en_passant=(val)
    @en_passant = val.nil? ? "-" : val
  end

  def castling=(val)
    @castling = (val.nil? || val.empty?) ? "-" : val
  end

  # @param board_fen [String] the fen representation of the board
  # @example
  #   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 } }
                       .reverse
                       .transpose
    self.board = PGN::Board.new(squares)
  end

  # @return [String] the fen representation of the board
  # @example
  #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
  #
  def board_string
    self.board
        .squares
        .transpose
        .reverse
        .map {|row| row.map {|e| e.nil? ? "_" : e } }
        .map {|row| row.join }
        .join("/")
        .gsub(/_+/) {|match| match.length }
  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

    PGN::Position.new(
      self.board,
      player,
      castling,
      en_passant,
      self.halfmove.to_i,
      self.fullmove.to_i,
    )
  end

  # @return [String] the FEN string
  # @example
  #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  #
  def to_s
    [
      self.board_string,
      self.active,
      self.castling,
      self.en_passant,
      self.halfmove,
      self.fullmove,
    ].join(" ")
  end

  def inspect
    self.to_s
  end
end

#en_passant ⇒ String

Returns the current en passant square.

Examples:

"e3" # white just moved e2 -> e4
"-"  # no current en passant square

Returns:

  • (String) —

    the current en passant square



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pgn/fen.rb', line 37

class FEN
  # The FEN string representing the starting position in chess
  #
  INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

  attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove

  # @return [PGN::FEN] a {PGN::FEN} object representing the starting
  #   position
  #
  def self.start
    PGN::FEN.new(INITIAL)
  end

  # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
  #
  def self.from_attributes(attrs)
    fen = PGN::FEN.new
    attrs.each do |key, val|
      fen.send("#{key}=", val)
    end
    fen
  end

  # @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
  end

  def en_passant=(val)
    @en_passant = val.nil? ? "-" : val
  end

  def castling=(val)
    @castling = (val.nil? || val.empty?) ? "-" : val
  end

  # @param board_fen [String] the fen representation of the board
  # @example
  #   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 } }
                       .reverse
                       .transpose
    self.board = PGN::Board.new(squares)
  end

  # @return [String] the fen representation of the board
  # @example
  #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
  #
  def board_string
    self.board
        .squares
        .transpose
        .reverse
        .map {|row| row.map {|e| e.nil? ? "_" : e } }
        .map {|row| row.join }
        .join("/")
        .gsub(/_+/) {|match| match.length }
  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

    PGN::Position.new(
      self.board,
      player,
      castling,
      en_passant,
      self.halfmove.to_i,
      self.fullmove.to_i,
    )
  end

  # @return [String] the FEN string
  # @example
  #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  #
  def to_s
    [
      self.board_string,
      self.active,
      self.castling,
      self.en_passant,
      self.halfmove,
      self.fullmove,
    ].join(" ")
  end

  def inspect
    self.to_s
  end
end

#fullmove ⇒ String

Note:

The number of full moves. This is incremented after black plays.

Returns the fullmove counter.

Returns:

  • (String) —

    the fullmove counter



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pgn/fen.rb', line 37

class FEN
  # The FEN string representing the starting position in chess
  #
  INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

  attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove

  # @return [PGN::FEN] a {PGN::FEN} object representing the starting
  #   position
  #
  def self.start
    PGN::FEN.new(INITIAL)
  end

  # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
  #
  def self.from_attributes(attrs)
    fen = PGN::FEN.new
    attrs.each do |key, val|
      fen.send("#{key}=", val)
    end
    fen
  end

  # @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
  end

  def en_passant=(val)
    @en_passant = val.nil? ? "-" : val
  end

  def castling=(val)
    @castling = (val.nil? || val.empty?) ? "-" : val
  end

  # @param board_fen [String] the fen representation of the board
  # @example
  #   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 } }
                       .reverse
                       .transpose
    self.board = PGN::Board.new(squares)
  end

  # @return [String] the fen representation of the board
  # @example
  #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
  #
  def board_string
    self.board
        .squares
        .transpose
        .reverse
        .map {|row| row.map {|e| e.nil? ? "_" : e } }
        .map {|row| row.join }
        .join("/")
        .gsub(/_+/) {|match| match.length }
  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

    PGN::Position.new(
      self.board,
      player,
      castling,
      en_passant,
      self.halfmove.to_i,
      self.fullmove.to_i,
    )
  end

  # @return [String] the FEN string
  # @example
  #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  #
  def to_s
    [
      self.board_string,
      self.active,
      self.castling,
      self.en_passant,
      self.halfmove,
      self.fullmove,
    ].join(" ")
  end

  def inspect
    self.to_s
  end
end

#halfmove ⇒ String

Note:

This is the number of halfmoves since the last pawn advance or capture

Returns the halfmove clock.

Returns:

  • (String) —

    the halfmove clock



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/pgn/fen.rb', line 37

class FEN
  # The FEN string representing the starting position in chess
  #
  INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

  attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove

  # @return [PGN::FEN] a {PGN::FEN} object representing the starting
  #   position
  #
  def self.start
    PGN::FEN.new(INITIAL)
  end

  # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
  #
  def self.from_attributes(attrs)
    fen = PGN::FEN.new
    attrs.each do |key, val|
      fen.send("#{key}=", val)
    end
    fen
  end

  # @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
  end

  def en_passant=(val)
    @en_passant = val.nil? ? "-" : val
  end

  def castling=(val)
    @castling = (val.nil? || val.empty?) ? "-" : val
  end

  # @param board_fen [String] the fen representation of the board
  # @example
  #   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 } }
                       .reverse
                       .transpose
    self.board = PGN::Board.new(squares)
  end

  # @return [String] the fen representation of the board
  # @example
  #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
  #
  def board_string
    self.board
        .squares
        .transpose
        .reverse
        .map {|row| row.map {|e| e.nil? ? "_" : e } }
        .map {|row| row.join }
        .join("/")
        .gsub(/_+/) {|match| match.length }
  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

    PGN::Position.new(
      self.board,
      player,
      castling,
      en_passant,
      self.halfmove.to_i,
      self.fullmove.to_i,
    )
  end

  # @return [String] the FEN string
  # @example
  #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
  #
  def to_s
    [
      self.board_string,
      self.active,
      self.castling,
      self.en_passant,
      self.halfmove,
      self.fullmove,
    ].join(" ")
  end

  def inspect
    self.to_s
  end
end

Class Method Details

.from_attributes(attrs) ⇒ PGN::FEN

Returns a PGN::FEN object with the given attributes.

Returns:



53
54
55
56
57
58
59
 
# File 'lib/pgn/fen.rb', line 53

def self.from_attributes(attrs)
  fen = PGN::FEN.new
  attrs.each do |key, val|
    fen.send("#{key}=", val)
  end
  fen
end

.start ⇒ PGN::FEN

Returns a PGN::FEN object representing the starting position.

Returns:



47
48
49
 
# File 'lib/pgn/fen.rb', line 47

def self.start
  PGN::FEN.new(INITIAL)
end

Instance Method Details

#board_string ⇒ String

Returns the fen representation of the board.

Examples:

PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"

Returns:

  • (String) —

    the fen representation of the board



100
101
102
103
104
105
106
107
108
109
 
# File 'lib/pgn/fen.rb', line 100

def board_string
  self.board
      .squares
      .transpose
      .reverse
      .map {|row| row.map {|e| e.nil? ? "_" : e } }
      .map {|row| row.join }
      .join("/")
      .gsub(/_+/) {|match| match.length }
end

#board_string=(board_fen) ⇒ Object

Examples:

fen.board_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"

Parameters:

  • board_fen (String) —

    the fen representation of the board



86
87
88
89
90
91
92
93
94
 
# File 'lib/pgn/fen.rb', line 86

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 } }
                     .reverse
                     .transpose
  self.board = PGN::Board.new(squares)
end

#inspect ⇒ Object 



144
145
146
 
# File 'lib/pgn/fen.rb', line 144

def inspect
  self.to_s
end

#to_position ⇒ PGN::Position

Returns a Position representing the current position.

Returns:



114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/pgn/fen.rb', line 114

def to_position
  player     = self.active == 'w' ? :white : :black
  castling   = self.castling.split('') - ['-']
  en_passant = self.en_passant == '-' ? nil : en_passant

  PGN::Position.new(
    self.board,
    player,
    castling,
    en_passant,
    self.halfmove.to_i,
    self.fullmove.to_i,
  )
end

#to_s ⇒ String

Returns the FEN string.

Examples:

PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

Returns:

  • (String) —

    the FEN string



133
134
135
136
137
138
139
140
141
142
 
# File 'lib/pgn/fen.rb', line 133

def to_s
  [
    self.board_string,
    self.active,
    self.castling,
    self.en_passant,
    self.halfmove,
    self.fullmove,
  ].join(" ")
end