def get_object_size(frames: List[str]) -> Tuple[int, int]:
"""Return max size of object."""
if not frames:
return 0, 0
object_row_size = max([get_frame_size(frame, rows_only=True) for frame in frames])
object_column_size = max([get_frame_size(frame, columns_only=True) for frame in frames])
return object_row_size, object_column_size
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)
async def run_spaceship(canvas):
global spaceship_position_row, spaceship_position_col
field_size_row, field_size_col = canvas.getmaxyx()
spaceship_size_row, spaceship_size_col = get_frame_size(
current_spaceship_frame)
spaceship_position_row, spaceship_position_col = field_size_row // 2, field_size_col // 2
draw_frame(canvas, spaceship_position_row, spaceship_position_col,
current_spaceship_frame)
old_frame = current_spaceship_frame
await asyncio.sleep(0.01)
while True:
draw_frame(canvas,
spaceship_position_row,
spaceship_position_col,
old_frame,
negative=True)
spaceship_position_row, spaceship_position_col = change_position(
spaceship_position_row, spaceship_position_col, spaceship_size_row,
spaceship_size_col, spaceship_speed_row, spaceship_speed_col,
field_size_row, field_size_col)
for key in list(active_obstacles.keys()):
if active_obstacles[key].has_collision(spaceship_position_row, spaceship_position_col,\
spaceship_size_row, spaceship_size_col):
await show_gameover(canvas)
return
draw_frame(canvas, spaceship_position_row, spaceship_position_col,
current_spaceship_frame)
old_frame = current_spaceship_frame
await asyncio.sleep(0.1)
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_frame_size_rows, garbage_frame_size_columns = get_frame_size(
garbage_frame)
obstacle = Obstacle(row, column, garbage_frame_size_rows,
garbage_frame_size_columns)
obstacles.append(obstacle)
try:
while row < rows_number:
obstacle.row = row
draw_frame(canvas, row, column, garbage_frame)
await sleep()
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
garbage_frame_center_row = row + garbage_frame_size_rows // 2
garbage_frame_center_column = column + garbage_frame_size_columns // 2
await explode(canvas, garbage_frame_center_row,
garbage_frame_center_column)
return
finally:
obstacles.remove(obstacle)
async def fly_garbage(canvas,
column: int,
garbage_frame: str,
tics: Union[int, float],
speed: float = 0.5) -> 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
frame_rows, frame_columns = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, frame_rows, frame_columns)
obstacles.append(obstacle)
while row < rows_number:
obstacle.row = row
draw_frame(canvas, row, column, garbage_frame)
await sleep(tics)
if obstacle in obstacles_in_last_collisions:
draw_frame(canvas, row, column, garbage_frame, negative=True)
obstacles_in_last_collisions.remove(obstacle)
obstacles.remove(obstacle)
return
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.8):
global obstacles
"""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, columns = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, rows, columns)
obstacles.append(obstacle)
canvas.addstr('')
try:
while row < rows_number:
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
obstacle.row += speed
if obstacle in obstacles_in_last_collisions:
explode_row = row + (rows / 2)
explode_column = column + (columns / 2)
obstacles_in_last_collisions.remove(obstacle)
await explode(canvas, explode_row, explode_column)
finally:
obstacles.remove(obstacle)
async def show_gameover(canvas):
"""Show gameover"""
rows_number, columns_number = canvas.getmaxyx()
go_row, go_col = get_frame_size(GAMEOVER)
while True:
draw_frame(canvas, (rows_number - go_row) // 2,
(columns_number - go_col) // 2, GAMEOVER)
await asyncio.sleep(0.1)
async def show_gameover(canvas):
max_available_row, max_available_column = get_terminal_size()
gameover_frame = get_game_over_texts()
rows, columns = get_frame_size(gameover_frame)
center_row = (max_available_row / 2) - (rows / 2)
center_column = (max_available_column / 2) - (columns / 2)
while True:
draw_frame(canvas, center_row, center_column, gameover_frame)
await asyncio.sleep(0)
async def show_gameover(canvas):
window_row_size, window_col_size = canvas.getmaxyx()
with open('pictures/game_over.txt', 'r') as text:
gameover = text.read()
frame_row_size, frame_col_size = get_frame_size(gameover)
middle_row = (window_row_size - frame_row_size) // 2
middle_col = (window_col_size - frame_col_size) // 2
while True:
draw_frame(canvas, middle_row, middle_col, gameover)
await asyncio.sleep(0)
async def game_over(canvas, frame: str) -> None:
canvas_rows_size, canvas_columns_size = get_canvas_size(canvas)
row_size, column_size = get_frame_size(frame)
row = (canvas_rows_size - row_size) // 2
column = (canvas_columns_size - column_size) // 2
while True:
draw_frame(canvas, row, column, frame)
await sleep()
async def explode(canvas, center_row, center_column):
rows, columns = get_frame_size(EXPLOSION_FRAMES[0])
corner_row = center_row - rows / 2
corner_column = center_column - columns / 2
curses.beep()
for frame in EXPLOSION_FRAMES:
draw_frame(canvas, corner_row, corner_column, frame)
await asyncio.sleep(0)
draw_frame(canvas, corner_row, corner_column, frame, negative=True)
await asyncio.sleep(0)
async def fill_orbit_with_garbage(canvas, columns: int) -> None:
while True:
frame = random.choice(frames)
tics = get_tics(game_state.year)
coroutines.append(
fly_garbage(canvas,
column=random.randint(
1, columns -
get_frame_size(frame, columns_only=True)),
garbage_frame=frame,
tics=int(tics * random.randint(1, 3)) or 1))
await sleep(int(tics * 5))
async def run_spaceship(canvas):
global year
global spaceship_frame
global coroutines
global obstacles
global spaceship_frame
max_available_row, max_available_column = get_terminal_size()
row, column = max_available_row - 10, max_available_column / 2
row_speed = column_speed = 0
while True:
current_year = year.get('current_year')
frame_rows_number, frame_columns_number = get_frame_size(
spaceship_frame)
prev_sprite_row, prev_sprite_column = row, column
prev_spaceship_frame = spaceship_frame
row_pos, column_pos, space = read_controls(canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
row_pos, column_pos)
row += row_pos + row_speed
column += column_pos + column_speed
if space and current_year >= 2020:
# for gun position in the center of the spaceship
column_for_fire = column + 2
fire_animation = fire(canvas,
row,
column_for_fire,
rows_speed=FIRE_SPEED)
coroutines.append(fire_animation)
row = correct_row(max_available_row, row, frame_rows_number)
column = correct_column(max_available_column, column,
frame_columns_number)
for obstacle in obstacles:
if obstacle.has_collision(row, column):
draw_frame(canvas,
prev_sprite_row,
prev_sprite_column,
prev_spaceship_frame,
negative=True)
coroutines.append(show_gameover(canvas))
return
await asyncio.sleep(0)
draw_frame(canvas,
prev_sprite_row,
prev_sprite_column,
prev_spaceship_frame,
negative=True)
draw_frame(canvas, row, column, spaceship_frame, negative=False)
async def run_spaceship(canvas, start_row, start_column):
"""Display animation of a spaceship."""
spaceship_frame_files = [
os.path.join(SPACESHIP_FRAMES_FOLDER, file)
for file in os.listdir(SPACESHIP_FRAMES_FOLDER)
]
spaceship_frames = read_frames(spaceship_frame_files)
tics_between_animations = 2
max_rows, max_columns = (max_coordinate - BORDER_LENGTH
for max_coordinate in canvas.getmaxyx())
min_rows = min_columns = BORDER_LENGTH
row, column = start_row, start_column
row_speed = column_speed = 0
spaceship_animations_cycle = itertools.chain.from_iterable(
[[frame] * tics_between_animations for frame in spaceship_frames])
for spaceship_frame in itertools.cycle(spaceship_animations_cycle):
rows_direction, columns_direction, fire_button_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
rows_direction,
columns_direction)
row = row + row_speed
column = column + column_speed
spaceship_size_rows, spaceship_size_columns = get_frame_size(
spaceship_frame)
row = max(row, min_rows)
row = min(row, max_rows - spaceship_size_rows)
column = max(column, min_columns)
column = min(column, max_columns - spaceship_size_columns)
if fire_button_pressed and year >= GUN_AVAILABLE_YEAR:
spaceship_center_column = column + spaceship_size_columns // 2
coroutines.append(
draw_fire(canvas,
start_row=row,
start_column=spaceship_center_column))
draw_frame(canvas, row, column, spaceship_frame)
await sleep()
draw_frame(canvas, row, column, spaceship_frame, negative=True)
for obstacle in obstacles:
if obstacle.has_collision(row, column, spaceship_size_rows,
spaceship_size_columns):
obstacles_in_last_collisions.append(obstacle)
coroutines.append(show_gameover(canvas))
return
async def show_gameover(canvas):
"""Show "Game Over" text in the center of the screen."""
gameover_frame = read_frames([GAME_OVER_FRAME_FILE])[0]
gameover_frame_size_rows, gameover_frame_size_columns = get_frame_size(
gameover_frame)
central_row, central_column = (max_coordinate // 2
for max_coordinate in canvas.getmaxyx())
row = central_row - gameover_frame_size_rows // 2
column = central_column - gameover_frame_size_columns // 2
while True:
draw_frame(canvas, row, column, gameover_frame)
await sleep()
def control_screen_borders(canvas, row, column):
window_row_size, window_col_size = canvas.getmaxyx()
frame_row_size, frame_col_size = get_frame_size(FRAME)
border_col = window_col_size - frame_col_size
border_row = window_row_size - frame_row_size
if row <= 0:
row = 1
elif border_row <= row:
row = window_row_size - (frame_row_size + EDGE_INDENT)
elif column <= 0:
column = 2
elif border_col <= column:
column = window_col_size - (frame_col_size + EDGE_INDENT)
else:
row, column
return row, column
async def animate_spaceship(canvas, row, column, frame_1, frame_2):
# 19, 77
max_row, max_column = canvas.getmaxyx()
min_row, min_column = 0, 0
space_ship_row, space_ship_column = get_frame_size(frame_1)
while True:
old_row = row
old_column = column
row_direction, column_direction, space_pressed = read_controls(canvas)
row = row + row_direction
column = column + column_direction
spaceship_left_upper_point = (row, column)
spaceship_right_upper_point = (row, column + space_ship_column)
spaceship_left_lower_point = (row + space_ship_row, column)
spaceship_right_lower_point = (row + space_ship_row,
column + space_ship_column)
space_points = [
spaceship_left_upper_point, spaceship_right_upper_point,
spaceship_left_lower_point, spaceship_right_lower_point
]
is_border = False
for point in space_points:
point_row, point_column = point
if point_row >= max_row or point_row <= min_row or point_column >= max_column or point_column <= min_column:
is_border = True
row = old_row
column = old_column
if not is_border:
draw_frame(canvas,
start_row=row,
start_column=column,
text=frame_1)
canvas.refresh()
await sleep()
# стираем предыдущий кадр, прежде чем рисовать новый
draw_frame(canvas, row, column, text=frame_1, negative=True)
draw_frame(canvas, row, column, text=frame_2)
canvas.refresh()
await sleep()
draw_frame(canvas, row, column, text=frame_2, negative=True)
async def fly_garbage(canvas, column, garbage_frame, obstacle_id, speed=0.05):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same"""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
obstacle_size_row, obstacle_size_col = get_frame_size(garbage_frame)
active_obstacles[obstacle_id] = Obstacle(row, column, obstacle_size_row,
obstacle_size_col, obstacle_id)
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0.1)
draw_frame(canvas, row, column, garbage_frame, negative=True)
if not active_obstacles.get(obstacle_id):
await explode(canvas, row + obstacle_size_row // 2,
column + obstacle_size_col // 2 - 1)
return
else:
active_obstacles[obstacle_id].row += speed
row += speed
