def btrialpawn(h, sq):
assert board.blackToMove()
assert h == len(board.history)
assert board.manAt(sq) == -man.pawn
global mvs
# pawn may move 2 squares on first move
if rank(sq) == 7 and board.empty(bak(sq)) and board.empty(bak(bak(sq))):
mvs.append((h, "-", sq, bak(bak(sq))))
# pawn moves only one square if beyond original position
if rank(sq) > 2:
if board.manAt(bak(sq)) == 0:
mvs.append((h, "-", sq, bak(sq)))
if man.isWhite(board.manAt(dbr(sq))):
mvs.append((h, "x", sq, dbr(sq), board.manAt(dbr(sq))))
if man.isWhite(board.manAt(dbl(sq))):
mvs.append((h, "x", sq, dbl(sq), board.manAt(dbl(sq))))
# pawn promotes on reaching last rank
if rank(sq) == 2:
if board.manAt(bak(sq)) == 0:
for pmn in [-man.queen, -man.rook, -man.bishop, -man.knight]:
mvs.append((h, "-/", sq, bak(sq), 0, pmn))
if man.isWhite(board.manAt(dbr(sq))):
for pmn in [-man.queen, -man.rook, -man.bishop, -man.knight]:
mvs.append((h, "x/", sq, dbr(sq), board.manAt(dbr(sq)), pmn))
if man.isWhite(board.manAt(dbl(sq))):
for pmn in [-man.queen, -man.rook, -man.bishop, -man.knight]:
mvs.append((h, "x/", sq, dbl(sq), board.manAt(dbl(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)) == 2 and rank(nsq(mv)) == 4:
if nsq(mv) in [rgt(sq), lft(sq)]:
mvs.append((h, "xep", sq, bak(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 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 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 btrialrook(h, sq):
assert board.blackToMove()
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.isWhite(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
done = True
elif man.isBlack(board.manAt(s)):
done = True
def btrialbishop(h, sq):
assert board.blackToMove()
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.isWhite(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
done = True
elif man.isBlack(board.manAt(s)):
done = True
def btrialking(h, sq):
assert board.blackToMove()
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.isWhite(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
elif man.isBlack(board.manAt(s)):
pass
if board.blackAllowOO and board.empty(f8) and board.empty(g8):
mvs.append((h, "OO", e8))
if board.blackAllowOOO and board.empty(d8) and board.empty(
c8) and board.empty(b8):
mvs.append((h, "OOO", e8))
def btrialknight(h, sq):
assert board.blackToMove()
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))
elif man.isWhite(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
def btrialqueen(h, sq):
assert board.blackToMove()
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.isWhite(board.manAt(s)):
mvs.append((h, "x", sq, s, board.manAt(s)))
done = True
elif man.isBlack(board.manAt(s)):
done = True
else:
print "error in btrialqueen"
sys.exit(1)
def btrials(h, sqset):
assert board.blackToMove()
assert h == len(board.history)
global mvs
mvs = []
for sq in sqset:
assert man.isBlack(board.manAt(sq))
if board.manAt(sq) == -man.pawn:
btrialpawn(h, sq)
elif board.manAt(sq) == -man.knight:
btrialknight(h, sq)
elif board.manAt(sq) == -man.bishop:
btrialbishop(h, sq)
elif board.manAt(sq) == -man.rook:
btrialrook(h, sq)
elif board.manAt(sq) == -man.queen:
btrialqueen(h, sq)
elif board.manAt(sq) == -man.king:
btrialking(h, sq)
else:
print "btrials: 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")
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)
g,nline = min(g,AlphaBetaWithMemory(alpha,b,d-1,line+[mv]))
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,oline = TT[board.hash][0]
TT[board.hash] = lower,g,nline
# found an accurate minimax value - will not occur if called with zero window
if g>alpha and g<beta:
