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)