def setState(self, state): self.cHP = state[0] self.moves = [ Move.Move(c.PM[self.index][0], state[1]), Move.Move(c.PM[self.index][1], state[2]) ]
def getBishopMoves(self, row, col, moves): piecePinned = False pinDirection = () for i in range(len(self.pins) - 1, -1, -1): if (self.pins[i][0] == row and self.pins[i][1] == col): piecePinned = True pinDirection = (self.pins[i][2], self.pins[i][3]) if self.board[row][col][ 1] != 'Q': #can't remove queen from pin on rook moves, only remove it on bishop moves, b/c getQueenMoves calls getRookMoves self.pins.remove(self.pins[i]) break directions = ( (-1, -1), (-1, 1), (1, -1), (1, 1)) #up, left, down, right enemyColor = 'b' if self.whiteToMove else 'w' for d in directions: for i in range(1, 8): endRow = row + d[0] * i endCol = col + d[1] * i if 0 <= endRow < 8 and 0 <= endCol < 8: #on board if not piecePinned or pinDirection == d or pinDirection == ( -d[0], -d[1]): #see rook explanation endPiece = self.board[endRow][endCol] if endPiece == "--": #empty space valid moves.append( Move((row, col), (endRow, endCol), self.board)) elif endPiece[0] == enemyColor: #enemy piece valid moves.append( Move((row, col), (endRow, endCol), self.board)) break else: #friendly place invalid break else: #off brand break
def g_min(self, board, depth): if board.terminal_state() or depth == self.max_depth: last_move = Move.Move(board.get_last_move().get_row(), board.get_last_move().get_col()) return last_move children = board.get_children(-1) min_move = Move.Move(1000) min_score = board.victor() # temp_board = Board.Board() for child in children: move = self.g_max(child, depth + 1) temp_board = copy.deepcopy(child) temp_board.make_move(move.get_row(), move.get_col(), move.get_val()) if temp_board.victor() <= min_score: if temp_board.victor() == min_score: if random.randint(0, 1) == 0: min_move.set_row(child.get_last_move().get_row()) min_move.set_col(child.get_last_move().get_col()) min_move.set_val(move.get_val()) min_score = child.victor() else: min_move.set_row(child.get_last_move().get_row()) min_move.set_col(child.get_last_move().get_col()) min_move.set_val(move.get_val()) min_score = child.victor() return min_move
def parseProperty(self, node, isroot): ''' parse contents in one node ''' name = self.m_tokenizer.sval done = False while not done: ttype = self.m_tokenizer.nextToken() if ttype != '[': done = True self.m_tokenizer.pushBack() if done: break if name == 'C': val = self.parseComment() else: val = self.parseValue() # print(name + '[' + val + ']') if name == 'W': point = HexPoint.get(val) node.setMove(Move.Move(point, HexColor.WHITE)) elif name == 'B': point = HexPoint.get(val) node.setMove(Move.Move(point, HexColor.BLACK)) elif name == 'AB': node.addSetup(HexColor.BLACK, HexPoint.get(val)) elif name == 'AW': node.addSetup(HexColor.WHITE, HexPoint.get(val)) elif name == 'AE': node.addSetup(HexColor.EMPTY, HexPoint.get(val)) elif name == 'LB': node.addLabel(val) elif name == 'FF': node.setSgfProperty(name, val) x = self.parseInt(val) if x < 1 or x > 4: raise self.SgfError("Invalid SGF Version! (" + x + ")") elif name == 'GM': node.setSgfProperty(name, val) if not isroot: self.sgfWarning("GM property in non-root node!") if self.parseInt(val) != self.__GM_HEXGAME: raise self.SgfError("Not a Hex game!") elif name == 'SZ': node.setSgfProperty(name, val) if not isroot: self.sgfWarning("GM property in non-root node!") sp = val.split(':') if len(sp) == 1: x = self.parseInt(sp[0]) self.m_gameinfo.setBoardSize(x,x) elif len(sp) == 2: x = self.parseInt(sp[0]) y = self.parseInt(sp[1]) self.m_gameinfo.setBoardSize(x,y) else: raise self.SgfError("Malformed boardsize!") else: node.setSgfProperty(name, val)
def getMove(self, currentState): coords = self.coordList chosenMove = None #check if no move has been submitted first if self.moveType == None: return None #callbacks have made sure coord list #wasn't empty if we got to this point #create the appropriate move if self.moveType == MOVE_ANT: chosenMove = Move(MOVE_ANT, coords, None) elif self.moveType == BUILD: if self.buildType == None: return None #callbacks have checked to make sure coord list is length 1 loc = currentState.board[coords[0][0]][coords[0][1]] #we also know from callback that loc contains ant OR hill, not both chosenMove = Move(BUILD, coords, self.buildType) elif self.moveType == END: chosenMove = Move(END, None, None) else: #bad move type pass #clear out move type and coord list self.moveType = None self.buildType = None self.coordList = [] return chosenMove
def getPossibleMoves(self): return [ Move(0, 1, False), Move(1, 0, False), Move(0, -1, False), Move(-1, 0, False) ]
def get_moves(self): moves = [] direction = self.active_player.direction pieces = self.get_pieces(self.active_player) for piece in pieces: #print(str(piece.row) + ',' + str(piece.col)) # Straight if piece.row + direction >= 0 and piece.row + direction < self.board.rows: if self.board.board[piece.row + direction][piece.col].value == '-': moves.append( Move.Move((piece.row, piece.col), (piece.row + direction, piece.col))) # Left if piece.row + direction >= 0 and piece.row + direction < self.board.rows: if piece.col + direction >= 0 and piece.col + direction < self.board.cols: if self.board.board[piece.row + direction][ piece.col + direction].value != self.active_player.symbol: moves.append( Move.Move((piece.row, piece.col), (piece.row + direction, piece.col + direction))) # Right if piece.row + direction >= 0 and piece.row + direction < self.board.rows: if piece.col - direction >= 0 and piece.col - direction < self.board.cols: if self.board.board[piece.row + direction][ piece.col - direction].value != self.active_player.symbol: moves.append( Move.Move((piece.row, piece.col), (piece.row + direction, piece.col - direction))) sorted_moves = [] for move in moves: if self.board.board[move.newPosition[0]][ move.newPosition[1]].value != '-': sorted_moves.insert(0, move) elif self.active_player.symbol == 'o' and move.newPosition[ 0] < self.active_player.shortest_distance: sorted_moves.insert(0, move) elif self.active_player.symbol == 'x' and ( 7 - move.newPosition[0] ) < self.active_player.shortest_distance: sorted_moves.insert(0, move) else: sorted_moves.append(move) #for move in moves: #print(str(move.currentPosition[0]) + ',' + str(move.currentPosition[1]) + " to " + str(move.newPosition[0]) + ',' + str(move.newPosition[1])) return sorted_moves
def list_all_legal_moves(self): retVal = [] for richtung in [-1, +1, 0]: for bauer in self.posWhite: move = Move(bauer, richtung) if self.checkIfLegal(move): retVal.append(move) if len(retVal) == 0: move = Move(None, None, True) # Pass retVal.append(move) return retVal
def _extendRight(self, partialWord, node, row, col, firstAnchor, score): """Place right portion of word""" if row > 14: return if col == 15: if node.endsWord and not firstAnchor: # found legal move foundMove = Move.Move(partialWord, row, col - 1, score) self.moveList.append(foundMove) return if self.boardState[row][col].isEmpty(): if node.endsWord and not firstAnchor: # found legal move foundMove = Move.Move(partialWord, row, col - 1, score) self.moveList.append(foundMove) for e in node.neighbors: workingScore = score.cheapishCopy() if e in self.robotRack and self._crossCheckContains( e, row, col): self.robotRack.remove(e) # calculate score additions letterS = (self._letterMultiplier( self.boardState[row][col].special) * self._wordToScore(e)) sidePartScore = self.boardState[row][col].sideScore wordMult = self._wordMultiplier( self.boardState[row][col].special) workingScore.word += letterS # if a side word is made, add value for the whole word if sidePartScore > 0: workingScore.sideParts += sidePartScore + self._wordToScore( e) workingScore.wordMultiplier *= wordMult workingScore.tilesUsed += 1 self._extendRight(partialWord + e, node.neighbors[e], row, col + 1, False, workingScore.cheapishCopy()) self.robotRack.append(e) else: if self.boardState[row][col].get() in node.neighbors: score.word += self._wordToScore( self.boardState[row][col].get()) self._extendRight( partialWord + self.boardState[row][col].get(), node.neighbors[self.boardState[row][col].get()], row, col + 1, False, score.cheapishCopy())
def __init__(self, num): """ Constructor :param num: player number """ self.player = Player.Player(num) if num == 1: self.opponent = Player.Player(2) self.board = Board.Board(ROWS, COLS, self.player, self.opponent) self.move = Move.Move(self.board, self.player, self.opponent) else: self.opponent = Player.Player(1) self.board = Board.Board(ROWS, COLS, self.opponent, self.player) self.move = Move.Move(self.board, self.opponent, self.player)
def getPossibleMoves(self): board = self._board pos = board.getChessmanPosition(self) getCellValue = Tools.secureFunc(board.getCellValue, error_message="error") def isAlienChessmanInCell(x, y): value = getCellValue(x, y) if value == "error": return False return value.getColor() != self.getColor() if value else False def searchEmptyCellsLine(vector, i): result = [] if not getCellValue(pos["x"] + i * vector["x"], pos["y"] + i * vector["y"]): result = [ Move(i * vector["x"], i * vector["y"], can_kill=False) ] result = result + searchEmptyCellsLine(vector, i + 1) return result moves = [] if pos: for vec in [{ "x": 1, "y": 1 }, { "x": 1, "y": -1 }, { "x": -1, "y": -1 }, { "x": -1, "y": 1 }]: barrier_distance = len(searchEmptyCellsLine(vec, 1)) + 1 if isAlienChessmanInCell( pos["x"] + vec["x"] * barrier_distance, pos["y"] + vec["y"] * barrier_distance): moves = moves + searchEmptyCellsLine( vec, barrier_distance + 1) # если есть ходы, которыми можем срубить, тогда нет смысла добавлять обычные ходы, т.к. рубить обязательно if len(moves) == 0: moves.append(Move(-1, 1, limit=False, can_kill=False)) moves.append(Move(1, 1, limit=False, can_kill=False)) moves.append(Move(-1, -1, limit=False, can_kill=False)) moves.append(Move(1, -1, limit=False, can_kill=False)) return moves
def getKingMoves(self, row, col, moves): rowMoves = (-1, -1, -1, 0, 0, 1, 1, 1 ) #split to put into KingLocation variables colMoves = (-1, 0, 1, -1, 1, -1, 0, 1) #read those ^^ vertically, to get each of the directions allyColor = 'w' if self.whiteToMove else 'b' for i in range(8): endRow = row + rowMoves[i] endCol = col + colMoves[i] if 0 <= endRow < 8 and 0 <= endCol < 8: #on board endPiece = self.board[endRow][endCol] if endPiece[ 0] != allyColor: #when not ally piece, can move there #place king on end square and check for checks if (allyColor == 'w'): self.whiteKingLocation = (endRow, endCol) else: self.blackKingLocation = (endRow, endCol) inCheck, pins, checks = self.checkForPinsAndChecks() if not inCheck: moves.append( Move((row, col), (endRow, endCol), self.board)) #place king back on original location if allyColor == 'w': self.whiteKingLocation = (row, col) else: self.blackKingLocation = (row, col)
def __init__(self, name, moves, level, nature, exp, HP, db): # Base stats self.db = db self.base_HP = db.get_base_stats(name, "HP") self.base_attack = db.get_base_stats(name, "attack") self.base_defense = db.get_base_stats(name, "defense") self.base_sp_attack = db.get_base_stats(name, "sp_attack") self.base_sp_defense = db.get_base_stats(name, "sp_defense") self.base_speed = db.get_base_stats(name, "speed") self.HP = HP self.moves = dict(((move, Move(move, db)) for move in moves)) self.level = level self.nature = nature # nature self.exp = exp self.IV_EV_4 = math.floor((self.HP - self.level - 10) * (100 / self.level) - 2 * self.base_HP) self.TEST = self.calculate_HP() self.attack_stat = self.calculate_other_stat(self.base_attack, "Attack") self.defense_stat = self.calculate_other_stat(self.base_defense, "Defense") self.sp_attack_stat = self.calculate_other_stat( self.base_sp_attack, "Sp. Attack") self.sp_defense_stat = self.calculate_other_stat( self.base_sp_defense, "Sp. Defense") self.speed_stat = self.calculate_other_stat(self.base_speed, "Speed") self.item = None
def get_moves(self, state: HEX) -> [Move]: out = [] for e in state.get_all_legal_moves(): copy: HEX = state.__copy__() copy.do_move_from_cell(e) out.append(Move(state, e, copy, state.player)) return out
def __init__(self, index, state=None): # Constants self.index = index self.name = c.PN[index] self.level = 5 self.baseSpeed = c.PBS[index][4] self.attack = c.PS[index][1] self.defense = c.PS[index][2] self.speed = c.PS[index][4] # State self.cHP = c.PS[index][0] self.moves = [Move.Move(c.PM[index][0]), Move.Move(c.PM[index][1])] if state is not None: self.setState(state)
def get_moves_white(self): for i in range(self.rows): for j in range(self.columns): if self.matrix[i][j] == 0: # adds down move if legal if i < self.rows - 1 and self.matrix[i + 1][j] == 1: self.moveset.append(Move(i, j, i + 1, j)) # adds up move if legal if i > 0 and self.matrix[i - 1][j] == 1: self.moveset.append(Move(i, j, i - 1, j)) # adds left move if legal if j > 0 and self.matrix[i][j - 1] == 1: self.moveset.append(Move(i, j, i, j - 1)) # adds right move if legal if j < self.columns - 1 and self.matrix[i][j + 1] == 1: self.moveset.append(Move(i, j, i, j + 1))
def listAllMovementMoves(currentState): result = [] # first get all MOVE_ANT moves for each ant in the inventory myInv = getCurrPlayerInventory(currentState) for ant in myInv.ants: # skip ants that have already moved if (ant.hasMoved): continue # create a Move object for each valid movement path allPaths = listAllMovementPaths(currentState, ant.coords, UNIT_STATS[ant.type][MOVEMENT]) # remove moves that take the queen out of her territory if (ant.type == QUEEN): tmpList = [] for path in allPaths: if (isPathOkForQueen(path)): tmpList.append(path) allPaths = tmpList # construct the list of moves using the paths for path in allPaths: result.append(Move(MOVE_ANT, path, None)) return result
def set_valid_moves(board, move_list, cell, neighbors): x_src = cell.x y_src = cell.y for cell_dest in neighbors: x_dest = cell_dest.x y_dest = cell_dest.y move_list.append(Move(x_src, y_src, x_dest, y_dest, None, None, None)) return move_list #list of moves
def get_moves_in_direction(self, piece: Piece, dx: int, dy: int): moves = [] curr_x = piece.x + dx curr_y = piece.y + dy if dx == 0 and dy == 0: return moves while 0 <= curr_x < BOARD_SIZE_X_MAX and 0 <= curr_y < BOARD_SIZE_Y_MAX: possible_piece = self.get_piece(curr_x, curr_y) if possible_piece is not None: if possible_piece.owner is not piece.owner: moves.append(Move(curr_x, curr_y)) break else: moves.append(Move(curr_x, curr_y)) curr_x += dx curr_y += dy return moves
def searchEmptyCellsLine(vector, i): result = [] if not getCellValue(pos["x"] + i * vector["x"], pos["y"] + i * vector["y"]): result = [ Move(i * vector["x"], i * vector["y"], can_kill=False) ] result = result + searchEmptyCellsLine(vector, i + 1) return result
def approachGate(surge, sway, yaw, timeout): ApproachGate = smach.StateMachine(outcomes=['success', 'abort', 'failure'], output_keys=['angle']) ApproachGate.userdata.angle = 0 ApproachGate.userdata.speed = 0.2 ApproachGate.userdata.moveTime = 5 ApproachGate.userdata.timeout = timeout ApproachGate.userdata.div = False ApproachGate.userdata.latch = False with ApproachGate: smach.StateMachine.add( 'Move', Move(surge, sway), transitions={ 'success': 'Relocate', }, #Kyle: changed existence to success or failure remapping={ 'angle': 'angle', 'speed': 'speed', 'moveTime': 'moveTime' }) smach.StateMachine.add('Relocate', Locate(), transitions={ 'success': 'RotateToSection', 'failure': 'Latch' }, remapping={ 'timeout': 'timeout', 'angle': 'angle', 'div': 'div' }) smach.StateMachine.add('Latch', Latch(), transitions={ 'dedReckon': 'success', 'continue': 'Move', 'search': 'failure' }, remapping={ 'latchIn': 'latch', 'latchOut': 'latch', 'angle': 'angle', 'div': 'div' }) smach.StateMachine.add('RotateToSection', RotateTo(yaw, increment=True), transitions={ 'success': 'Latch', 'abort': 'abort' }, remapping={ 'timeout': 'timeout', 'angle': 'angle' }) return ApproachGate
def getQueenSideCastleMoves(self, row, col, moves, allyColor): if self.board[row][col - 1] == '--' and self.board[row][ col - 2] == '--' and self.board[row][col - 3] == '--': if not self.squareUnderAttack( row, col - 1) and not self.squareUnderAttack(row, col - 2): moves.append( Move((row, col), (row, col - 2), self.board, isCastleMove=True))
def getPossibleMoves(self): return [ Move(1, 2), Move(2, 1), Move(2, -1), Move(1, -2), Move(-1, -2), Move(-2, -1), Move(-2, 1), Move(-1, 2) ]
def getPossibleMoves(self): return [ Move(0, 1), Move(1, 0), Move(0, -1), Move(-1, 0), Move(1, 1), Move(1, -1), Move(-1, -1), Move(-1, 1) ]
def returnValidMoves(self, color, playingField): allValidMoves = [] #allValidMoves = [[0 for i in range(len(playingField))] for j in range(len(playingField))] for i in range(len(playingField)): for j in range(len(playingField)): tilesToFlip = [] if playingField[i][j] == 0: nw = self.isValid(color, -1, -1, i, j, playingField) if nw: for count in range(nw + 1): tilesToFlip.append([i - count, j - count]) nn = self.isValid(color, -1, 0, i, j, playingField) if nn: for count in range(nn + 1): tilesToFlip.append([i - count, j]) ne = self.isValid(color, -1, 1, i, j, playingField) if ne: for count in range(ne + 1): tilesToFlip.append([i - count, j + count]) ee = self.isValid(color, 0, 1, i, j, playingField) if ee: for count in range(ee + 1): tilesToFlip.append([i, j + count]) se = self.isValid(color, 1, 1, i, j, playingField) if se: for count in range(se + 1): tilesToFlip.append([i + count, j + count]) ss = self.isValid(color, 1, 0, i, j, playingField) if ss: for count in range(ss + 1): tilesToFlip.append([i + count, j]) sw = self.isValid(color, 1, -1, i, j, playingField) if sw: for count in range(sw + 1): tilesToFlip.append([i + count, j - count]) ww = self.isValid(color, 0, -1, i, j, playingField) if ww: for count in range(ww + 1): tilesToFlip.append([i, j - count]) points = nw + nn + ne + ee + se + ss + sw + ww if (points > 0): move = Move.Move([i, j], points, color, tilesToFlip) allValidMoves.append(move) return allValidMoves
def getMoves(self, player): moves = [] for i in range(self.hauteur): for j in range(self.largeur): if (self.board[i][j] == player): for m in self.voisin((i, j), True): if (type(m[0]) == tuple): move = mv.Move((i, j), (m[0][0], m[0][1]), m[1]) moves.append(move) return moves
def __init__(self): """ Constructor """ self.player1 = Player.Player(1) self.player2 = Player.Player(2) self.board = Board.Board(ROWS, COLS, self.player1, self.player2) self.move = Move.Move(self.board, self.player1, self.player2) self.current_player = self.player1 self.board.reset_board()
def addMove(self, type): self.moveList.append(Move.Move(type)) if self.firstMove == None: self.firstMove = self.moveList[0] else: self.moveList[-2].next = self.moveList[-1] self.moveList[-1].previous = self.moveList[-2] return self.calculatePosibilities()
def buildAnt(self, ant): food = self.handler.currentState.inventories[ self.handler.currentState.whoseTurn].foodCount if food >= UNIT_STATS[ant][4]: self.handler.submitHumanMove(Move(BUILD, [self.hillCoords], ant)) else: self.setInstructionText( "You need %d food to build that ant, try something else." % UNIT_STATS[ant][4])
def filter_valid_moves(self, piece: Piece, suggest_promote: bool = False): moveset = piece.get_current_move_set() valid: list[Move] = [] for move in moveset: if self.is_move_in_board_and_not_on_ally(piece, move): valid.append(move) if suggest_promote and not move.promote and self.is_promote( piece, move): valid.append(Move(move.x, move.y, True)) return valid