async def fly_garbage(canvas, column, garbage_frame, speed=0.5): rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 row_size, column_size = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, row_size, column_size) obstacles.append(obstacle) while row < rows_number: draw_frame(canvas, row, column, garbage_frame) obstacle.row, obstacle.column = row, column await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) await explode(canvas, row + row_size // 2, column + column_size // 2) break row += speed obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number) row = 1 height, width = curses_tools.get_frame_size(garbage_frame) obstacle = Obstacle(row, column, rows_size=height, columns_size=width) _, bounding_column, bounding_frame = obstacle.dump_bounding_box() state.obstacles.append(obstacle) while obstacle.row < rows_number: # curses_tools.draw_frame(canvas, obstacle.row - 1, bounding_column, bounding_frame) curses_tools.draw_frame(canvas, obstacle.row, column, garbage_frame) await asyncio.sleep(0) curses_tools.draw_frame(canvas, obstacle.row, column, garbage_frame, negative=True) # curses_tools.draw_frame(canvas, obstacle.row - 1, bounding_column, bounding_frame, negative=True) obstacle.row += speed if obstacle in state.obstacles_in_last_collisions.copy(): state.obstacles_in_last_collisions.remove(obstacle) state.obstacles.remove(obstacle) state.coroutines.append( explode(canvas, obstacle.row + height // 2, column + width // 2)) return
async def fly_garbage(canvas, column: int, garbage_frame: TrashFrame, obstacle_id: int, obstacles: dict, destoyed_obstacle_ids: set): """ Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start. """ rows_number, columns_number = canvas.getmaxyx() corrected_column = column - garbage_frame.width - 1 column = min(max(1, corrected_column), column) obstacles[obstacle_id] = Obstacle(0, column, garbage_frame.height, garbage_frame.width) speed = 0.01 + random() row = 0 while row < rows_number: draw_frame(canvas, row, column, garbage_frame.frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame.frame, negative=True) if obstacle_id in destoyed_obstacle_ids: destoyed_obstacle_ids.remove(obstacle_id) center_row = row + int(garbage_frame.height / 2) center_col = column + int(garbage_frame.width / 2) await explode(canvas, center_row, center_col) break row += speed obstacles[obstacle_id].row = row del obstacles[obstacle_id]
async def fly_garbage(canvas, column, garbage_frame, status, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 rows_size, columns_size = get_frame_size(garbage_frame) obstacle_object = Obstacle(row, column, rows_size, columns_size) status.obstacles.append(obstacle_object) try: while row < rows_number: if obstacle_object in status.obstacles_in_last_collisions: await explode(canvas, row + rows_size // 2, column + columns_size // 2) status.obstacles_in_last_collisions.remove(obstacle_object) return draw_frame(canvas, row, column, garbage_frame) await sleep() draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacle_object.row = row finally: status.obstacles.remove(obstacle_object)
async def fly_garbage(playground, column, garbage_frame, speed=0.5): """ Animate garbage, flying from top to bottom. Column position will stay same, as specified on start. """ min_row, min_col, max_row, max_col = get_playground_limits(playground) column = max(column, min_col) column = min(column, max_col) row = min_row rows, cols = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, rows, cols) obstacles.append(obstacle) center_row = round(rows / 2) center_col = round(cols / 2) while row < max_row: if obstacle in obstacles_in_last_collision: obstacles.remove(obstacle) obstacles_in_last_collision.remove(obstacle) del obstacle await explode(playground, row + center_row, column + center_col) return obstacle.row = row draw_frame(playground, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(playground, row, column, garbage_frame, negative=True) row += speed else: obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 rows_size, columns_size = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, rows_size, columns_size) obstacles.append(obstacle) try: while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacle.row = row if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) await explode(canvas, row, column) return finally: obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) obstacle_height, obstacle_width = get_frame_size(garbage_frame) obstacle = Obstacle( 0, column, rows_size=obstacle_height, columns_size=obstacle_width ) obstacles.append(obstacle) row = 0 while row < rows_number and obstacle not in obstacles_in_last_collisions: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacle.row = row if obstacle in obstacles_in_last_collisions: center_obstacle_row = row + obstacle_height / 2 center_obstacle_column = column + obstacle_width / 2 await explode(canvas, center_obstacle_row, center_obstacle_column) obstacles_in_last_collisions.remove(obstacle) obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 1 frame_rows, frame_columns = get_frame_size(garbage_frame) barrier = Obstacle(row, column, frame_rows, frame_columns) obstacles.append(barrier) while row < rows_number - frame_rows - 3: # -3 to save the year info barrier.row = row draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed if barrier in obstacles_in_last_collisions: await explode(canvas, row, column) obstacles_in_last_collisions.remove(barrier) obstacles.remove(barrier) return False obstacles.remove(barrier)
async def fly_garbage(canvas, column, garbage_frame, speed=0.2): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" height, width = canvas.getmaxyx() rows_number, columns_number = height, width row_size, column_size = get_frame_size(garbage_frame) column = max(column, 0) column = min(column, columns_number - 1) row = 0 obstacle = Obstacle(row, column, row_size, column_size) global_obstacles.append(obstacle) while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) if obstacle in global_obstacles_in_last_collisions: global_obstacles_in_last_collisions.remove(obstacle) await explode(canvas, row + row_size // 2, column + column_size // 2) global_obstacles.remove(obstacle) return row += speed obstacle.row = row global_obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, obstacles, speed=0.5): """ Animate garbage, flying from top to bottom. Column position will stay same, as specified on start. """ from main import obstacles_in_last_collisions rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 row_size, col_size = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, rows_size=row_size, columns_size=col_size) obstacles.append(obstacle) while row < rows_number: obstacle.row = row draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) obstacles.remove(obstacle) explode_row, explode_col = get_garbage_center( row, column, row_size, col_size ) await explode(canvas, explode_row, explode_col) return obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" global obstacles global obstacles_in_last_collision global coroutines rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 row_size, column_size = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, row_size, column_size) obstacles.append(obstacle) while row < rows_number: if obstacle in obstacles_in_last_collision: coroutines.append( explode(canvas, row + row_size // 2, column + column_size // 2)) obstacles_in_last_collision.remove(obstacle) break draw_frame(canvas, row, column, garbage_frame) obstacle.row = row obstacle.column = column await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5, uid=None): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 garbage_rows, garbabe_columns = get_frame_size(garbage_frame) global obstacles global obstacles_in_last_collisions obstacle = Obstacle(row, column, garbage_rows, garbabe_columns) obstacles.append(obstacle) try: while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await sleep(1) draw_frame(canvas, row, column, garbage_frame, negative=True) if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) await explode(canvas, row + garbage_rows / 2, column + garbabe_columns / 2) return row += speed obstacle.row = row finally: obstacles.remove(obstacle)
def __init__(self, y, height, board): focus = Point(FLOOR - height, y) dimensions = Dimension(height, 7) pipe = IDENTIFIER['pipe'] spring = IDENTIFIER['spring'] shape = [[pipe, pipe, spring, spring, spring, pipe, pipe]] * height Obstacle.__init__(self, focus, shape, dimensions, board)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 global obstacles, coros row_size, col_size = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, row_size, col_size) obstacles.append(obstacle) try: while row < rows_number: if obstacle in obstacles_in_last_collisions: obstacles.remove(obstacle) await explode(canvas, row, column) return None else: draw_frame(canvas, row, column, garbage_frame) obstacle.row = row await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed finally: if obstacle in obstacles: obstacles.remove(obstacle)
def main(): '''Test the functionality''' pygame.init() map = FlameMap() SAMPLES = 300 samples = np.linspace(-5, 5, SAMPLES) X, Y = np.meshgrid(samples, samples) grid = np.dstack((X, Y)) if (True): print "Single segment" p1 = Vector2(-1.0, 1.0) p2 = Vector2(1.0, 0.0) seg = Segment(p1, p2) s = time.clock() dist = computeSegmentDistance(seg, grid) e = time.clock() print "\tTook %f seconds to compute %d distances" % (e - s, grid.size / 2) surface = map.colorOnSurface((dist.min(), dist.max()), dist.T[:, ::-1]) imgSeg = imgSpaceSegment(seg, (-5.0, 5.0), (-5.0, 5.0), SAMPLES, SAMPLES) pygame.draw.line(surface, (255, 255, 255), (imgSeg.p1.x, imgSeg.p1.y), (imgSeg.p2.x, imgSeg.p2.y)) pygame.image.save(surface, 'distFieldSeg.png') if (True): print "Obstacle" o = Obstacle() o.closed = True # create a hexagonal obstacle RADIUS = 2.0 RAD_SAMPLE = 12 for i in xrange(RAD_SAMPLE): theta = 2.0 * np.pi / RAD_SAMPLE * i x = np.cos(theta) * RADIUS y = np.sin(theta) * RADIUS o.vertices.append(Vector3(x, y, 0)) s = time.clock() dist = computeObstacleDistance(o, grid) e = time.clock() print "\tTook %f seconds to compute %d distances" % (e - s, grid.size / 2) ## print dist surface = map.colorOnSurface((dist.min(), dist.max()), dist.T[:, ::-1]) for seg in o.segments: imgSeg = imgSpaceSegment(seg, (-5.0, 5.0), (-5.0, 5.0), SAMPLES, SAMPLES) pygame.draw.line(surface, (255, 255, 255), (imgSeg.p1.x, imgSeg.p1.y), (imgSeg.p2.x, imgSeg.p2.y)) pygame.image.save(surface, 'distFieldObst.png')
async def fly_garbage(canvas, obstacles, obstacles_collisions, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Column position will stay same, as specified on start. E.g. with open('garbage.txt', "r") as garbage_file: frame = garbage_file.read() coroutine = fly_garbage(canvas, 10, frame): """ assert speed > 0, AssertionError("Speed has to be positive") assert len(garbage_frame) and all(garbage_frame), AssertionError( "Frame can not be empty or has 0 height or width") frame, frame_height, frame_width = garbage_frame rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 obstacle = Obstacle(row, column, frame_height, frame_width) obstacles.add(obstacle) while row < rows_number: if obstacle in obstacles_collisions: draw_frame(canvas, row, column, frame, negative=True) await explode(canvas, row, column) break draw_frame(canvas, row, column, frame) await asyncio.sleep(0) draw_frame(canvas, row, column, frame, negative=True) row += speed obstacle.row = row # delete obstacle obstacles.discard(obstacle) # restore borders border = ord('|') canvas.border(border, border)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """ Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start. """ rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 garbage_row, garbage_column = get_frame_size(garbage_frame) while row < rows_number: draw_frame(canvas, row, column, garbage_frame) obstacles.append(Obstacle(row, column, garbage_row, garbage_column)) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) obstacles.pop(0) # for obst in obstacles_in_last_collisions: # return obst row += speed
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): rows_number, columns_number = canvas.getmaxyx() row = 0 column = max(column, 0) column = min(column, columns_number - 1) obstacle_width, obstacle_height = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, obstacle_width, obstacle_height) globals_vars.obstacles.append(obstacle) try: while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacle.row += speed if obstacle in globals_vars.obstacles_in_last_collisions: await explode(canvas, obstacle.row, obstacle.column) globals_vars.obstacles.remove(obstacle) globals_vars.obstacles_in_last_collisions.remove(obstacle) break finally: if obstacle in globals_vars.obstacles: globals_vars.obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 obstacle_row, obstacle_column = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, obstacle_row, obstacle_column) obstacles.append(obstacle) # coroutines.append(show_obstacles(canvas, obstacles)) while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacle.row += speed if obstacle in obstacles_in_last_collision: obstacles.remove(obstacle) obstacles_in_last_collision.remove(obstacle) await explode(canvas, row + obstacle_row // 2, column + obstacle_column // 2) return else: obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start. """ global obstacles rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 frame_height, frame_width = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, frame_height, frame_width) obstacles.append(obstacle) await sleep(1) while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacle.row += speed # Remove garbage that has encountered fire if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) obstacles.remove(obstacle) await explode(canvas, row, column) return # Remove an obstacle flying over the edge obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() frame_rows, frame_columns = get_frame_size(garbage_frame) column = max(column, 0) column = min(column, columns_number - 1) uid = uuid.uuid4() row = 0 while row < rows_number: if uid in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(uid) obstacles.pop(uid) await explode(canvas, row, column) return obstacles[uid] = Obstacle(row, column, frame_rows, frame_columns, uid=uid) draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed obstacles.pop(uid)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() global obstacles global obstacles_in_last_collisions column = max(column, 0) column = min(column, columns_number - 1) row = 0 while row < rows_number: draw_frame(canvas, row, column, garbage_frame) garbage_height, garbage_length = get_frame_size(garbage_frame) obstacle = Obstacle(row, column, garbage_height, garbage_length) obstacles.append(obstacle) if delay := get_garbage_delay_tics(year): await sleep(delay) draw_frame(canvas, row, column, garbage_frame, negative=True) obstacles.remove(obstacle) if obstacle in obstacles_in_last_collisions: await explode(canvas, row + garbage_height // 2, column + garbage_length // 2) obstacles_in_last_collisions.remove(obstacle) return row += speed
async def fly_garbage(canvas, column, garbage_frame, speed=1): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" global OBSTACLES rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) row = 0 obstacle_row_size, obstacle_column_size = get_frame_size(garbage_frame) garbage_obstacle_frame = Obstacle(row, column, obstacle_row_size, obstacle_column_size) OBSTACLES.append(garbage_obstacle_frame) await sleep(1) while row < rows_number: draw_frame(canvas, row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, row, column, garbage_frame, negative=True) row += speed garbage_obstacle_frame.row += speed for obstacle in OBSTACLES_IN_LAST_COLLISION: if garbage_obstacle_frame is obstacle: OBSTACLES.remove(garbage_obstacle_frame) await explode(canvas, row, column) return
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): row_max, column_max = get_max_coords(canvas) column = min(max(column, 0), column_max) row = 0 height, width = get_frame_size(garbage_frame) global obstacles_list, obstacles_in_last_collisions uid = uuid.uuid4() obstacle = Obstacle(row, column, height, width, uid) obstacles_list.append(obstacle) while obstacle.row < row_max: draw_frame(canvas, obstacle.row, column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, obstacle.row, column, garbage_frame, negative=True) if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) obstacles_list.remove(obstacle) row = obstacle.row + obstacle.rows_size / 2 column = obstacle.column + obstacle.columns_size / 2 await explode(canvas, round(row), round(column)) return obstacle.row += speed obstacles_list.remove(obstacle)
async def fill_orbit_with_garbage( state, canvas, width, ): frames = get_trash_frames() while True: garbage_speed, time_to_sleep = get_garbage_delay_tics(state["level"]) if time_to_sleep == None: await sleep() continue column = randint(1, width) frame = choice(frames) rows, columns = get_frame_size(frame) garbage_obstacle = Obstacle(0, column, rows, columns) state["obstacles"].append(garbage_obstacle) state["routines"].append( fly_garbage( state, garbage_obstacle, canvas, column, frame, speed=garbage_speed, ), ) await sleep(time_to_sleep)
def generate_obstacles(self, penalty): """ Desc: Generates all obstacles with penalty. This is selected by picking the spots randomly. Also removes occupied spots. Input(s): penalty: Penalty incurred for each obstacle Output(s): spots: Randomized list of coordinates for spots """ obstacles = [] num_spots = self.world_size[0] * self.world_size[1] num_obstacles = int(ceil(self.obs_percent * num_spots)) logging.info("Num of obstacles: %d" % num_obstacles) # choose obstacles obstacle_indices = np.unravel_index(random.sample(range(num_spots), num_obstacles), self.world_size) # set spot to obstacle obstacle_indices = np.array(list(zip(obstacle_indices[0], obstacle_indices[1]))) # unravel_index gives y first self.spots[obstacle_indices[:,1], obstacle_indices[:,0], 2] = 3 logging.info("Obstacle positions: ") for pos in obstacle_indices: logging.info(pos) obstacles = [Obstacle(pos, penalty) for pos in obstacle_indices] return obstacle_indices, obstacles
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Column position will stay the same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() garbage_current_row = 0 garbage_rows_takes, garbage_columns_takes = get_frame_size(garbage_frame) column = max(column, 0) garbage_current_column = min(column, columns_number - garbage_columns_takes) current_obstacle = Obstacle(garbage_current_row, garbage_current_column, garbage_rows_takes, garbage_columns_takes) obstacles.append(current_obstacle) try: while garbage_current_row < rows_number: if current_obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(current_obstacle) return draw_frame(canvas, garbage_current_row, garbage_current_column, garbage_frame) await asyncio.sleep(0) draw_frame(canvas, garbage_current_row, garbage_current_column, garbage_frame, negative=True) garbage_current_row += speed current_obstacle.row += speed finally: obstacles.remove(current_obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5): """Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start.""" rows_number, columns_number = canvas.getmaxyx() column = max(column, 0) column = min(column, columns_number - 1) # Get frame row size and run it higher so # that it appears gradually instead suddenly row = -utils.get_frame_size(garbage_frame)[0] + BORDER_WIDTH + 1 row_size, column_size = utils.get_frame_size(garbage_frame) obstacle = Obstacle(row, column, row_size, column_size) obstacles.append(obstacle) while obstacle.row < rows_number - BORDER_WIDTH * 2 - DERIVED_WINDOW_HEIGHT: if obstacle in obstacles_in_last_collisions: obstacles_in_last_collisions.remove(obstacle) coroutines.append( explode(canvas, obstacle.row + row_size // 2, obstacle.column + column_size // 2)) break utils.draw_frame(canvas, obstacle.row, obstacle.column, garbage_frame) await asyncio.sleep(0) utils.draw_frame(canvas, obstacle.row, obstacle.column, garbage_frame, negative=True) obstacle.row += speed obstacles.remove(obstacle)
def add_obstacle(row, column, rows_size=1, columns_size=1, uid=None): obstacle = Obstacle(row, column, rows_size, columns_size, uid) state.obstacles.append(obstacle) try: yield obstacle finally: state.obstacles.remove(obstacle)
def create_frame_obstacles(row, column, frame, uid=None): frame_row_size, frame_column_size = ct.get_frame_size(frame) frame_obstacle = Obstacle(row=row, column=column, rows_size=frame_row_size, columns_size=frame_column_size, uid=uid) OBSTACLES.append(frame_obstacle) return frame_obstacle