def replaySequence(graphicalDisplay, sequence): ########################################## gameBoard = core.Board(8, 16) while 1: moveOptions = gameBoard.getMoveOptions() if len(moveOptions) == 0: return gameBoard.score, gameBoard.splitRecord break try: nextMove = sequence[len(gameBoard.splitRecord)] except IndexError: pass print("Move {0} of {1}: Split box #{2}".format( len(gameBoard.splitRecord), len(sequence), nextMove)) #determine best moves best_indices = [ i for i, x in enumerate(gameBoard.weights) if x == max(gameBoard.weights) ] graphicalDisplay.HighlightNextBox(nextMove) graphicalDisplay.HighlightAlgoBoxes(best_indices) graphicalDisplay.Update(gameBoard) userinput = input("Press any key to continue") if nextMove not in moveOptions: print("------ IMPOSSIBLE MOVE REQUESTED -----") break if gameBoard.weights[nextMove] != max(gameBoard.weights): print("~~~Made move not recommended by algorithm.~~~") indices = [ i for i, x in enumerate(gameBoard.weights) if x == max(gameBoard.weights) ] print("Box(es) recommended:") print(indices) print("Weight of box(es) recommended:") print(max(gameBoard.weights)) print("Weight of box chosen:") print(gameBoard.weights[nextMove]) # print(gameBoard.weights) if userinput == "w": findWeights(gameBoard, weightverbose=1) userinput = input("Press any key to continue") core.makeMove(gameBoard, nextMove)
def getBoardFromSequence(sequence): # Recreate a game board by replaying the sequence that leads to it ########################################## gameBoard = core.Board(8, 16) tempSequence = sequence[:] while 1: if len(tempSequence) == 0: return gameBoard chosenBox = tempSequence.pop(0) core.makeMove(gameBoard, chosenBox)
def playSplitRandomly(gameBoard): #Play a single game of SPL-T ########################################## while 1: moveOptions = gameBoard.getMoveOptions() if len(moveOptions) == 0: return gameBoard.score, gameBoard.splitRecord nextMove = random.choice(moveOptions) core.makeMove(gameBoard, nextMove)
def TimeCalc(): i = 0 num_games = 100 total_pre_move_time = 0 total_move_time = 0 total_cluster_time = 0 total_weight_time = 0 while i < num_games: splits = 0 game_pre_move_time = 0 game_move_time = 0 game_cluster_time = 0 game_weight_time = 0 gameBoard = core_weight.Board() while 1: start = time.time() moveOptions = gameBoard.getMoveOptions() if len(moveOptions) == 0: break bestSplit = max(range(len(gameBoard.weights)), key=gameBoard.weights.__getitem__) end = time.time() game_pre_move_time += end - start move_time, cluster_time, weight_time = core_weight.makeMove( gameBoard, bestSplit) game_move_time += move_time game_cluster_time += cluster_time game_weight_time += weight_time splits += 1 total_pre_move_time += game_pre_move_time / splits total_move_time += game_move_time / splits total_cluster_time += game_cluster_time / splits total_weight_time += game_weight_time / splits print('Game ' + str(i), end='\r') i += 1 total_pre_move_time = total_pre_move_time / num_games total_move_time = total_move_time / num_games total_cluster_time = total_cluster_time / num_games total_weight_time = total_weight_time / num_games print('Average time to execute weight selection/get move options = ' + str(total_pre_move_time)) print('Average time to execute move = ' + str(total_move_time)) print('Average time to calculate clusters = ' + str(total_cluster_time)) print('Average time to calculate weights = ' + str(total_weight_time))
def playSplitWeighted(gameBoard): #Play a single game of SPL-T ########################################## while 1: moveOptions = gameBoard.getMoveOptions() if len(moveOptions) == 0: return gameBoard.score, gameBoard.splitRecord remainingDistance = random.random() * sum(gameBoard.weights) move = -1 for i, weight in enumerate(gameBoard.weights): remainingDistance -= weight if remainingDistance < 0: move = i break core.makeMove(gameBoard, move)
def replaySequence(graphicalDisplay, sequence): ########################################## gameBoard = core.Board(8, 16) while 1: moveOptions = gameBoard.getMoveOptions() if len(moveOptions) == 0: return gameBoard.score, gameBoard.splitRecord break nextMove = sequence[len(gameBoard.splitRecord)] print("Move {0} of {1}: Split box #{2}".format( len(gameBoard.splitRecord), len(sequence), nextMove)) graphicalDisplay.HighlightBox(nextMove) graphicalDisplay.Update(gameBoard) tempDelay = input("Press any key to continue") if nextMove not in moveOptions: print("------ IMPOSSIBLE MOVE REQUESTED -----") break if gameBoard.weights[nextMove] != max(gameBoard.weights): print("~~~Made move not recommended by algorithm.~~~") indices = [ i for i, x in enumerate(gameBoard.weights) if x == max(gameBoard.weights) ] print("Box(es) recommended:") print(indices) print("Weight of box(es) recommended:") print(max(gameBoard.weights)) print("Weight of box chosen:") print(gameBoard.weights[nextMove]) core.makeMove(gameBoard, nextMove)
try: userinput = int(userinput) except ValueError: pass if userinput == "w": print(gameBoard.splitAction) for box, weight in enumerate(gameBoard.weights): if weight != 0: print("Weight of box %d is %d" % (box, weight)) splitRequest = input("Input box to split:") try: splitRequest = int(splitRequest) except ValueError: splitRequest = bestSplit core.makeMove(gameBoard, splitRequest) boards.append(deepcopy(gameBoard)) newAlgoMaxLength = playUntilEnd(deepcopy(gameBoard)) print("New algorithm split record: %d" % newAlgoMaxLength) elif userinput == "ww": findWeights(gameBoard, weightverbose=1) splitRequest = input("Input box to split:") try: splitRequest = int(splitRequest) except ValueError: splitRequest = bestSplit core.makeMove(gameBoard, splitRequest) boards.append(deepcopy(gameBoard))
else: weights.append(0) #to prevent negative weights, we take the lowest weight and add it to the entire list, making the worst block have no shot at being chosen #and other negative blocks with a low chance at being chosen minWeight = min(weights) if minWeight <=0: minWeight = -minWeight weights = [x+minWeight+.01 for x in weights] for boxind, box in enumerate(gameBoard.box): if not box.splitPossible(gameBoard.splitAction): weights[boxind] = 0 if weightverbose: print("Final weights vector:") print(weights) if timingInfo: end = time.time() print("Time to calculate weights until fall for turn {}: {}".format(curr_splits,end-start)) return weights if __name__ == '__main__': gb = core.Board() core.makeMove(gb,0) core.makeMove(gb,0) core.makeMove(gb,0) core.makeMove(gb,0) core.makeMove(gb,1) findCluster(gb)
weight_diff = game_board.weights[high_weight_indices[ 0]] - game_board.weights[high_weight_indices[1]] else: weight_diff = 100 if piggyback and game_num == 0: #if piggybacking, select moves from sequence at first best_split_ind = piggyback_sequence[len(game_board.splitRecord)] print("Game {}, Split {} - (restart {}, base {})".format( game_num, len(game_board.splitRecord), restart_splits, exploring_from), end='\r') old_game_board = copy.deepcopy(game_board) core.makeMove(game_board, best_split_ind) #After making the move, if the most recent block has points and #is not 1x1, then it made an unecessarily big cluster and we should add it #OR if there was another split option within 3 weight but not identical most_recent_box = game_board.box[-1] split_created_big_cluster = ((most_recent_box.points != 0) and (most_recent_box.width != 1 or most_recent_box.height != 1)) another_as_good_option = ((weight_diff < 3) and (weight_diff > 1) and len(game_board.splitRecord) > 875) #don't add all almost as good options because the problem becoms intractible add_every_blank_good_options = 2 if another_as_good_option: