def __init__(self): self.state = State() self.state.initial_state() self.possible_action_keys = [] self.two_players = False self.player_vs_ai_white = False self.ai_agent = MinimaxABAgent(player_color=0)
def __init__(self, root=None, master=None): super().__init__(master) self.master = master self.root = root # State self.state = State() # Views # Make the top level window to be resizable, and take up entire available width top = self.winfo_toplevel() top.rowconfigure(0, weight=1) top.columnconfigure(0, weight=1) self.rowconfigure(0, weight=1) self.columnconfigure(0, weight=1) self.menu_bar = V_menubar.GameViewMenuBar(self, self) self.main_menu = V_menu.MainMenu(self, self) self.practice_view = V_practice.PracticeView(self, self, self.state) self.vsCpu_view = V_vsCpu.VsCpuView(self, self, self.state) self.stats_view = V_stats.StatsView(self, self) self.main_menu.draw() self.grid(sticky=tk.N + tk.S + tk.E + tk.W) # Music mx.init() mx.music.load('./resources/music.mp3') mx.music.play(loops=-1) mx.music.set_volume(0.07) self.key_sound = mx.Sound('./resources/Keyboard Sounds_Cherry Clear.mp3') # Initiate Playtime counting self.incrementPlayTime()
def play_with_ai_white(self, ai_agent=ControllerConfig.AI_AGENT): """ Returns ------- dict Dict of possible action and state """ self.state = State() self.state.initial_state() self.player_vs_ai_white = True state_dict = AIElements.get_state_dict(self.state) possible_action = AIElements.get_possible_action(self.state) self.possible_action_keys = possible_action.keys() if ai_agent == 'random': self.ai_agent = RandomAgent() elif ai_agent == 'minimaxab': self.ai_agent = MinimaxABAgent(player_color=0) elif ai_agent == 'azero': self.ai_agent = AlphaZeroAgent() self.old_state_reward = deepcopy(self.state) return { "state": state_dict, "possible_action": possible_action, "task": "CHANGE_PLAYER" }
def test_unsolvable(self): # given initial_state = State(self.board2) # when solvability = initial_state.is_solvable() # then self.assertEqual(solvability, False)
def test_solvable_3x3(self): # given initial_state = State(self.board3) # when solvability = initial_state.is_solvable() # then self.assertEqual(solvability, True)
def _retrieve_choices(self, policy): choices_with_usable = [[ policy.hit_certainty_in(State(player_sum, opponent_sum, True)) for opponent_sum in range(2, 12) ] for player_sum in range(12, 22)] choices_without_usable = [[ policy.hit_certainty_in(State(player_sum, opponent_sum, False)) for opponent_sum in range(2, 12) ] for player_sum in range(12, 22)] return choices_with_usable, choices_without_usable
def warrior(game_map, game_params, game_teams): global start global ticks while True: state = State(input(), game_teams, game_params) my_buildings = state.my_buildings() my_squads = state.my_squads() # сортируем по остаточному пути my_squads.sort(key=lambda c: c.way.left, reverse=False) enemy_buildings = state.enemy_buildings() enemy_squads = state.enemy_squads() neutral_buildings = state.neutral_buildings() forges_buildings = state.forges_buildings() if state.ability_ready(AbilityType.Area_damage): cast_aoe(enemy_squads, enemy_buildings, game_map, game_teams) move_units(enemy_buildings, my_buildings, enemy_squads, game_map, game_teams) ticks += 1 print("end")
def test_single_iteration(self): # given initial_state = State(self.board1) expected_states = [ State(self.board12, [MoveDown()], [self.board1]), State(self.board11, [MoveRight()], [self.board1]), ] # when states = self._iterate(initial_state) # then self.assertListEqual(states, expected_states)
def _retrieve_choices(self, policy): choices_with_usable = [[ policy.make_decision_in(State(player_sum, opponent_sum, True)).value for opponent_sum in range(2, 12) ] for player_sum in range(12, 22)] choices_without_usable = [[ policy.make_decision_in(State(player_sum, opponent_sum, False)).value for opponent_sum in range(2, 12) ] for player_sum in range(12, 22)] return choices_with_usable, choices_without_usable
def should_merge(self, state_1: State, state_2: State) -> bool: # import os # if state_1.get_state_id_config() == state_2.get_state_id_config(): # if self.get_phash_from_state(state_1) - self.get_phash_from_state(state_2) < VisualSimilarityMerger.PHASH_EPSILON: # return True # else: # state_1_image_path = next(iter(state_1.image_paths)) # cmd = f"open {state_1_image_path}; open {next(iter(state_2.image_paths))}" # print(cmd) # os.system(cmd) # return False # else: # return False return self.get_phash_from_state(state_1) - self.get_phash_from_state(state_2) < VisualSimilarityMerger.PHASH_EPSILON \ and state_1.get_state_id_config() == state_2.get_state_id_config()
def get_state(): state = State() first = True for file in os.listdir("examples"): if os.path.splitext(file)[1] != ".zip": continue zfile = ZipFile("examples/" + file) content = zfile.read("contents.xml") tree = ElementTree.fromstring(content) if first: state.fromXml(tree) first = False else: state.merge(tree) return state
def populate_board(self, seed): board = np.zeros((self.size, self.size), 'b') num_pieces = int((self.size * self.size) / 2) pieces = [] if seed is not None: if seed != "random": self.rand_seed_used = seed np.random.seed(seed) # Generate random positions for pieces squares = np.arange(0, self.size * self.size) np.random.shuffle(squares) # Populate board with equal amount of white and black pieces for i in range(num_pieces): num = squares[i] Y = int(num / self.size) X = int(num % self.size) piece = 1 if i < num_pieces/2 else -1 board[Y][X] = piece pieces.append((Y, X)) pieces.sort() else: # Position pieces as a 'Chess formation'. board[:][0:2] = -1 board[:][-2:] = 1 pieces.extend([(0, x) for x in range(self.size)]) pieces.extend([(1, x) for x in range(self.size)]) pieces.extend([(self.size-2, x) for x in range(self.size)]) pieces.extend([(self.size-1, x) for x in range(self.size)]) self.init_state = State(board, True, pieces=pieces)
def updateEnvironment(self): # Aqui vamos a actualizar el entorno for chrom in self.environment: # Por cada cromo en el entorno, si no esta en el listado, # aumentarlo mediante un append if chrom not in self.un: self.un.append(chrom) self.minCosts = list() costs = list() newEnvironment = list() # Creamos un nuevo entorno for chrom in self.environment: state = State(chrom) costs.append(state.cost) if min(costs) == 0: self.solution = costs.index(min(costs)) self.goal = self.environment[self.solution] return self.environment while len(newEnvironment) < self.d: minCost = min(costs) minIndex = costs.index(minCost) self.minCosts.append(costs[minIndex]) newEnvironment.append(self.environment[minIndex]) costs.remove(minCost) self.environment.remove(self.environment[minIndex]) self.environment = newEnvironment # Seteamos la nueva variable en el entorno ya mencionado # para seguir trabajando con esto print(self.minCosts, ">>", len(self.un))
def play_starting_in(self, initial_state: State) -> GameInfo: game_info = GameInfo() player_state = self._play_stage(initial_state=initial_state, policy=self._player_policy, log_action=game_info.log_player) if player_state == BUST: game_info.set_winner(Winner.DEALER) return game_info dealer_cards = (initial_state.opponent_points, self._deck.get_next_card()) dealer_state = self._play_stage(initial_state=State.from_deal( *dealer_cards, player_state.current_sum), policy=self._dealer_policy, log_action=game_info.log_dealer) if dealer_state == BUST: game_info.set_winner(Winner.PLAYER) return game_info if player_state.current_sum > dealer_state.current_sum: game_info.set_winner(Winner.PLAYER) elif player_state.current_sum == dealer_state.current_sum: game_info.set_winner(Winner.DRAW) else: game_info.set_winner(Winner.DEALER) return game_info
def update(self): """ Update the command line interface to the latest controller state. """ # print configuration print(format_fans(fans=Configuration.fans)) print(format_ports(ports=Configuration.ports)) print(format_ambients(ambients=Configuration.ambients)) print(format_limits(limits=Configuration.limits)) # print runtime state print(format_pwms(pwms=State().pwms)) print(format_rpms(rpms=State().rpms)) print(format_temps(temps=State().temperatures)) print(format_headrooms(headrooms=State().headrooms)) print()
def epsilon_greedy_from_values(cls, values: dict, exploring_prob: Callable): mapping = dict() for s in State.get_all_states(): if values[StateActionPair(s, Action.STICK)] > values[StateActionPair(s, Action.HIT)]: mapping[s] = [1. - exploring_prob(), exploring_prob()] else: mapping[s] = [exploring_prob(), 1. - exploring_prob()] return Policy.from_probabilistic_mapping(mapping)
def from_values(cls, values: dict): mapping = dict() for s in State.get_all_states(): if s.current_sum < 12: mapping[s] = Action.HIT elif values[StateActionPair(s, Action.STICK)] > values[StateActionPair(s, Action.HIT)]: mapping[s] = Action.STICK else: mapping[s] = Action.HIT return Policy.from_deterministic_mapping(mapping)
def fight_agent(best_model: str, current_model: str, ae, round_fight=AlphaZeroConfig.ROUND_ARENA, max_turn=AlphaZeroConfig.MAX_TURN_ARENA, max_simulation=AlphaZeroConfig.MAX_SIMULATION_ARENA): """ The pitted 2 agents. We will check who is the best here. :param best_model: The current best model file path :param current_model: The current model file path :param ae: The Action Encoder :param round_fight: number of round to determine the winner :param max_turn: The maximum turn of the game. If the current turn is higher than max turn. It will be cut and the outcome of the game is draw. :param max_simulation: The maximum of simulation :return: dict, The dictionary of the score """ from ai_modules.reinforcement_algorithm import AlphaZeroAgent loss_win = {0: 0, 1: 0} for round in range(round_fight): print("ROUND {}".format(round + 1)) terminal = False count_turn = 1 state = State() state.initial_state() best_model_agent = AlphaZeroAgent(state, max_simulation, best_model) # 1 current_model_agent = None # 0 while not terminal and count_turn <= max_turn: print("=======TURN {} ========".format(count_turn)) state.print_board() current_player_turn = state.get_player_turn() if current_player_turn == 1: key, dict_key = best_model_agent.choose_action(state) state = AIElements.result_function(state, dict_key) if current_model_agent is not None: current_model_agent.enemy_turn_action(key, state) else: if current_model_agent is None: current_model_agent = AlphaZeroAgent( state, max_simulation, current_model) key, dict_key = current_model_agent.choose_action(state) state = AIElements.result_function(state, dict_key) best_model_agent.enemy_turn_action(key, state) print("Player %d choose action %s" % (current_player_turn, key)) game_ended = state.is_terminal() if game_ended: print("Player {} Win".format(count_turn % 2)) loss_win[(current_player_turn) % 2] += 1 terminal = True count_turn += 1 if count_turn > max_turn: print("ROUND {} DRAW".format(round + 1)) return loss_win
def cpu_button_press(self, index): assert index in range(9) # Adds token to the tic tac toe board if not self.state.add_token(CONST.LOC_LOCAL_CPU, index): return self.vsCpu_view.update_tooltip(f'You had made your move at grid {index}!') self.play_sound() self.refresh_boards() # Checks for winning winner = State.checkWinningState(self.state.cpu_board) # Player wins, or tied if winner is not None: Controller.show_cpu_winner(winner, self.state.isPlayerFirst) self.state.game_set(CONST.LOC_LOCAL_CPU, winner) self.vsCpu_view.update_tooltip(f'A new game has begin') self.refresh_boards() # After refresh, check if CPU moves first if not self.state.isPlayerFirst: move = self.state.cpu_moves() self.play_sound() self.refresh_boards() self.vsCpu_view.update_tooltip(f'CPU had made its move at grid {move}!') return # Player moves but not yet deterministic. CPU moves and check state move = self.state.cpu_moves() self.play_sound() self.refresh_boards() self.vsCpu_view.update_tooltip(f'CPU had made its move at grid {move}!') winner = State.checkWinningState(self.state.cpu_board) # Tie or CPU wins if winner is not None: Controller.show_cpu_winner(winner, self.state.isPlayerFirst) self.state.game_set(CONST.LOC_LOCAL_CPU, winner) self.refresh_boards() self.vsCpu_view.update_tooltip('A new game has begin') # After refresh, check if CPU moves first if not self.state.isPlayerFirst: move = self.state.cpu_moves() self.play_sound() self.refresh_boards() self.vsCpu_view.update_tooltip(f'CPU had made its move at grid {move}!')
def test_two_iterations(self): # given initial_state = State(self.board1) expected_states = [ State(self.board121, [MoveDown(), MoveUp()], [self.board1, self.board12]), State(self.board122, [MoveDown(), MoveRight()], [self.board1, self.board12]), State(self.board112, [MoveRight(), MoveDown()], [self.board1, self.board11]), State(self.board111, [MoveRight(), MoveLeft()], [self.board1, self.board11]), ] # when states1 = self._iterate(initial_state) states2 = [s for states in states1 for s in self._iterate(states)] # then self.assertListEqual(states2, expected_states)
def __init__(self, num_of_states: int = 1, num_of_actions: int = 1, alfa: float = 0.1, lambd: float = 0.1, epsilon=0.1, g_init: float = 0, n_init: float = 0): """ Actor only approch model """ self.states = [] for _ in range(num_of_states): state = State(num_of_actions=num_of_actions, alfa=alfa, lambd=lambd, epsilon=epsilon, g_init=g_init, n_init=n_init) self.states.append(state)
def test_whole_state(self): # given start_state = self.state2 target_state = State(self.board1, [MoveLeft()], [self.board2]) # when solved_state = IDFS().solve(start_state, h0) # then self.assertEqual(target_state, solved_state)
def start_state(self): super.__doc__ board = np.zeros((self.size, self.size), dtype="b") half = self.size // 2 board[half][half - 1] = 1 board[half - 1][half] = 1 board[half][half] = -1 board[half - 1][half - 1] = -1 pieces = [(half, half - 1), (half - 1, half), (half, half), (half - 1, half - 1)] return State(board, True, pieces=pieces)
def play_with_two_players_start(self): """ Return the initial state Returns ------- dict Dict of possible Action and state """ self.state = State() self.state.initial_state() self.two_players = True state_dict = AIElements.get_state_dict(self.state) possible_action = AIElements.get_possible_action(self.state) self.possible_action_keys = possible_action.keys() return { "state": state_dict, "possible_action": possible_action, "task": "CHANGE_PLAYER" }
class TestState(unittest.TestCase): rows = 2 cols = 2 board1 = Board([Node(0), Node(1), Node(2), Node(3)], rows, cols) board2 = Board([Node(1), Node(0), Node(2), Node(3)], rows, cols) board3 = Board([Node(1), Node(3), Node(0), Node(2)], rows, cols) state1 = State(board1) state2 = State(board2) state3 = State(board3) def test_board_only(self): # given start_state = self.state2 # when solved_state = DFS().solve(start_state, h0) # then self.assertListEqual(self.board1.content, solved_state.current_board.content) def test_whole_state(self): # given start_state = self.state2 target_state = State(self.board1, [MoveLeft()], [self.board2]) # when solved_state = DFS().solve(start_state, h0) # then self.assertEqual(target_state, solved_state) def test_longer(self): start_state = self.state3 # when solved_state = DFS().solve(start_state, h0) # then self.assertEqual(sorted(start_state.current_board.content), solved_state.current_board.content)
def make_temp_board_solution(self, i, j, BestCost): tempBoard = self.copyBoard() # creamos una variable temporal de borde tempBoard[i] = (tempBoard[i] + j + 1) % self.d tempState = State(tempBoard) if tempState.cost < BestCost: BestCost = tempState.cost self.solutions.clear() self.solutions.append([tempBoard[i], i, BestCost]) elif tempState.cost == BestCost: self.solutions.append([tempBoard[i], i, BestCost]) return BestCost
def result(self, state, action): super.__doc__ copy_arr = np.copy(state.board) new_state = State(copy_arr, not state.player, [p for p in state.pieces]) if not action: return new_state player_num = 1 if state.player else -1 y, x = action.dest result(copy_arr, y, x, self.size, player_num) new_state.pieces.append((y, x)) return new_state
def control(self, rpms): # TODO adjust pwms to rpms temperatures = get_temps() headrooms = get_headrooms(temperatures=temperatures) pwms = get_pwms(headrooms=headrooms) State().update(headrooms=headrooms, pwms=pwms, rpms=rpms, temperatures=temperatures)
def __init__(self, screen_dimension): self.width, self.height = screen_dimension self._background = pygame.transform.scale( pygame.image.load( os.path.join('../', 'assets', 'img', 'background.jpg')), (self.width, self.height)) self._level_creator = LevelCreator() self._level = 1 self._state = State( self._level_creator.create(self._level, (self.width, self.height))) self._header = None self._buttons = [] pygame.mixer.music.stop()
def main(user_interface): controller = Controller() user_interface = _get_user_interface(ui=user_interface) ttys = ['/dev/ttyACM0', '/dev/ttyACM1', '/dev/ttyACM2', '/dev/ttyACM3'] with Bridgehead(ttys=ttys, baudrate=9600) as bridgehead: rpms = [None] * len(Configuration.fans) while True: controller.control(rpms) user_interface.update() try: rpms = bridgehead(pwms=State().pwms) except KeyboardInterrupt: break
def __init__(self, maze_rows, maze_cols): self.__maze_rows = maze_rows self.__maze_cols = maze_cols self.__maze = self.generate_random_grid() self.__states = StateMap.get_instance() for i in range(0, maze_rows): for j in range(0, maze_cols): if self.__maze[i, j] == 1: cell_type = CellType.block else: cell_type = CellType.empty if (i, j) == (maze_rows - 1, maze_cols - 1): cell_type = CellType.end s = State(i, j, self.__maze, cell_type) self.__states.add_state(i, j, s)