async def show_caption(canvas):
"""Show scenario text in the bottom of the screen."""
global year
max_rows, max_columns = canvas.getmaxyx()
caption_window_nlines = 1 + BORDER_LENGTH * 2
caption_window_ncols = max_columns // CAPTION_WINDOW_LENGTH_PART
caption_window_begin_y = max_rows - BORDER_LENGTH - caption_window_nlines
caption_window_begin_x = max_columns // 2 - caption_window_ncols // 2
caption_window = canvas.derwin(
caption_window_nlines,
caption_window_ncols,
caption_window_begin_y,
caption_window_begin_x,
)
while True:
caption_text = f'Year {year}'
if year in PHRASES:
caption_text = caption_text + '. ' + PHRASES[year]
caption_row = 1
caption_column = caption_window_ncols // 2 - len(caption_text) // 2
draw_frame(caption_window, caption_row, caption_column, caption_text)
await sleep()
draw_frame(caption_window,
caption_row,
caption_column,
caption_text,
negative=True)
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 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 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 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)
def main(options):
filename = 'three_crosses_2.txt'
state = read_input(filename)
for frame in range(0, 150):
print('--[Frame {}]-------------------'.format(frame))
for car in state.get_cars():
print(repr(car))
draw_frame(state, frame)
state.tick()
async def show_year(canvas):
"""Show current year from global game_state.year on left bottom of canvas."""
canvas_rows_size, canvas_columns_size = get_canvas_size(canvas)
while True:
draw_frame(canvas, canvas_rows_size - 2, 0,
f"Year: {str(game_state.year)}")
canvas.syncup()
await sleep(2)
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 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 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 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 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
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await sleep()
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
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()
async def show_obstacles(canvas, obstacles):
while True:
boxes = []
for obstacle in obstacles:
boxes.append(obstacle.dump_bounding_box())
for row, column, frame in boxes:
draw_frame(canvas, row, column, frame)
await asyncio.sleep(0)
for row, column, frame in boxes:
draw_frame(canvas, row, column, frame, negative=True)
async def spaceship(canvas, row, column, frame1, frame2):
"""Spaceship animation."""
while True:
row, column = get_spaceship_move(canvas, frame1, row, column)
draw_frame(canvas, row, column, frame1)
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame1, negative=True)
row, column = get_spaceship_move(canvas, frame2, row, column)
draw_frame(canvas, row, column, frame2)
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame2, 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
async def run_spaceship(canvas):
row_speed = column_speed = 0
old_frame = ''
global coros, obstacles, year
old_row, old_col = row, column = 15, 35
while True:
for obstacle in obstacles:
is_collision = obstacle.has_collision(row, column)
if is_collision:
obstacles_in_last_collisions.append(obstacle)
draw_frame(canvas, old_row, old_col, old_frame, negative=True)
await show_gameover(canvas)
return None
else:
keyboard_row, keyboard_column, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
keyboard_row,
keyboard_column)
row += row_speed
column += column_speed
row, column = control_screen_borders(canvas, row, column)
if space_pressed and year > 1970:
coros.append(fire(canvas, row - 1, column + 2))
draw_frame(canvas, old_row, old_col, old_frame, negative=True)
draw_frame(canvas, row, column, FRAME)
old_frame = FRAME
old_row, old_col = row, column
await asyncio.sleep(0)
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: 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)
def main(options):
output = 'frames/frame_{:04d}.png'
if options.test:
filename = 'sample.txt'
else:
filename = 'input.txt'
state = read_input(filename)
frame = 0
print(state)
draw_frame(state, frame)
while True:
state.tick()
frame += 1
draw_frame(state, frame)
if state.crashed:
print('Found crash')
print('crashed: {} {}'.format(state.crashed, type(state.crashed)))
print(state)
a, *b = list(state.crashed)
solution = '{},{}'.format(a.x, a.y)
print('Solution of part 1 is {}'.format(solution))
break
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 rocket(canvas,
row: int,
column: int,
frames: List,
speed_of_rocket=1,
speed_animation_divider=1):
canvas_rows_size, canvas_columns_size = get_canvas_size(canvas)
animation_groups = [[frame] * speed_animation_divider for frame in frames]
animation = chain(*animation_groups)
frames_infinite_cycle = cycle(animation)
current_frame = ''
row_speed, column_speed = 0, 0
for frame in frames_infinite_cycle:
object_row_size, object_column_size = get_object_size(frames)
for obstacle in game_state.obstacles:
if obstacle.has_collision(row, column, object_row_size,
object_column_size):
draw_frame(canvas, row, column, current_frame, negative=True)
game_state.coroutines.append(
game_over(
canvas,
read_animation_frames(settings.GAME_OVER_FRAME)[0]))
game_state.coroutines.append(explode(canvas, row + 2, column))
return
draw_frame(canvas, row, column, current_frame, negative=True)
rocket_rows_direction, rocket_column_direction, space_pressed = read_controls(
canvas)
row_speed, column_speed = update_speed(row_speed, column_speed,
rocket_rows_direction,
rocket_column_direction)
row += row_speed * speed_of_rocket
column += column_speed * speed_of_rocket
row = limit_axis_coord(row, object_row_size, canvas_rows_size)
column = limit_axis_coord(column, object_column_size,
canvas_columns_size)
if space_pressed and game_state.year > settings.CANNON_APPEARS_YEAR:
game_state.coroutines.append(
fire(canvas, row - 1, column + object_column_size // 2))
draw_frame(canvas, row, column, frame)
current_frame = frame
canvas.refresh()
await sleep(1)
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 you_have_a_gun_info(canvas):
canvas_rows_size, canvas_columns_size = get_canvas_size(canvas)
draw_frame(canvas, canvas_rows_size - 3, 0,
"You have a gun! Press SPACE to fire")
await sleep(4)
draw_frame(canvas,
canvas_rows_size - 3,
0,
"You have a gun! Press SPACE to fire",
negative=True)
await sleep(2)
draw_frame(canvas, canvas_rows_size - 3, 0,
"You have a gun! Press SPACE to fire")
await sleep(4)
draw_frame(canvas,
canvas_rows_size - 3,
0,
"You have a gun! Press SPACE to fire",
negative=True)
await sleep(2)
draw_frame(canvas, canvas_rows_size - 3, 0,
"You have a gun! Press SPACE to fire")
await sleep(30)
draw_frame(canvas,
canvas_rows_size - 3,
0,
"You have a gun! Press SPACE to fire",
negative=True)
while True:
draw_frame(canvas, canvas_rows_size - 3, 0, "Press SPACE to fire")
await sleep(2)
