def listToMoves (board, movstrs, type=None, testvalidate=False, ignoreErrors=False): # Work on a copy to ensure we don't break things board = board.clone() moves = [] for mstr in movstrs: try: if type == None: move = parseAny (board, mstr) elif type == SAN: move = parseSAN (board, mstr) elif type == AN: move = parseAN (board, mstr) elif type == LAN: move = parseLAN (board, mstr) except ParsingError: if ignoreErrors: break raise if testvalidate: if not validateMove (board, move): if not ignoreErrors: raise ParsingError, (mstr, 'Validation', board.asFen()) break moves.append(move) board.applyMove(move) return moves
def defends(board, fcord, tcord): """ Could fcord attack tcord if the piece on tcord wasn't on the team of fcord? Doesn't test check. """ # Work on a board copy, as we are going to change some stuff board = board.clone() if board.friends[WHITE] & bitPosArray[fcord]: color = WHITE else: color = BLACK opcolor = 1 - color boards = board.boards[color] opboards = board.boards[opcolor] # To see if we now defend the piece, we have to "give" it to the other team piece = board.arBoard[tcord] #backup = boards[piece] #opbackup = opboards[piece] boards[piece] &= notBitPosArray[tcord] opboards[piece] |= bitPosArray[tcord] board.friends[color] &= notBitPosArray[tcord] board.friends[opcolor] |= bitPosArray[tcord] # Can we "attack" the piece now? backupColor = board.color board.setColor(color) from lmove import newMove from validator import validateMove islegal = validateMove(board, newMove(fcord, tcord)) board.setColor(backupColor) # We don't need to set the board back, as we work on a copy #boards[piece] = backup #opboards[piece] = opbackup #board.friends[color] |= bitPosArray[tcord] #board.friends[opcolor] &= notBitPosArray[tcord] return islegal
def defends (board, fcord, tcord): """ Could fcord attack tcord if the piece on tcord wasn't on the team of fcord? Doesn't test check. """ if board.friends[WHITE] & bitPosArray[fcord]: color = WHITE else: color = BLACK opcolor = 1-color boards = board.boards[color] opboards = board.boards[opcolor] board.lock.acquire() try: # To see if we now defend the piece, we have to "give" it to the other team piece = board.arBoard[tcord] backup = boards[piece] opbackup = opboards[piece] boards[piece] &= notBitPosArray[tcord] opboards[piece] |= bitPosArray[tcord] board.friends[color] &= notBitPosArray[tcord] board.friends[opcolor] |= bitPosArray[tcord] # Can we "attack" the piece now? backupColor = board.color board.setColor(color) from lmove import newMove from validator import validateMove islegal = validateMove (board, newMove(fcord, tcord)) board.setColor(backupColor) # Set board back boards[piece] = backup opboards[piece] = opbackup board.friends[color] |= bitPosArray[tcord] board.friends[opcolor] &= notBitPosArray[tcord] finally: board.lock.release() return islegal
def defends (board, fcord, tcord): """ Could fcord attack tcord if the piece on tcord wasn't on the team of fcord? Doesn't test check. """ # Work on a board copy, as we are going to change some stuff board = board.clone() if board.friends[WHITE] & bitPosArray[fcord]: color = WHITE else: color = BLACK opcolor = 1-color boards = board.boards[color] opboards = board.boards[opcolor] # To see if we now defend the piece, we have to "give" it to the other team piece = board.arBoard[tcord] #backup = boards[piece] #opbackup = opboards[piece] boards[piece] &= notBitPosArray[tcord] opboards[piece] |= bitPosArray[tcord] board.friends[color] &= notBitPosArray[tcord] board.friends[opcolor] |= bitPosArray[tcord] # Can we "attack" the piece now? backupColor = board.color board.setColor(color) from lmove import newMove from validator import validateMove islegal = validateMove (board, newMove(fcord, tcord)) board.setColor(backupColor) # We don't need to set the board back, as we work on a copy #boards[piece] = backup #opboards[piece] = opbackup #board.friends[color] |= bitPosArray[tcord] #board.friends[opcolor] &= notBitPosArray[tcord] return islegal
def defencive_moves_tactic(model, ply, phase): # ------------------------------------------------------------------------ # # Test if we threat something, or at least put more pressure on it # # ------------------------------------------------------------------------ # # We set bishop value down to knight value, as it is what most people expect bishopBackup = PIECE_VALUES[BISHOP] PIECE_VALUES[BISHOP] = PIECE_VALUES[KNIGHT] board = model.getBoardAtPly(ply).board oldboard = model.getBoardAtPly(ply - 1).board move = model.getMoveAtPly(ply - 1).move fcord = FCORD(move) tcord = TCORD(move) piece = board.arBoard[tcord] found_threatens = [] found_increases = [] # What do we attack now? board.setColor(1 - board.color) for ncap in genCaptures(board): # getCaptures also generate promotions if FLAG(ncap) in PROMOTIONS: continue # We are only interested in the attacks of the piece we just moved if FCORD(ncap) != TCORD(move): continue # We don't want to move back if TCORD(ncap) == FCORD(move): continue # We don't thread the king. We check him! (in another function) if board.arBoard[TCORD(ncap)] == KING: continue # If we also was able to attack that cord last time, we don't care if validateMove(oldboard, newMove(FCORD(move), TCORD(ncap))): continue # Test if we threats our enemy, at least more than before see0 = staticExchangeEvaluate(oldboard, TCORD(ncap), 1 - oldboard.color) see1 = staticExchangeEvaluate(board, TCORD(ncap), 1 - oldboard.color) if see1 > see0: # If a new winning capture has been created if see1 > 0: # Find the easiest attack attacks = getAttacks(board, TCORD(ncap), board.color) v, cord = min((PIECE_VALUES[board.arBoard[fc]], fc) for fc in iterBits(attacks)) easiestAttack = newMove(cord, TCORD(ncap)) found_threatens.append(toSAN(board, easiestAttack, True)) # Even though we might not yet be strong enough, we might still # have strengthened another friendly attack else: found_increases.append(reprCord[TCORD(ncap)]) board.setColor(1 - board.color) # -------------------------------------------------------------------- # # Test if we defend a one of our pieces # # -------------------------------------------------------------------- # found_defends = [] # Test which pieces were under attack used = [] for ncap in genCaptures(board): # getCaptures also generate promotions if FLAG(ncap) in PROMOTIONS: continue # We don't want to know about the same cord more than once if TCORD(ncap) in used: continue used.append(TCORD(ncap)) # If the attack was poining on the piece we just moved, we ignore it if TCORD(ncap) == FCORD(move) or TCORD(ncap) == TCORD(move): continue # If we were already defending the piece, we don't send a new # message if defends(oldboard, FCORD(move), TCORD(ncap)): continue # If the attack was not strong, we ignore it see = staticExchangeEvaluate(oldboard, ncap) if see < 0: continue v = defends(board, TCORD(move), TCORD(ncap)) # If the defend didn't help, it doesn't matter. Like defending a # bishop, threatened by a pawn, with a queen. # But on the other hand - it might still be a defend... # newsee = staticExchangeEvaluate(board, ncap) # if newsee <= see: continue if v: found_defends.append(reprCord[TCORD(ncap)]) # ------------------------------------------------------------------------ # # Test if we are rescuing an otherwise exposed piece # # ------------------------------------------------------------------------ # # Rescuing is only an option, if our own move wasn't an attack if oldboard.arBoard[tcord] == EMPTY: see0 = staticExchangeEvaluate(oldboard, fcord, oldboard.color) see1 = staticExchangeEvaluate(board, tcord, oldboard.color) if see1 > see0 and see1 > 0: yield _("rescues a %s") % reprPiece[board.arBoard[tcord]].lower() if found_threatens: yield _("threatens to win material by %s") % join(found_threatens) if found_increases: yield _("increases the pressure on %s") % join(found_increases) if found_defends: yield _("defends %s") % join(found_defends) PIECE_VALUES[BISHOP] = bishopBackup
def attack_type (model, phase): # We set bishop value down to knight value, as it is what most people expect bishopBackup = PIECE_VALUES[BISHOP] PIECE_VALUES[BISHOP] = PIECE_VALUES[KNIGHT] board = model.boards[-1].board oldboard = model.boards[-2].board if len(model.moves) > 1: oldmove = model.moves[-2].move oldboard3 = model.boards[-3].board else: oldmove = None move = model.moves[-1].move tcord = TCORD(move) if oldboard.arBoard[tcord] != EMPTY: if oldmove and oldboard3.arBoard[TCORD(oldmove)] != EMPTY and \ TCORD(oldmove) == tcord: yield _("takes back material") else: see = staticExchangeEvaluate(oldboard, move) if see == 0: yield _("exchanges material") elif see > 0: yield _("captures material") elif see < 0: yield _("sacrifies material") # ------------------------------------------------------------------------ # # Test if we threats something, or at least puts more preassure on it # # ------------------------------------------------------------------------ # # What do we attack now? board.setColor(1-board.color) for ncap in genCaptures(board): # getCaptures also generate promotions if FLAG(ncap) in PROMOTIONS: continue # We are only interested in the attacks of the piece we just moved if FCORD(ncap) != TCORD (move): continue # We don't thread the king. We check him! (in another function) if board.arBoard[TCORD(ncap)] == KING: continue # If we also was able to attack that cord last time, we don't care if validateMove(oldboard, newMove(FCORD(move), TCORD(ncap))): continue # We will always attack first with the lowest valued piece. # Where is it? lowest = None cord = None attacks = getAttacks (board, TCORD(ncap), board.color) for fcord in iterBits(attacks): v = PIECE_VALUES[board.arBoard[fcord]] if lowest == None or v < lowest: lowest = v cord = fcord assert cord != None, "How can there not be any attacks, when ncap exists? %s" % toString(attacks) easiestAttack = newMove(cord, TCORD(ncap)) # Now test if we threats our enemy, or they are too strong see = staticExchangeEvaluate(board, easiestAttack) if see > 0: # If a new winning capture has been created yield _("threatens to win material %s") % toSAN(board,easiestAttack, True) elif bitLength(attacks) > 1: # Even though we might not yet be strong enough, we might still # have strengthened another friendly attack yield _("increases the pressure on %s") % reprCord[TCORD(ncap)] board.setColor(1-board.color) # ------------------------------------------------------------------------ # # Test if we defend a one of our pieces # # ------------------------------------------------------------------------ # # Test which pieces were under attack used = [] for ncap in genCaptures(board): # getCaptures also generate promotions if FLAG(ncap) in PROMOTIONS: continue # We don't want to know about the same cord more than once if TCORD(ncap) in used: continue used.append(TCORD(ncap)) # If the attack was poining on the piece we just moved, we ignore it if TCORD(ncap) == FCORD(move) or TCORD(ncap) == TCORD(move): continue # If we were already defending the piece, we don't send a new message if defends(oldboard, FCORD(move), TCORD(ncap)): continue # If the attack was not strong, we ignore it oldboard.setColor(1-oldboard.color) see = staticExchangeEvaluate(oldboard, ncap) oldboard.setColor(1-oldboard.color) if see < 0: continue v = defends(board, TCORD(move), TCORD(ncap)) # If the defend didn't help, it doesn't matter. Like defending a bishop, # threatened by a pawn, with a queen. # But on the other hand - it might still be a defend... # newsee = staticExchangeEvaluate(board, ncap) # if newsee <= see: continue if v: yield _("defends %s") % reprCord[TCORD(ncap)] PIECE_VALUES[BISHOP] = bishopBackup
def defencive_moves_tactic (model, ply, phase): # ------------------------------------------------------------------------ # # Test if we threat something, or at least put more pressure on it # # ------------------------------------------------------------------------ # # We set bishop value down to knight value, as it is what most people expect bishopBackup = PIECE_VALUES[BISHOP] PIECE_VALUES[BISHOP] = PIECE_VALUES[KNIGHT] board = model.getBoardAtPly(ply).board oldboard = model.getBoardAtPly(ply-1).board move = model.getMoveAtPly(ply-1).move fcord = FCORD(move) tcord = TCORD(move) piece = board.arBoard[tcord] found_threatens = [] found_increases = [] # What do we attack now? board.setColor(1-board.color) for ncap in genCaptures(board): # getCaptures also generate promotions if FLAG(ncap) in PROMOTIONS: continue # We are only interested in the attacks of the piece we just moved if FCORD(ncap) != TCORD (move): continue # We don't want to move back if TCORD(ncap) == FCORD(move): continue # We don't thread the king. We check him! (in another function) if board.arBoard[TCORD(ncap)] == KING: continue # If we also was able to attack that cord last time, we don't care if validateMove(oldboard, newMove(FCORD(move), TCORD(ncap))): continue # Test if we threats our enemy, at least more than before see0 = staticExchangeEvaluate(oldboard, TCORD(ncap), 1-oldboard.color) see1 = staticExchangeEvaluate(board, TCORD(ncap), 1-oldboard.color) if see1 > see0: # If a new winning capture has been created if see1 > 0: # Find the easiest attack attacks = getAttacks (board, TCORD(ncap), board.color) v, cord = min((PIECE_VALUES[board.arBoard[fc]],fc) for fc in iterBits(attacks)) easiestAttack = newMove(cord, TCORD(ncap)) found_threatens.append(toSAN(board,easiestAttack, True)) # Even though we might not yet be strong enough, we might still # have strengthened another friendly attack else: found_increases.append(reprCord[TCORD(ncap)]) board.setColor(1-board.color) # -------------------------------------------------------------------- # # Test if we defend a one of our pieces # # -------------------------------------------------------------------- # found_defends = [] # Test which pieces were under attack used = [] for ncap in genCaptures(board): # getCaptures also generate promotions if FLAG(ncap) in PROMOTIONS: continue # We don't want to know about the same cord more than once if TCORD(ncap) in used: continue used.append(TCORD(ncap)) # If the attack was poining on the piece we just moved, we ignore it if TCORD(ncap) == FCORD(move) or TCORD(ncap) == TCORD(move): continue # If we were already defending the piece, we don't send a new # message if defends(oldboard, FCORD(move), TCORD(ncap)): continue # If the attack was not strong, we ignore it see = staticExchangeEvaluate(oldboard, ncap) if see < 0: continue v = defends(board, TCORD(move), TCORD(ncap)) # If the defend didn't help, it doesn't matter. Like defending a # bishop, threatened by a pawn, with a queen. # But on the other hand - it might still be a defend... # newsee = staticExchangeEvaluate(board, ncap) # if newsee <= see: continue if v: found_defends.append(reprCord[TCORD(ncap)]) # ------------------------------------------------------------------------ # # Test if we are rescuing an otherwise exposed piece # # ------------------------------------------------------------------------ # # Rescuing is only an option, if our own move wasn't an attack if oldboard.arBoard[tcord] == EMPTY: see0 = staticExchangeEvaluate(oldboard, fcord, oldboard.color) see1 = staticExchangeEvaluate(board, tcord, oldboard.color) if see1 > see0 and see1 > 0: yield _("rescues a %s") % reprPiece[board.arBoard[tcord]].lower() if found_threatens: yield _("threatens to win material by %s") % join(found_threatens) if found_increases: yield _("increases the pressure on %s") % join(found_increases) if found_defends: yield _("defends %s") % join(found_defends) PIECE_VALUES[BISHOP] = bishopBackup