def successors(self, state): """successors. The successors function must return (or yield) a list of pairs (a, s) in which a is the action played to reach the state s. :param state: the state for which we want the successors """ for action in SeegaRules.get_player_actions(state, self.position): next_state = deepcopy(state) SeegaRules.act(next_state, action, self.position) yield action, next_state
def successors(self, state): """successors. The successors function must return (or yield) a list of pairs (a, s) in which a is the action played to reach the state s. :param state: the state for which we want the successors """ next_player = state.get_next_player() is_our_turn = next_player == self.position successors = list() if not is_our_turn and self._already_tracked(state): return list() for action in SeegaRules.get_player_actions(state, next_player): next_state = deepcopy(state) if SeegaRules.act(next_state, action, next_player): successors.append((action, next_state)) # Sort states with their evaulation values (reverse : min/max) successors.sort(key=lambda x: self.evaluate(x[1]), reverse=not is_our_turn) # logging.info(f'Next states for {["oponent", "us"][is_our_turn]} -> {successors}') # Get all not already tracked states if loosing and is our turn if is_our_turn and self._alpha_winning(state) < 0.5: not_tracked = list( filter(lambda elem: not self._already_tracked(elem[1]), successors)) if not_tracked: successors = not_tracked return successors
def play(self, state, remain_time): print("") print(f"Player {self.position} is playing.") print("time remain is ", remain_time, " seconds") if self._total_time is None: self._total_time = remain_time self._remaining_time = remain_time def time_policy(policy="exponential", min_frac=1 / 2000, max_frac=1 / 100): """time_policy. :param policy: the desired policy between ('linear', 'exponential') :param min_frac: the minimum fraction of total time allowed for computing time :param max_frac: the maximum fraction of total time allowed for computing time """ min, max = self._total_time * min_frac, self._total_time * max_frac # Calculate the linear and exponential policy logging.info(f"alpha time : {self._alpha_time}") schedulers = dict( linear=min + self._alpha_time * (max - min), exponential=min + (np.exp(self._alpha_time * math.log(2)) - 1) * (max - min), ) return schedulers[policy] self._max_running_time = time_policy("exponential") print(self._max_running_time) # Begining the search self._start_minimax = perf_counter() best_action = self.iterative_deepening(state) tracked_state = deepcopy(state) SeegaRules.act(tracked_state, best_action, self.position) self._track_state(tracked_state) return best_action
def successors(self, state): # #player = state._next_player # actions = SeegaRules.get_player_actions(state, self.color.value) # SeegaRules.act(s, a, self.color.value) next_player = state._next_player actions = SeegaRules.get_player_actions(state, next_player) successors = list() for a in actions: s = deepcopy(state) possible_states = SeegaRules.act(s, a, next_player) if possible_states: successors.append((a, possible_states[0])) if state.phase == 2: successors.sort(key=lambda t: self.evaluate(t[1]), reverse=next_player != self.position) return successors
def successors(self, state): """successors. The successors function must return (or yield) a list of pairs (a, s) in which a is the action played to reach the state s. :param state: the state for which we want the successors """ next_player = state.get_next_player() is_our_turn = next_player == self.position successors = list() if not is_our_turn and self._already_tracked(state): return list() actions = SeegaRules.get_player_actions(state, next_player) if state.phase == 2: nn_actions = self._agent._state_to_actions(state, reverse=not is_our_turn) actions = list( filter( lambda x: any([self._action_eq(x, a) for a in actions]), nn_actions, )) for action in actions: next_state = deepcopy(state) if SeegaRules.act(next_state, action, next_player): successors.append((action, next_state)) # Get all not already tracked states if loosing and is our turn if is_our_turn and self._alpha_winning(state) < 0.5: not_tracked = list( filter(lambda elem: not self._already_tracked(elem[1]), successors)) if not_tracked: successors = not_tracked return successors