def undo():
mv = board.lastMove()
if mv == None:
print "at start of game"
else:
move.umake(mv)
auto()
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 bestForBlack(mvlist, d):
# black tries to minimize
global cnt, ttHits
t0 = time.clock()
cnt = 0
assert len(mvlist) > 0
assert d > 0
beta = inf
#beta = +300
for mv in mvlist:
c0 = cnt
make(mv)
cnt = cnt + 1
if enableTT and BTT.has_key(board.hash):
score, ln = BTT[board.hash]
ttHits = ttHits + 1
else:
score, ln = F2(-inf, beta, d - 1, [mv])
#score,ln=G2x(inf,min_score,d-1,[mv])
BTT[board.hash] = (score, ln)
umake(mv)
if not silent:
print >> blog, "%6s %6s %s" % (score, cnt - c0, prline(ln))
blog.flush()
if score < beta:
best, beta, bestln = mv, score, ln
t1 = time.clock()
return best, beta, cnt, t1 - t0, bestln
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 bestForWhite(mvlist, d):
# white tries to maximize
global cnt, ttHits
t0 = time.clock()
cnt = 0
assert len(mvlist) > 0
assert d > 0
alpha = -inf
#alpha = -300
for mv in mvlist:
c0 = cnt
make(mv)
cnt = cnt + 1
if enableTT and WTT.has_key(board.hash):
score, ln = WTT[board.hash]
ttHits = ttHits + 1
else:
score, ln = G2(alpha, +inf, d - 1, [mv])
WTT[board.hash] = (score, ln)
umake(mv)
if not silent:
print >> wlog, "%6s %6s %s" % (score, cnt - c0, prline(ln))
wlog.flush()
if score > alpha:
best, alpha, bestln = mv, score, ln
t1 = time.clock()
return best, alpha, cnt, t1 - t0, bestln
def bmobility(mvs):
if board.colorToMove() == 'black':
return len(mvs)
else:
move.make((len(board.history), 'null'))
cnt = len(trial.trialmoves())
move.umake(board.lastMove())
return -cnt
def forBlack(mvs):
"random move best for black paired with static score"
assert len(mvs) > 0
min_score = 99999
for mv in mvs:
move.make(mv)
score = static.eval()
if score < min_score:
best, min_score = [mv], score
elif score == min_score:
best.append(mv)
move.umake(mv)
return (random.choice(best), score)
def forWhite(mvs):
"random move best for white paired with static score"
assert len(mvs) > 0
max_score = -99999
for mv in mvs:
move.make(mv)
score = static.eval()
if score > max_score:
best, max_score = [mv], score
elif score == max_score:
best.append(mv)
move.umake(mv)
return (random.choice(best), score)
def cmp0(mv0, mv1):
move.make(mv0)
s0 = static.eval()
move.umake(mv0)
move.make(mv1)
s1 = static.eval()
move.umake(mv1)
if s0 < s1:
return -1
elif s0 == s1:
return 0
else:
return +1
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 prline(mvs):
s = ""
c = 0
for mv in mvs:
legals = legal.moves()
if move.color(mv) == 'white':
s = s + ("%s %s" % (num(mv), san.pr(mv, legals)))
else:
if c == 0:
s = "%s ...%s " % (num(mv), san.pr(mv, legals))
else:
s = s + (" %s " % san.pr(mv, legals))
move.make(mv)
c = c + 1
while c > 0:
move.umake(board.lastMove())
c = c - 1
return s
def G2(alpha, beta, d, ln):
global cnt
# determine the successor positions
mvlist = moves(d)
if len(mvlist) == 0:
return static.eval(), ln
m = beta
#mln = ln #?
for mv in mvlist:
make(mv)
cnt = cnt + 1
mln = ln + [mv]
t, tln = F2(alpha, m, d - 1, mln)
umake(mv)
if t < m:
m, mln = t, tln
if m <= alpha:
break
return m, mln
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)
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]
# move tests
print "------------------ game 1 ---------------------"
game =((0,"-",12,28), (1,"-",52,36),
(2,"-", 6,21), (3,"-",57,42),
(4,"-", 5,33), (5,"-",48,40),
(6,"-",33,24), (7,"-",62,45),
(8,"x",21,36,BP), (9,"x",42,36,WN),
(10,"OO",4))
for i in xrange(0,len(game)):
move.make(game[i])
board.dump()
for i in xrange(len(game)-1,-1,-1):
move.umake(game[i])
board.dump()
print "e4=",rd("e4")
print "d4=",rd("d4")
print "a1=",rd("a1")
print "h8=",rd("h8")
def mov(n,so,t,sn=999,sm=999):
if t=="-":
return (n,"-",rd(so),rd(sn))
elif t=="x":
return (n,"x",rd(so),rd(sn),sm)
elif t=="OO":
return (n,"OO",rd(so))
elif t=="OOO":
