def main(): road = Road(number_of_cars=30) number_of_runs = 100 seconds_in_run = 60 road.place_cars() speed_limit_list = [] positions_list = [] speeds_list = [] mean_speeds = [] st_devs = [] for _ in range(number_of_runs): speeds, positions = road.simulate_n_seconds(seconds_in_run) mean = np.mean(speeds) stdv = np.std(speeds) speed_limit_list.append(mean + stdv) mean_speeds.append(mean) st_devs.append(stdv) if _ in {0, 9, 34, 74, 99}: positions_list.append(positions[:]) speeds_list.append(speeds) return (int(np.mean(speed_limit_list)), positions_list, speeds_list, mean_speeds, st_devs)
def setUp(self): """ Compute following code before each test. """ self.road = Road(road_length = 3.0,density_max = 120.0,free_v = 50.0,mean_time_gap =0.6,source=0.8) self.road.make_cells() self.cell = Cell(self.road)
def run_simulation(VISUALIZE=True): road = Road(SPEED_LIMIT, TRAFFIC_DENSITY, LANE_SPEEDS, AMOUNT_OF_ROAD_VISIBLE) road.populate_traffic() ego_config = { 'speed_limit': SPEED_LIMIT, 'num_lanes': len(LANE_SPEEDS), 'goal': GOAL, 'max_acceleration': MAX_ACCEL } # ego car starts at lane 2, s=0, goal is s=300, lane 0 road.add_ego(2, 0, ego_config) timestep = 0 # only check if reached GOAL s, if reached check if reached GOAL lane # each iteration advance() on sec while road.get_ego().s <= GOAL[0]: timestep += 1 if timestep > 150: if VISUALIZE: print("Taking too long to reach goal. Go faster!") break road.advance() if VISUALIZE: print(road) time.sleep(float(1.0) / FRAMES_PER_SECOND) ego = road.get_ego() if VISUALIZE: if ego.lane == GOAL[1]: print("You got to the goal in {} seconds!".format(timestep)) else: print("You missed the goal. You are in lane {} instead of {}.".format(ego.lane, GOAL[1])) return timestep, ego.lane
def __init__(self): self._image_count = 0 # Camera variables self._calibration_images_dir = '../camera_cal/calibration*.jpg' self._calibration_images_nx = 9 self._calibration_images_ny = 6 self._calibration_matrix = None self._initialize_calibration_matrix() # Thresholding variables self._sx_params = {"Active": True, "Orient": 'x', "Thresh": (20, 190)} self._sy_params = {"Active": True, "Orient": 'y', "Thresh": (20, 190)} self._sdir_params = {"Active": True, "Thresh": (0.8, 1.5), "Sobel_kernel": 15} self._mag_params = {"Active": True, "Thresh": (0, 255), "Sobel_kernel": 3} self._s_color_params = {"Active": True, "Thresh": (170, 255)} self._thresholder = None self._initialize_thresholder() # Masking self._masker = None self._initialize_masker() # Perspective transform self._perspective_transformer = None self._initialize_perspective_transformer() # WindowSearch self._window_searcher = None self._initialize_window_searcher() # Road self._road = Road()
def main(): # define display variables size = [WIN_SIZE_X, WIN_SIZE_Y] screen = pygame.display.set_mode(size) done = False clock = pygame.time.Clock() # define starting variables start_pos = np.array([20, size[1] / 2]) start_dir = 10.0 god = God(50, start_pos, start_dir) road = Road(size, width=50) # start a separate "god" evolutionary thread, different than the display update thread t = Thread(target=god.run, args=([road])) t.start() # main loop while not done: clock.tick(10) for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop screen.fill((255, 255, 255)) road.draw(screen) god.draw(screen) pygame.display.flip() pygame.quit()
def run_simulation(VISUALIZE=True): road = Road(SPEED_LIMIT, TRAFFIC_DENSITY, LANE_SPEEDS, AMOUNT_OF_ROAD_VISIBLE) road.populate_traffic() ego_config = { 'speed_limit': SPEED_LIMIT, 'num_lanes': len(LANE_SPEEDS), 'goal': GOAL, 'max_acceleration': MAX_ACCEL, } # Ego begins travelling at lane #2. road.add_ego(2, 0, ego_config) timestep = 0 while road.get_ego().s <= GOAL[0]: timestep += 1 if timestep > 150: # simulation time limit if VISUALIZE: print("Taking too long to reach goal. Go faster!") break road.advance() if VISUALIZE: print(road) time.sleep(float(1.0) / FRAMES_PER_SECOND) # Completed to the goal distance ego = road.get_ego() if VISUALIZE: if ego.lane == GOAL[1]: print("You got to the goal in %d seconds!" % timestep) else: print("You missed the goal. " "You are in lane %d instead of %d." % (ego.lane, GOAL[1])) return timestep, ego.lane
def basicRoad(): r = Road() r.addSegment(Segment(100, theGear=Gear.DIRECT)) r.addSegment(Segment(50, theGear=Gear.TURN)) r.addSegment(Segment(100, theGear=Gear.DIRECT)) r.addSegment(Segment(50, theGear=Gear.TURN)) return r
def __init__(self, *args, **kwargs): super(Tester, self).__init__(*args, **kwargs) vehicles = [] vehicles.append({}) vehicles[0]['id'] = 'truck' vehicles[0]['vClass'] = 'truck' vehicles[0]['length'] = 15.0 vehicles[0]['maxSpeed'] = 90.0 vehicles[0]['accel'] = 1.0 vehicles[0]['decel'] = 5.0 vehicles[0]['sigma'] = 0.0 vehicles.append({}) vehicles[1]['id'] = 'car' vehicles[1]['vClass'] = 'passenger' vehicles[1]['length'] = 4.0 vehicles[1]['maxSpeed'] = 120.0 vehicles[1]['accel'] = 1.0 vehicles[1]['decel'] = 5.0 vehicles[1]['sigma'] = 0.0 road_params = {} road_params['road_type'] = 'intersection' road_params['name'] = 'intersection_test' road_params['nb_lanes'] = 1 road_params['nodes'] = np.array([[-200., 0.], [0., 0.], [200., 0.], [0., -200.], [0., 200.], [-1000, 0], [1000, 0], [0, -1000], [0, 1000]]) road_params['priority'] = np.array([[0, 5, 0, 0, 0, 5, 0, 0, 0], [5, 0, 5, 3, 3, 0, 0, 0, 0], [0, 5, 0, 0, 0, 0, 5, 0, 0], [0, 3, 0, 0, 0, 0, 0, 3, 0], [0, 3, 0, 0, 0, 0, 0, 0, 3], [5, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0]]) road_params['edges'] = np.array(road_params['priority'] > 0, dtype=int) road_params['routes'] = np.array([[0, 1, 2, 6], [0, 1, 3, 7], [2, 1, 0, 5], [2, 1, 4, 8], [3, 1, 4, 8]]) road_params['vehicles'] = vehicles road_params['lane_change_duration'] = 4 road_params['max_road_speed'] = 35 road_params['overtake_right'] = True road_params['lane_width'] = 3.2 road_params['emergency_decel_warn_threshold'] = 10 road_params['collision_action'] = 'warn' road_params['no_display_step'] = 'true' road_params['view_position'] = np.array([200, 200]) road_params['view_delay'] = 100 road_params['zoom'] = 250 self.road = Road(road_params)
def get_final_velocity(self): road = Road() car_list = road.populate_road() while self.time <= self.t_max: for index, car in enumerate(car_list): if index >= len(car_list) - 1: car_list[index].update_car(car_list[0], road) else: car_list[index].update_car(car_list[index+1], road) self.time += self.d_time return car_list
def baseRoad(request): _ = Road() print('\n') try: lengths = request.param except AttributeError: lengths = [] for length in lengths: _.addSegment(Segment(length)) print('adding segment with length {}'.format(length)) print('road created') return _
def __init__(self, _num_of_roads, size_of_road, size_of_bridge): if _num_of_roads < 4: self.num_of_roads = 4 if _num_of_roads % 2 == 1: self.num_of_roads += 1 else: self.num_of_roads = _num_of_roads self.roads = [None] * self.num_of_roads # self.roads = [Road(size_of_road)] * self.num_of_roads for i in range(self.num_of_roads): self.roads[i] = Road(size_of_road) self.bridge = Road(size_of_bridge) self.state = []
def __init__(self, pos, nodes, G,direction=None, machine=None, main=False, radius=None): Road.__init__(self, pos, nodes, G, direction,radius=radius) self.m=machine self.trees=[] self.harvestTrees=0 #used to take care of the overlapping problem.. tL=G.terrain.GetTrees(self.pos, self.radius+1) #+1 to be sure... for tree in tL: if col.pointInPolygon(tree.pos, self.getNodes()): #tree inside road, #check if tree already belongs to a road: if not self._checkIfTaken(tree): self.harvestTrees+=1 self.trees.append(tree) self.startPoint=None #the startpoint of a corridor is where it intersects the mainRoad.This is where the crane is supposed to begin. self.main=main
def create_objects(self): background = pyglet.graphics.OrderedGroup(0) foreground = pyglet.graphics.OrderedGroup(1) self.road = Road(x=0, y=0, batch=self.batch, group=background) self.player = Player(x=PLAYER_POS_X, y=PLAYER_POS_Y, batch=self.batch, group=foreground) self.lines = [] for coords in lines_coordinates: x0, y0, x1, y1 = coords self.lines.append(pyglet.shapes.Line(x0, y0, x1, y1))
class GameScene(Scene): grass = (0, 80, 0) def __init__(self, width, height, scene_stack, difficulty): super(GameScene, self).__init__(width, height, scene_stack) self.difficulty = difficulty self.counter = 0 self.road = Road(width, height) def update(self): self.road.update(10) def draw(self, surface): self.road.draw(surface)
class Game(pyglet.window.Window): def __init__(self, *args, **kwargs): super(Game, self).__init__(fullscreen=True, *args, **kwargs) # Set batch and entities self.batch = pyglet.graphics.Batch() self.create_objects() # Set handlers self.push_handlers(self.player.key_handler) # Set frequence pyglet.clock.schedule_interval(self.update, 1 / 60.0) def create_objects(self): background = pyglet.graphics.OrderedGroup(0) foreground = pyglet.graphics.OrderedGroup(1) self.road = Road(x=0, y=0, batch=self.batch, group=background) self.player = Player(x=PLAYER_POS_X, y=PLAYER_POS_Y, batch=self.batch, group=foreground) self.lines = [] for coords in lines_coordinates: x0, y0, x1, y1 = coords self.lines.append(pyglet.shapes.Line(x0, y0, x1, y1)) ## Uncomment for printing control lines # self.lines.append(pyglet.shapes.Line( # x0, y0, x1, y1, color=LINE_RGB_COLOR, batch=self.batch, group=foreground)) def update(self, dt): if not self.player.crashed: self.player.update(dt) self.player.check_collision() self.player.check_on_line(self.lines) else: self.player.reset() self.road.update(dt) def on_mouse_press(self, x, y, button, modifiers): print(x, y) def on_draw(self): self.clear() self.batch.draw()
class Game(object): def __init__(self, tps, res): # Config self.tps = tps self.res = res # Init pygame.init() self.screen = pygame.display.set_mode(self.res) self.tps_clock = pygame.time.Clock() self.tps_delta = 0.0 self.cars = [] self.road = Road(self) self.map = Map(self) print(self.map.board) self.spawn_car(self.road.position_s2_line) while True: # Handle events for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit(0) elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: sys.exit(0) # Ticking self.tps_delta += self.tps_clock.tick() / 1000.0 while self.tps_delta > 1 / self.tps: self.tick() self.tps_delta -= 1 / self.tps # Drawing self.screen.fill((0, 0, 0)) self.draw() pygame.display.flip() def tick(self): list(map(lambda x: x.tick(), self.cars)) def draw(self): self.road.draw() list(map(lambda x: x.draw(), self.cars)) def spawn_car(self, position): car = Car(self, position) self.cars.append(car)
def load_sections(self, road_network): self.cursor.execute('SELECT * FROM get_section();') for (id, name, number_lanes, speed_limit, capacity, from_node_id, to_node_id, length) in self.cursor.fetchall(): if id in road_network.sections: raise Error("section id=%d already exists" % id) if from_node_id not in road_network.nodes: raise Error("section id=%d unknown from-node=%d" % (id, from_node_id)) if to_node_id not in road_network.nodes: raise Error("section id=%d unknown to-node=%d" % (id, to_node_id)) road_name = name.title() if road_name not in road_network.roads: road_network.roads[road_name] = Road(road_name) road = road_network.roads[road_name] from_node = road_network.nodes[from_node_id] to_node = road_network.nodes[to_node_id] section = Section(id, road, number_lanes, speed_limit, capacity, from_node, to_node, length) from_node.add_from_section(section) to_node.add_to_section(section) road_network.sections[id] = section road.sections.append(section)
def initialize_2(): global time, lightAgents, envir, cars time = 0 road_1 = Road(0, 10, 10) car_1 = Car(0, 0) cars = []
def set_roads(self, G, node_dict): """ Method: set_roads Method Arguments: * G - The graph of a real section of the world that will be produced from using the osmnx package and the lat and lon provided by the user input. * node_dict - The node dictionary that will be used to show which roads are connected to each other. Output: * A dictionary of the edges created will be returned, where each edge id is their key. """ edge_dict = {} id = 0 for e in G.edges(data=True): start = node_dict[e[0]] destination = node_dict[e[1]] length = int(e[2]['length']) #name = e[2]['name'] edge_to_insert = Road(id, start, destination, length) if id in edge_dict: print("duplicate edge") edge_dict[id] = edge_to_insert id+=1 #removed bad edge return edge_dict
def parse(self): data = open(u'graph%d' % self.game, u'r').read() for line in data.split(u'\n'): line = line.strip() if not line: continue line = line.split(u' ') self.parsed[int(line[0])][int(line[1])] = True self.parsed[int(line[1])][int(line[0])] = True try: self.connections[int(line[1])][int(line[0])].append(int(line[2])) self.connections[int(line[0])][int(line[1])].append(int(line[2])) except: pass data = open(u'roads%d' % self.game, u'r').read() for line in data.split(u'\n'): line = line.strip() if not line: continue line = line.split(u' ') self.roads[int(line[0])] = Road( int(line[0]), int(line[1]), int(line[2]), float(line[3]), float(line[4]), float(line[5]), )
def readRoads(e, nodes): roads = [] # Desired road types driveable = [ "motorway", "trunk", "primary", "secondary", "tertiary", "residential", "service", "living_street", "track", "road", "unclassified" ] for r in driveable.copy(): driveable.append(r + "_link") # Read all roads/ways into an array for road in e.findall('way'): r = Road(road.get("id")) supported = False # Read all information about each road for tag in road.findall('tag'): setattr(r, tag.get("k").replace(":", "_"), tag.get("v")) # Filter out unwanted roads if tag.get('k') == "highway": if tag.get('v') in driveable: supported = True if not supported: continue # Connect to the nodes for nd in road.findall('nd'): r.nodes.append(nodes[nd.get("ref")]) roads.append(r) return roads
def get_string(self): self.new_string = input("Type the string to validate: ") # self.create_error_character() self.reviewed = [] current_state = self.initial_state self.roads = [Road([current_state], True)] self.make_epsilon_transitions() for symbol in self.new_string: # self.make_epsilon_transitions() self.change_road_status() for road in self.roads: if road.check_now == True: aux_state = [] for transition in self.transitions_objects: aux_state.append(transition.get_next_state(road.way[-1], symbol)) aux_state = [state for state in aux_state if state != "error"] if len(aux_state) > 0: if ( len(aux_state) > 1 ): self.create_new_roads(road, aux_state) road.add_to_road(aux_state[0]) else: road.add_to_road(aux_state[0]) else: road.add_error(road.way[-1], symbol) self.make_epsilon_transitions()
def build_map(map_arg): new_map = [[]] map_file = open(map_arg, "r") map_file_contents = map_file.read() x_index = 0 y_index = 0 for c in map_file_contents: if c == 'N' or c == 'M' or c == 'B' or c == 'R': node = Node(x_index, y_index, c) new_map[y_index].append(node) x_index += 1 elif c == '+': road = Road(x_index, y_index) new_map[y_index].append(road) x_index += 1 elif c == '\n': x_index = 0 y_index += 1 new_map.append([]) else: new_map[y_index].append(None) x_index += 1 for y, row in enumerate(new_map): for x, location in enumerate(row): if location: if x < len(row) - 1: east_loc = new_map[y][x + 1] if east_loc: location.add_neighbor(Direction.EAST, east_loc) if y < len(new_map) - 1 and new_map[y + 1]: south_loc = new_map[y + 1][x] if south_loc: location.add_neighbor(Direction.SOUTH, south_loc) return new_map
def parse_map(filename): # initialize location dictionary {ID -> Location} and road dictionary {ID -> list[Road]} locationDict = {} roadDict = {} # parse file with open(filename, "r") as file: for line in file: # remove \n and split line by delimiter line = line.rstrip() splitLine = line.split("|") # create new Location instances for "location" lines and add them to locationDict if splitLine[0] == "location": newLocation = Location(splitLine[1], splitLine[2], splitLine[3]) locationDict[splitLine[1]] = newLocation # create new Road instances for "road" lines and add them to roadDict elif splitLine[0] == "road": newRoad = Road(splitLine[4], splitLine[3], splitLine[1], splitLine[2]) if splitLine[1] in roadDict.keys(): roadDict[splitLine[1]] += [newRoad] else: roadDict[splitLine[1]] = [newRoad] if splitLine[2] in roadDict.keys(): roadDict[splitLine[2]] += [newRoad] else: roadDict[splitLine[2]] = [newRoad] file.close() return locationDict, roadDict
def __init__(self, asurface): self.crashed = False self.hud = HUD(asurface) self.status = GameStatus.PLAYING self.road = Road(asurface) self.surface = asurface self.surface_width = surface.get_width() self.surface_height = surface.get_height() self.car = Car(surface) self.obstacles = [] self.adding_obstacle = False
def test_init(): try: Road(1, 2, -30, []) assert False except ValueExpectedException as ex: print() print(ex.message) assert True
def random_wind_smoothing(road: Road, maxh: int): """ Global max/wind smoothing function similar to wind_smoothing. The difference is that the grains are randomly distributed over all lowest positions with the lowest height and not to the first position in the road with the lowest height. :param road: Road class instance :param maxh: positive integer, threshold value, above this value all grains are removed :return: """ while max(road) > maxh: for i in range(road.size): if road[i] > maxh: temp_minimum = min(road) temp_minimum_indices = np.where(road.piles == temp_minimum) chosen_index = np.random.choice(temp_minimum_indices[0]) road.remove_grain(i) road.add_grain(chosen_index)
def setup_road(self, start, end, image): ''' Sets up a single, 1-D road. ''' r = Road(start, end, height=self.img_size) x_len = int(r.length) # - self.img_size y_len = self.img_size * 2 s = Sprite(image, (x_len, y_len)) x = start.x y = self.height - start.y angle = r.angle # force angle between [0, 360) while angle < 0: angle += 360 while angle >= 360.0: angle -= 360 # This is the logic for the direction the bmp should face. # It's messy because of the way pygame handles PNG's (position is # top left corner of the bmp) image_flipped = False # DONT ASK if 90.0 <= angle < 270.0: image_flipped = True x = end.x y = self.height - end.y if angle == 0.0: x += self.img_size elif angle == 90.0: if image_flipped: y += self.img_size else: y -= self.img_size elif angle == 180.0: if image_flipped: x += self.img_size else: x -= self.img_size elif angle == 270.0: y += self.img_size if angle == 0.0 or angle == 180.0: y -= self.img_size / 2 else: x -= self.img_size / 2 s.move_to(x=x, y=y) s.set_angle(angle) self.window.add_sprite(s) return r
def create_scenario(self): """ Create the scenrario here, some of this could be moved to an __init__ """ road_data = Road.generate_random_road_data() self.road = Road(**road_data) # determine number of signals to create num_signals = int(self.road.length / 4) self.signals = [] for x in range(1, num_signals): data = Signal.generate_random_signal_data(x, self.road.length) signal = Signal(**data) self.signals.append(signal) vehicle_data = Vehicle.generate_random_vehicle_data() self.vehicle = Vehicle(**vehicle_data)
def wind_smoothing(road: Road, maxh: int): """ Global max/wind smoothing function. Takes all the grains above a threshold maxh and puts them to the lowest heights (globally). This methods puts the grains to the first position with the lowest height. :param road: Road class instance :param maxh: positive integer, threshold value, above this value all grains are removed :return: """ while max(road) > maxh: for i in range(road.size): if road[i] > maxh: temp_minimum = min(road) for j in range(road.size): if road[j] == temp_minimum: road.remove_grain(i) road.add_grain(j) break
def parseROAD(self, data): data = data.split(u' ') id = int(data[0]) destination = int(data[1]) speed = float(data[2]) cost = float(data[3]) length = float(data[4]) return Road(id, None, destination, speed, cost, length)
def __init__(self, dimensions, path, background_images, asphalt_textures, templates_collection, seed=0, set_seed=True): self.w, self.h = dimensions self.path = path # Where the image will be saved self.road = Road(self.w, self.h) # Defining the dictionaries containing random images self.templates_collection = templates_collection self.backgrounds = background_images self.grounds = asphalt_textures if set_seed: random.seed(seed)
def test_hard_road_slowing_factor(): road = Road(length=7000, slowing_factor=1, hard_road=True) assert road.slow_factor(position=0, car_slowing_chance=0.1) == 0.1 assert road.slow_factor(position=500, car_slowing_chance=0.1) == 0.1 assert road.slow_factor(position=1000, car_slowing_chance=0.1) == 0.1 * 1.4 assert road.slow_factor(position=1500, car_slowing_chance=0.1) == 0.1 * 1.4 assert road.slow_factor(position=2000, car_slowing_chance=0.1) == 0.1 assert road.slow_factor(position=3500, car_slowing_chance=0.1) == 0.1 * 2.0 assert road.slow_factor(position=5500, car_slowing_chance=0.1) == 0.1 * 1.2 assert road.slow_factor(position=6500, car_slowing_chance=0.1) == 0.1
def test_validate_position(): road = Road(length=1000, slowing_factor=2) assert road.validate(0) == 0 assert road.validate(1) == 1 assert road.validate(1000) == 0 assert road.validate(1001) == 1 assert road.validate(2000) == 0 assert road.validate(2001) == 1 assert road.validate(-1) == 999 assert road.validate(-1000) == 0 assert road.validate(-1005) == 995 assert road.validate(-2005) == 995
def test_road_curve(): test_road = Road(2) test_car = Car() test_car.speed = 8 test_car_two = Car(20) td = test_road.set_tail_distance(test_car, test_car_two) test_car.set_new_speed(test_car_two, td) test_car.change_position() test_road.check_end_of_lap(test_car) test_car.check_position(test_car_two) test_road.check_end_of_lap(test_car) assert test_car.speed == 10
def test_choose_speed_stop_please(): test_road = Road(2) test_car = Car(75) test_car.speed = 12 test_car_two = Car(80) test_car_two.speed = 2 td = test_road.set_tail_distance(test_car, test_car_two) test_car.set_new_speed(test_car_two, td) test_car.change_position() test_road.check_end_of_lap(test_car) test_car.check_position(test_car_two) test_road.check_end_of_lap(test_car) assert test_car.speed == 0
def test_choose_speed_steady_fast(): test_road = Road(2) test_car = Car() test_car.speed = 10 test_car_two = Car(14) test_car_two.speed = 12 td = test_road.set_tail_distance(test_car, test_car_two) test_car.set_new_speed(test_car_two, td) test_car.change_position() test_road.check_end_of_lap(test_car) test_car.check_position(test_car_two) test_road.check_end_of_lap(test_car) assert test_car.speed == 12
def init (self): self._changed = set() self._changed_rects = [] self.overlays = [] self.ui = {} self.dirty = True if self.ident != self._last_ident: self.game.clear_caches() data = conf.LEVELS[self.ident] sx, sy = LEVEL_SIZE self.objs = objs = [[[] for j in xrange(sx)] for i in xrange(sy)] self.road = Road(self) self.frog = Frog(self, data['frog pos'], data.get('frog dirn', 1)) for pos, os in data['objs'].iteritems(): if isinstance(os, basestring): os = (os,) objs[pos[0]][pos[1]] = [getattr(obj_module, obj)(self, pos) for obj in os] self.update_held()
from grid import Grid from road import Road, Junction, StopSign, TrafficLight, Roundabout, NullJunction g = Grid(94, 46) r = Road("Iodine Road", [ [4, 5], [4, 6], [4, 7], [4, 8] ]) r.classification = 3 r.numLanes = 6 r.speed = 50 r.toll = 1 g.roads.append(r) s = Road("Bromine Road", [ [20, 8], [19, 8], [18, 8], [17, 8], [16, 7], [15, 7], [14, 8], [13, 8], [12, 8], [11, 8], [10, 8], [9, 8], [8, 8], [7, 8], [6, 8], [5, 8], [4, 8] ]) s.classification = 3 s.numLanes = 6 s.speed = 50 s.toll = 1 g.roads.append(s) junctionRS = TrafficLight([r, s], []) junctionRS.loc = [4, 8] r.replaceJunction(junctionRS) s.replaceJunction(junctionRS) g.save("./data/roadNetwork.db") #h = Grid(10, 10) #h.reconstruct("./data/roadNetwork.db") #for rd in h.roads: # print(rd.name + " " + str(rd.path) + " " + str(rd.junctions) + " " + str(rd.numLanes) + " " + str(rd.classification) + " " + str(rd.speed) + " " + str(rd.toll) + " " + str(rd.ID))
class Level (object): def __init__ (self, game, event_handler, ident = 0): self.game = game event_handler.add_event_handlers({ pg.MOUSEBUTTONDOWN: self._click, pg.MOUSEMOTION: self._move_mouse }) event_handler.add_key_handlers([ (conf.KEYS_BACK, self.end, eh.MODE_ONDOWN) ]) self._held_sfc = pg.Surface(TILE_SIZE).convert_alpha() self._held_sfc.fill(conf.UI_BG) self._last_ident = self.ident = ident self._locked = False self.drop_input() self.game.linear_fade(*conf.INIT_FADE) self.init() def init (self): self._changed = set() self._changed_rects = [] self.overlays = [] self.ui = {} self.dirty = True if self.ident != self._last_ident: self.game.clear_caches() data = conf.LEVELS[self.ident] sx, sy = LEVEL_SIZE self.objs = objs = [[[] for j in xrange(sx)] for i in xrange(sy)] self.road = Road(self) self.frog = Frog(self, data['frog pos'], data.get('frog dirn', 1)) for pos, os in data['objs'].iteritems(): if isinstance(os, basestring): os = (os,) objs[pos[0]][pos[1]] = [getattr(obj_module, obj)(self, pos) for obj in os] self.update_held() def restart (self): self.cutscene(self.init, *conf.RESTART) def end (self, *args): self.cutscene(self.game.quit_backend, *conf.END, persist = True) def _progress (self): if hasattr(self, '_cleanup'): self._cleanup() self.game.switch_backend(level_backends[self.ident], self.ident) def progress (self): self.ident += 1 if self.ident >= len(conf.LEVELS): self.end() else: self.cutscene(self._progress, *conf.PROGRESS) def _end_cutscene (self): self._locked = False def cutscene (self, evt_f, evt_t, fade, ctrl_t = None, persist = False): self._locked = True self.frog.stop() self.game.linear_fade(*fade, persist = persist) self.game.scheduler.add_timeout(evt_f, seconds = evt_t) if ctrl_t is None: ctrl_t = evt_t self.game.scheduler.add_timeout(self._end_cutscene, seconds = ctrl_t) def _click (self, evt): if self._locked: return if self._grab_click(evt) and evt.button in conf.ACTION_SETS: self._rm_ui('msg') pos = tuple(x / s for x, s in zip(evt.pos, TILE_SIZE)) self.frog.action(conf.ACTION_SETS[evt.button], self.objs[pos[0]][pos[1]], pos) def _move_mouse (self, evt): if self._grab_move(evt): orig_x, orig_y = evt.pos x = orig_x / TILE_SIZE[0] y = orig_y / TILE_SIZE[1] obj = self.top_obj(self.objs[x][y]) if obj is None: self._rm_ui('label') return label = obj_module.name(obj) sfc = self.game.render_text( 'label', label, conf.FONT_COLOUR, bg = conf.UI_BG, pad = conf.LABEL_PADDING, cache = ('label', label) )[0] o = conf.LABEL_OFFSET ws, hs = sfc.get_size() x, y = orig_x + o[0], orig_y - hs + o[1] w, h = conf.RES x = min(max(x, 0), w - ws) y = min(max(y, 0), h - hs) self._add_ui('label', sfc, (x, y)) def _native_click (self, evt): return True def _native_move (self, evt): return True def grab_input (self, click, move): self._grab_click = click self._grab_move = move def drop_input (self): self._grab_click = self._native_click self._grab_move = self._native_move def change_tile (self, tile): self._changed.add(tuple(tile)) def rect_tiles (self, rect): sx, sy = TILE_SIZE x, y, w, h = rect x0 = int(x / sx) y0 = int(y / sy) x1 = int(ceil(float(x + w) / sx)) y1 = int(ceil(float(y + h) / sy)) w, h = LEVEL_SIZE tiles = [] for i in xrange(x0, x1): if 0 <= i < w: for j in xrange(y0, y1): if 0 <= j < h: tiles.append((i, j)) return tiles def change_rect (self, rect, tiles = None): if tiles is None: tiles = self.rect_tiles(rect) self._changed.update(tiles) self._changed_rects.append(rect) return tiles def add_obj (self, obj, pos): self.objs[pos[0]][pos[1]].append(obj) if isinstance(obj, obj_module.OneTileObj): self.change_tile(pos) road = self.road if road.tile_rect.collidepoint(pos) and hasattr(obj, 'on_crash') and \ road.lane_moving(pos[1]): obj.on_crash(self.frog, road) assert not (obj.holdable and obj.solid) def rm_obj (self, obj, pos = None): if pos is None: pos = obj.pos self.objs[pos[0]][pos[1]].remove(obj) if isinstance(obj, obj_module.OneTileObj): self.change_tile(pos) if self.road.tile_rect.collidepoint(pos) and \ hasattr(obj, 'on_uncrash'): obj.on_uncrash(self.frog, self.road) def top_obj (self, objs): # select uppermost (last) obj return objs[-1] if objs else None def solid_objs (self, *ignore): # return set of tiles of containing solid objects objs = set() for x, col in enumerate(self.objs): for y, os in enumerate(col): for o in os: if o.solid and o not in ignore: objs.add((x, y)) break return objs def _add_ui (self, ident, sfc, pos = None): if pos is None: pos = conf.UI_POS[ident] ui = self.ui if ident in ui: ui[ident].hide() ui[ident] = Overlay(self, sfc, pos).show() def _rm_ui (self, ident): ui = self.ui if ident in ui: overlay = ui[ident] del ui[ident] overlay.hide() def update_held (self): sfc = self._held_sfc if self.frog.item is not None: sfc = sfc.copy() self.frog.item.draw(sfc, (0, 0)) self._add_ui('held', sfc) def say (self, msg): sfc = self.game.render_text( 'msg', msg, conf.FONT_COLOUR, width = conf.MSG_WIDTH, bg = conf.UI_BG, pad = conf.MSG_PADDING, cache = ('msg', msg) )[0] self._add_ui('msg', sfc) def update (self): self.frog.update() self.road.update() self._changed.update(self.road.tiles) def _draw_objs (self, screen, objs): last = None # draw non-solid for o in objs: if isinstance(o, obj_module.OneTileObj): if o.solid: last = o else: o.draw(screen) # draw solid if last is not None: last.draw(screen) def _draw_cars (self, screen): for dirn, cars in self.road.cars: for car in cars: car.draw(screen) def draw (self, screen): bg = self.game.img('bg.png') draw_objs = self._draw_objs overlays = self.overlays road = self.road if self.dirty: self.dirty = False # background screen.blit(bg, (0, 0)) # objects for col in self.objs: for objs in col: if objs: draw_objs(screen, objs) # moving cars self._draw_cars(screen) # overlays for overlay in overlays: overlay.draw(screen) rtn = True else: # draw changed tiles rects = self._changed_rects in_road_rect = road.tile_rect.collidepoint objs = self.objs sx, sy = TILE_SIZE todo_os = set() # draw bg and objs screen.blit(bg, road.rect, road.rect) for x, y in road.tiles: draw_objs(screen, objs[x][y]) for overlay in overlays: if (x, y) in overlay.tiles: todo_os.add(overlay) for tile in self._changed: if in_road_rect(tile): continue x, y = tile this_objs = objs[x][y] x *= sx y *= sy r = (x, y, sx, sy) screen.blit(bg, (x, y), r) draw_objs(screen, this_objs) # add to changed rects rects.append(r) # add overlays for overlay in overlays: if tile in overlay.tiles: todo_os.add(overlay) self._draw_cars(screen) rects.append(road.rect) # draw overlays for overlay in todo_os: overlay.draw(screen) rtn = rects self._changed = set() self._changed_rects = [] return rtn
def test_tail_distance(): test_road = Road(2) test_car = Car() test_car_two = Car(10) assert test_road.set_tail_distance(test_car, test_car_two) == 6