async def fill_orbit_with_garbage(canvas,
coros,
garbage_frames,
level,
initial_timeout=5,
complexity_factor=5,
timeout_min=0.3):
_, columns_number = canvas.getmaxyx()
border_size = 1
while True:
current_trash_frame = random.choice(garbage_frames)
_, trash_column_size = get_frame_size(current_trash_frame)
random_column = random.randint(border_size,
columns_number - border_size)
actual_column = min(
columns_number - trash_column_size - border_size,
random_column + trash_column_size - border_size,
)
trash_coro = fly_garbage(canvas, actual_column, current_trash_frame)
coros.append(trash_coro)
timeout_step = level[0] / complexity_factor
garbage_respawn_timeout = initial_timeout - timeout_step
if garbage_respawn_timeout <= timeout_min:
garbage_respawn_timeout = timeout_min
await sleep(garbage_respawn_timeout)
async def fill_orbit_with_garbage(canvas, garbage_frames):
_, max_col = canvas.getmaxyx()
while True:
state.coroutines.append(
fly_garbage(canvas, random.randint(0, max_col),
random.choice(garbage_frames)))
await sleep(get_garbage_delay_tics(state.year) or 30)
async def fill_orbit_with_garbage(canvas, garbage, maxx):
global coroutines
while True:
frame = garbage[random.randint(0, len(garbage) - 1)]
col = random.randint(1, maxx - frame[2])
if len(coroutines) < (MAX_STAR_COUNT + 3 + 10):
coroutines.append(fly_garbage(canvas, col, frame[0]))
await sleep_loop(random.randint(0, 30))
async def fill_orbit_with_garbage(canvas):
screen = curses.initscr()
_, max_column = get_canvas_maxyx(screen)
garbage_frames = get_all_garbage()
uid = 0
while True:
column = random.randint(0, max_column)
frame = garbage_frames[random.randint(0, len(garbage_frames)-1)]
event_loop.create_task(sg.fly_garbage(canvas,
column,
frame,
uid,
obstacles,
obstacles_in_last_collisions))
uid += 1
await sleep(get_garbage_delay_tics(year))
async def fill_orbit_with_garbage(canvas, garbage_frames):
while True:
garbage_delay = get_garbage_delay_tics(current_year)
if garbage_delay:
await sleep(garbage_delay)
max_y, max_x = get_real_maxyx(canvas)
coroutines.append(
fly_garbage(
canvas,
randint(1, max_x - 3),
choice(garbage_frames),
obstacles=obstacles,
obstacles_in_last_collisions=obstacles_in_last_collisions,
speed=uniform(.1, 1)))
else:
await sleep(TICKS_IN_YEAR
) # засыпаем на весь год, т.к. в этом году еще чисто
async def fill_orbit_with_garbage(canvas):
_, columns_number = canvas.getmaxyx()
offset = 7
while True:
tics = get_garbage_delay_tics(globals_vars.year)
place = random.randint(1 - offset, columns_number - offset)
speed = random.randint(1, 3)
garbage_frame = random.choice(GARBAGE_FRAMES)
garbage = get_frames_from_file(garbage_frame)[0]
if globals_vars.year >= OCCURRENCE_GARBAGE_YEAR:
globals_vars.coroutines.append(
fly_garbage(canvas, place, garbage, speed))
if tics is not None:
await sleep_delay(tics * TIC_TIMEOUT)
else:
await sleep_delay(1)
async def fill_orbit_with_garbage(self):
id_val = 0
while True:
if self.garbage_delay_tics < 0:
await sleep(1)
continue
else:
await sleep(self.garbage_delay_tics)
max_x = self.window_size.dx - BORDER_SIZE
start_x = randint(1, max_x - 1)
frame = random.choice(TRASH_FRAMES)
coroutine = fly_garbage(self.canvas, start_x, frame, id_val,
self.obstacles,
self.destroyed_obstacle_ids)
self.coroutines.append(coroutine)
id_val += 1
async def fill_orbit_with_garbage(canvas, garbage_frames, window_size,
border_depth):
global is_running
global level, max_level, garbage_speed
await sleep(20)
while is_running.state:
frame = random.choice(garbage_frames)
coroutines.append(
fly_garbage(canvas,
frame,
obstacles,
obstacles_in_last_collisions,
is_running,
window_size,
border_depth,
speed=garbage_speed))
await sleep(max_level + 1 - level)
async def fill_orbit_with_garbage(canvas, rows, columns, frames):
number_of_garbage = 0
while True:
garbage_delay_tics = get_garbage_delay_tics(year)
if not garbage_delay_tics:
await asyncio.sleep(0)
continue
coroutines.append(
fly_garbage(
canvas,
random.randint(
OFFSET_FROM_EDGE_OF_SCREEN,
columns - OFFSET_FROM_EDGE_OF_SCREEN
),
random.choice(frames),
number_of_garbage, obstacles,
obstacles_in_last_collisions,
random.uniform(0.1, 1)
)
)
number_of_garbage += 1
await sleep(random.randint(0, garbage_delay_tics))
async def fill_orbit_with_garbage(canvas):
"""Spawn a lot of space garbage."""
_, max_column_num = canvas.getmaxyx()
frames = [load_frame(filepath) for filepath in settings.GARBAGE_PATHS]
while True:
garbage_timeout = get_garbage_delay_tics(global_vars.year)
if garbage_timeout and not global_vars.is_game_over:
current_trash_frame = random.choice(frames)
_, trash_column_size = get_frame_size(current_trash_frame)
random_column = random.randint(
BORDER_MARGIN,
max_column_num - trash_column_size - BORDER_MARGIN,
)
random_color = random.choice(global_vars.color_names)
global_vars.coroutines.append(
fly_garbage(
canvas=canvas,
column=random_column,
garbage_frame=current_trash_frame,
color=random_color,
))
await sleep(garbage_timeout or 1)
async def fill_orbit_with_garbage(canvas):
global sleeping_events
global obstacles
global year
_, max_x = canvas.getmaxyx()
while True:
sleep_time = get_garbage_delay_tics(year)
if not sleep_time:
await AwaitableSleep(YEAR_IN_SECONDS)
continue
max_garbage_x = get_max_writable_x(max_x, 20)
garbage_x = random.randint(MIN_CANVAS_COORDINATE, max_garbage_x)
new_garbage_frame = random.choice(list(space_garbage.frames.values()))
sleeping_events.append([
0,
fly_garbage(canvas,
garbage_x,
new_garbage_frame,
obstacles=obstacles)
])
await AwaitableSleep(sleep_time)
