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: