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":