def wpenalty():
penalty = 0
for sq in board.whiteMen:
# penalty for knight and bishop on original rank
if firstrank(sq):
if manAt(sq) == man.knight:
penalty = penalty - 66
# get that kings knight out
if sq == g1:
penalty = penalty - 50
elif manAt(sq) == man.bishop:
penalty = penalty - 61
# get that kings bishop out
if sq == f1:
penalty = penalty - 50
# penalty for center pawn on original squares
if sq in [e2, d2, c2]:
if manAt(sq) == man.pawn:
penalty = penalty - 96
# a knight on the rim is dim
if afile(sq) or hfile(sq):
if manAt(sq) == man.knight:
penalty = penalty - 89
# penalty for king in center
if manAt(sq) == man.king:
if centerfile(sq):
penalty = penalty - 77
if not firstrank(sq):
penalty = penalty - 100
return penalty
def bpenalty():
penalty = 0
for sq in board.blackMen:
# penalty for knight and bishop on original rank
if lastrank(sq):
if manAt(sq) == -man.knight:
penalty = penalty + 66
# get that kings knight out
if sq == g8:
penalty = penalty + 50
elif manAt(sq) == -man.bishop:
penalty = penalty + 61
# get that kings bishop out
if sq == f8:
penatly = penalty + 50
# penalty for center pawn on original squares
if sq in [e7, d7, c7]:
if manAt(sq) == -man.pawn:
penalty = penalty + 96
# a knight on the rim is dim
if afile(sq) or hfile(sq):
if manAt(sq) == -man.knight:
penalty = penalty + 89
# penalty for king in center
if manAt(sq) == -man.king:
if centerfile(sq):
penalty = penalty + 77
if not lastrank(sq):
penalty = penalty + 100
return penalty
def prdashPiece(mv, mvs):
assert tag(mv) == "-"
assert isPiece(manAt(osq(mv)))
# simplest form - pln
p = man.pr(manAt(osq(mv)))
ln = square.pr(nsq(mv))
s = "%s%s" % (p, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# disabiguate by file - pfln
f = "abcdefgh"[col(osq(mv))]
s = "%s%s%s" % (p, f, ln)
found = algebraic.find(s, mvs)
if (len(found)) == 1:
return s
# disambiguate by rank - prln
r = "12345678"[row(osq(mv))]
s = "%s%s%s" % (p, r, ln)
found = algebraic.find(s, mvs)
if (len(found)) == 1:
return s
# disambiguate by both -rare but possible - prfln
s = "%s%s%s%s" % (p, r, f, ln)
if (len(found)) == 1:
return s
# there should be no other cases given that move is legal
assert False
def prcapturePiece(mv, mvs):
assert tag(mv) in ["x", "x/", "xep"]
assert isPiece(manAt(osq(mv)))
# simplest form - pxln
p = man.pr(manAt(osq(mv)))
ln = square.pr(nsq(mv))
s = "%sx%s" % (p, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# disambiguate by file - pfxln
f = "abcdefgh"[col(osq(mv))]
s = "%s%sx%s" % (p, f, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# disambiguate by rank - prxln
r = "12345678"[row(osq(mv))]
s = "%s%sx%s" % (p, r, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# disambiguate by both - prfxln
s = "%s%s%sx%s" % (p, r, f, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# if move is legal there should be no other cases
assert False
def mkdashpromote(mv):
assert tag(mv) in ["-/", "x/"]
assert man.isPawn(board.manAt(osq(mv)))
assert board.manAt(nsq(mv)) == cmn(mv)
assert not color(mv) == 'white' or man.whiteQRBN(pmn(mv))
assert not color(mv) == 'black' or man.blackQRBN(pmn(mv))
assert not color(mv) == 'white' or board.manAt(osq(mv)) == man.pawn
assert not color(mv) == 'black' or board.manAt(osq(mv)) == -man.pawn
assert not tag(mv) == "-/" or cmn(mv) == 0
assert not tag(mv) == "x/" or cmn(mv) != 0
assert board.valid()
# update board
zobrist.PlaceMan(osq(mv), 0)
#board.theBoard[osq(mv)] = 0
zobrist.PlaceMan(nsq(mv), pmn(mv))
#board.theBoard[nsq(mv)] = pmn(mv)
# maintain Men
if color(mv) == 'white':
board.whiteMen.remove(osq(mv))
board.whiteMen.add(nsq(mv))
else:
board.blackMen.remove(osq(mv))
board.blackMen.add(nsq(mv))
board.history[hmc(mv)] = mv
assert not tag(mv) == "-" or board.valid()
def mkxep(mv):
assert tag(mv) == "xep"
assert board.manAt(nsq(mv)) == 0
if color(mv) == 'white':
assert board.manAt(osq(mv)) == man.pawn
assert board.manAt(bak(nsq(mv))) == -man.pawn
zobrist.PlaceMan(osq(mv), 0)
#board.theBoard[osq(mv)]=0
zobrist.PlaceMan(nsq(mv), man.pawn)
#board.theBoard[nsq(mv)]=man.pawn
zobrist.PlaceMan(bak(nsq(mv)), 0)
#board.theBoard[bak(nsq(mv))]=0
board.whiteMen.remove(osq(mv))
board.whiteMen.add(nsq(mv))
board.blackMen.remove(bak(nsq(mv)))
else:
assert board.manAt(osq(mv)) == -man.pawn
assert board.manAt(fwd(nsq(mv))) == man.pawn
zobrist.PlaceMan(osq(mv), 0)
#board.theBoard[osq(mv)]=0
zobrist.PlaceMan(nsq(mv), -man.pawn)
#board.theBoard[nsq(mv)]= -man.pawn
zobrist.PlaceMan(fwd(nsq(mv)), 0)
#board.theBoard[fwd(nsq(mv))]=0
board.blackMen.remove(osq(mv))
board.blackMen.add(nsq(mv))
board.whiteMen.remove(fwd(nsq(mv)))
board.history[hmc(mv)] = mv
def bbonus():
bonus = 0
for sq in board.blackMen:
#bonus for rook in center
if manAt(sq) == -man.rook:
if sq in [d8, e8, f8]:
bounus = bonus - 11
# bonus king at castled sq
elif manAt(sq) == -man.king:
if sq == g8:
bonus = bonus - 12
return bonus
def wbonus():
# bonus for rook in center
bonus = 0
for sq in board.whiteMen:
if manAt(sq) == man.rook:
if sq in [d1, e1, f1]:
bounus = bonus + 11
#bonus king at castled sq
elif manAt(sq) == man.king:
if sq == g1:
bonus = bonus + 12
return bonus
def prcapturePawn(mv, mvs):
assert tag(mv) in ["x", "x/", "xep"]
assert isPawn(manAt(osq(mv)))
# simplest form - fxln
f = "abcdefgh"[col(osq(mv))]
ln = square.pr(nsq(mv))
if tag(mv) == "x/":
q = man.pr(pmn(mv))
s = "%sx%s=%s" % (f, ln, q)
else:
s = "%sx%s" % (f, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# disambiguate by both - rfxln
rf = square.pr(osq(mv))
if tag(mv) == "x/":
s = "%sx%s=%s" % (rf, ln, q)
else:
s = "%sx%s" % (rf, ln)
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
# if move is legal there should be no other cases
assert False
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 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 umkcapture(mv):
assert tag(mv) == "x"
assert man.isMan(mn(mv))
assert not color(mv) == 'white' or man.isBlack(mn(mv))
assert not color(mv) == 'black' or man.isWhite(mn(mv))
assert board.valid()
umkdash(mv)
# board.theBoard[nsq(mv)] = cmn(mv) # WHAT ???
# note the theBoard will be invalid at this point
if color(mv) == 'white':
assert man.isBlack(board.manAt(nsq(mv)))
board.blackMen.add(nsq(mv))
else:
assert man.isWhite(board.manAt(nsq(mv)))
board.whiteMen.add(nsq(mv))
# after the above board maintennance it will be valid again
assert board.valid()
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 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 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 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 noKingCapture(mvs):
for mv in mvs:
if move.tag(mv) in ["x","x/"]:
if man.isKing(move.cmn(mv)):
print "error (king capture): ",mv
return False
if man.isKing(manAt(move.nsq(mv))):
print "error (king at nsq): ",mv
return False
return True
def mkdash(mv):
assert tag(mv) in ["-", "x"]
assert not tag(mv) == "-" or man.isEmpty(cmn(mv))
assert not tag(mv) == "x" or man.isMan(cmn(mv))
assert man.isMan(board.manAt(osq(mv)))
assert board.valid()
# maintain allow flags
if color(mv) == 'white':
if osq(mv) == e1 and board.manAt(e1) == man.king:
board.whiteAllowOO = False
board.whiteAllowOOO = False
elif osq(mv) == h1 and board.manAt(h1) == man.rook:
board.whiteAllowOO = False
elif osq(mv) == a1 and board.manAt(a1) == man.rook:
board.whiteAllowOOO = False
else:
if osq(mv) == e8 and board.manAt(e8) == -man.king:
board.blackAllowOO = False
board.blackAllowOOO = False
elif osq(mv) == h8 and board.manAt(h8) == -man.rook:
board.blackAllowOO = False
elif osq(mv) == a8 and board.manAt(a8) == -man.rook:
board.blackAllowOOO = False
# maintain KingAt and Men sets
if color(mv) == 'white':
board.whiteMen.remove(osq(mv))
board.whiteMen.add(nsq(mv))
if board.manAt(osq(mv)) == man.king:
board.whiteKingAt = nsq(mv)
else:
board.blackMen.remove(osq(mv))
board.blackMen.add(nsq(mv))
if board.manAt(osq(mv)) == -man.king:
board.blackKingAt = nsq(mv)
# update board
zobrist.PlaceMan(nsq(mv), board.theBoard[osq(mv)])
zobrist.PlaceMan(osq(mv), 0)
#board.theBoard[nsq(mv)] = board.theBoard[osq(mv)]
#board.theBoard[osq(mv)] = 0
# update history
board.history[hmc(mv)] = mv
assert not tag(mv) == "-" or board.valid()
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 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 prdashPawn(mv, mvs):
assert tag(mv) == "-" or tag(mv) == "-/"
assert isPawn(manAt(osq(mv)))
# simplest form - ln
ln = square.pr(nsq(mv))
if tag(mv) == "-/":
q = man.pr(pmn(mv))
s = "%s=%s" % (ln, q)
else:
s = ln
found = algebraic.find(s, mvs)
if len(found) == 1:
return s
def mkcapture(mv):
assert tag(mv) == "x"
assert not color(mv) == 'white' or man.isBlack(board.manAt(nsq(mv)))
assert not color(mv) == 'black' or man.isWhite(board.manAt(nsq(mv)))
assert board.valid()
assert not man.isKing(board.manAt(nsq(mv)))
mkdash(mv)
if color(mv) == 'white':
board.blackMen.remove(nsq(mv)) # <<--------
# capturing rooks on original squares affects castling
if nsq(mv) == h8:
board.blackAllowOO = False
elif nsq(mv) == a8:
board.blackAllowOOO = False
else:
board.whiteMen.remove(nsq(mv))
# capturing rooks on original squares affects castling
if nsq(mv) == h1:
board.whiteAllowOO = False
elif nsq(mv) == a1:
board.whiteAllowOOO = False
assert board.valid()
def umkdashpromote(mv):
assert tag(mv) in ["-/", "x/"]
assert board.manAt(osq(mv)) == 0
assert board.manAt(nsq(mv)) == pmn(mv)
assert not color(mv) == 'white' or man.whiteQRBN(pmn(mv))
assert not color(mv) == 'black' or man.blackQRBN(pmn(mv))
assert not tag(mv) == "-/" or cmn(mv) == 0
assert not tag(mv) == "x/" or cmn(mv) != 0
assert board.valid()
zobrist.PlaceMan(nsq(mv), cmn(mv))
#board.theBoard[nsq(mv)] = cmn(mv)
if color(mv) == 'white':
zobrist.PlaceMan(osq(mv), man.pawn)
#board.theBoard[osq(mv)] = man.pawn
board.whiteMen.remove(nsq(mv))
board.whiteMen.add(osq(mv))
else:
zobrist.PlaceMan(osq(mv), -man.pawn)
#board.theBoard[osq(mv)] = -man.pawn
board.blackMen.remove(nsq(mv))
board.blackMen.add(osq(mv))
del board.history[hmc(mv)]
assert not tag(mv) == "-" or board.valid()
def whiteKnightAttacks(sq):
for s in [
dfl(fwd(sq)),
dfr(fwd(sq)),
dfr(rgt(sq)),
dbr(rgt(sq)),
dbr(bak(sq)),
dbl(bak(sq)),
dbl(lft(sq)),
dfl(lft(sq))
]:
if board.manAt(s) == man.knight:
return True
return False
def mkxep(mv):
assert tag(mv) == "xep"
assert board.manAt(nsq(mv)) == 0
if color(mv) == 'white':
assert board.manAt(osq(mv)) == man.pawn
assert board.manAt(bak(nsq(mv))) == -man.pawn
board.theBoard[osq(mv)] = 0
board.theBoard[nsq(mv)] = man.pawn
board.theBoard[bak(nsq(mv))] = 0
board.whiteMen.remove(osq(mv))
board.whiteMen.add(nsq(mv))
board.blackMen.remove(bak(nsq(mv)))
else:
assert board.manAt(osq(mv)) == -man.pawn
assert board.manAt(fwd(nsq(mv))) == man.pawn
board.theBoard[osq(mv)] = 0
board.theBoard[nsq(mv)] = -man.pawn
board.theBoard[fwd(nsq(mv))] = 0
board.blackMen.remove(osq(mv))
board.blackMen.add(nsq(mv))
print "mv=", mv
board.whiteMen.remove(fwd(nsq(mv)))
board.history[hmc(mv)] = mv
def prPieceData():
cnt = 0
d = ""
for r in xrange(7,-1,-1):
for f in xrange(0,8):
sq = r*8 + f
m = board.manAt(sq)
if man.isMan(m):
if cnt>0:
d = d + str(cnt)
cnt = 0
d = d+sym[m]
else:
assert man.isEmpty(m)
cnt = cnt+1
if r>0:
d = d + "/"
return d
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 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
av = av + "K"
if board.whiteAllowOOO:
av = av + "Q"
if board.blackAllowOO:
av = av + "k"
if board.blackAllowOOO:
av = av + "q"
if av=="":
av = "-"
def prEpTargetSq():
if len(board.history)=0:
return "-"
mv = board.lastmove()
if move.tag(mv)=="-" and board.manAt(move.nsq(mv))==man.pawn:
if move.color(mv)=='white':
if square.rank(move.osq(mv))==2 and square.rank(move.nsq(mv))==4:
return square.pr(square.fwd(move.osq(mv)))
else:
assert move.color(mv)=='black'
if square.rank(move.osq(mv))==7 and square.rank(move.nsq(mv))==5:
return square.pr(square.bak(move.osq(mv)))
else:
return "-"
def prHalfMoveClock():
#number of half moves since the last pawn advance or capturing move
return "0" # TBD
def prFullMoveNumber():
def whitePawnAttacks(sq):
for d in [dbr, dbl]:
if board.manAt(d(sq)) == man.pawn:
return True
return False
