async def print_info(canvas):
phrase = PHRASES.get(year)
while True:
phrase = PHRASES.get(year) or phrase
canvas.addstr(1, 1, '{}: {}'.format(year, phrase))
canvas.addstr(10, 1, 'len {}'.format(len(obstacles)))
await sleep(0.1)
async def show_messages(canvas):
message_template = "Year: {} {}"
while True:
yr = message_template.format(year, PHRASES.get(year, ''))
draw_frame(canvas, 0, 0, yr)
await asyncio.sleep(0)
draw_frame(canvas, 0, 0, yr, negative=True)
def update_infoplate(canvas, status):
max_row, max_column = canvas.getmaxyx()
plate = canvas.derwin(3, 0, max_row - 3, 0)
phrase = PHRASES.get(status.year) or ""
plate.clear()
draw_frame(plate, 1, (max_column - len(phrase)) // 2, phrase)
draw_frame(plate, 1, max_column - 15, "Year: %d" % status.year)
plate.box()
async def draw_phrases(canvas):
"""Phrases drawing function."""
global year
#calculate phrase position
y_crd, x_crd = canvas.getmaxyx()
x_crd = int(x_crd / 2.2)
phrase = ''
while True:
if PHRASES.get(year):
phrase = PHRASES.get(year)
try:
canvas.addstr(1, x_crd, phrase)
except TypeError:
pass
await sleep()
async def show_message(canvas, row_max, col_max):
info_zone = canvas.derwin(row_max - 4, col_max - 60)
phrase = PHRASES[globs.year]
x, y = info_zone.getmaxyx()
while True:
if PHRASES.get(globs.year):
phrase = PHRASES[globs.year]
info_zone.addstr(x - 2, y - 50,
f'Year: {int(globs.year)} {phrase}')
else:
info_zone.addstr(x - 2, y - 50,
f'Year: {int(globs.year)} {phrase}')
await asyncio.sleep(0)
async def increment_year(canvas):
""" Increment year to run the scenario of the game """
global year
while True:
for _ in range(15):
if year in PHRASES.keys():
message = "{} {}".format(year, PHRASES[year] + " " * 30)
else:
message = "{} {}".format(year, "..." + " " * 30)
canvas.addstr(0, 0, message, curses.A_DIM)
await asyncio.sleep(0)
year += 1
async def control_time(canvas):
global current_year, current_message
while True:
max_y, max_x = get_real_maxyx(canvas)
window = canvas.derwin(1, int(max_x / 2), max_y - 1,
max(1, int(max_x / 2 - 25)))
draw_frame(window, 0, 0, str(current_year))
current_message = PHRASES.get(current_year, None) or current_message
if current_message:
draw_frame(window, 0, 8, current_message)
await sleep(TICKS_IN_YEAR)
draw_frame(window, 0, 8, current_message, negative=True)
current_year += 1
def draw(canvas):
n_stars = 100
max_y, max_x = canvas.getmaxyx()
canvas.nodelay(True)
curses.curs_set(False)
border_width = 1
spaceship_width, spaceship_height = animations.get_spaceship_size()
for i in range(n_stars):
row = random.randint(border_width, max_y - border_width - 1)
column = random.randint(border_width, max_x - border_width - 1)
symbol = random.choice('+*.:')
initial_state = random.randint(0, 30)
star = animations.blink(canvas, row, column, symbol, initial_state)
game_state.coroutines.append(star)
spaceship_animation = animations.animate_spaceship(canvas)
spaceship_drawing = animations.run_spaceship(
canvas, (max_y - spaceship_width) // 2,
(max_x - spaceship_height) // 2)
game_state.coroutines.append(spaceship_animation)
game_state.coroutines.append(spaceship_drawing)
game_state.coroutines.append(fill_orbit_with_garbage(canvas))
info_subwin_size = (1, 62)
message_template = 'Year: {} {:<50}'
info_subwin = canvas.derwin(*info_subwin_size, border_width, border_width)
try:
while True:
exhausted_coroutines = set()
for cor in game_state.coroutines:
try:
cor.send(None)
except StopIteration as e:
exhausted_coroutines.add(cor)
canvas.border()
year = int(game_state.current_year)
message = message_template.format(year, PHRASES.get(year, ''))
info_subwin.addstr(0, 0, message)
canvas.refresh()
game_state.coroutines = [
cor for cor in game_state.coroutines
if cor not in exhausted_coroutines
]
time.sleep(config.TIC_TIMEOUT)
game_state.current_year += 1 / config.TICS_PER_YEAR
except KeyboardInterrupt:
exit()
async def show_year(status_bar):
current_phrase = ""
phrases_years = list(PHRASES.keys())
phrases_years.sort(reverse=True)
_, cols = status_bar.getmaxyx()
while True:
for phrase_year in phrases_years:
if phrase_year <= year:
current_phrase = PHRASES[phrase_year]
break
status = "{} - {}".format(int(year), current_phrase)
status_col = round((cols - len(status)) / 2)
draw_frame(status_bar, 0, status_col, status, padding=0)
await asyncio.sleep(0)
draw_frame(status_bar, 0, status_col, status, negative=True, padding=0)
async def print_event(sub_canvas):
global year
event = 0
max_row, max_column = sub_canvas.getmaxyx()
while True:
year_label = f'Year: {year}'
sub_canvas.addstr(1,
get_label_center_coords(max_column, len(year_label)),
year_label)
if year in PHRASES.keys():
event = year
phrase = PHRASES[year]
sub_canvas.addstr(2,
get_label_center_coords(max_column, len(phrase)),
phrase)
if event == year - 3:
sub_canvas.addstr(2,
get_label_center_coords(max_column, len(phrase)),
' ' * len(phrase))
await sleep(1)
async def show_years(canvas, years):
assert bool(years), AssertionError(
"Years has to be initiated with int value.")
height, width = canvas.getmaxyx()
row = height // 2
column = width // 2
while True:
year_frame = str(years[0]) + " " + PHRASES.get(years[0], "")
frame_column = column - len(year_frame) // 2
draw_frame(canvas, row, frame_column, year_frame)
await sleep_for(15)
draw_frame(canvas, row, frame_column, year_frame, negative=True)
async def draw_year(canvas):
global year
shown_message = ''
year_row = label_column = 1
message_row = 2
while True:
canvas.addstr(year_row, label_column, str(year))
year_message = PHRASES.get(year)
if year_message:
canvas.addstr(message_row, label_column, year_message)
shown_message = year_message
if shown_message and not year_message:
canvas.addstr(
message_row,
label_column,
' ' * (YEAR_WINDOW_WIDTH - label_column)
)
shown_message = ''
await sleep()
async def show_game_progress(canvas):
global year
while True:
canvas.border()
phrase = PHRASES.get(year, DEFAULT_PHRASE)
content = f'Year - {year}: {phrase}'
draw_frame(
canvas,
GameProgressWindowSettings.CONTENT_START_ROW,
GameProgressWindowSettings.BORDER_DELTA,
content,
)
await AwaitableSleep(1)
draw_frame(
canvas,
GameProgressWindowSettings.CONTENT_START_ROW,
GameProgressWindowSettings.BORDER_DELTA,
content,
negative=True,
)
async def show_years(canvas):
screen_rows, screen_columns = canvas.getmaxyx()
left_corner_row = round(screen_rows * WINDOW_RATE)
left_corner_column = 0
window = canvas.derwin(left_corner_row, left_corner_column)
window_rows, window_columns = window.getmaxyx()
middle_row, middle_column = window_rows / 2, window_columns / 2
global year
while year <= FINAL_YEAR:
if year in PHRASES.keys():
frame = '{} - {}'.format(year, PHRASES[year])
else:
frame = str(year)
frame_rows, frame_columns = get_frame_size(frame)
row = middle_row - frame_rows / 2
column = middle_column - frame_columns / 2
draw_frame(window, row, column, frame)
await asyncio.sleep(0)
draw_frame(window, row, column, frame, negative=True)
async def update_info_about_years(info_area, column, tics):
for _ in range(tics):
phrase = ' '.join([PHRASES[year], str(year)]) if PHRASES.get(year) else str(year)
info_area.addstr(0, 0, ' ' * (column - len(phrase)) + phrase)
info_area.refresh()
await asyncio.sleep(0)