def aStar(rootNode, heur, timeout): open_list = PQ() closed_list = [] search_path = [] rootNode.fn = rootNode.hn = rootNode.h( heur) # g(n) is 0 by default, so we only set f(n) & h(n) open_list.insert(rootNode.fn, rootNode) # Add initial node start_time = perf_counter() # Start the timer timedOut = False while (open_list.notEmpty()): elapsed_time = perf_counter() # if algorithm's runtime has exceeded the specified amount, stop execution if ((elapsed_time - start_time) >= timeout): timedOut = True return (None, None, None, None, None, None, timedOut) else: currCost, node = open_list.pop() # get node and its g(n) clist_node_index = index( node.state, closed_list ) # get index of node in closed list or -1 if absent # node has been visited, but we must check if it now has a lower f(n) value if clist_node_index >= 0: if (node.fn < closed_list[clist_node_index].fn): del closed_list[ clist_node_index] # new f(n) < old f(n), so delete old node from cl open_list.insert(node.fn, node) else: closed_list.append( node ) # node is visited for the first time, add to closed list search_path.append(node) # update search path # goal achieved, stop algorithm and return results if (node.isGoal(node.state)): moves, costs, sol_path = node.traceSolution([], [], []) totalCost = sum(costs) end_time = (elapsed_time - start_time) return (moves, costs, sol_path, search_path, totalCost, end_time, timedOut) # Return final values # goal not achieved yet, generate next nodes and keep evaluating else: node.generateSuccessors() successors = node.successors for successor in successors: if successor not in closed_list: successor.hn = successor.h(heur) successor.gn = currCost + successor.cost successor.fn = successor.gn + successor.hn open_list.insert(successor.fn, successor)
def __init__(self): #This allows access to specific entities #sEntityType:(sEntityName:entity) self._dEntities = {} #This orders the entities so that the ones with the highest draw # priority will be first in the list (highest priority is 0.) self._pqDrawableEntities = PQ()
def gbfs(rootNode, heur, timeout): open_list = PQ() closed_list = [] search_path = [] rootNode.hn = rootNode.h(heur) open_list.insert(rootNode.hn, rootNode) # Add initial node start_time = perf_counter() # Start the timer timedOut = False while (open_list.notEmpty()): elapsed_time = perf_counter() # if algorithm's runtime has exceeded the specified amount, stop execution if ((elapsed_time - start_time) >= timeout): timedOut = True return (None, None, None, None, None, None, timedOut) else: node = open_list.pop()[ 1] # We don't care about the heuristic value returned # if node has not been visited yet, process it if node.state not in closed_list: closed_list.append( node.state ) # node is visited for the first time, add to closed list search_path.append(node) # update search path # goal achieved, stop algorithm and return results if (node.isGoal(node.state)): moves, costs, sol_path = node.traceSolution([], [], []) totalCost = sum(costs) end_time = (elapsed_time - start_time) return (moves, costs, sol_path, search_path, totalCost, end_time, timedOut) # Return final values # goal not achieved yet, generate next nodes and keep evaluating else: node.generateSuccessors() successors = node.successors for successor in successors: if successor not in closed_list: successor.hn = successor.h(heur) open_list.insert(successor.hn, successor)
def ucs(rootNode, timeout): open_list = PQ() closed_list = set() search_path = [] open_list.insert(0, rootNode) # Add initial node with g(n) of 0 start_time = perf_counter() # Start the timer timedOut = False while (open_list.notEmpty()): elapsed_time = perf_counter() # if algorithm's runtime has exceeded the specified amount, stop execution if ((elapsed_time - start_time) >= timeout): timedOut = True return (None, None, None, None, None, None, timedOut) else: currCost, node = open_list.pop() # get node and its g(n) # if node has not been visited yet, process it if (str(node.state) not in closed_list): closed_list.add( str(node.state) ) # node is visited for the first time, add to closed list search_path.append(node) # goal achieved, stop algorithm and return results if (node.isGoal(node.state)): moves, costs, sol_path = node.traceSolution([], [], []) totalCost = sum(costs) end_time = (elapsed_time - start_time) return (moves, costs, sol_path, search_path, totalCost, end_time, timedOut) # Return final values # goal not achieved yet, generate next nodes and keep evaluating else: node.generateSuccessors() successors = node.successors for successor in successors: if successor not in closed_list: successor.gn = currCost + successor.cost open_list.insert(successor.gn, successor)
def __init__(self, sName, sType, iDrawPriority, dAttribs): Entity.__init__(self, sName, sType, iDrawPriority, {}) #This takes all of the entities out of the dComponents dEntities = dAttribs.pop("entity", {}) #"These are the entities that are being loaded into the Entity_PQueue" #print dEntities #This orders the entities so that the ones with the highes t draw # priority will be first in the list (highest priority is 0.) self._pqEntities = PQ() #This is Pymunk's Space() class basically. But it's in a component. # It will contain the collidable object for Entities. Entity._Add_Component( self, getClass("Collision_Space")( {"componentID":"EntityPool", \ "gravity":dAttribs["gravity"].split(",")} ) ) #This will insert the entities into the PriorityQueue through the proper method. for entity in dEntities.values(): self._Add_Entity(entity)
def search_for_path_winter(self, object_orien, start, final): """ Search for path during the winter season :param start:Start point :param final:Point to be reached :return:Final list containing the final path """ object_orien.speed_through_different_paths[(178, 255, 255)] = 5 object_orien.speed_through_different_paths[(0, 0, 255)] = 0.1 # To keep track of g values cost_so_far = {} # Priority queue initialization s = PQ() # To keep track of predecessors to help in backtracking predecessor = {} # Insert start point into the priority queue s.put(start, 0) # g value of start is 0 cost_so_far[start] = 0 # f value of start is 0 + h(start) f_value = {} f_value[start] = object_orien.calculateh(start[0], start[1], final[0], final[1]) final_path_list = [] # Exiting condition when no path is found while not s.empty(): # Fetch the element in the priority queue with the lowest g(n) + h(n) value point_explored = s.get() # To keep the final path final_path_list = [] # Exiting condition for when there exists a path between the start point and end point supplied to this function if point_explored == final: #Backtracking to find the actual path from the start point to the final point curr = final while curr != start: final_path_list.insert(0, curr) curr = predecessor[curr] final_path_list.insert(0, start) break # Get the neighbours of the element fetched from the priority queue neighbour_list = self.getNeighbour_winter(object_orien, int(point_explored[0]), int(point_explored[1])) # Loop through all the neighbours of fetched element for neighbour in neighbour_list: # Calculate g value for the neighbour calculated_g_value = cost_so_far[ point_explored] + object_orien.calculateg( neighbour[0], neighbour[1], point_explored[0], point_explored[1]) # Calculate h value for the neighbour calculated_h_value = object_orien.calculateh( neighbour[0], neighbour[1], final[0], final[1]) # If neighbour not already in queue or neighbour calculated f value less than than its tracked f value till now if neighbour not in cost_so_far or \ calculated_g_value + calculated_h_value < f_value[neighbour]: cost_so_far[neighbour] = calculated_g_value f_value[ neighbour] = calculated_g_value + calculated_h_value s.put(neighbour, calculated_g_value + calculated_h_value) predecessor[neighbour] = point_explored return final_path_list