def get_next_vertex(current_vertex: Vertex, edge_name: str, step_cost: Callable,
env_config: EnvironmentConfiguration) -> Vertex:
"""
:param current_vertex: the current state
:param edge_name: edge name from current vertex to the next vertex
:param step_cost: function that receives parent_vertex, action, new_node and returns the step cost.
:param env_config: environment configuration
:return: The new vertex
"""
current_state = current_vertex.get_state()
current_vertex_name = current_vertex.get_vertex_name()
edges_dict = env_config.get_edges()
vertexes_dict = env_config.get_vertexes()
if edge_name not in edges_dict:
current_vertex.set_state(current_state)
print("No operation for this agent")
current_vertex.set_cost(
current_vertex.get_cost() + step_cost(current_vertex, Edge("", 0, ("", "")), current_vertex))
return current_vertex # No operation
edge = edges_dict[edge_name]
first_vertex, sec_vertex = edge.get_vertex_names()
next_vertex_name = first_vertex if sec_vertex == current_vertex_name else sec_vertex
next_vertex = vertexes_dict[next_vertex_name]
next_state = State(next_vertex_name, copy.deepcopy(current_state.get_required_vertexes()))
if next_vertex_name in current_state.get_required_vertexes():
next_state.set_visited_vertex(next_vertex_name)
next_vertex.set_state(next_state)
people_in_next_vertex = next_vertex.get_people_num()
new_next_vertex = Vertex(people_in_next_vertex, next_state, next_vertex.get_edges(),
current_vertex, edge.get_edge_name(), current_vertex.get_depth(),
EnvironmentUtils.g(current_vertex, env_config) + step_cost(current_vertex, edge, next_vertex))
return new_next_vertex
def get_next_vertex(current_vertex: Vertex,
edge_name: str,
step_cost: Callable,
env_config: EnvironmentConfiguration,
is_max_player: bool = True) -> Vertex:
"""
:param current_vertex: the current state
:param edge_name: edge name from current vertex to the next vertex
:param step_cost: function that receives parent_vertex, action, new_node and returns the step cost.
:param is_max_player: True if this is the max player, false otherwise
:param env_config: environment configuration
:return: The new vertex
"""
current_state = current_vertex.get_state()
current_vertex_name = current_vertex.get_vertex_name()
edges_dict = env_config.get_edges()
vertexes_dict = env_config.get_vertexes()
if edge_name not in edges_dict:
current_vertex.set_state(current_state)
print("edge_name= ", edge_name)
print("No operation for this agent")
current_vertex.set_cost(current_vertex.get_cost() + step_cost(
current_vertex, Edge("", 0, ("", "")), current_vertex))
return current_vertex # No operation
edge = edges_dict[edge_name]
first_vertex, sec_vertex = edge.get_vertex_names()
next_vertex_name = first_vertex if sec_vertex == current_vertex_name else sec_vertex
next_vertex = vertexes_dict[next_vertex_name]
scores_of_agents = current_state.get_scores_of_agents()
if next_vertex_name in current_state.get_required_vertexes(
) and not current_state.get_required_vertexes()[next_vertex_name]:
scores_of_agents = (scores_of_agents[0] +
next_vertex.get_people_num(),
scores_of_agents[1]) if is_max_player else (
scores_of_agents[0], scores_of_agents[1] +
next_vertex.get_people_num())
next_state = State(
next_vertex_name, scores_of_agents,
copy.deepcopy(current_state.get_required_vertexes()),
current_state.get_cost() +
step_cost(current_vertex, edge, next_vertex))
if next_vertex_name in current_state.get_required_vertexes():
next_state.set_visited_vertex(next_vertex_name)
next_vertex.set_state(next_state)
people_in_next_vertex = next_vertex.get_people_num()
next_state.set_parent_state(current_state)
new_next_vertex = Vertex(
people_in_next_vertex, next_state, next_vertex.get_edges(),
current_vertex, edge.get_edge_name(), current_vertex.get_depth(),
EnvironmentUtils.g(current_vertex, env_config) +
step_cost(current_vertex, edge, next_vertex))
return new_next_vertex
def get_possible_moves(current_state: State, env_config: EnvironmentConfiguration) -> List[Edge]:
current_vertex_name = current_state.get_current_vertex_name()
vertexes_dict = env_config.get_vertexes()
edges_dict = {k: v for k, v in env_config.get_edges().items() if k not in env_config.get_blocked_edges()}
current_vertex = vertexes_dict[current_vertex_name]
names_of_edges = [edge for edge in current_vertex.get_edges() if edge not in env_config.get_blocked_edges()]
possible_edges = []
for edge_name in names_of_edges:
possible_edges.append(edges_dict[edge_name])
return possible_edges
def print_environment(env_config: EnvironmentConfiguration):
num_of_vertex = env_config.get_vertices_num()
deadline = env_config.get_deadline()
edges_dict = env_config.get_edges()
vertexes_dict = env_config.get_vertexes()
print(EnvironmentUtils._NUMBER_OF_VERTICES_PREFIX + EnvironmentUtils._SPACE_SEPARATOR + str(
num_of_vertex))
print(EnvironmentUtils._DEADLINE_PREFIX + EnvironmentUtils._SPACE_SEPARATOR + str(deadline))
for vertex in vertexes_dict.values():
EnvironmentUtils.__print_vertex(vertex)
for edge in edges_dict.values():
EnvironmentUtils.__print_edge(edge)
print("Blocked edges: ", env_config.get_blocked_edges())
def read_configuration(file_path: str):
with open(file_path, 'r') as f:
lines = [
line.split(ConfigurationReader.COMMENT_SEPARATOR)[0].strip()
for line in f if line.strip()
] # removes comments & empty lines.
vertexes_dict = {}
edges_dict = {}
vertices_num = -1
deadline = -1 # default values.
for current_line in lines:
if current_line.startswith("#N"):
vertices_num = int(
current_line.split(ConfigurationReader.SPACE_SEPARATOR)[1])
elif current_line.startswith("#D"):
deadline = float(
current_line.split(ConfigurationReader.SPACE_SEPARATOR)[1])
elif current_line.startswith("#V"):
name, vertex = ConfigurationReader.create_vertex(current_line)
vertexes_dict[name] = vertex
elif current_line.startswith("#E"):
name, edge = ConfigurationReader.create_edge(current_line)
edges_dict[name] = edge
# add the edge name to relevant vertexes
first_vertex, second_vertex = edge.get_vertex_names()
vertexes_dict[first_vertex].add_edge_name(edge.get_edge_name())
vertexes_dict[second_vertex].add_edge_name(
edge.get_edge_name())
return EnvironmentConfiguration(vertices_num, deadline, vertexes_dict,
edges_dict)
def get_required_vertexes(
env_config: EnvironmentConfiguration) -> Dict[str, bool]:
required_vertexes = {}
for vertex_name in env_config.get_vertexes().values():
if vertex_name.get_people_num() > 0:
required_vertexes[vertex_name.get_vertex_name()] = False
return required_vertexes
def __make_node(self, state: State, env_conf: EnvironmentConfiguration):
name = state.get_current_vertex_name()
vertex = env_conf.get_vertexes()[name]
vertex.set_state(state)
vertex.set_cost(
len(state.get_required_vertexes()) -
sum(state.get_required_vertexes().values()))
return vertex
def get_saved_people_num(state: State, current_traveled_states, env_conf: EnvironmentConfiguration) -> List[int]:
score = 0
traveled_vertexes = [vertex_name for vertex_name in StateUtils.get_state_traveled_vertexes(state) if
vertex_name not in current_traveled_states]
current_traveled_states.append(state.get_current_vertex_name())
vertexes_dict = env_conf.get_vertexes()
for vertex in traveled_vertexes:
score += vertexes_dict[vertex].get_people_num()
return score
def g(node: Vertex, env_conf: EnvironmentConfiguration) -> int:
current_node = copy.deepcopy(node)
edges = env_conf.get_edges()
edges_of_path = []
cost = 0
while current_node is not None:
edges_of_path.append(current_node.get_action() if current_node.get_action() is not None else "")
current_node = current_node.get_parent_vertex()
# calculate the cost to the solution
for edge_name in filter(None, edges_of_path):
cost += edges[edge_name].get_weight()
return cost
def __result(self, action: str, state: State, is_max: bool,
env_config: EnvironmentConfiguration) -> State:
"""
:param action: edge name
:param state: current state
:return: next state after moving on edge action from the given state
"""
next_vertex = env_config.get_vertexes()[
state.get_current_vertex_name()]
next_vertex.set_state(state)
return EnvironmentUtils.get_next_vertex(next_vertex, action,
self.step_cost, env_config,
is_max).get_state()
def __successor_func(
self, node: Vertex,
env_conf: EnvironmentConfiguration) -> List[Tuple[str, Vertex]]:
current_state = node.get_state()
edges_list = EnvironmentUtils.get_possible_moves(
current_state, env_conf)
self._expansions_num += 1
names_of_edges = [edge.get_edge_name() for edge in edges_list]
edge_to_next_state_list = []
for edge_name in names_of_edges:
next_vertex = EnvironmentUtils.get_next_vertex(
node, edge_name, self.step_cost, env_conf)
env_conf.get_vertexes()[
next_vertex.get_vertex_name()] = next_vertex
edge_to_next_state_list.append((edge_name, next_vertex))
return edge_to_next_state_list
def restore_solution(
self, goal_node: Vertex,
env_conf: EnvironmentConfiguration) -> Tuple[List, int]:
vertexes_path = []
current_node = goal_node
edges = env_conf.get_edges()
edges_of_path = []
cost = 0
while current_node is not None:
edges_of_path.append(current_node.get_action() if current_node.
get_action() is not None else "")
vertexes_path.append(copy.deepcopy(current_node))
current_node = current_node.get_parent_vertex()
vertexes_path.reverse()
# calculate the cost to the solution
for edge_name in filter(None, edges_of_path):
cost += edges[edge_name].get_weight()
return vertexes_path, cost
def minimax(self, state: State, action_to_state: str, depth: int,
alpha: int, beta: int, is_max_player: bool,
env_config: EnvironmentConfiguration):
if TerminalEvaluator.was_deadline_passed(state,
env_config.get_deadline()):
return None, TerminalEvaluator.terminate_eval(
state.get_parent_state(), self.__mode, is_max_player)
if TerminalEvaluator.are_no_more_people(state):
return action_to_state, TerminalEvaluator.terminate_eval(
state, self.__mode, is_max_player)
if depth == 0:
return action_to_state, TerminalEvaluator.cut_off_utility_eval(
state, is_max_player, env_config.get_vertexes())
possible_edges = EnvironmentUtils.get_possible_moves(state, env_config)
possible_actions = [edge.get_edge_name() for edge in possible_edges]
if is_max_player:
# Max Player
best_action = None
max_utility_value = -10000000
max_opponent_utility = -10000000
best_score = None
for action in possible_actions:
possible_next_state = self.__result(action,
copy.deepcopy(state),
is_max_player, env_config)
is_max_next_player = False if self.__mode == MiniMaxAgent.ADVERSARIAL_MODE else True
new_action, scores = self.minimax(
copy.deepcopy(possible_next_state), action, depth - 1,
alpha, beta, is_max_next_player, env_config)
print("cost of possible_next_state = ",
possible_next_state.get_cost())
current_utility, opponent_utility = scores
if self.__is_better_score(max_utility_value, current_utility,
max_opponent_utility,
opponent_utility):
max_utility_value = current_utility
max_opponent_utility = opponent_utility
best_score = scores
best_action = action
alpha = max(alpha, current_utility)
if self.__mode == MiniMaxAgent.ADVERSARIAL_MODE and beta <= alpha:
break
return best_action, best_score
else:
# Min Player
min_utility_value = 10000000
best_action = None
best_score = None
for action in possible_actions:
possible_next_state = self.__result(action, state,
is_max_player, env_config)
_, scores = self.minimax(copy.deepcopy(possible_next_state),
action, depth - 1, alpha, beta, True,
env_config)
current_utility = scores[1] # score of the minimum player
if current_utility < min_utility_value:
min_utility_value = current_utility
best_score = scores
best_action = action
beta = min(beta, current_utility)
if self.__mode == MiniMaxAgent.ADVERSARIAL_MODE and beta <= alpha:
break
return best_action, best_score