def where_did_it_go(cfg: configuration.Configuration, movie, index): path = cfg.path.points cheerio = path[index] box_size = cfg.cheerio_radius * 6 safety_distance = cfg.cheerio_radius * 3 + cfg.stone_size start_x = cheerio.x + safety_distance box1 = rectangle.Rectangle(start_x, cheerio.y - box_size, start_x + box_size, cheerio.y) box2 = rectangle.Rectangle(start_x, cheerio.y, start_x + box_size, cheerio.y + box_size) while index < len(path) and path[index].x < cheerio.x + cfg.cheerio_radius: index += 1 if index == len(path): return "done" if abs(path[index].y - cheerio.y) < cfg.cheerio_radius / 8: return "skip" density1 = box_density(cfg, box1) density2 = box_density(cfg, box2) if abs(density1 - density2) < 0.1: return "skip" if movie: if density1 > density2: color1 = "red" color2 = "blue" else: color1 = "blue" color2 = "red" movie.background([(box1, color1), (box2, color2), (circle.Circle(cheerio, cfg.cheerio_radius / 3), "green")]) return (density1 > density2) == (path[index].y > cheerio.y)
def __init__(self, width, height, fps): game_mouse.Game.__init__(self, "Shapes", width, height, fps) self.sun = circle.Circle(0, 0, 150, (255, 255, 0)) self.sky = rectangle.Rectangle(600, 400, 0, 0, (20, 160, 255)) self.houseBody = rectangle.Rectangle(400, 250, 100, 200, (247, 210, 45)) self.door = rectangle.Rectangle(70, 150, 265, 300, (64, 52, 12)) self.roof = triangle.Triangle([(300, 50), (550, 200), (50, 200)], (117, 8, 8)) return
def main(): rec1 = rectangle.Rectangle(10, 20) print(rec1) rec2 = rectangle.Rectangle(height=40, width=20) print(rec2) print('Width = ', rec1.get_width()) print('Height = ', rec1.get_height()) rec1.set_width(50) rec1.set_height(100) print(rec1) print('Area = ', rec1.get_area())
def domination_rectangle(self, p, r, ref_rect): """ Given two points, returns the rectangle area in which point p dominates point r. Input: p->[x1,y1] & r->[x2,y2] Output: Rectangle(bottom_left, top_right) or None otherwise """ # Find the domination segments for every query dimension domination_segs = [] for dimension in self.dims: domination_segs.append( self.domination_segment(p, r, dimension, ref_rect)) # Construct the rectangle if None not in domination_segs: # Rectangle's points bottom_left = [] top_right = [] for indx, segment in enumerate(domination_segs): bottom_left.append(segment[0][indx]) top_right.append(segment[1][indx]) # Build a Rectangle instance domination_rect = rect.Rectangle(bottom_left, top_right) else: domination_rect = None # Return return domination_rect
def game_logic(self, keys, newkeys, buttons, newbuttons, mouse_position): x = mouse_position[0] y = mouse_position[1] if pygame.K_c in newkeys: self.circles.append(circle.Circle(x, y, self.width, self.height)) if pygame.K_r in newkeys: self.rectangles.append( rectangle.Rectangle(x, y, self.width, self.height)) if pygame.K_p in newkeys: self.polygons.append(polygon.Polygon(x, y, self.width, self.height)) if 1 in newbuttons: print("button clicked") for c in self.circles: c.move_logic(x, y) for c2 in self.circles: if c2 is not c: if c.collision_logic_c(c2): print("boom-c") for r in self.rectangles: if c.collision_logic_p(r): print("boom-c") for p in self.polygons: if c.collision_logic_p(p): print("boom-c") for r in self.rectangles: r.move_logic() for p in self.polygons: p.move_logic() return
def __init__(self, filename, x, y, h, w): ''' Constructs a surface object paramlist: filename (file name for image file), x (x coordinate), y (y coordinate), h (height), w (width) return: none ''' self.image = filename self.rect = rectangle.Rectangle(x, y, h, w)
def CalculRectangleActif(self, centre, rayon, direction, d): p = [ centre[0] + rayon * sin(direction), centre[1] - rayon * cos(direction) ] rec = rectangle.Rectangle(p[0], p[1], direction, d + rayon, 2 * rayon) return rec
def __init__(self): ''' ''' self._parent = None self._batch = None self._bg_group = None self._fg_group = None self._background = rectangle.Rectangle(filled=True) self._foreground = rectangle.Rectangle(filled=False) self._focusable = False self._activable = False self._style = theme.default self._state = state.default self._minimum_size = [0,0] self._size_request = [0,0] self._size_allocation = [0,0] self._expand = [True,True] self._position = [0,0] self._deleted = True
def test_rectangle_10_20(): rect = rectangle.Rectangle(10.0, 20.0) rect.print() area = rect.area() perimeter = rect.perimeter() assert 200.0 == area and 60.0 == perimeter # test_circle_0() # test_circle_10() # test_rectangle_10_20()
def crea_figura(tipus): if (tipus == 'C'): fig = cercle.Cercle() elif (tipus == 'T'): fig = triangle.Triangle() elif (tipus == 'R'): fig = rectangle.Rectangle() else: raise Exception('Tipus de figura no valid') fig.llegeix() return fig
def inicializeMap(self, matrix, mode=None): if mode == 'creation': grassImg = config.Config.GRASS_IMAGE regPathImg = config.Config.REGULAR_PATH_IMAGE spawnImg = config.Config.SPAWN_IMAGE desPawnImg = config.Config.DESPAWN_IMAGE centralPathImg = config.Config.CENTRAL_PATH_IMAGE changeDirImg = config.Config.CHANGEDIR_IMAGE else: grassImg = config.Config.GRASS_IMAGE regPathImg = config.Config.REGULAR_PATH_IMAGE spawnImg = config.Config.REGULAR_PATH_IMAGE desPawnImg = config.Config.REGULAR_PATH_IMAGE centralPathImg = config.Config.REGULAR_PATH_IMAGE changeDirImg = config.Config.REGULAR_PATH_IMAGE x, y = 0, 0 for i in range(0, self._dimension[0]): x = 0 for j in range(0, self._dimension[1]): if matrix[i][j] == config.Config.MAP_NUMBMATRIX_GRASS: self._map[i][j] = (0, rectangle.Rectangle( (x, y), self.getRectWidth(), self.getRectHeight(), grassImg)) elif matrix[i][j] == config.Config.MAP_NUMBMATRIX_PATH: self._map[i][j] = (1, rectangle.Rectangle( (x, y), self.getRectWidth(), self.getRectHeight(), regPathImg)) elif matrix[i][j] == config.Config.MAP_NUMBMATRIX_SPAWN: self._map[i][j] = (2, rectangle.Rectangle( (x, y), self.getRectWidth(), self.getRectHeight(), spawnImg)) elif matrix[i][j] == config.Config.MAP_NUMBMATRIX_DESPAWN: self._map[i][j] = (3, rectangle.Rectangle( (x, y), self.getRectWidth(), self.getRectHeight(), desPawnImg)) elif matrix[i][j] == config.Config.MAP_NUMBMATRIX_CENTRALPATH: self._map[i][j] = (4, rectangle.Rectangle( (x, y), self.getRectWidth(), self.getRectHeight(), centralPathImg)) elif matrix[i][ j] == config.Config.MAP_NUMBMATRIX_CHANGEDIRECTION: self._map[i][j] = (5, rectangle.Rectangle( (x, y), self.getRectWidth(), self.getRectHeight(), changeDirImg)) x += self.getRectWidth() y += self.getRectHeight()
def boxes_stats(cfg, box_size_in_cheerio_radii=6): size = box_size_in_cheerio_radii * cfg.cheerio_radius index = 0 path = cfg.path.points result = [] while index < len(path) and path[index].x < 1 - size: p = path[index] box = rectangle.Rectangle(p.x, p.y - size / 2, p.x + size, p.y + size / 2) r, ant_res = run.Run(run.AntRunner(cfg, index), containing_box=box).run() result.append((box_density(cfg, box), ant_res, MotionPath(r).length())) while index < len(path) and path[index].x < box.qx: index += 1 return result
def main(): s1 = circle.Circle(10) s2 = rectangle.Rectangle(10, 5) s3 = rectangle.Square(5) triangles = [ triangle.IsocelesTriangle(10, 10), triangle.EquilateralTriangle(5) ] shapes = [s1, s2, s3] + triangles for s in shapes: s.print_all()
def main(): parser = argparse.ArgumentParser() parser.add_argument("n", type=int, help="Number of squares to attempt to fit") parser.add_argument("--up-to", action="store_true", default=False, help="Show results in csv format up to n") args = parser.parse_args() if args.up_to: for i in range(1, args.n): square = rectangle.Rectangle(Fraction(1, 1)) solution = square.solve(i) print("%s,%s,%s" % (i, float(solution), str(solution))) else: square = rectangle.Rectangle(Fraction(1, 1)) solved = square.solve(args.n) print("Efficieny of %s tiles is %s (%s)" % (args.n, float(solved), str(solved)))
def boxes(cfg, box_size_in_cheerio_radii=6, draw=True): if draw: movie = Movie() movie.background([(cfg, "black")]) size = box_size_in_cheerio_radii * cfg.cheerio_radius index = 0 path = cfg.path.points result = [] while index < len(path) and path[index].x < 1 - size: p = path[index] box = rectangle.Rectangle(p.x, p.y - size / 2, p.x + size, p.y + size / 2) good = 0 times = 10 for i in range(times): cfg.start = p cfg.reset_runseed() r, sim_res = run.Run(run.SimulationRunner(cfg), containing_box=box).run() if sim_res: good += 1 if draw: if sim_res: color = "green" else: color = "black" movie.background([(MotionPath(r), color)]) r, ant_res = run.Run(run.AntRunner(cfg, index), containing_box=box).run() if draw: if ant_res: color = "green" else: color = "black" movie.background([(MotionPath(r), "blue")]) box.add_text('{:.0f}%,{:.0f}%'.format(box_density(cfg, box) * 100, good / times * 100)) movie.background([(box, color)]) result.append((box_density(cfg, box), ant_res, good / times)) while index < len(path) and path[index].x < box.qx: index += 1 if draw: movie.save_figure(cfg.file_name + "_boxes") movie.close() # movie.just_draw() return result
def startApp(): width = 0 length = 0 try: width = float(input('Please specify the width: ')) length = float(input('Please specify the length: ')) except ValueError: print('Please type digits only') return startApp() rec = r.Rectangle(width,length) rec.display_area() rec.display_perimeter() print() startApp()
def transformLineInMap(line_matrix, x, y, widht, height, imageList): if (is_empty(line_matrix)): return empty if first(line_matrix) == config.Config.MAP_NUMBMATRIX_GRASS: return cons( (0, rectangle.Rectangle((x, y), widht, height, imageList[0])), transformLineInMap(rest(line_matrix), x + widht, y, widht, height, imageList)) elif first(line_matrix) == config.Config.MAP_NUMBMATRIX_PATH: return cons( (1, rectangle.Rectangle((x, y), widht, height, imageList[1])), transformLineInMap(rest(line_matrix), x + widht, y, widht, height, imageList)) elif first(line_matrix) == config.Config.MAP_NUMBMATRIX_SPAWN: return cons( (2, rectangle.Rectangle((x, y), widht, height, imageList[2])), transformLineInMap(rest(line_matrix), x + widht, y, widht, height, imageList)) elif first(line_matrix) == config.Config.MAP_NUMBMATRIX_DESPAWN: return cons( (3, rectangle.Rectangle((x, y), widht, height, imageList[3])), transformLineInMap(rest(line_matrix), x + widht, y, widht, height, imageList)) elif first(line_matrix) == config.Config.MAP_NUMBMATRIX_CENTRALPATH: return cons( (4, rectangle.Rectangle((x, y), widht, height, imageList[4])), transformLineInMap(rest(line_matrix), x + widht, y, widht, height, imageList)) elif first(line_matrix) == config.Config.MAP_NUMBMATRIX_CHANGEDIRECTION: return cons( (5, rectangle.Rectangle((x, y), widht, height, imageList[5])), transformLineInMap(rest(line_matrix), x + widht, y, widht, height, imageList))
def __init__(self, width, height, fps): game_mouse.Game.__init__(self, "Shapes", width, height, fps) self.r = rectangle.Rectangle(200, 100, 0, 0, (255, 255, 255)) self.r2 = rectangle.Rectangle(300, 50, 200, 300, (0, 255, 0)) return
def test_rectangle_20_10(): rect = rectangle.Rectangle(20.0, 10.0) rect.print() area = rect.area() perimeter = rect.perimeter() assert 200.0 == area and 60.0 == perimeter
def test_rectangle_10_10(): rect = rectangle.Rectangle(10.0, 10.0) rect.print() area = rect.area() perimeter = rect.perimeter() assert 100.0 == area and 40.0 == perimeter
def setUp(self): self.RectangleA = rectangle.Rectangle(-1, -1, 1, 1) self.RectangleB = rectangle.Rectangle(0, 0, 2, 2)
def main(): # Initialize window object and set size window = pyglet.window.Window() window.set_size(576, 432) # Images background = pyglet.resource.image('magic8_blank.jpg') ask_img = pyglet.resource.image('ask.png') clear_img = pyglet.resource.image('clear.png') quit_img = pyglet.resource.image('quit.png') # Button rectangles ask = rectangle.Rectangle(20, 30, 100, 30) clear = rectangle.Rectangle(140, 30, 100, 30) quit = rectangle.Rectangle(260, 30, 100, 30) # Replies replies = [ 'Definitely!', 'Possibly.', 'It\'s in the stars.', 'Nope.', 'Sorry.', 'No way.', 'No.', 'Yes', 'Try again.', 'Not this time.' 'Hmmm.', 'Of course.', 'Ha. ..Ha. Ha.', 'Oh yeah. Big time.', 'Can\'t say', 'Totally!', 'Yep.', 'Naturally, yes.', 'Ohh yeah.' ] # 8 Ball Result answer = pyglet.text.Label('', font_name="Arial", font_size=36, x=window.width // 2, y=window.height // 2, anchor_x='center', anchor_y='center') # Drawing event handler @window.event def on_draw(): window.clear() background.blit(0, 0) ask_img.blit(ask.x, ask.y) clear_img.blit(clear.x, clear.y) quit_img.blit(quit.x, quit.y) answer.draw() # Button Press event handler @window.event def on_mouse_press(x, y, button, modifiers): within_ask = ask.in_rect(x, y) within_clear = clear.in_rect(x, y) within_quit = quit.in_rect(x, y) if within_ask: answer.text = replies[random.randrange(len(replies))] if within_clear: answer.text = '' if within_quit: pyglet.app.exit() # Displays all events to console - find event names/parameters - debugging # window.push_handlers(pyglet.window.event.WindowEventLogger()) pyglet.app.run()
class World: def __init__(self, position, width, height, layout_file=None): self.position = position self.width = self.safe_assign("Width", width, int, WORLD_DEFAULT_WIDTH) self.height = self.safe_assign("Height", height, int, WORLD_DEFAULT_HEIGHT) self.cell_width = TILE_WIDTH self.cell_height = TILE_HEIGHT self.occupied_locations = [] self.layout = [] self.tile_types = [] self.waypoints = [] self.start_cell = None if layout_file is not None: self.load_from_file(layout_file) self.start = self.get_cell_top_left( self.loc_to_cell(self.start_cell[0], self.start_cell[1])) self.order_waypoints() def get_position(self): return self.position def get_dims(self): return (self.width, self.height) def get_width(self): return self.width def get_height(self): return self.height # attempts to assign a variable called var_name (for debugging) # to a value of value but assigns it to value: default # if the original type cannot be casted into desired_type def safe_assign(self, var_name, value, desired_type, default): if type(desired_type) != type(type(int)): print "Desired_type was not a valid type" print "Defaulting to type(str)" desired_type = str if type(value) != desired_type: print str(var_name) + " expected to be " + str(desired_type) print "Attempting Cast..." try: value = desired_type(value) except: print "Unable to convert ", type( value), " to type " + str(desired_type) print "Defaulting to", default value = default print "Type-cast completed" return value # attempts to open the world file and store the information # does nothing if the file was invalid in any way def load_from_file(self, layout_file): # locate the file if not os.path.exists(layout_file): print "Error loading world file " + layout_file + ": File was not found." print "File will not be loaded" return # open and read the file f = open(layout_file, 'rb') fin = [line.strip() for line in f.readlines()] f.close() # skip past the non-world data fin = fin[4:] # skips money, lives, and towers skip = int(fin[0]) fin = fin[skip + 1:] # grab the dimensions of the world and the starting # tile of the path data = fin[0].split() dim = [0, 0] try: dim[0] = int(data[0]) dim[1] = int(data[1]) if len(data) != 4: raise Exception("Invalid layout description\n" + str(dim)) self.start_cell = (int(data[2]), int(data[3])) # verify dimensions layout = [] fin = fin[1:] for line in fin: if len(line) != dim[0]: raise Exception("Invalid/Mismatched width\n" + str(line)) else: layout.append(line) if len(layout) != dim[1]: l = "" for i in layout: l += i + '\n' l = l.strip() raise Exception("Invalid/Mismatched height\n" + l) except Exception, e: print "Error loading world file " + layout_file + ": Invalid formatting" print e return False # fills remaining tiles to fill world size row_size = self.width / self.cell_width col_size = self.height / self.cell_height filled_rows = int(dim[0]) filled_cols = int(dim[1]) empty_rows = row_size - filled_rows empty_cols = col_size - filled_cols for i in range(len(layout)): fill = empty_rows * str(GRASS) layout[i] = layout[i] + fill for i in range(empty_cols): fill = row_size * str(GRASS) layout.append(fill) # records each tile and its type self.layout = [] waypoints = [] for j in range(len(layout)): r_row = [] t_row = [] t_locations = [] for i in range(len(layout[j])): tile = layout[j][i] if tile == str(GRASS): img = GRASS_IMG elif tile == str(ROCK): img = ROCK_IMG else: img = PATH_IMG if tile == str(WAYPOINT): waypoints.append((i, j)) x = self.position[0] + (i) * self.cell_width y = self.position[1] + (j) * self.cell_height t_row.append(int(tile)) # tower location default to 0 t_locations.append(0) r_row.append( rectangle.Rectangle(KIND_TILE, (x, y), self.cell_width, self.cell_height, img)) self.layout.append(r_row) self.tile_types.append(t_row) self.occupied_locations.append(t_locations) for point in waypoints: self.waypoints.append( self.get_cell_top_left(self.loc_to_cell(point[0], point[1]))) return True
def main(): """This is the main function of the demo""" clock = pygame.time.Clock() # list of all nodes nodes: typing.List[rt.Rectangle] = [] # variables used in handling drag event mouse_x = 0 mouse_y = 0 _node: rt.Rectangle = None horizontal_aligned_node: rt.AlignPoint = None vertical_aligned_node: rt.AlignPoint = None # Create a triangle nodes.append(rt.Rectangle(200, 100, 60, 40)) nodes.append(rt.Rectangle(300, 400, 80, 40)) nodes.append(rt.Rectangle(170, 300, 80, 80)) nodes.append(rt.Rectangle(600, 200, 100, 100)) # Initial the Rectangle rt.Rectangle.screen = screen rt.Rectangle.nodes = nodes is_draging = False running = True while running: for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == K_ESCAPE: running = False elif event.type == pygame.MOUSEBUTTONDOWN: position = (click_x, click_y) = event.pos # Check if a node is clicked for node in nodes: if node.collidepoint(position): is_draging = True mouse_x = click_x mouse_y = click_y _node = node break elif event.type == pygame.MOUSEBUTTONUP: is_draging = False _node = None horizontal_aligned_node = None vertical_aligned_node = None elif event.type == pygame.MOUSEMOTION: if is_draging: (click_x, click_y) = event.pos horizontal_aligned_node = \ _node.move_horiontally(click_x - mouse_x) vertical_aligned_node = \ _node.move_vertically(click_y - mouse_y) mouse_x = click_x mouse_y = click_y # if the user click the window close button. elif event.type == pygame.QUIT: running = False # Refresh screen with white color screen.fill((255, 255, 255)) # Draw all rectangles for node in nodes: node.draw() # If two nodes are aligned, hightlight them and draw the line if _node is not None: # Horizontal direction if horizontal_aligned_node is not None: pygame.draw.rect(screen, HIGHTLIGHT_COLOR, _node) if horizontal_aligned_node.node != "window": pygame.draw.rect(screen, HIGHTLIGHT_COLOR, horizontal_aligned_node.node) draw_line(horizontal_aligned_node, _node) else: draw_line(horizontal_aligned_node, None) # Vertical direction if vertical_aligned_node is not None: pygame.draw.rect(screen, HIGHTLIGHT_COLOR, _node) if vertical_aligned_node.node != "window": pygame.draw.rect(screen, HIGHTLIGHT_COLOR, vertical_aligned_node.node) draw_line(vertical_aligned_node, _node, 'vertical') else: draw_line(vertical_aligned_node, None, 'vertical') # Update the screen pygame.display.flip() # - constant game speed / FPS clock.tick(FPS)
def setUp(self): self.square = rectangle.Rectangle(Fraction(1, 1))
def start(self): self.group = pygame.sprite.LayeredDirty() self.game_group = pygame.sprite.LayeredDirty() self.ui_group = pygame.sprite.LayeredDirty() self.time = 0 galaxy = self.game.run_info.get_current_level_galaxy() self.galaxy = galaxy alien_code = galaxy['alien'] alien_obj = alien.ALIENS[alien_code] self.nametext = typewriter.Typewriter(alien_obj.title, "huge", V2(50, 31) + self.game.game_offset, multiline_width=500, center=False, time_offset = -1) self.group.add(self.nametext) self.group.add(typewriter.Typewriter("ALIEN FORCES", "big", V2(50, 15) + self.game.game_offset, PICO_LIGHTGRAY, multiline_width=300, center=False)) self.loading_text = Text("Loading...", "small", V2(game.RES[0] - 70, 326) + self.game.game_offset, center=False) self.loading_text.offset = (0.5, 0) self.group.add(self.loading_text) self.portrait = SimpleSprite(V2(50, 65) + self.game.game_offset, "assets/%sgraphic.png" % alien_code) pygame.draw.rect(self.portrait.image, PICO_BLACK, (0,0,self.portrait.width, self.portrait.height), 1) self.group.add(self.portrait) self.portrait.pos = (0,-1000) #self.portrait.visible = False self.tips = [] self.quote = None difficulty_width = 150 difficulty_pos = V2(game.RES[0] / 2 - difficulty_width / 2, 175) + self.game.game_offset if galaxy['difficulty'] > 1: difficulty_pos = V2(game.RES[0] * 0.3 - difficulty_width / 2, 215) + self.game.game_offset labels = ['Mining Rate', 'Attack Power', 'Tech Level'] images = ['econ', 'attack', 'tech'] elements = [] for i in range(3): pos = difficulty_pos + V2(0, i * 20) t = Text(labels[i], "small", pos + V2(60, 0), PICO_ORANGE) t.offset = (1,0) self.group.add(t) t.visible = False elements.append(t) maxelem = 5 if i == 2: maxelem = 3 for z in range(maxelem): f = FrameSprite(pos + V2(70 + z * 14, -3), "assets/enemystrength-%s.png" % images[i], 11) if z >= DIFFICULTY_VALUES[galaxy['difficulty']][i]: f.frame = 1 else: f.frame = 0 self.group.add(f) f.visible = False elements.append(f) self.tips.append(elements) if galaxy['difficulty'] > 1: tw = 150 if galaxy['difficulty'] < 3: i = 0 elif galaxy['difficulty'] < 6: i = 1 else: i = 2 tip = alien_obj.tips[i] x = game.RES[0] * 0.7 img = pygame.image.load(resource_path(tip[0])) s = SimpleSprite(V2(x, 165) + self.game.game_offset, img) s.offset = (0.5, 0) self.group.add(s) t = Text(tip[1], "small", V2(x - tw / 2, 240) + self.game.game_offset, multiline_width=tw, center=False) self.group.add(t) s.visible = False t.visible = False r = rectangle.Rectangle(V2(x - tw / 2, 169) + self.game.game_offset, (19, 11), PICO_YELLOW) t2 = Text("TIP", "small", V2(x - tw / 2 + 2, 171) + self.game.game_offset, PICO_BLACK) r.visible = False t2.visible = False self.group.add(r) self.group.add(t2) self.tips.append((r, t2)) self.tips.append((s, t)) else: self.quote = Text(alien_obj.get_quote(), "pixolde", V2(game.RES[0] / 2, 270) + self.game.game_offset, PICO_YELLOW, multiline_width=400) self.quote.offset = (0.5, 0) self.group.add(self.quote) self.quote.visible = False if galaxy['mods']: self.group.add(SimpleSprite(V2(61, 322) + self.game.game_offset, "assets/exclamation.png")) self.group.add(Text("DANGER", "small", V2(79, 320) + self.game.game_offset, PICO_YELLOW, multiline_width=400, center=False)) self.group.add(Text(MOD_STRINGS[galaxy['mods'][0]], "small", V2(79, 330) + self.game.game_offset, PICO_WHITE, multiline_width=400, center=False)) self.warnings = self.group.sprites()[-3:] for warning in self.warnings: warning.visible = False self.sm = Machine(UIEnabledState(self)) self.game.load_in_thread(self.load_level, self.on_loaded_level)
import rectangle r = rectangle.Rectangle( 0, 0, 3, 3, )
def test_eq_rectangle(self): self.assertTrue(self.RectangleA == rectangle.Rectangle(-1, -1, 1, 1)) self.assertTrue(self.RectangleB == rectangle.Rectangle(0, 0, 2, 2))
def range_skyline_computation(self): """ The backbone of the algorithm implementation """ # Import the root's keys into the main heap for key in self.rtree.root.entries: cur_rect = rect.Rectangle(self.qs, self.qe) heapq.heappush(self.main, [ self.priority_main(key, self.mindist_point(cur_rect)), id(key), key, cur_rect ]) # Check maximum heap size if len(self.main) > self.maximum_main_size: self.maximum_main_size = len(self.main) # Iterate through secondary heap sec_heap_empty = False while not sec_heap_empty: # Iterate through main heap while len(self.main) != 0: # Remove top entry e, qe = list(heapq.heappop(self.main))[2:] # Logfile self.logfile.write_log_file( "e:", str(e.rect.min_x) + "," + str(e.rect.min_y) + " - " + str(e.rect.max_x) + "," + str(e.rect.max_y)) self.logfile.write_log_file("Qe:", str(qe)) # Find non dominated rectangle area by RSS points qee = self.iterate_rss(self.get_point_closest_to_qs(e), qe) if qee != None: # Different mindist points if not self.same_mindist(qe, qee): self.logfile.write_log_file("Qee: ", str(qee)) self.logfile.write_log_file("Diff starts:", "qees != qes") # Insert into secondary heap if e.is_leaf: # Data Point heapq.heappush(self.secondary, [ self.priority_secondary( self.mindist_point(qee)), id(e), e, qee ]) else: # MBR #heapq.heappush(self.secondary, [self.priority_secondary(self.mindist_point(qee)), id(e), e, qe]) for ee in e.child.entries: heapq.heappush(self.secondary, [ self.priority_secondary( self.mindist_point(qee)), id(ee), ee, qe ]) # Check maximum heap size if len(self.secondary) > self.maximum_secondary_size: self.maximum_secondary_size = len(self.secondary) # Same mindist points else: # Logfile self.logfile.write_log_file("Qee:", str(qee)) self.logfile.write_log_file("Same starts", "qees == qes") # MBR if not e.is_leaf: # Logfile self.logfile.write_log_file("e", "is an MBR") qee = qe # Iterate throuhg the child nodes of e for ee in e.child.entries: qeee = self.iterate_rss( self.get_point_closest_to_qs(ee), qee) if qeee != None: # Different mindist points if not self.same_mindist(qee, qeee): if ee.is_leaf: # Data Point heapq.heappush( self.secondary, [ self.priority_secondary( self.mindist_point( qeee)), id(ee), ee, qeee ]) else: # MBR for eee in ee.child.entries: heapq.heappush( self.secondary, [ self. priority_secondary( self.mindist_point( qeee)), id(eee), eee, qee ]) # Same mindist points else: if ee.is_leaf: # Data Point heapq.heappush( self.main, [ self.priority_main( ee, self.mindist_point( qeee)), id(ee), ee, qeee ]) else: # MBR for eee in ee.child.entries: heapq.heappush( self.main, [ self.priority_main( ee, self.mindist_point( qeee)), id(eee), eee, qee ]) # Check maximum heap size if len(self.main) > self.maximum_main_size: self.maximum_main_size = len(self.main) if len(self.secondary ) > self.maximum_secondary_size: self.maximum_secondary_size = len( self.secondary) # Data Point else: # Logfile self.logfile.write_log_file( "e", "is a LEAF - Data Point") # Update the RSS entries' rectangle area self.update_RSS_items(self.get_minDim(e), qee) # Insert e into the RSS self.RSS.append([self.get_minDim(e), qee]) # Clean entries with None as rectangle area self.RSS = self.clean_RSS(self.RSS) # Logfile self.logfile.write_log_file("RSS", str(self.RSS)) if len(self.secondary) > 0: self.push_to_main() else: sec_heap_empty = True
def test_ne_rectangle(self): self.assertTrue(self.RectangleA != rectangle.Rectangle(-2, -2, 2, 2))