def legals():
mvs = legal.moves()
for mv in mvs:
if board.whiteToMove():
print "%s %s" % (move.num(mv), san.pr(mv, mvs))
else:
print "%s ...%s" % (move.num(mv), san.pr(mv, mvs))
def wtrialpawn(h, sq):
assert board.whiteToMove()
assert h == len(board.history)
assert board.manAt(sq) == man.pawn
global mvs
# pawn may move 2 squares on first move
if rank(sq) == 2 and board.empty(fwd(sq)) and board.empty(fwd(fwd(sq))):
mvs.append((h, "-", sq, fwd(fwd(sq))))
# pawn moves only one square fwd if beyond original position and square is empty
if rank(sq) < 7:
if board.manAt(fwd(sq)) == 0:
mvs.append((h, "-", sq, fwd(sq)))
if man.isBlack(board.manAt(dfr(sq))):
mvs.append((h, "x", sq, dfr(sq), board.manAt(dfr(sq))))
if man.isBlack(board.manAt(dfl(sq))):
mvs.append((h, "x", sq, dfl(sq), board.manAt(dfl(sq))))
# pawn promotes on reaching last rank
if rank(sq) == 7:
if board.manAt(fwd(sq)) == 0:
for pmn in [man.queen, man.rook, man.bishop, man.knight]:
mvs.append((h, "-/", sq, fwd(sq), 0, pmn))
if man.isBlack(board.manAt(dfr(sq))):
for pmn in [man.queen, man.rook, man.bishop, man.knight]:
mvs.append((h, "x/", sq, dfr(sq), board.manAt(dfr(sq)), pmn))
if man.isBlack(board.manAt(dfl(sq))):
for pmn in [man.queen, man.rook, man.bishop, man.knight]:
mvs.append((h, "x/", sq, dfl(sq), board.manAt(dfl(sq)), pmn))
# en passant
if len(board.history) > 0:
mv = board.lastMove()
if tag(mv) == "-" and board.manAt(nsq(mv)) == -man.pawn and rank(
osq(mv)) == 7 and rank(nsq(mv)) == 5:
if nsq(mv) in [rgt(sq), lft(sq)]:
mvs.append((h, "xep", sq, fwd(nsq(mv))))
def moves():
assert manAt(board.whiteKingAt) == king
assert manAt(board.blackKingAt) == -king
legalmoves = []
for mv in trial.trialmoves():
if not (move.tag(mv) in ["OO","OOO"]) and man.isKing(manAt(move.nsq(mv))):
print "legal.19: mv=",mv
board.dump()
move.make(mv)
assert manAt(board.whiteKingAt) == king
assert manAt(board.blackKingAt) == -king
if board.blackToMove():
if move.isOO(mv):
if not blackAttacks(e1) and not blackAttacks(f1) and not blackAttacks(g1):
legalmoves.append(mv)
elif move.isOOO(mv):
if not blackAttacks(e1) and not blackAttacks(d1) and not blackAttacks(c1):
legalmoves.append(mv)
elif not blackAttacks(board.whiteKingAt):
legalmoves.append(mv)
elif board.whiteToMove():
if move.isOO(mv):
if not whiteAttacks(e8) and not whiteAttacks(f8) and not whiteAttacks(g8):
legalmoves.append(mv)
elif move.isOOO(mv):
if not whiteAttacks(e8) and not whiteAttacks(d8) and not whiteAttacks(c8):
legalmoves.append(mv)
elif not whiteAttacks(board.blackKingAt):
legalmoves.append(mv)
move.umake(mv)
assert manAt(board.whiteKingAt) == king
assert manAt(board.blackKingAt) == -king
assert noKingCapture(legalmoves) # you never see a king captured in any legal move
return legalmoves
def best(mvlist):
global t0
if board.whiteToMove():
alpha = -inf
for mv in mvlist:
move.make(mv)
t0 = time.clock()
#score = max(score,itterative_deepening())
#score = itterative_deepening()
score = MDTF(0, depth + 1)
if score > alpha:
bestmv, alpha = mv, score
move.umake(mv)
print score, san.pr(mv, mvlist)
return bestmv, alpha, 0, 0 # the 0,0 are just dummy placeholder values
else:
assert board.blackToMove()
beta = inf
for mv in mvlist:
move.make(mv)
t0 = time.clock()
#score = min(score,itterative_deepening())
#score = itterative_deepening()
score = MDTF(0, depth + 1)
if score < beta:
bestmv, beta = mv, score
move.umake(mv)
print score, san.pr(mv, mvlist)
return bestmv, beta, 0, 0 # the 0,0 are just a dummy placeholder values
def moves():
assert manAt(board.whiteKingAt) == king
assert manAt(board.blackKingAt) == -king
legalmoves = []
for mv in trial.trialmoves():
make(mv)
assert manAt(board.whiteKingAt) == king
assert manAt(board.blackKingAt) == -king
if blackToMove():
if isOO(mv):
if not blackAttacks(e1) and not blackAttacks(f1) and not blackAttacks(g1):
legalmoves.append(mv)
elif isOOO(mv):
if not blackAttacks(e1) and not blackAttacks(d1) and not blackAttacks(c1):
legalmoves.append(mv)
elif not blackAttacks(board.whiteKingAt):
legalmoves.append(mv)
elif whiteToMove():
if isOO(mv):
if not whiteAttacks(e8) and not whiteAttacks(f8) and not whiteAttacks(g8):
legalmoves.append(mv)
elif isOOO(mv):
if not whiteAttacks(e8) and not whiteAttacks(d8) and not whiteAttacks(c8):
legalmoves.append(mv)
elif not whiteAttacks(board.blackKingAt):
legalmoves.append(mv)
umake(mv)
assert manAt(board.whiteKingAt) == king
assert manAt(board.blackKingAt) == -king
assert noKingCapture(legalmoves) # you never see a king captured in any legal move
return legalmoves
def mybest_static(silent=False):
mvlist = legal.moves()
if len(mvlist) > 0:
if board.whiteToMove():
mv, score = best.forWhite(mvlist)
else:
mv, score = best.forBlack(mvlist)
if not silent:
if move.color(mv) == 'white':
msg = "After %s %s [%s]" % (move.num(mv), san.pr(
mv, mvlist), score)
else:
msg = "After %s ...%s [%s]" % (move.num(mv), san.pr(
mv, mvlist), score)
move.make(mv)
if not silent:
print msg
auto()
if verbose:
board.dump()
assert board.valid() # aggressive validation
return True
else:
print "no moves"
return False
def state(legals):
if len(legals)==0:
if blackToMove() and whiteAttacks(board.blackKingAt):
return 'whiteMates'
elif whiteToMove() and blackAttacks(board.whiteKingAt):
return 'blackMates'
else:
return 'stalemate'
else:
return 'continue'
def best(mvlist):
assert len(mvlist) > 0
assert depth1 > 0
if board.whiteToMove():
mvlist.sort(cmp)
b, s, cnt, t01, ln = bestForWhite(mvlist, depth1)
else:
mvlist.sort(cmp)
b, s, cnt, t01, ln = bestForBlack(mvlist, depth1)
return b, s, cnt, t01
def mate(legals):
assert False # do not call
if len(legals)==0:
if board.blackToMove() and attack.whiteAttacks(board.blackKingAt):
return True
elif board.whiteToMove() and attack.blackAttacks(board.whiteKingAt):
return True
else:
return False
else:
return False
def report_result():
assert len(legal.moves()) == 0
if board.whiteToMove():
if blackAttacks(board.whiteKingAt):
put_result("1-0", "black mates")
else:
put_result("1/2-1/2", "stalemate")
else:
assert board.blackToMove()
if whiteAttacks(board.blackKingAt):
put_result("0-1", "white mates")
else:
put_result("1/2-1/2", "stalemate")
def AlphaBetaWithMemory(alpha, beta, d):
if TT.has_key(board.hash):
lowerbound, upperbound = TT[board.hash]
if lowerbound >= beta:
return lowerbound
if upperbound <= alpha:
return upperbound
alpha = max(alpha, lowerbound)
beta = min(beta, upperbound)
if d == 0:
g = static.eval()
elif board.whiteToMove():
g, a = -inf, alpha # save original alpha value
for mv in legal.moves():
if g >= beta:
break
move.make(mv)
g = max(g, AlphaBetaWithMemory(a, beta, d - 1))
move.umake(mv)
a = max(a, g)
else:
assert board.blackToMove()
g, b = +inf, beta #save original beta value
for mv in legal.moves():
if g <= alpha:
break
move.make(mv)
g = min(g, AlphaBetaWithMemory(alpha, b, d - 1))
move.umake(mv)
# transition table storing of bounds
# fail low implies an upper bound
if g <= alpha:
if TT.has_key(board.hash):
lower, upper = TT[board.hash]
else:
lower, upper = -inf, +inf
TT[board.hash] = lower, g
# found an accurate minimax value - will not occur if called with zero window
if g > alpha and g < beta:
TT[board.hash] = g, g
# fail high result implies a lower bound
if g > beta:
if TT.has_key(board.hash):
lower, upper = TT[board.hash]
else:
lower, upper = -inf, +inf
TT[board.hash] = g, upper
return g
def wtrialbishop(h, sq):
assert board.whiteToMove()
assert h == len(board.history)
assert board.manAt(sq) == man.bishop
global mvs
for dir in [dfr, dfl, dbr, dbl]:
s = dir(sq)
done = False
while not s == None and not done:
if board.empty(s):
mvs.append((h, "-", sq, s))
s = dir(s)
elif man.isBlack(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
done = True
elif man.isWhite(board.manAt(s)):
done = True
def wtrialrook(h, sq):
assert board.whiteToMove()
assert h == len(board.history)
assert board.manAt(sq) == man.rook
global mvs
for dir in [fwd, rgt, bak, lft]:
s = dir(sq)
done = False
while not s == None and not done:
if board.empty(s):
mvs.append((h, "-", sq, s))
s = dir(s)
elif man.isBlack(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
done = True
elif man.isWhite(board.manAt(s)):
done = True
def wtrialking(h, sq):
assert board.whiteToMove()
assert h == len(board.history)
assert board.manAt(sq) == man.king
global mvs
for dir in [fwd, dfr, rgt, dbr, bak, dbl, lft, dfl]:
s = dir(sq)
if board.empty(s):
mvs.append((h, "-", sq, s))
elif man.isBlack(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
elif man.isWhite(board.manAt(s)):
pass
if board.whiteAllowOO and board.empty(f1) and board.empty(g1):
mvs.append((h, "OO", e1))
if board.whiteAllowOOO and board.empty(d1) and board.empty(
c1) and board.empty(b1):
mvs.append((h, "OOO", e1))
def wtrialknight(h, sq):
assert board.whiteToMove()
assert h == len(board.history)
assert board.manAt(sq) == man.knight
global mvs
for s in [
dfr(fwd(sq)),
dfr(rgt(sq)),
dbr(rgt(sq)),
dbr(bak(sq)),
dbl(bak(sq)),
dbl(lft(sq)),
dfl(lft(sq)),
dfl(fwd(sq))
]:
if board.empty(s):
mvs.append((h, "-", sq, s))
if man.isBlack(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
def wtrialqueen(h, sq):
assert board.whiteToMove()
assert h == len(board.history)
assert board.manAt(sq) == man.queen
global mvs
for dir in [fwd, rgt, bak, lft, dfr, dfl, dbr, dbl]:
s = dir(sq)
done = False
while not s == None and not done:
if board.empty(s):
mvs.append((h, "-", sq, s))
s = dir(s)
elif man.isBlack(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
done = True
elif man.isWhite(board.manAt(s)):
done = True
else:
print "error in wtrialqueen"
sys.exit(1)
def wtrials(h, sqset):
assert board.whiteToMove()
assert h == len(board.history)
global mvs
mvs = []
for sq in sqset:
assert man.isWhite(board.manAt(sq))
if board.manAt(sq) == man.pawn:
wtrialpawn(h, sq)
elif board.manAt(sq) == man.knight:
wtrialknight(h, sq)
elif board.manAt(sq) == man.bishop:
wtrialbishop(h, sq)
elif board.manAt(sq) == man.rook:
wtrialrook(h, sq)
elif board.manAt(sq) == man.queen:
wtrialqueen(h, sq)
elif board.manAt(sq) == man.king:
wtrialking(h, sq)
else:
print "wtrials: square not occupied"
return mvs
def reply():
global playing
assert playing
mvs = legal.moves()
if len(mvs) > 0:
mv = random.choice(mvs)
s = san.pr(mv, mvs) # use a different notation
put_move(s)
move.make(mv)
else:
assert len(mvs) == 0
playing = False
if board.whiteToMove():
if blackAttacks(board.whiteKingAt):
put_result("1-0", "white checkmated")
else:
put_result("1/2-1/2", "stalemate")
else:
assert board.blackToMove()
if whiteAttacks(board.blackKingAt):
put_result("0-1", "black checkmated")
else:
put_result("1/2-1/2", "stalemate")
if lowerbound >= upperbound:
break
return g,line
def AlphaBetaWithMemory(alpha,beta,d,line)
if TT.has_key(board.hash):
lowerbound,upperbound,cont = TT[board.hash]
if lowerbound >= beta:
return lowerbound,line+cont
if upperbound <= alpha:
return upperbound,line+cont
alpha = max(alpha,lowerbound)
beta = min(beta,upperbound)
if d==0:
g = static.eval()
elif board.whiteToMove():
g,a,nline = -inf,alpha,line # save original alpha value
for mv in legal.moves():
if g >= beta:
break
move.make(mv)
g,nline = max(g,AlphaBetaWithMemory(a,beta,d-1,line+[mv]))
move.umake(mv)
a = max(a,g)
else:
assert board.blackToMove()
g,b,nline = +inf,beta,line #save original beta value
for mv in legal.moves():
if g <= alpha:
break
move.make(mv)
def trialmoves():
if board.whiteToMove():
return wtrials(len(board.history), board.whiteMen)
else:
return btrials(len(board.history), board.blackMen)
def toMove():
if board.whiteToMove():
return 'white'
else:
return 'black'
def prActiveColor():
if board.whiteToMove():
return "w"
else
return "b"
