def blocked_squares(self, source, target):
"""Returns occupied squares between source and target."""
rtn = []
xs = x_of(source)
ys = y_of(source)
xt = x_of(target)
yt = y_of(target)
if xt > xs:
dx = 1
elif xt < xs:
dx = -1
else:
dx = 0
if yt > ys:
dy = 1
elif yt < ys:
dy = -1
else:
dy = 0
max_slide = max(abs(xs - xt), abs(ys - yt))
if max_slide > 1:
for t in range(1, max_slide):
path = to_square(xs + dx * t, ys + dy * t)
if self._pieces[path] != c.EMPTY:
rtn.append(path)
return rtn
def __str__(self):
"""Renders a ASCII diagram showing the board position."""
s = ''
s += ' +-------------------------+\n'
for y in reversed(range(self.size)):
s += str(y + 1) + '| '
for x in range(self.size):
piece = c.PIECES[self._pieces[to_square(x, y)]]
bit = bu.xy_to_bit(x, y)
p = self._probs[bit]
if p < 0.01:
piece = '.'
s += piece + ' '
s += '|\n |'
for x in range(self.size):
bit = bu.xy_to_bit(x, y)
p = self._probs[bit]
if 0.01 < p < 0.99:
prob = str(int(100 * p))
if len(prob) <= 2:
s += ' '
s += prob
if len(prob) < 2:
s += ' '
else:
s += ' '
s += ' |\n'
s += ' +-------------------------+\n '
for x in range(self.size):
s += to_rank(x) + ' '
return s
def _bit_board(self) -> int:
rtn = 0
for x in range(self.size):
for y in range(self.size):
s = to_square(x, y)
if self._pieces[s] != c.EMPTY:
rtn = bu.set_nth_bit(bu.xy_to_bit(x, y), rtn, True)
return rtn
def load_fen(self, fen):
"""Sets up a position from the first component of a FEN string."""
y = self.size
for row in fen.split('/'):
y -= 1
x = 0
for char in row:
if '1' <= char <= '9':
x += int(char)
else:
piece = c.REV_PIECES[char]
square = to_square(x, y)
self._pieces[square] = piece
x += 1
self.board.with_state(self._bit_board())
self._probs = self.board.get_probability_distribution(self.reps)
def _reset_state(self):
"""Resets all the values that represent the state to default values. """
self._pieces = {}
self._sampled = {}
for x in range(self.size):
for y in range(self.size):
s = to_square(x, y)
self._pieces[s] = 0
self.ep_flag = None
self.white_moves = True
self.castling_flags = {
'o-o': True,
'o-o-o': True,
'O-O': True,
'O-O-O': True,
}
def test_fen():
b = ab.AsciiBoard()
b.load_fen('8/8/8/8/2pB2p1/1kP3P1/P3P3/2bb4')
expected_pieces = {
'c4': -c.PAWN,
'd4': c.BISHOP,
'g4': -c.PAWN,
'b3': -c.KING,
'c3': c.PAWN,
'g3': c.PAWN,
'a2': c.PAWN,
'e2': c.PAWN,
'c1': -c.BISHOP,
'd1': -c.BISHOP,
}
for x in range(8):
for y in range(8):
square = m.to_square(x, y)
assert b._pieces[square] == expected_pieces.get(square, c.EMPTY)
def test_fen():
b = ab.AsciiBoard()
b.load_fen("8/8/8/8/2pB2p1/1kP3P1/P3P3/2bb4")
expected_pieces = {
"c4": -c.PAWN,
"d4": c.BISHOP,
"g4": -c.PAWN,
"b3": -c.KING,
"c3": c.PAWN,
"g3": c.PAWN,
"a2": c.PAWN,
"e2": c.PAWN,
"c1": -c.BISHOP,
"d1": -c.BISHOP,
}
for x in range(8):
for y in range(8):
square = m.to_square(x, y)
assert b._pieces[square] == expected_pieces.get(square, c.EMPTY)
def __init__(self,
size: Optional[int] = 8,
reps: Optional[int] = 1000,
board=None):
self._pieces = {}
self._sampled = {}
self.reps = reps
self.board = board or qb.CirqBoard(0)
for x in range(size):
for y in range(size):
s = to_square(x, y)
self._pieces[s] = 0
self.size = size
self.ep_flag = None
self.white_moves = True
self.castling_flags = {
'o-o': True,
'o-o-o': True,
'O-O': True,
'O-O-O': True,
}
def bit_to_square(bit: int) -> str:
"""Transform a bitboard bit number into algebraic square notation."""
return move.to_square(bit % 8, bit // 8)
