async def starship_animation(canvas, start_row, start_column, images):
for image in cycle(images):
image_row, image_col = get_frame_size(image)
rows_number, columns_number = canvas.getmaxyx()
row_bottom = rows_number - image_row
col_right = columns_number - image_col
rows_direct, columns_direct, space_pressed = read_controls(canvas)
start_row = start_row + rows_direct
start_column = start_column + columns_direct
if max(start_row, image_row) == image_row:
start_row = 0
if min(start_row, row_bottom) == row_bottom:
start_row = row_bottom
if max(start_column, image_col) == image_col:
start_column = 0
if min(start_column, col_right) == col_right:
start_column = col_right
draw_frame(canvas, start_row, start_column, image, negative=False)
canvas.refresh()
await asyncio.sleep(0)
draw_frame(canvas, start_row, start_column, image, negative=True)
async def animate_spaceship(canvas, row, column, frames):
"""Spaceship animation with keyboard control and limitts"""
# get max size of the canvas
rows, columns = canvas.getmaxyx()
max_row, max_column = rows - 1, columns - 1
while True:
for frame in frames:
# calculate max coordinates for ship
frame_row, frame_column = get_frame_size(frame)
row = min(row, max_row - frame_row)
row = max(1, row)
column = min(column, max_column - frame_column)
column = max(1, column)
# draw frame for 0.2 second
draw_frame(canvas, row, column, frame, negative=False)
for _ in range(2):
await asyncio.sleep(0)
# erase frame
draw_frame(canvas, row, column, frame, negative=True)
# read keyboard and move ship
rows_direction, columns_direction, _ = read_controls(canvas, 2)
row += rows_direction
column += columns_direction
async def control_spaceship(canvas, rocket_frames, row, column):
global is_collision
rocket_height, rocket_wide = get_frame_size(rocket_frames[0])
rocket_frames = cycle(rocket_frames)
row_speed = column_speed = 0
while True:
rocket_frame = next(rocket_frames)
rows_direction, columns_direction, space_pressed = read_controls(
canvas)
if space_pressed and year >= 2020:
coroutines.append(fire(canvas, row - 1, column + rocket_wide // 2))
row_speed, column_speed = update_speed(row_speed, column_speed,
rows_direction,
columns_direction)
row += row_speed
column += column_speed
if column <= 1 or column >= SCREEN_WIDE - rocket_wide:
column -= column_speed
if row <= 1 or row >= SCREEN_HEIGHT - rocket_height:
row -= row_speed
coroutines.append(draw_rocket(canvas, rocket_frame, row, column))
for obstacle in obstacles:
if obstacle.has_collision(row - 1, column):
obstacles_in_last_collision.append(obstacle)
await explode(canvas, row + 5, column + 2)
is_collision = True
coroutines.append(
show_gameover(canvas, SCREEN_HEIGHT // 2,
SCREEN_WIDE // 2))
return
await asyncio.sleep(0)
async def run_spaceship(canvas, frames):
height, width = get_frame_size(frames[0])
row_max, col_max = get_canvas_max_coords(canvas)
row = row_max - height // 2
col = col_max // 2 - width // 2
row_speed = col_speed = 0
cur_frame = None
while True:
for obstacle in obstacles:
if obstacle.has_collision(row, col):
draw_frame(canvas, row, col, cur_frame, negative=True)
await show_gameover(canvas)
row_change, col_change, shot_made = read_controls(canvas)
if shot_made and year >= YEAR_GUN_ON:
fire = animate_fire(canvas, row, col + width // 2)
coroutines.append(fire)
row_speed, col_speed = update_speed(row_speed, col_speed, row_change, col_change)
row += row_speed
col += col_speed
row = min(row, row_max - height)
col = min(col, col_max - width)
row = max(row, BORDER)
col = max(col, BORDER)
draw_frame(canvas, row, col, spaceship_frame)
cur_frame = spaceship_frame
await sleep()
draw_frame(canvas, row, col, cur_frame, negative=True)
async def run_spaceship(canvas, start_row, start_col):
row, column = start_row, start_col
row_speed, column_speed = 0, 0
min_row, min_column = FRAME_BORDER_SIZE, FRAME_BORDER_SIZE
max_row, max_column = get_correct_window_dimensions(canvas)
while True:
temp_spaceship_frame = spaceship_frame
# frame_size = get_frame_size(temp_spaceship_frame)
rows, columns = get_frame_size(temp_spaceship_frame)
move_row, move_column, space_pressed = read_controls(canvas)
row_speed, column_speed = update_speed(
row_speed, column_speed, move_row, move_column)
row, column = row + row_speed, column + column_speed
column = min(max(min_column, column), max_column -
columns - FRAME_BORDER_SIZE)
row = min(max(min_row, row), max_row -
rows - FRAME_BORDER_SIZE)
collisions = [obstacle
for obstacle in obstacles if obstacle.has_collision(row, column, rows, columns)]
if collisions:
await show_gameover(canvas, start_row, start_col)
if space_pressed and year >= PLASMA_GUN_ERA:
coroutines.append(
fire(canvas, row, column + columns // 2))
draw_frame(canvas, row, column, temp_spaceship_frame)
await sleep()
draw_frame(canvas, row, column, temp_spaceship_frame, negative=True)
async def run_spaceship(canvas, canvas_vertical_center, canvas_horizontal_center, frames):
row, column = canvas_vertical_center, canvas_horizontal_center
frame_rows, frame_columns = get_frame_size(frames[0])
canvas_rows, canvas_column = canvas.getmaxyx()
row_speed, column_speed = 0, 0
while True:
rows_direction, columns_direction, space_pressed = read_controls(canvas)
row_speed, column_speed = update_speed(row_speed, column_speed, rows_direction, columns_direction)
row = max(1, min(row + row_speed, canvas_rows - frame_rows - 1))
column = max(1, min(column + column_speed, canvas_column - frame_columns - 1))
previous_spaceship_frame = spaceship_frame
draw_frame(canvas, row, column, spaceship_frame, negative=False)
plasma_gun_activation_year = 2020
if year > plasma_gun_activation_year and space_pressed:
coroutines.append(fire(canvas, row, column + 2))
await asyncio.sleep(0)
draw_frame(canvas, row, column, previous_spaceship_frame, negative=True)
for index, obstacle in enumerate(obstacles.copy()):
# add show_gameover coroutine if spaceship meet garbage
if obstacle.has_collision(row, column):
coroutines.append(
show_gameover(canvas, canvas_vertical_center, canvas_horizontal_center)
)
return
async def animate_spaceship(canvas, row, column, frames):
row_speed = column_speed = 0
screen_rows, screen_columns = canvas.getmaxyx()
max_row, max_column = screen_rows - OFFSET_FROM_EDGE_OF_SCREEN, screen_columns - OFFSET_FROM_EDGE_OF_SCREEN
for frame in cycle(frames):
frame_rows, frame_columns = get_frame_size(frame)
for _ in range(2):
rows_direction, columns_direction, space_pressed = read_controls(canvas)
row_speed, column_speed = update_speed(row_speed, column_speed, rows_direction, columns_direction)
row += row_speed
column += column_speed
row = max(
OFFSET_FROM_EDGE_OF_SCREEN,
min(row + rows_direction, max_row - frame_rows)
)
column = max(
OFFSET_FROM_EDGE_OF_SCREEN,
min(column + columns_direction, max_column - frame_columns)
)
draw_frame(canvas, row, column, frame, color=[1, 2])
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame, negative=True)
if space_pressed and year >= YEAR_OF_GUN_AVAILABILITY:
coroutines.append(
fire(canvas, row, column + round(frame_columns / 2), -3)
)
for obstacle in obstacles:
if not obstacle.has_collision(row, column, frame_rows, frame_columns):
continue
coroutines.append(show_gameover(canvas))
return
async def run_spaceship(canvas, spaceship_frame, coroutines, obstacles,
obstacles_collisions, years, timeout, row, column):
assert all(i >= 0 for i in (row, column, timeout)), AssertionError(
"row, column and timeout have to be non-negative")
assert bool(years), AssertionError(
"Years has to be initiated with int value.")
height, width = canvas.getmaxyx()
row_speed = 0
column_speed = 0
# "spinlock" waiting for updating spaceship_frame
while not spaceship_frame:
await asyncio.sleep(0)
frame, rocket_height, rocket_width = spaceship_frame
draw_frame(canvas, row, column, frame)
while True:
collisions = set(
filter(lambda o: o.has_collision(row, column), obstacles))
if collisions:
obstacles_collisions.update(collisions)
draw_frame(canvas, row, column, frame, negative=True)
await explode(canvas, row, column)
coroutines.append(get_game_over(canvas))
spaceship_frame[0] = None
return
# handle a user control
row_shift, col_shift, space = read_controls(canvas)
draw_frame(canvas, row, column, frame, negative=True)
row_speed, column_speed = update_speed(row_speed, column_speed,
row_shift, col_shift)
# keep rocket in borders
row = calc_location(row + row_speed, height - rocket_height - 1)
column = calc_location(column + column_speed, width - rocket_width - 1)
# shoot
if space and years[0] >= 2020:
coroutines.append(
fire(canvas, obstacles, obstacles_collisions, row - 1,
column + 2, -2))
frame, rocket_height, rocket_width = spaceship_frame
draw_frame(canvas, row, column, frame)
await asyncio.sleep(0)
async def run_spaceship(canvas):
# Положение корабля и отрисовка
global spaceship_frame
max_row, max_col = canvas.getmaxyx()
frame_max_row, frame_max_col = get_frame_size(load_frames("rocket")[0])
row = max_row - (frame_max_row + 1)
col = max_col // 2
row_speed = col_speed = 0
while True:
drow, dcol, space = read_controls(canvas)
border = 1
row_speed, col_speed = update_speed(row_speed, col_speed, drow, dcol)
if border < (col + col_speed) < (max_col - frame_max_col - border):
col += col_speed
if border < (row + row_speed) < (max_row - frame_max_row - border):
row += row_speed
if space and (globalvars.year >= 2020):
coroutines.append(fire(canvas, row, col + 2))
for obstacle in obstacles:
if obstacle.has_collision(row, col):
coroutines.append(show_gameover(canvas))
return
draw_frame(canvas, row, col, spaceship_frame)
old_frame = spaceship_frame
await asyncio.sleep(0)
draw_frame(canvas, row, col, old_frame, negative=True)
async def run_spaceship(canvas, row, column):
""" controls location of spaceship and draws it on the screen"""
row_speed = column_speed = 0
global spaceship_frame
global coroutines
global year
spaceship_collision = False
while not spaceship_collision:
maxx, maxy = canvas.getmaxyx()
rows_direction, columns_direction, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
rows_direction,
columns_direction)
frame_rows, frame_columns = get_frame_size(spaceship_frame)
row, column = speed_reduction_near_border(row, column, frame_rows,
frame_columns, maxx, maxy,
row_speed, column_speed)
draw_frame(canvas, row, column, spaceship_frame)
last_frame = spaceship_frame
frame_rows, frame_columns = get_frame_size(spaceship_frame)
await sleep(1)
if space_pressed and (year >= 2020):
coroutines.append(fire(canvas, row, column + 2))
draw_frame(canvas, row, column, last_frame, negative=True)
if if_collision_append_collision_list(row, column, frame_rows,
frame_columns):
spaceship_collision = True
coroutines.append(
explode(canvas, row + frame_rows // 2, column + frame_columns // 2))
coroutines.append(show_gameover(canvas))
async def run_spaceship(canvas):
global spaceship_frame
global coroutines
global year
row, column = 5, 8
row_speed = column_speed = 0
while True:
last_spaceship_frame = spaceship_frame
row_control, col_control, space_control = read_controls(canvas)
row_size, column_size = get_frame_size(last_spaceship_frame)
if space_control and year > 2020:
coroutines.append(fire(canvas, row, column + column_size // 2))
row_speed, column_speed = update_speed(row_speed, column_speed,
row_control, col_control)
row += row_speed
column += column_speed
for obstacle in obstacles:
if obstacle.has_collision(row, column, row_size, column_size):
coroutines.append(show_gameover(canvas))
return
draw_frame(canvas, row, column, last_spaceship_frame)
await sleep()
draw_frame(canvas, row, column, last_spaceship_frame, True)
async def run_spaceship(canvas, row, column):
""" Анимация ракеты с поддержкой перемещения"""
global year
row_speed = column_speed = 0
MAX_Y, MAX_X = canvas.getmaxyx()
while True:
current_frame, current_row, current_column = spaceship_frame, row, column
draw_frame(canvas, row, column, spaceship_frame)
row_acceleration, column_acceleration, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
row_acceleration,
column_acceleration)
for obstacle in obstacles:
if obstacle.has_collision(row, column):
await show_gameover(canvas)
return
if (BORDER < row + row_speed < MAX_Y - FRAME_HEIGHT - BORDER):
row += row_speed
if (BORDER < column + column_speed < MAX_X - FRAME_WIDTH - BORDER):
column += column_speed
if space_pressed and year >= 2020:
coroutines.append(
fire(canvas, row, column + FRAME_WIDTH / 2, obstacles,
obstacles_in_last_collisions))
await sleep(0.1)
draw_frame(canvas, current_row, current_column, current_frame, True)
draw_frame(canvas, row, column, spaceship_frame)
async def run_spaceship(canvas, row, column):
global spaceship_frame, year
row_speed = column_speed = 0
max_row, max_column = get_canvas_maxyx(canvas)
frame_rows, frame_columns = ctools.get_frame_size(spaceship_frame)
while True:
row_d, column_d, space_pressed = ctools.read_controls(canvas)
row_speed, column_speed = update_speed(row_speed,
column_speed,
row_d,
column_d)
row = min(max(row + row_speed, 0), max_row - frame_rows)
column = min(max(column + column_speed, 0), max_column - frame_columns)
sh_frame = spaceship_frame
ctools.draw_frame(canvas, row, column, sh_frame)
await sleep(1)
ctools.draw_frame(canvas, row, column, sh_frame, True)
if space_pressed and year > 2020:
event_loop.create_task(fire(canvas,
row - 1,
column + frame_columns // 2))
for obstacle in obstacles:
if obstacle.has_collision(row, column, frame_rows, frame_columns):
await show_gameover(canvas)
return
async def animate_spaceship(canvas, row, column, frame1, frame2):
canvas_max_height, canvas_max_width = canvas.getmaxyx() # (26, 191)
frame_rows, frame_columns = get_frame_size(frame1) # (9, 5)
# while loop needs to be here not to throw StopIteration and work forever...
while True:
draw_frame(canvas, row, column, frame1)
await asyncio.sleep(0)
# flush the previous frame before drawing the next one
draw_frame(canvas, row, column, frame1, negative=True)
# update coordinates after pressing some arrow
row_diff, column_diff, _ = read_controls(canvas)
# Horizontal restriction: right <-> left
if 0 < (column + column_diff) < (canvas_max_width - frame_columns):
column += column_diff
# Vertical restriction: up ↕ down
if 0 < (row + row_diff) < (canvas_max_height - frame_rows):
row += row_diff
draw_frame(canvas, row, column, frame2)
await asyncio.sleep(0)
async def run_spaceship(canvas, window_rows, window_columns, frame_rows,
frame_columns):
global starship_row, starship_column, obstacles
# вычисляем правую и нижнию границу один раз при условии что размеры окна не меняются во время работы
max_allowed_row = window_rows - frame_rows - 1
max_allowed_column = window_columns - frame_columns - 1
row_speed = column_speed = 0
while True:
rows_direction, columns_direction, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
rows_direction,
columns_direction)
new_row = starship_row + row_speed * SPEED
new_column = starship_column + column_speed * SPEED
starship_row = median([1, new_row, max_allowed_row])
starship_column = median([1, new_column, max_allowed_column])
if space_pressed and YEAR >= 2020:
coroutine = fire(canvas, starship_row, starship_column +
frame_columns // 2) # середина корабля
coroutines.append(coroutine)
for obstacle in obstacles:
if obstacle.has_collision(starship_row, starship_column,
frame_rows, frame_columns):
coroutines.append(
show_gameover(canvas, window_rows, window_columns))
return
await asyncio.sleep(0)
async def animate_spaceship(canvas, row, column):
with open("frames/rocket_frame_1.txt") as file1:
frame1 = file1.read()
with open("frames/rocket_frame_2.txt") as file2:
frame2 = file2.read()
frame_rows, frame_columns = get_frame_size(frame1)
max_row, max_column = canvas.getmaxyx()
while True:
rows_direction, columns_direction, space_pressed = read_controls(
canvas)
if check_ship_inside_border(current_coordinate=row,
step=rows_direction,
frame_size=frame_rows,
border=max_row):
row += rows_direction
if check_ship_inside_border(current_coordinate=column,
step=columns_direction,
frame_size=frame_columns,
border=max_column):
column += columns_direction
draw_frame(canvas, row, column, frame1)
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame1, negative=True)
draw_frame(canvas, row, column, frame2)
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame2, negative=True)
async def run_spaceship(canvas, row, column):
"""Determine the position of the spaceship and display it.
Params:
* canvas: window object from curses
* row: number of row
* column: number of column
"""
# Define height and width of the canvas
canvas_height, canvas_width = canvas.getmaxyx()
global spaceship_frame, row_speed, column_speed, year
while True:
# Define height and width of the frame
frame_height, frame_width = get_frame_size(spaceship_frame)
rows_direction, columns_direction, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(
row_speed,
column_speed,
rows_direction,
columns_direction,
)
# Subtract 1 so as not to erase the borders
row_number = min(
row + row_speed,
canvas_height - frame_height - 1,
)
column_number = min(
column + column_speed,
canvas_width - frame_width - 1,
)
# Set 1 so as not to erase the borders
row = max(row_number, 1)
column = max(column_number, 1)
# Make a gun shot if the user presses a space
# and a year 2020 or more
if space_pressed and year >= YEAR_CREATION_LASER_GUN:
fire_coroutine = fire(canvas, row, column, rows_speed=-2)
coroutines.append(fire_coroutine)
draw_frame(canvas, row, column, spaceship_frame)
# Stores the last frame of the animation that was drawn,
# and which you want to erase later
last_frame = spaceship_frame
await sleep()
draw_frame(canvas, row, column, last_frame, negative=True)
for obstacle in obstacles:
if obstacle.has_collision(row, column, frame_height, frame_width):
gameover_coroutine = show_gameover(canvas)
coroutines.append(gameover_coroutine)
return
async def run_spaceship(
canvas, start_row, start_column, gun_activation_year=2020):
row, column = start_row, start_column
row_speed = column_speed = 0
canvas_height, canvas_width = canvas.getmaxyx()
while True:
current_frame = spaceship_frame
rows_direction, columns_direction, space_pressed = read_controls(
canvas=canvas,
)
row_speed, column_speed = update_speed(
row_speed=row_speed,
column_speed=column_speed,
rows_direction=rows_direction,
columns_direction=columns_direction,
)
row += row_speed
column += column_speed
frame_height, frame_width = get_frame_size(current_frame)
row = limit(
value=row,
min_value=1,
max_value=canvas_height - frame_height - 1,
)
column = limit(
value=column,
min_value=1,
max_value=canvas_width - frame_width - 1,
)
draw_frame(canvas, row, column, current_frame)
if space_pressed and row > 1 and year >= gun_activation_year:
coroutines.append(
animate_gun_shot(
canvas=canvas,
start_row=row - 1,
start_column=column + 2,
)
)
await sleep()
draw_frame(canvas, row, column, current_frame, negative=True)
for obstacle in obstacles:
if obstacle.has_collision(
obj_corner_row=row, obj_corner_column=column):
coroutines.append(
show_gameover(canvas=canvas),
)
return
async def animate_spaceship(canvas, row, column, frames, row_speed,
column_speed, spaceship_obstacle):
row_speed, column_speed = row_speed, column_speed
for frame in itertools.cycle(frames):
# getmaxyx() - возвращает ширину и высоту окна, которые всегда на единицу больше чем координаты крайних ячеек
max_rows, max_columns = canvas.getmaxyx()
rows_direction, columns_direction, space_pressed = ct.read_controls(
canvas=canvas)
row_speed, column_speed = update_speed(
row_speed=row_speed,
column_speed=column_speed,
rows_direction=rows_direction,
columns_direction=columns_direction)
row += row_speed
column += column_speed
ct.draw_frame(canvas=canvas,
start_row=row,
start_column=column,
text=frame)
await sleep(1)
# стираем предыдущий кадр, прежде чем рисовать новый
ct.draw_frame(canvas=canvas,
start_row=row,
start_column=column,
text=frame,
negative=True)
if space_pressed and YEAR > 2020:
COROUTINES.append(fire(canvas, row - 1, column + 2))
frame_rows, frame_columns = ct.get_frame_size(text=frame)
# frame_rows и BORDER_WIDTH - учитываем размер модели и рамку на нижней рамке
row = min(max_rows - frame_rows - BORDER_WIDTH, row)
# frame_columns и BORDER_WIDTH - учитываем размер модели и рамку на правой рамке
column = min(max_columns - frame_columns - BORDER_WIDTH, column)
row = max(
row, BORDER_WIDTH
) # BORDER_WIDTH отвечает за контроль от перехода выше верхней рамки
column = max(
column, BORDER_WIDTH
) # BORDER_WIDTH отвечает за контроль от перехода левее левой рамки
spaceship_obstacle.row = row
spaceship_obstacle.column = column
if life_points <= 0:
await explode(canvas, spaceship_obstacle.row,
spaceship_obstacle.column)
OBSTACLES.remove(spaceship_obstacle)
await show_game_over(canvas=canvas, row=row, column=column)
return None
async def run_spaceship(canvas, coros, start_row, start_column,
frame_container, level, start_year):
height, width = canvas.getmaxyx()
border_size = 1
frame_size_y, frame_size_x = get_frame_size(frame_container[0])
frame_pos_x = round(start_column) - round(frame_size_x / 2)
frame_pos_y = round(start_row) - round(frame_size_y / 2)
row_speed, column_speed = 0, 0
while True:
direction_y, direction_x, spacebar = read_controls(canvas)
current_year = start_year + level[0]
if spacebar and current_year >= 2020:
shot_pos_x = frame_pos_x + round(frame_size_x / 2)
shot_pos_y = frame_pos_y - 0
shot_coro = fire(canvas, shot_pos_y, shot_pos_x)
coros.append(shot_coro)
row_speed, column_speed = update_speed(row_speed, column_speed,
direction_y, direction_x)
frame_pos_x += column_speed
frame_pos_y += row_speed
frame_x_max = frame_pos_x + frame_size_x
frame_y_max = frame_pos_y + frame_size_y
field_x_max = width - border_size
field_y_max = height - border_size
frame_pos_x = min(frame_x_max, field_x_max) - frame_size_x
frame_pos_y = min(frame_y_max, field_y_max) - frame_size_y
frame_pos_x = max(frame_pos_x, border_size)
frame_pos_y = max(frame_pos_y, border_size)
current_frame = frame_container[0]
draw_frame(canvas, frame_pos_y, frame_pos_x, current_frame)
await asyncio.sleep(0)
draw_frame(canvas,
frame_pos_y,
frame_pos_x,
current_frame,
negative=True)
for obstacle in obstacles_actual:
if obstacle.has_collision(frame_pos_y, frame_pos_x):
game_over_coro = show_gameover(
canvas, height, width,
load_frame_from_file('game_over/game_over.txt'))
coros.append(game_over_coro)
return
def get_updated_coordinates(canvas, frame, row, column, row_speed, column_speed):
row_direction, column_direction, space_pressed = read_controls(canvas)
row_speed, column_speed = update_speed(row_speed, column_speed, row_direction, column_direction)
rows_in_frame, columns_in_frame = get_frame_size(frame)
rows_number, columns_number = canvas.getmaxyx()
row = min(max(row + row_speed, 0), rows_number - rows_in_frame)
column = min(max(column + column_speed, 0), columns_number - columns_in_frame)
return row, column, row_speed, column_speed, space_pressed
async def run_spaceship(canvas, start_row, start_column):
"""Spaceship behavoir: control with arrow keys, animate frames,
check for collisions with garbage."""
global spaceship_frame, spaceship_flame_frame, coroutines, obstacles
row = start_row
column = start_column
# Get canvas limits and spaceship dimentions.
row_max, column_max = canvas.getmaxyx()
spaceship_height, spaceship_width = get_frame_size(spaceship_frame)
row_limits = (0, row_max - spaceship_height)
column_limits = (0, column_max - spaceship_width)
row_speed = column_speed = 0
previous_spaceship_flame_frame = ''
previous_spaceship_frame = ''
while True:
rows_direction, columns_direction, space_pressed = read_controls(canvas)
# Calculate new speed and new coordinates.
row_speed, column_speed = update_speed(row_speed, column_speed, rows_direction, columns_direction)
if row >= max(row_limits) and row_speed >= 0 or row <= min(row_limits) and row_speed <= 0:
row_speed = 0
row = row + row_speed
if column >= max(column_limits) and column_speed >= 0 or column <= min(column_limits) and column_speed <= 0:
column_speed = 0
column = column + column_speed
# Power-on the plasma gun.
if space_pressed and year > YEAR_PLASMA_GUN_INVENTED:
coroutines.append(animate_fire(canvas, row, column +2, rows_speed=-0.6, columns_speed=0))
# Animate frames.
draw_frame(canvas, row, column, spaceship_frame)
draw_frame(canvas, row, column, spaceship_flame_frame, color='yellow')
await asyncio.sleep(0)
draw_frame(canvas, row, column, previous_spaceship_frame, negative=True)
draw_frame(canvas, row, column, previous_spaceship_flame_frame, negative=True)
previous_spaceship_frame = spaceship_frame
previous_spaceship_flame_frame = spaceship_flame_frame
# Check for collisions with garbage.
for obstacle in obstacles:
if obstacle.has_collision(row, column):
obstacles.remove(obstacle)
await explode(canvas, row, column)
await show_gameover(canvas)
return
def run(self, canvas):
canvas.nodelay(True)
curses.curs_set(False)
self.canvas = canvas
stars = self.generate_stars()
for star_coords, attributes in stars.items():
x, y = star_coords
symbol, delay = attributes
self.coroutines.append(star_blink(canvas, y, x, delay, symbol))
self.space_coords = self.canvas_center_coords
self.coroutines.append(self.space_animation())
self.coroutines.append(self.fill_orbit_with_garbage())
self.coroutines.append(self.add_fire())
self.coroutines.append(self.show_game_over())
self.coroutines.append(self.show_year_label())
snap_index = 0
while True:
if not self.is_space_died:
y_direction, x_direction, is_shot = read_controls(canvas)
self.is_shot = is_shot and self.current_year > 2019
x, y = self.space_coords
v_x, v_y = self.space_x_speed, self.space_y_speed
v_y, v_x = update_speed(v_y, v_x, y_direction, x_direction)
x += v_x
y += v_y
self.space_x_speed, self.space_y_speed = v_x, v_y
self.space_coords = self.get_space_corrected_coords(x, y)
for coroutine in self.coroutines.copy():
try:
coroutine.send(None)
except StopIteration:
self.coroutines.remove(coroutine)
if len(self.coroutines) == 0:
break
canvas.refresh()
canvas.border()
time.sleep(ANIMATION_DELAY)
if not snap_index % (
ONE_YEAR_DURATION_IN_SECONDS / ANIMATION_DELAY):
self.current_year += 1
snap_index += 1
async def run_spaceship(canvas, coroutines, frames_container, border_size):
main_window_height, main_window_width = canvas.getmaxyx()
start_ship_row = main_window_height - border_size
start_ship_column = main_window_width / 2
frame_size_y, frame_size_x = get_frame_size(frames_container[0])
frame_pos_x = round(start_ship_row) - round(frame_size_x / 2)
frame_pos_y = round(start_ship_column)
row_speed, column_speed = 0, 0
while True:
direction_y, direction_x, spacepressed = read_controls(canvas)
if spacepressed:
shot_pos_x = frame_pos_x + round(frame_size_x / 2)
shot_pos_y = frame_pos_y
shot_coroutine = fire(canvas, shot_pos_y, shot_pos_x)
coroutines.append(shot_coroutine)
row_speed, column_speed = update_speed(row_speed, column_speed,
direction_y, direction_x)
frame_pos_x += column_speed
frame_pos_y += row_speed
frame_pos_x_max = frame_pos_x + frame_size_x
frame_pos_y_max = frame_pos_y + frame_size_y
game_field_x_max = main_window_width - border_size
game_field_y_max = main_window_height - border_size
frame_pos_x = min(frame_pos_x_max, game_field_x_max) - frame_size_x
frame_pos_y = min(frame_pos_y_max, game_field_y_max) - frame_size_y
frame_pos_x = max(frame_pos_x, border_size)
frame_pos_y = max(frame_pos_y, border_size)
frame = frames_container[0]
draw_frame(canvas, frame_pos_y, frame_pos_x, frame)
await asyncio.sleep(0)
draw_frame(canvas, frame_pos_y, frame_pos_x, frame, negative=True)
gameover_frame = load_frame_from_file(GAME_OVER_FRAME_PATH)
for obstacle in obstacles:
if obstacle.has_collision(frame_pos_y, frame_pos_x):
gameover_coroutine = show_gameover(canvas, gameover_frame)
coroutines.append(gameover_coroutine)
return
async def drive_spaceship(canvas, start_row, start_column, animation_frame_1,
animation_frame_2):
row, column = start_row, start_column
row_speed = column_speed = 0
rows_number, columns_number = canvas.getmaxyx()
frame_rows, frame_columns = get_frame_size(animation_frame_1)
while True:
rows_direction, columns_direction, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
rows_direction,
columns_direction)
row += row_speed
upper_border = BORDER
if row < upper_border:
row = upper_border
bottom_border = rows_number - frame_rows - BORDER
if row > bottom_border:
row = bottom_border
column += column_speed
left_border = BORDER
if column < left_border:
column = left_border
right_border = columns_number - frame_columns - BORDER
if column > right_border:
column = right_border
if space_pressed:
spaceship_head_column = column + (frame_columns / 2)
coroutines.append(
fire(canvas,
start_row=row,
start_column=spaceship_head_column,
rows_speed=ROWS_SPEED,
columns_speed=COLUMNS_SPEED))
for obstacle in obstacles:
if obstacle.has_collision(row, column):
coroutines.append(show_gameover(canvas, game_over_frame))
return None
await animate_spaceship(animation_frame_1)
await run_spaceship(canvas, row, column)
await animate_spaceship(animation_frame_2)
await run_spaceship(canvas, row, column)
async def animate_spaceship(canvas, row, column, frames):
max_row_num, max_column_num = canvas.getmaxyx()
for frame in itertools.cycle(frames):
draw_frame(canvas, row, column, frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame, negative=True)
row_shift, column_shift, space_pressed = read_controls(canvas)
# checking for collisions with screen borders
frame_rows, frame_columns = get_frame_size(frame)
if 0 < row + row_shift < max_row_num - frame_rows:
row += row_shift
if 0 < column + column_shift < max_column_num - frame_columns:
column += column_shift
async def animate_spaceship(canvas, row, column, frames):
"""Spaceship animation with keyboard control and limitts"""
# get max size of the canvas
rows, columns = canvas.getmaxyx()
max_row, max_column = rows - 1, columns - 1
row_speed = column_speed = 0
while True:
for frame in frames:
# read keyboard and move ship or fire
rows_direction, columns_direction, space = read_controls(canvas, 1)
row_speed, column_speed = update_speed(row_speed, column_speed,
rows_direction,
columns_direction,
RAW_SPACE_SPEED,
COLUMN_SPACE_SPEED)
row += row_speed
column += column_speed
# calculate max coordinates for ship
frame_row, frame_column = get_frame_size(frame)
row = min(row, max_row - frame_row)
row = max(1, row)
column = min(column, max_column - frame_column)
column = max(1, column)
if space:
coroutines.append(
fire(canvas, row, column + round(frame_column / 2),
FIRE_SPEED))
# draw frame for 0.2 second
draw_frame(canvas, row, column, frame, negative=False)
# check collision
for obs_id, obs in obstacles.items():
if obs.has_collision((row, column)):
obstacles_to_stop.append(obs_id)
coroutines.append(show_gameover(canvas))
draw_frame(canvas, row, column, frame, negative=True)
return
# check collision
await sleep(2)
# erase frame
draw_frame(canvas, row, column, frame, negative=True)
async def run_spaceship(canvas, window_size, border_depth):
"""
Draw and move the rocket
"""
global is_running
global coroutines
global weapon
frame_size = get_frame_size(spaceship_frame)
frame_size_y, frame_size_x = frame_size
window_size_y, window_size_x = window_size
rocket_start_position_y = window_size_y - frame_size_y - border_depth
row = rocket_start_position_y
window_center_x = median([
1,
window_size_x,
])
frame_width_half = median([
1,
frame_size_x,
])
rocket_start_position_x = window_center_x - frame_width_half
column = rocket_start_position_x
last_frame = spaceship_frame
try:
while True:
draw_frame(canvas, row, column, last_frame, negative=True)
readkeys = read_controls(canvas)
row, column = move_spaceship(readkeys, row, column, window_size,
frame_size, border_depth)
draw_frame(canvas, row, column, spaceship_frame)
last_frame = spaceship_frame
_, _, space_pressed = readkeys
if space_pressed and weapon:
coroutines.append(fire(canvas, row, column + frame_width_half))
await asyncio.sleep(0)
for obstacle in obstacles:
if obstacle.has_collision(row, column, frame_size_y,
frame_size_x):
return
finally:
is_running.state = False
draw_frame(canvas, row, column, last_frame, negative=True)
coroutines.append(show_game_over(canvas, window_size))
def get_direction(canvas, row, column, row_size, column_size):
max_row, max_column = canvas.getmaxyx()
rows_direction, columns_direction, space_pressed = read_controls(canvas)
if rows_direction == 0:
new_row = row
else:
new_row = calculate_coordinate(row, max_row, rows_direction, row_size)
if columns_direction == 0:
new_column = column
else:
new_column = calculate_coordinate(column, max_column,
columns_direction, column_size)
return new_row, new_column
async def run_spaceship(canvas, start_row, start_column):
row_number, column_number = canvas.getmaxyx()
max_row = row_number - BORDER_SIZE
max_column = column_number - BORDER_SIZE
row_speed = column_speed = 0
while True:
row_direction, column_direction, pressed_space = read_controls(canvas)
row_speed, column_speed = update_speed(
row_speed,
column_speed,
row_direction / 10,
column_direction / 10
)
new_row = start_row + row_speed
new_column = start_column + column_speed
ship_height, ship_width = get_frame_size(spaceship_frame)
frame_max_row = new_row + ship_height
frame_max_column = new_column + ship_width
new_row = min(frame_max_row, max_row) - ship_height
new_column = min(frame_max_column, max_column) - ship_width
new_row = max(new_row, BORDER_SIZE)
new_column = max(new_column, BORDER_SIZE)
start_row, start_column = new_row, new_column
draw_frame(canvas, start_row, start_column, spaceship_frame)
drawn_frame = spaceship_frame
if pressed_space and year >= GUN_YEAR:
fire_column = start_column + OFFSET_TO_SPACESHIP_EDGE
coroutines.append(fire(canvas, start_row, fire_column))
await sleep()
draw_frame(canvas, start_row, start_column, drawn_frame, negative=True)
ship_collided = False
for obstacle in obstacles:
ship_collided = ship_collided or obstacle.has_collision(
start_row,
start_column,
obj_size_rows=ship_height,
obj_size_columns=ship_width
)
if ship_collided:
break
await show_gameover(canvas)
