def main(speed=0.1, sort_method=sort_alg.bubble_sort): screen = pygame.display.set_mode(resolution, 0, 32) clock = pygame.time.Clock() grid_view = GridView(screen, width, height, grid_size, grid_line_color) sort_alg.generate_random_array() path_track = sort_method() print path_track # some utility variable index = 0 pass_time = 0 while True: for event in pygame.event.get(): if event.type == QUIT: exit() screen.fill(background_color) grid_view.draw_array_in_grid(path_track[index][0], cell_color, path_track[index][1], special_cell_color) grid_view.draw() time_passed_second = clock.tick() / 1000.0 pass_time += time_passed_second if pass_time >= speed: pass_time = 0 index = index + 1 if index >= len(path_track): index = len(path_track) - 1 pygame.display.update()
def main(speed=0.1, sort_method=sort_alg.bubble_sort): screen = pygame.display.set_mode(resolution, 0, 32) clock = pygame.time.Clock() grid_view = GridView(screen, width, height, grid_size, grid_line_color) sort_alg.generate_random_array() path_track = sort_method() print path_track # some utility variable index = 0 pass_time = 0 while True: for event in pygame.event.get(): if event.type == QUIT: exit() screen.fill(background_color) grid_view.draw_array_in_grid(path_track[index][0], cell_color, path_track[index][1], special_cell_color) grid_view.draw() time_passed_second = clock.tick() / 1000.0 pass_time += time_passed_second if pass_time >= speed: pass_time = 0 index = index + 1 if index >= len(path_track): index = len(path_track) - 1 pygame.display.update()
class Grid(): def __init__(self): pygame.init() pygame.display.set_caption("Grid with agents") self.model = GridModel() self.view = GridView(self.model) self.control = GridControl(self.model) def start_loop(self, parameters): clock = pygame.time.Clock() crashed = False timestep = 0 while not crashed: timestep = timestep + 1 print("t = " + str(timestep)) # handle input crashed = self.control.check_events() self.model.update() # draw screen self.view.draw() # update pygame.display.update() clock.tick(parameters.updates)
def main(maze_method, speed=0.010, mode=0): """ the main program of the program mode 0: default mode, build the wall mode 1: first all cell are wall, then pull down the wall """ screen = pygame.display.set_mode(resolution, 0, 32) clock = pygame.time.Clock() maze, cell_list = maze_method() path_finder = MazePathFinder(maze, (2, 1), (cell_row_num * 2, cell_col_num * 2 + 1), height // grid_size, width // grid_size) path = path_finder.bfs_find_path() index = 0 path_index = 0 maze_finished = False pass_time = 0 grid_view = GridView(screen, width, height, grid_size, grid_line_color) while True: for event in pygame.event.get(): if event.type == QUIT: exit() press_key = pygame.key.get_pressed() # press F5 to regenerate the maze if press_key[K_F5]: index = 0 path_index = 0 maze, cell_list = maze_method() path_finder = MazePathFinder(maze, (2, 1), (cell_row_num * 2, cell_col_num * 2 + 1), height // grid_size, width // grid_size) path = path_finder.bfs_find_path() maze_finished = False # print index if mode == 0: screen.fill(background_color) else: screen.fill(cell_color) # draw the cell for i in range(index + 1): if mode == 0: grid_view.fill_a_cell(cell_list[i][1], cell_list[i][0], cell_color) else: grid_view.fill_a_cell(cell_list[i][1], cell_list[i][0], background_color) # draw the grid grid_view.draw() # draw the path if maze_finished and path: for i in range(path_index + 1): grid_view.fill_a_cell_with_circle(path[len(path) - i - 1][1], path[len(path) - i - 1][0], path_color) time_passed_seconds = clock.tick() / 1000.0 pass_time += time_passed_seconds if pass_time >= speed: pass_time = 0 if maze_finished: if path_index + 1 < len(path): path_index += 1 if index >= len(cell_list) - 1: # print 'maze_finished' maze_finished = True if index + 1 < len(cell_list): index += 1 pygame.display.update()
def main(maze_method, speed=0.010, mode=0): """ the main program of the program mode 0: default mode, build the wall mode 1: first all cell are wall, then pull down the wall """ screen = pygame.display.set_mode(resolution, 0, 32) clock = pygame.time.Clock() maze, cell_list = maze_method() path_finder = MazePathFinder(maze, (2, 1), (cell_row_num * 2, cell_col_num * 2 + 1), height//grid_size, width//grid_size) path = path_finder.bfs_find_path() index = 0 path_index = 0 maze_finished = False pass_time = 0 grid_view = GridView(screen, width, height, grid_size, grid_line_color) while True: for event in pygame.event.get(): if event.type == QUIT: exit() press_key = pygame.key.get_pressed() # press F5 to regenerate the maze if press_key[K_F5]: index = 0 path_index = 0 maze, cell_list = maze_method() path_finder = MazePathFinder(maze, (2, 1), (cell_row_num * 2, cell_col_num * 2 + 1), height//grid_size, width//grid_size) path = path_finder.bfs_find_path() maze_finished = False #print index if mode == 0: screen.fill(background_color) else: screen.fill(cell_color) # draw the cell for i in range(index + 1): if mode == 0: grid_view.fill_a_cell(cell_list[i][1], cell_list[i][0], cell_color) else: grid_view.fill_a_cell(cell_list[i][1], cell_list[i][0], background_color) # draw the grid grid_view.draw() # draw the path if maze_finished and path: for i in range(path_index + 1): grid_view.fill_a_cell_with_circle(path[len(path) - i - 1][1], path[len(path) - i - 1][0], path_color) time_passed_seconds = clock.tick() / 1000.0 pass_time += time_passed_seconds if pass_time >= speed: pass_time = 0 if maze_finished: if path_index + 1 < len(path): path_index += 1 if index >= len(cell_list) - 1: #print 'maze_finished' maze_finished = True if index + 1 < len(cell_list): index += 1 pygame.display.update()
class System(): """docstring for System""" def __init__(self, display): self.time = 0 self.agents = dict() self.display = display self.model = GridModel() if display: pygame.init() pygame.display.set_caption("Grid with agents") self.view = GridView(self) self.control = GridControl(self.model) self.entities = [Entity(x) for x in constants.FRUITS] self.entity_global_average_price = {} self.price_trends = {} self.total_negotiations = [] #This is a dict to maintain price update requests coming from system in the given time step self.entity_global_price_updates = {} def create_agent(self, name, agent_id, no_agents, x=None, y=None): """Create a new Agent in the system.""" x = randint(0, constants.TILES_X - 1) if x == None else x y = randint(0, constants.TILES_Y - 1) if y == None else x new_agent = Agent(name=name, agent_id=agent_id, no_agents=no_agents, x_pos=x, y_pos=y) self.agents[name] = new_agent def advance(self): """Advance the time by a value of 1.""" requests_sent = 0 requests_received = 0 responses_sent = 0 responses_received = 0 self.set_global_average_price_for_all_entities( ) # Update global average price collected in the last step. items = list(self.agents.items()) shuffle(items) # Let all agents send their messages for name, agent in items: agent.send_requests() responses_sent += agent.send_responses() # Let all agents receive messages for name, agent in items: requests_received += agent.receive_requests() responses_received += agent.receive_responses() for name, agent in items: agent.neighbors = self.get_neighbors(agent) if isinstance(agent.state, NegotiationState): if not isinstance(agent.state.other_agent.state, NegotiationState): agent.state = RandomWalkState(this_agent=agent) continue time_remaining = constants.MAX_TIME - self.time if agent.patience * time_remaining * 0.5 < agent.state.duration or \ (agent.state.buy_or_sell == 'sell' and agent.state.other_agent.money < agent.state.price_each*agent.state.quantity) or \ (agent.state.buy_or_sell == 'buy' and agent.money < agent.state.price_each*agent.state.quantity) or \ (agent.state.buy_or_sell == 'sell' and agent.entities_info[agent.state.fruit]['quantity'] < agent.state.quantity) or \ (agent.state.buy_or_sell == 'buy' and agent.state.other_agent.entities_info[agent.state.fruit]['quantity'] < agent.state.quantity): agent.state.decline() continue # Accept offer if within price range if agent.state.buy_or_sell == 'buy': if agent.state.other_agent.state.price_each <= agent.state.price_each: agent.state.accept() continue # At this point, price should be further negotiated if agent.state.buy_or_sell == 'buy': agent.state.price_each = triangular( agent.state.price_each, agent.entities_info[agent.state.fruit] ['max_buying_price'] * (1 + agent.elasticity), agent.state.price_each) #/(1+agent.state.duration) agent.state.duration += 1 if agent.state.buy_or_sell == 'sell': agent.state.price_each = triangular( agent.entities_info[agent.state.fruit] ['min_selling_price'] * (1 - agent.elasticity), agent.state.price_each, agent.state.price_each) #/(1+agent.state.duration) agent.state.duration += 1 elif isinstance( agent.state, RandomWalkState ) and not agent.incoming_requests and not agent.incoming_responses: agent.random_walk() elif isinstance( agent.state, WalkToAgentState ) and not agent.incoming_requests and not agent.incoming_responses: agent.search_agent(self.find_path(agent)) elif isinstance(agent.state, WaitForResponseState): if agent.state.counter <= 0: agent.state = RandomWalkState(this_agent=agent) else: agent.state.counter = agent.state.counter - 1 for name, agent in self.agents.items(): agent.set_color( max_money=max([a.money for _, a in self.agents.items()])) agent.freeze_movement = False self.time += 1 self.model.update() closed = False # draw screen if self.display: self.view.draw() # update pygame.display.update() time.sleep(0) closed = self.control.check_events() return closed # set the neighbors of an agent (required for preventing agents from walking through each other) def get_neighbors(self, agent): neighbors = [None, None, None, None] # [North, East, South, West] for name, possible_neighbor in self.agents.items(): if possible_neighbor.x_pos == agent.x_pos and possible_neighbor.y_pos == ( agent.y_pos - 1): neighbors[constants.NORTH] = possible_neighbor if possible_neighbor.x_pos == ( agent.x_pos + 1) and possible_neighbor.y_pos == agent.y_pos: neighbors[constants.EAST] = possible_neighbor if possible_neighbor.x_pos == agent.x_pos and possible_neighbor.y_pos == ( agent.y_pos + 1): neighbors[constants.SOUTH] = possible_neighbor if possible_neighbor.x_pos == ( agent.x_pos - 1) and possible_neighbor.y_pos == agent.y_pos: neighbors[constants.WEST] = possible_neighbor return neighbors #This will return current global price of the entity def get_entity_global_average_price(self, entity_name): return self.entity_global_average_price.get(entity_name, None) #This will return list of all entities in the System def get_all_entities(self): return self.entities #This will return all agents in a list other than agents in except list def get_all_agents_in_list(self, except_agents=[]): return [ agent for name, agent in self.agents.items() if name not in except_agents ] #To set global average price of entity def update_entity_global_average_price(self, entity_name, price, quantity): if entity_name in self.entity_global_price_updates.keys(): self.entity_global_price_updates[entity_name].append( (price, quantity)) else: self.entity_global_price_updates[entity_name] = [(price, quantity)] #Should only be called when time step changes def set_global_average_price_for_all_entities(self): def _weighted_sum(tpls): ttl = sum([x[1] for x in tpls]) return sum([x[0] * x[1] for x in tpls]) / ttl for entity_name, prices in self.entity_global_price_updates.items(): if len(prices) > 0: weighted_sum = _weighted_sum(prices) gape = (self.entity_global_average_price.get( entity_name, weighted_sum) + weighted_sum) / 2 self.entity_global_average_price[entity_name] = gape #Add average price to entity trend temp_price = self.entity_global_average_price.get( entity_name, None) if temp_price: self.add_price_to_entity_trend(entity_name, temp_price) #Reset this when all the calculation are done self.reset_enity_global_price_updates_dict() def add_price_to_entity_trend(self, entity_name, price): entity_trend = self.price_trends.get(entity_name, None) if not entity_trend: self.price_trends[entity_name] = EntityTimeSeries(entity_name) entity_trend = self.price_trends[entity_name] entity_trend.add_price_to_time_series(price) def reset_enity_global_price_updates_dict(self): self.entity_global_price_updates = dict() def is_price_going_up(self, entity_name): entity_trend = self.price_trends.get(entity_name, None) return entity_trend.is_price_going_up() if entity_trend else ( 'CAN NOT TELL', False) def is_price_going_down(self, entity_name): entity_trend = self.price_trends.get(entity_name, None) return entity_trend.is_price_going_down() if entity_trend else ( 'CAN NOT TELL', False) def get_fraction_change_in_price(self, entity_name): entity_trend = self.price_trends.get(entity_name, None) if entity_trend: return entity_trend.get_fraction_change_in_price() return 0.0 def agent_at(self, x, y): for name, agent in self.agents.items(): if agent.x == x and agent.y == y: return agent return None def find_path(self, agent): target = agent.state.other_agent directions = [] if constants.BFS: distances = [ constants.INF, constants.INF, constants.INF, constants.INF ] # [north, east, south, west] distances[constants.NORTH] = self.bfs( (agent.x_pos, agent.y_pos - 1), (target.x_pos, target.y_pos)) distances[constants.EAST] = self.bfs( (agent.x_pos + 1, agent.y_pos), (target.x_pos, target.y_pos)) distances[constants.SOUTH] = self.bfs( (agent.x_pos, agent.y_pos + 1), (target.x_pos, target.y_pos)) distances[constants.WEST] = self.bfs( (agent.x_pos - 1, agent.y_pos), (target.x_pos, target.y_pos)) min_dist = min(distances) if min_dist == constants.INF: return directions if distances[constants.NORTH] == min_dist: directions.append(constants.NORTH) if distances[constants.EAST] == min_dist: directions.append(constants.EAST) if distances[constants.SOUTH] == min_dist: directions.append(constants.SOUTH) if distances[constants.WEST] == min_dist: directions.append(constants.WEST) else: if target.y_pos < agent.y_pos: directions.append(constants.NORTH) # North if target.x_pos > agent.x_pos: directions.append(constants.EAST) # East if target.y_pos > agent.y_pos: directions.append(constants.SOUTH) # South if target.x_pos < agent.x_pos: directions.append(constants.WEST) # West return directions def bfs(self, start, end): explored = [] queue = [start] levels = {} levels[start] = 0 visited = [start] while queue: pos = queue.pop(0) x = pos[0] y = pos[1] explored.append(pos) neighbors = [(x, y - 1), (x + 1, y), (x, y + 1), (x - 1, y)] for neighbor in neighbors: if neighbor[0] < 0 or neighbor[0] >= constants.TILES_X or neighbor[1] < 0 or neighbor[1] \ >= constants.TILES_Y: continue if self.agent_at(neighbor[0], neighbor[1]) and not neighbor == end: continue if neighbor not in visited: queue.append(neighbor) visited.append(neighbor) levels[neighbor] = levels[pos] + 1 if end not in levels: # not a single step could have been taken (impossible position) return constants.INF return levels[end] def get_random_target(self, agent_id): name, target = choice(list(self.agents.items())) while target.agent_id == agent_id: name, target = choice(list(self.agents.items())) return target def print_info(self): """Print the information about the system.""" print("Time = {0}.\n".format(self.time)) #Initialize total negotiations. def initialize_total_negotiations_count(self): agents = self.get_all_agents_in_list() self.total_negotiations = [[[0, 0] for a in agents] for out_a in agents] #This will update negotiation count def update_negotiation_happened(self, agent1_id, agent2_id, isPositive): if isPositive: self.total_negotiations[agent1_id][agent2_id][0] += 1 self.total_negotiations[agent2_id][agent1_id][0] += 1 else: self.total_negotiations[agent1_id][agent2_id][1] += 1 self.total_negotiations[agent2_id][agent1_id][1] += 1 def get_total_negotiation(self, agent1_id, agent2_id): negotiations = self.total_negotiations[agent1_id][agent2_id] return (negotiations[0] + negotiations[1] + 1, negotiations[0], negotiations[1] ) #This will return total , total positive , total negative def get_negotiations_parameter_of_agent(self, agent_id): negotiations = self.total_negotiations[agent_id] total = 0 pos = 0 neg = 0 for temp in negotiations: total += temp[0] + temp[1] pos += temp[0] neg += temp[1] return (total, pos, neg)
def main(maze_method, speed=0.010, mode=0): pygame.init() check = 0 screen = pygame.display.set_mode(resolution) pygame.display.set_caption("A_star_Maze") clock = pygame.time.Clock() maze, cell_list = maze_method() # 랜덤으로 생성된 2차원 리스트 미로와 xxx 좌표가 담긴 리스트를 받는다 path = A_star_logic.main(maze, start_point, end_point) index = 0 maze_finished = False pass_time = 0 grid_view = GridView(screen, width, height, grid_size, grid_line_color) while True: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() press_key = pygame.key.get_pressed() # press F5 to regenerate the maze if press_key[pygame.K_F5]: index = 0 # path_index = 0 maze, cell_list = maze_method() path = A_star_logic.main(maze, start_point, end_point) maze_finished = False check = 0 elif press_key[pygame.K_d]: main(maze_method=get_maze_method(DFS), mode=1) pass elif press_key[pygame.K_k]: main(maze_method=get_maze_method(Kruskal), mode=1) # print index if mode == 0: screen.fill(background_color) else: screen.fill(cell_color) # draw the cell for i in range(index + 1): if mode == 0: grid_view.fill_a_cell( cell_list[i][1], cell_list[i][0], cell_color) else: grid_view.fill_a_cell( cell_list[i][1], cell_list[i][0], background_color) # draw the grid grid_view.draw() # draw the path if maze_finished and path: for i in range(len(path)): grid_view.fill_a_cell_with_circle( path[i][1], path[i][0], path_color) pygame.display.update() sleep(0.1) maze_finished = False check = 1 time_passed_seconds = clock.tick() / 1000.0 pass_time += time_passed_seconds if pass_time >= speed: pass_time = 0 if index >= len(cell_list) - 1 and check == 0: maze_finished = True print("랜덤으로 생성된 미로 탐색 비용은 : "+str(len(path))) if index + 1 < len(cell_list): index += 1 pygame.display.update()