def start(board, steps=100, size=20): for i in range(1, steps + 1): os.system('clear') print('step:', i, '/', steps) print_board(board, size) time.sleep(0.1) board = constrain(advance(board), size)
def test_en_passant(self): board = get_mock(7) print_board(board) assert_equal(board.en_passant, (6, 2)) assert_equal(board.evaluation_params()['material'], [12, 8]) assert_equal(board.evaluation_params()['activeness'], [24, 21]) assert_true(board.pieces[(6, 3)] == ('pawn', WHITE)) cnt = 0 for move in board.get_board_moves( capture_sort_key=Board.sort_take_by_value): revert_info = board.make_move(move) if revert_info is None: continue if cnt == 0: assert_equal(move['piece'], 'pawn') assert_equal(move['new_position'], (6, 2)) assert_equal(move['captured_piece'], 'pawn') assert_equal(board.evaluation_params()['material'], [11, 8]) assert_equal(board.evaluation_params()['activeness'], [22, 21]) assert_true((6, 3) not in board.pieces) cnt += 1 board.revert_move(revert_info) assert_true(board.pieces[(6, 3)] == ('pawn', WHITE))
def test_print(self, capsys): board = generate_board(4) print_board(4, board) captured = capsys.readouterr() assert captured.out == " 0 0 0 0\n 0 0 0 0\n 0 0 0 0\n 0 0 0 0\n"
def main(): board_size = 5 game = goboard.GameState.new_game(board_size) # temperature == c in w + c*sqrt(log N / n) # higher temperatures are more volatile, # lower temperaures create a more focused search temperature = 1.5 bots = { gotypes.Player.black: mcts.MCTSAgent(3, temperature), gotypes.Player.white: mcts.MCTSAgent(3, temperature), } while not game.is_over(): time.sleep(0.3) # print(chr(27) + "[2J") print_board(game.board) bot_move = bots[game.next_player].select_move(game) print_move(game.next_player, bot_move) game = game.apply_move(bot_move)
def __str__(self): """ to string, will be invoked when printing the node """ state_board = {} for p in self.state["players"]: state_board[p] = "*p*" for l in self.state["goals"]: if l in state_board: state_board[l] = state_board[l] + "*g*" else: state_board[l] = "*g*" for o in self.state["blocks"]: if o in state_board: state_board[o] = state_board[o] + "*b*" else: state_board[o] = "*b*" utils.print_board(state_board, message=self.transition_action + str(self.heuristic(self.state)), debug=True) return self.transition_action
def game(): # Count of the left ships ai_ships_left = len(FLEET) player_ships_left = len(FLEET) # Variables for storing AI move state last_hit_row = UNKNOWN last_hit_col = UNKNOWN ai_target_ship = None ai_hits = [] # Variables for storing player move state player_target_ship = None player_hits = [] # Add random ships to boards player_board.place_random_ships() ai_board.place_random_ships() print_board(ai_board, ai_guesses, SIZE) print('Battleships') print_board(player_board, player_guesses, SIZE) while ai_ships_left and player_ships_left: # Player turn ai_ships_left = player_turn(ai_ships_left, player_target_ship, player_hits) # AI turn player_ships_left = ai_turn(last_hit_row, last_hit_col, player_ships_left, ai_target_ship, ai_hits)
def main(): # Handles command line args if len(sys.argv) != 3: print("Incorrect amount of args") return args = sys.argv[1:] try: int(args[0]) float(args[1]) except ValueError: print("Incorrect arg types") return if(int(args[0]) != 1 and float(args[1]) != 2): print("Turn arg must be 1 or 2") return # Initializes board board = init_board() turn = int(args[0]) print("Initial board:") utils.print_board(board) # Loops until someone wins while len(utils.get_next_board_states(board, turn)) > 0: board = montecarlo(board, turn, float(args[1])) print(f"{turn} goes") utils.print_board(board) turn = utils.next_turn(turn) print(f"{utils.next_turn(turn)} wins!")
def test_mock_0_deep_3(self): lines = 17 for analyzer_class in analyzer_classes: analyzer = analyzer_class(max_deep=3, evaluation_func=material_evaluation, lines=lines) board = get_mock(0) print_board(board) analysis = analyzer.analyze(board) result = analysis['result'] to_check = [] for ind in xrange(9): to_check.append((result[ind]['evaluation'], result[ind]['moves'][-1]['piece'], result[ind]['moves'][-1]['new_position'])) to_check.sort() assert_equal(to_check[0], (-2, 'king', (3, 0))) assert_equal(to_check[1], (-2, 'king', (3, 1))) assert_equal(to_check[2], (-2, 'pawn', (0, 1))) assert_equal(to_check[3], (-2, 'rook', (0, 3))) assert_equal(to_check[4], (-2, 'rook', (0, 4))) assert_equal(to_check[5], (-2, 'rook', (0, 5))) assert_equal(to_check[6], (-2, 'rook', (0, 6))) assert_equal(to_check[7], (-1, 'rook', (1, 7))) assert_equal(to_check[8][0], 0) assert_equal(len(result), 16)
def predict_next_move(_): state, action = valid_data[np.random.choice(len(valid_data))] n_channel, row, column = state.shape if args.gpu >= 0: state = cuda.to_gpu(state) prediction = model.predict(state.reshape(1, n_channel, row, column)) print_board(state) print(f'action : {translate(int(action))}') print(f'prediction : {translate(int(np.argmax(F.softmax(prediction).data, axis=1)))}')
def print_initial_state(data): board_dict = dict(zip(ALL_CELLS, [""] * len(ALL_CELLS))) for cell in data[PIECES]: board_dict[tuple(cell)] = data[COLOUR] for cell in data[BLOCKS]: board_dict[tuple(cell)] = "BLOCK" print_board(board_dict, "", True)
def get_approx_path_costs(exit_cells, blocks): ApproxPathCosts.blocks = blocks for cell in exit_cells: ApproxPathCosts.path_costs[cell] = 0 uniform_cost_search(ApproxPathCosts(cell)) print_board(ApproxPathCosts.path_costs) return ApproxPathCosts.path_costs
def player_loop(board, pieces): previous_board = deepcopy(board) previous_pieces = deepcopy(pieces) original_board = deepcopy(board) original_pieces = deepcopy(pieces) current_move = "" found_first_undo = False print() utils.print_board(board) while (True): if (check_end(pieces)): print("Level Completed!") break print() new_move = read_move() if (new_move == "undo" and found_first_undo == False): found_first_undo = True board = previous_board pieces = previous_pieces current_move = current_move[:-1] elif (new_move == "undo"): print("Second Undo in a Row. not allowed :p") pass elif (new_move == "restart"): found_first_undo = False board = deepcopy(original_board) pieces = deepcopy(original_pieces) current_move = "" utils.print_board(board) continue elif (new_move == "h"): hint = search_algorithms.a_star(board, pieces, heuristics.min_string) print("Hint: ", hint[0]) else: found_first_undo = False previous_board = deepcopy(board) previous_pieces = deepcopy(pieces) current_move += new_move print("Current Move Sequence: {}".format(current_move)) execute_move(current_move, board, pieces)
def get_action(self, treeNode): state = treeNode.state print_board(state) while True: inp = input("Input position: ") try: lst = inp.split(",") assert(len(lst)==2) pos = tuple(int(l) for l in lst) break except: print() return pos
def next_pvc_move(size, board, move, win_conditions, is_first): if is_first == 1: board, move = utils.get_update_user_move(size, board, move) if move <= size * size - 1: board = play_comp_move(size, board, move, win_conditions) return board, move + 1 else: board = play_comp_move(size, board, move, win_conditions) utils.print_board(size, board) move += 1 if move <= size * size - 1: board, move = utils.get_update_user_move(size, board, move) return board, move
def main(): board_size = 9 game = goboard_slow.GameState.new_game(board_size) bots = { gotypes.Player.black: agent.naive.RandomBot(), gotypes.Player.white: agent.naive.RandomBot() } while not game.is_over(): time.sleep(1) print(chr(27) + "[2J") print_board(game.board) bot_move = bots[game.next_player].select_move(game) print_move(game.next_player, bot_move) game = game.apply_move(bot_move)
def game(player1, player2, status, iters, shows=False): while not status['finish']: turn = status['turn'] if shows: print_board(status) if turn == 0: # jugador real status = player1(status, 0) elif turn == 1: # implementacion de mancala / computadora status = player2(status, 1, iters) board = status['board'] score = [board[6], board[13]] return score.index(max(score))
def main(): parser = argparse.ArgumentParser() parser.add_argument("-b", "--board_size", type=int, default=15) parser.add_argument("-l", "--line_size", type=int, default=5) parser.add_argument("-r", "--num_rollouts", type=int, default=100) parser.add_argument("-C", "--exploration_coeff", type=float, default=1.0) parser.add_argument("-d", "--max_depth", type=int, default=5) parser.add_argument("-t", "--timeout", type=int, default=1) parser.add_argument("-s", "--selfplay", type=int, default=0) parser.add_argument("-w", "--num_workers", type=int, default=4) args = parser.parse_args() N, linesize = args.board_size, args.line_size num_rollouts, max_depth, timeout = args.num_rollouts, args.max_depth, args.timeout C = args.exploration_coeff game = Game(N, linesize) tree = Tree(game, num_rollouts, C, max_depth, timeout, num_workers=args.num_workers) turn = 0 print_board(tree.root.board) while (True): board = tree.root.board if (turn == 1): print("-" * (8 * N), "") print("Your Turn") if (args.selfplay == 0): pos = player_move(board) board = tree.player_move(pos) else: board = tree.play_one_move() else: print("\nComputer's Turn") board = tree.play_one_move() print_board(board) if (tree.root.gameover != 0): if (turn == 1): print("Congrats!! You Won...") else: print("Sorry!! You Lost... Better Luck Next Time") break turn = 1 - turn
def player_turn(ai_ships_left, player_target_ship, player_hits): """ :param ai_ships_left: int :param player_target_ship: Ship :param player_hits: list of made hits """ _row = int(input("Which row?")) _col = int(input("Which column?")) # If player chose the wrong cell while not player_guesses.is_cell_on_board(_row, _col): print("Incorrect input, please try again") _row = int(input("Which row?")) _col = int(input("Which column?")) # If a player can hit this cell player_hit = not ai_board.is_cell_water(_row, _col) while player_hit: player_guesses.board[_row][_col] = HIT if ai_ships_left: print('Hit!') player_hits.append((_row, _col)) # Check if any ai ship is sunk if not player_target_ship: player_target_ship = ai_board.get_hit_ship(_row, _col) else: is_ai_ship_sunk = player_target_ship.is_sunk(player_hits) if is_ai_ship_sunk: player_hits = [] ai_ships_left -= 1 player_target_ship = None print('AI ship sunk!') print_board(player_board, player_guesses, SIZE) # Asking again _row = int(input("Which row?")) _col = int(input("Which column?")) player_hit = not ai_board.is_cell_water(_row, _col) else: print('You win!') break print("Miss!") player_guesses.board[_row][_col] = MISS print_board(player_board, player_guesses, SIZE) return ai_ships_left
def test_castle_obstacle_not_valid(self): for mock_id in [1, 9, 14]: board = get_mock(mock_id) print_board(board) for move in board.get_board_moves(): revert_info = board.make_move(move) if revert_info is None: continue board.revert_move(revert_info) if (move['piece'] == 'king' and move['new_position'] == (6, 0)): assert_true(False)
def test_castle_beaten_cell_check(self): for mock_id in [11, 12, 13]: board = get_mock(mock_id) print_board(board) for move in board.get_board_moves(): revert_info = board.make_move(move) if revert_info is None: continue board.revert_move(revert_info) if (move['piece'] == 'king' and abs(move['new_position'][0] - move['position'][0]) == 2): assert_true(False)
def test_get_board_moves_2(self): for mock_id in xrange(MOCKS_COUNT): board = get_mock(mock_id) print_board(board) assert_equal(sorted(board.get_board_moves()), sorted(board.get_board_moves_old())) for move in board.get_board_moves(): revert_info = board.make_move(move) if not revert_info: continue assert_equal(sorted(board.get_board_moves()), sorted(board.get_board_moves_old())) board.revert_move(revert_info)
def main(): game = goboard.GameState.new_game(BOARD_SIZE) bot = alphabeta.AlphaBetaAgent(3, capture_diff) while not game.is_over(): print_board(game.board) if game.next_player == gotypes.Player.black: human_move = input('-- ') point = point_from_coords(human_move.strip()) move = goboard.Move.play(point) else: move = bot.select_move(game) print_move(game.next_player, move) game = game.apply_move(move)
def main(): board_size = 9 game = goboard.GameState.new_game(board_size) bot = agent.RandomBot() while not game.is_over(): print(chr(27) + "[2J") print_board(game.board) if game.next_player == gotypes.Player.black: human_move = input('-- ') point = point_from_coords(human_move.strip()) move = goboard.Move.play(point) else: move = bot.select_move(game) print_move(game.next_player, move) game = game.apply_move(move) print("Winner: ", game.winner())
def test_castle_become_invalid(self): for mock_id in [16]: board = get_mock(mock_id) print_board(board) assert_equal(board.castles[BLACK_QC], True) is_any_move = False for move in board.get_board_moves(): revert_info = board.make_move(move) if revert_info is None: continue assert_equal(board.castles[BLACK_QC], False) board.revert_move(revert_info) is_any_move = True assert_equal(is_any_move, True) assert_equal(board.castles[BLACK_QC], True)
def start_a_new_game(white, black): """ This function creates a new game of brandubh and asks the players to select moves until the game is over. """ game = GameState.new_game() next_move = ' ' while game.is_not_over(): # Clear the output screen and print the current board position print(chr(27) + "[2J") utils.print_board(game, next_move) time.sleep(0.5) if game.player == 1: action = white.select_move(game) move = action.move else: action = black.select_move(game) move = action.move if move: next_move = utils.COLS[move[1]] + str(move[0]) + ' ' + \ utils.COLS[move[3]] + str(move[2]) else: next_move = 'pass' # Try make the move and see if it is legal. If not, print # why it isn't to the screen and wait the next input # (Note, all actions produced by select_move methods should be legal, # this is just here to catch errors.) move_is_not_legal = game.take_turn(action) if move_is_not_legal: print(move_is_not_legal) # If the game is over, print the winning board position and who won print(chr(27) + "[2J") utils.print_board(game, next_move) winner = 'black' if game.winner == -1 else 'white' print('The winner is ' + winner) input('--')
def execute_move(move_sequence, board, pieces): if (len(move_sequence) == 0): utils.print_board(board) return move = move_sequence[-1] sort_pieces(pieces, move) for i in range(len(pieces)): cur_row = pieces[i].movable_row cur_col = pieces[i].movable_col if (move == "u"): newCoords = moveUp(board, cur_row, cur_col) pieces[i].movable_row = newCoords[0] elif (move == "d"): newCoords = moveDown(board, cur_row, cur_col) pieces[i].movable_row = newCoords[0] elif (move == "l"): newCoords = moveLeft(board, cur_row, cur_col) pieces[i].movable_col = newCoords[1] elif (move == "r"): newCoords = moveRight(board, cur_row, cur_col) pieces[i].movable_col = newCoords[1] size_board = int(len(board)**0.5) board[cur_row * size_board + cur_col] = "." board[newCoords[0] * size_board + newCoords[1]] = pieces[i].movable_symbol for i in range(len(pieces)): if (board[pieces[i].dest_row * size_board + pieces[i].dest_col] == "."): board[pieces[i].dest_row * size_board + pieces[i].dest_col] = pieces[i].dest_symbol utils.print_board(board)
def main(): board_size = get_board_size() players, white, black = get_players() os.system('cls') turn = 0 game = GameState.new_game(board_size, white, black) print_intro(game.board) bot_move = None while not game.is_over(): time.sleep(1) turn = turn + 1 print_board(game.board, turn, game.is_over(), game.next_player.other, bot_move) bot_move = players[game.next_player].select_move(game) game = game.apply_move(bot_move) print_board(game.board, turn, game.is_over(), game.next_player.other, bot_move) winner = game.winner() print('%s Wins!!!' % (winner))
def main(): board_size = 5 game = goboard.GameState.new_game(board_size) bots = { gotypes.Player.black: depthprune.DepthPrunedAgent(3, pruned_go.capture_diff), gotypes.Player.white: depthprune.DepthPrunedAgent(3, pruned_go.capture_diff), } while not game.is_over(): time.sleep(0.3) # print(chr(27) + "[2J") print_board(game.board) bot_move = bots[game.next_player].select_move(game) print_move(game.next_player, bot_move) game = game.apply_move(bot_move)
def run(self): overall_time = time.clock() board = [] iter_num = 0 for i in range(self.data.queens_num): row = (random.randint(0, 32767) % self.data.queens_num) board.append(row) while not self.is_solved(board): print("Iteration number " + str(iter_num)) utils.print_board(board, self.data.queens_num) print() random_col = (random.randint(0, 32767) % self.data.queens_num) board[random_col] = self.find_best_row(board, random_col) iter_num = iter_num + 1 overall_time = time.clock() - overall_time overall_clock_ticks = overall_time * self.data.clocks_per_second with open("output.txt", 'a') as file: file.write("Overall clock ticks: " + str(overall_clock_ticks) + "\n") file.write("Overall time: " + str(overall_time) + "\n") file.write("Overall iterations: " + str(iter_num) + "\n")
def test_mock_2_deep_4(self): lines = 17 for analyzer_class in analyzer_classes: analyzer = analyzer_class(max_deep=4, evaluation_func=material_evaluation, lines=lines) board = get_mock(2) print_board(board) analysis = analyzer.analyze(board) result = analysis['result'] to_check = [] for ind in xrange(9): to_check.append((result[ind]['evaluation'], result[ind]['moves'][-1]['piece'], result[ind]['moves'][-1]['new_position'])) to_check.sort(reverse=True) assert_equal(to_check[0], (997, 'queen', (6, 7))) assert_equal(to_check[1][0], 5) assert_equal(len(result), 17)