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 fill_orbit_with_garbage(canvas, coroutines, obstacles,
obstacles_collisions, years):
assert bool(years), AssertionError(
"Years has to be initiated with int value.")
assert years[0] >= 1957, AssertionError(
"Years has to be at least 1957 and more.")
_, width = canvas.getmaxyx()
width -= 1
garbage_frames = [(i, *get_frame_size(i))
for i in get_frames("frames/garbage/*.txt")]
# waiting for garbage epoch
while get_garbage_delay_tics(years[0]) is None:
await asyncio.sleep(0)
while True:
frame = choice(garbage_frames)
_, _, frame_width = frame
column = randint(1, width - frame_width)
speed = randint(1, 4) / 10
coroutines.append(
fly_garbage(canvas, obstacles, obstacles_collisions, column, frame,
speed))
# waiting before adding new one
await sleep_for(get_garbage_delay_tics(years[0]))
async def fill_orbit_with_garbage(canvas):
garbage = [
'duck', 'hubble', 'lamp', 'trash_large', 'trash_small', 'trash_xl'
]
while True:
garbage_name = choice(garbage)
column = randint(MIN_COL, MAX_COL)
coroutines.append(fly_garbage(canvas, column, get_frame(garbage_name)))
if delay := get_garbage_delay_tics(year):
await sleep(delay * 2)
await sleep(20)
async def fill_orbit_with_garbage(canvas):
garbage_frames = curses_tools.load_frames(config.GARBAGE_FRAMES_DIR)
max_y, max_x = canvas.getmaxyx()
while True:
garbage_delay = get_garbage_delay_tics(game_state.current_year)
if garbage_delay is None:
await asyncio.sleep(0)
continue
await sleep(get_garbage_delay_tics(game_state.current_year))
frame = random.choice(garbage_frames)
frame_height, frame_width = curses_tools.get_frame_size(frame)
column = random.randint(0, max_x - frame_width)
garbage_coroutine = animations.fly_garbage(canvas, column, frame)
game_state.coroutines.append(garbage_coroutine)
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,
frames,
columns_number,
spawn_rate_range=(5, 15)):
"""Fill orbit with random garbage in random columns."""
trash_frames = [
frames['duck'],
frames['hubble'],
frames['lamp'],
frames['trash_large'],
frames['trash_small'],
frames['trash_xl'],
]
trash_speeds = (0.5, 0.6)
while True:
delay = game_scenario.get_garbage_delay_tics(year)
if not delay:
await asyncio.sleep(0)
continue
coroutines.append(
fly_garbage(canvas=canvas,
column=random.randint(BORDER_WIDTH,
columns_number - BORDER_WIDTH),
garbage_frame=random.choice(trash_frames),
speed=random.choice(trash_speeds)))
await utils.sleep(delay)
async def fill_orbit_with_garbage(canvas, garbage_frames):
_, column_number = canvas.getmaxyx()
while True:
garbage_delay = get_garbage_delay_tics(year)
if garbage_delay:
garbage_frame = random.choice(garbage_frames)
garbage_column = random.randrange(1, column_number)
garbage_body = fly_garbage(canvas, garbage_column, garbage_frame)
coroutines.append(garbage_body)
await sleep(garbage_delay or 1)
async def fill_orbit_with_garbage(canvas, col_max, garbage_frames):
while True:
delay = get_garbage_delay_tics(globs.year)
if delay:
await sleep(delay)
else:
await sleep(25)
globs.coroutines.append(
fly_garbage(canvas, random.randint(1, col_max - 2),
random.choice(garbage_frames)))
await asyncio.sleep(0)
async def fill_orbit_with_garbage(canvas, max_column):
global coroutines
global year
global obstacles
while True:
tics_until_spawn = get_garbage_delay_tics(year)
if tics_until_spawn:
garbage_frame = choose_garbage_frame()
column = random.randint(1, max_column)
coroutines.append(fly_garbage(canvas, column, garbage_frame))
await sleep(tics_until_spawn - 1)
await sleep(1)
async def fill_orbit_with_garbage(canvas, col_max, frames):
while True:
delay = get_garbage_delay_tics(year)
if delay is None:
await sleep()
continue
frame = random.choice(frames)
height, width = get_frame_size(frame)
col = random.randint(BORDER, col_max - width)
garbage = fly_garbage(canvas, col, frame)
coroutines.append(garbage)
await sleep(delay)
async def fill_orbit_with_garbage(canvas, window_columns, trash_frames):
while True:
period = get_garbage_delay_tics(YEAR)
if period:
time_to_appear = random.randint(1, period)
await sleep(time_to_appear)
frame = random.choice(trash_frames)
frame_rows, frame_columns = get_frame_size(frame)
column = random.randint(1, window_columns - frame_columns -
1) # цифры - поправка на рамку
coroutine = fly_garbage(canvas, column, frame)
coroutines.append(coroutine)
await asyncio.sleep(0)
async def create_garbage_coros(canvas):
window_row_size, window_col_size = canvas.getmaxyx()
global coros, year
while True:
if year < 1961:
await asyncio.sleep(0)
else:
speed = get_garbage_delay_tics(year)
garbages_frames = fetch_garbages()
garbage_frame = random.choice(garbages_frames)
await sleep(random.randint(1, speed))
coros.append(
fly_garbage(canvas, random.randint(2, window_col_size),
garbage_frame))
async def fill_orbit_with_garbage(canvas, max_width):
garbage_objects = get_garbage_frames()
while True:
delay_tics = get_garbage_delay_tics(year)
if delay_tics:
random_garbage_column = random.randint(FRAME_BORDER_SIZE,
max_width - FRAME_BORDER_SIZE)
coroutines.append(
fly_garbage(canvas,
random_garbage_column,
random.choice(garbage_objects)))
await sleep(delay_tics or 1)
async def fill_orbit_with_garbage(canvas):
"""Control space debris."""
global coroutines, obstacles, year
garbage_frames = []
for filename in os.listdir(GARBAGE_FRAMES_DIR):
with open(os.path.join(GARBAGE_FRAMES_DIR, filename), "r") as garbage_file:
garbage_frames.append(garbage_file.read())
rows_number, columns_number = canvas.getmaxyx()
while True:
# Create debris coroutines with random garbage type, random column and
# delay depends on current year. Also create obstacles bounds.
if get_garbage_delay_tics(year) is not None:
column = random.randint(0, columns_number)
garbage_frame = random.choice(garbage_frames)
garbage_speed = random.randint(2, 10) * GARBAGE_SPEED
coroutines.append(fly_garbage(canvas, column, garbage_frame, garbage_speed))
if SHOW_OBSTACLES_BORDERS:
coroutines.append(show_obstacles(canvas, obstacles))
await sleep(get_garbage_delay_tics(year))
await asyncio.sleep(0)
async def fill_orbit_with_garbage(canvas, garbage, status):
if SHOW_OBSTACLES_ENABLED:
status.coroutines.append(show_obstacles(canvas, status.obstacles))
_, max_column = canvas.getmaxyx()
while True:
delay = get_garbage_delay_tics(status.year)
if delay != None and status.garbage_switcher == True:
status.coroutines.append(
fly_garbage(canvas, random.randint(1, max_column - 2),
random.choice(garbage), status))
await sleep(delay)
else:
await sleep()
async def fill_orbit_with_garbage(canvas):
global year
MAX_Y, MAX_X = canvas.getmaxyx()
while True:
delay = get_garbage_delay_tics(year)
if delay:
await sleep(delay / 10)
coroutines.append(
fly_garbage(
canvas, random.randint(BORDER, MAX_X - BORDER - 1),
TRASH_FRAMES[random.randint(0,
len(TRASH_FRAMES) - 1)]))
else:
await sleep(0.1)
async def run_asteroid_field(canvas, max_column):
"""Add random garbage"""
global year
# frames
trashes = []
# random pause before start
ticks_before_start = random.randint(0, 10)
with open('animations/trash_large.txt', "r") as f:
trashes.append(f.read())
with open('animations/trash_small.txt', "r") as f:
trashes.append(f.read())
while True:
if get_garbage_delay_tics(year) == None:
await asyncio.sleep(0)
else:
await sleep(get_garbage_delay_tics(year))
trash = random.choice(trashes)
column = random.randint(1, max_column)
obs_id = str(uuid.uuid4())
obstacles_coroutines[obs_id] = fly_garbage(canvas, column, trash,
obs_id)
coroutines.append(obstacles_coroutines[obs_id])
async def fill_orbit_with_garbage(canvas, garbage):
garbage_count = len(garbage)
_, columns_number = canvas.getmaxyx()
while True:
column = random.randint(1, columns_number)
garbage_number = random.randint(0, garbage_count - 1)
garbage_frame = garbage[garbage_number]
global year
tics = get_garbage_delay_tics(year)
if tics is None:
await asyncio.sleep(0)
else:
await sleep_exact(tics=tics)
coroutines.append(fly_garbage(canvas, column, garbage_frame))
async def fill_orbit_with_garbage(playground):
garbage_frames = get_frames('./garbage')
min_row, min_col, max_row, max_col = get_playground_limits(playground)
while True:
tics_timeout = get_garbage_delay_tics(year)
if not tics_timeout:
await asyncio.sleep(0)
continue
column = randint(min_col, max_col)
frame = choice(garbage_frames)
coroutines.append(fly_garbage(playground, column, frame))
await sleep(tics_timeout)
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):
frames = read_garbage_frames()
rows_number, columns_number = canvas.getmaxyx()
while True:
garbage_delay = get_garbage_delay_tics(year)
if not garbage_delay:
await sleep(0.1)
continue
await sleep(garbage_delay / 10)
garbage = fly_garbage(canvas,
column=random.randint(0, columns_number),
garbage_frame=random.choice(frames))
coroutines.append(garbage)
async def fill_orbit_with_garbage(canvas, frames):
state.coroutines.append(get_random_garbage(canvas, frames))
tics = 0
while True:
tics_delay = get_garbage_delay_tics(state.year)
if tics_delay and tics_delay <= tics:
tics = 0
state.coroutines.append(get_random_garbage(canvas, frames))
for o in state.coroutines.copy():
try:
o.send(None)
except StopIteration:
state.coroutines.remove(o)
tics += 1
await asyncio.sleep(0)
async def fill_orbit_with_garbage(canvas, canvas_width, trash_frames):
"""Add random garbage to canvas"""
global year
while True:
garbage_frequency = get_garbage_delay_tics(year)
await asyncio.sleep(0)
if not garbage_frequency:
continue
random_frame = random.choice(trash_frames)
_, frame_width = get_frame_size(random_frame)
# To prevent garbage from flying outside the borders,
# subtract 1 for the border and frame width
random_column = random.randint(1, canvas_width - frame_width - 1)
coroutines.append(fly_garbage(canvas, random_column, random_frame))
await sleep(garbage_frequency)
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):
"""Fill screen with garbage. Garbage amount slowly increases by time."""
garbage_frame_files = [
os.path.join(GARBAGE_FRAMES_FOLDER, file)
for file in os.listdir(GARBAGE_FRAMES_FOLDER)
]
garbage_frames = read_frames(garbage_frame_files)
global coroutines
global year
while True:
delay_tics = get_garbage_delay_tics(year)
if delay_tics is not None:
coroutines.append(
fly_garbage(canvas=canvas,
column=random.randint(0,
canvas.getmaxyx()[1]),
garbage_frame=random.choice(garbage_frames)))
await sleep(delay_tics)
else:
await sleep()
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):
'''Function controlls coroutines with garbage flying.'''
global coroutines
global year
frames = []
y_max, x_max = canvas.getmaxyx()
#read files with trash frames
trash_dir = 'frames/trash_frames/'
onlyfiles = [f for f in listdir(trash_dir) if isfile(join(trash_dir, f))]
for fl in onlyfiles:
with open(trash_dir + fl, 'r') as f:
frames.append(f.read())
while True:
#add random fly garbage coroutine after random sleep
delay = get_garbage_delay_tics(year) #delay for garbage spawning
if delay:
coroutines.append(
fly_garbage(canvas, random.randint(1, x_max),
random.choice(frames)))
await sleep(rnd(delay * 1, delay * 3))
await sleep()
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)
