def __init__(self, enemy_speed, label, dir_name=""):
self.text_storage = TextStorage(dir_name)
self.text_name, text = self.text_storage.get_random_string(label)
super().__init__(text)
self.enemy_input = UserInput(text)
self.enemy_speed = enemy_speed
self.inp_thread = Thread(target=self.input_thread)
self.en_thread = Thread(target=self.enemy_thread)
self.upd_thread = Thread(target=self.print_thread)
self.threads_active = False
self.enemy_finish = None
def __init__(self, dir_name):
self._user = User(settings.get_name_from_config())
self._strings = self._user.get_strings()
self._dir_name = dir_name
self._text_st = TextStorage(dir_name)
self._menu_items = {
'1': self._strings['start'],
'2': self._strings['enemy_game'],
'3': self._strings['show_stat'],
'4': self._strings['change_user'],
'5': self._strings['exit']
}
self._actions = {
"1": self.start_game,
"2": self.start_enemy_game,
"3": self.show_stat,
'4': self.change_name,
'5': SimpleGame.clear
}
def test_get_random_string(self):
storage = TextStorage(f'{PATH}/tests/test/')
storage.add_label('test1', 'test')
text, string = storage.get_random_string('test')
with open(f'{PATH}/texts/texts_test/json/test1.json') as f:
alls = json.load(f)
self.assertIn(string, alls)
self.assertIn(text, storage.get_texts_names()['*'])
class Menu:
def __init__(self, dir_name):
self._user = User(settings.get_name_from_config())
self._strings = self._user.get_strings()
self._dir_name = dir_name
self._text_st = TextStorage(dir_name)
self._menu_items = {
'1': self._strings['start'],
'2': self._strings['enemy_game'],
'3': self._strings['show_stat'],
'4': self._strings['change_user'],
'5': self._strings['exit']
}
self._actions = {
"1": self.start_game,
"2": self.start_enemy_game,
"3": self.show_stat,
'4': self.change_name,
'5': SimpleGame.clear
}
def run(self):
if not os.path.exists(f'{settings.PATH}/statistics.json'):
self.change_name()
while True:
self.print_options()
option = getch.getch()
if option in self._actions:
self._actions[option]()
if option == "5":
break
self._user.load_statistics()
def change_name(self):
SimpleGame.clear()
new_name = input(self._strings['input_name'] + ' ')
settings.change_user(new_name)
self._user.update_config()
self._user = User(settings.get_name_from_config())
def print_options(self):
SimpleGame.clear()
strings = self._user.get_strings()
print(f'{strings["welcome"]}, {self._user.name}')
print(strings['select'])
print()
for k, v in self._menu_items.items():
print(f'{k}. {v}')
def start_game(self):
label = self.get_label()
game = SimpleGame(label, self._dir_name)
game.start_game()
print(f'{self._user.get_strings()["press"]}')
while getch.getch() != '\r':
pass
def start_enemy_game(self):
label = self.get_label()
speed = self._user.stat['max_speed']
game = EnemyGame(speed + 5, label, self._dir_name)
game.start_game()
print(f'{self._user.get_strings()["press"]}')
while getch.getch() != '\r':
pass
def get_label(self):
print(self._strings['choose_label'])
print(f"1. {self._strings['choose_label_yes']}")
print(f"2. {self._strings['choose_label_no']}")
choice = getch.getch()
if choice == "1":
print(self.get_all_labels())
label = input(self._strings['write_label'])
if label in self._text_st.get_all_labels():
return label
else:
return None
elif choice == "2":
return None
def get_all_labels(self):
labels = self._text_st.get_all_labels()
return '\n'.join(labels)
def show_stat(self):
SimpleGame.clear()
stat = self._user.get_stat()
res = f'{self._strings["user"]} {self._user.name}\n' \
f'{self._strings["text_count"]}: {stat["text_count"]}\n' \
f'{self._strings["symbol_count"]}: {stat["symbol_count"]}\n' \
f'{self._strings["average_speed"]}: {stat["average_speed"]} ' \
f'{self._strings["speed"]}\n' \
f'{self._strings["average_errors"]}: {stat["average_errors"]}\n' \
f'{self._strings["dynamics"]}:\n'
dynamic = stat['dynamic']
for k, v in dynamic.items():
res += f'{k}: {v["average_speed"]} {self._strings["speed"]}\n'
print(res)
print(f'{self._user.get_strings()["press"]}')
while getch.getch() != '\r':
pass
class EnemyGame(Game):
TIMER = 5
def __init__(self, enemy_speed, label, dir_name=""):
self.text_storage = TextStorage(dir_name)
self.text_name, text = self.text_storage.get_random_string(label)
super().__init__(text)
self.enemy_input = UserInput(text)
self.enemy_speed = enemy_speed
self.inp_thread = Thread(target=self.input_thread)
self.en_thread = Thread(target=self.enemy_thread)
self.upd_thread = Thread(target=self.print_thread)
self.threads_active = False
self.enemy_finish = None
def start_game(self):
self.set_timer(self.current_state
(self.current_enemy_state(self.enemy_input),
self.current_state_string(self.user_input)))
self._start_time = timeit.default_timer()
self.inp_thread.start()
self.en_thread.start()
self.threads_active = True
self.inp_thread.join()
self.en_thread.join()
if self.is_exit:
SimpleGame.clear()
sys.exit()
finish_time = timeit.default_timer()
res_time = finish_time - self._start_time
if self.is_finished:
self.print_results(self.current_state(None,
self.result_string(
self.user_input,
res_time,
finish_time)))
self.get_label(self.text_storage, self.text_name)
self._user.update_stat(self.user_input, res_time,
self.calc_current_speed())
def input_thread(self):
while not self.user_input.is_done():
symbol = self.get_user_input()
if symbol == '\x03':
self.is_exit = True
break
if symbol is None:
self.is_finished = False
break
self.user_input.update(symbol)
self.print_results(
self.current_state(self.current_enemy_state(self.enemy_input),
self.current_state_string(self.user_input)))
def print_thread(self):
while not self.user_input.is_done():
if not self.inp_thread.is_alive():
break
self.print_results(
self.current_state(self.current_enemy_state(self.enemy_input),
self.current_state_string(self.user_input)))
time.sleep(0.5)
def enemy_thread(self):
while not self.enemy_input.is_done():
if not self.inp_thread.is_alive():
break
symbol = self.enemy_input.get_blank_text()[0]
self.enemy_input.update(symbol)
spd = (self.enemy_speed // 60) or 1
time.sleep(1 / spd)
self.print_results(
self.current_state(self.current_enemy_state(self.enemy_input),
self.current_state_string(self.user_input)))
self.enemy_finish = timeit.default_timer()
self.upd_thread.start()
self.upd_thread.join()
def result_string(self, user_input, res_time, finish_time):
s = f'{colored(user_input.text, "green")}\r\n' \
f'{self._strings["acc"]}: ' \
f'{user_input.accurate:.2%}\r\n' \
f'{self._strings["time"]}: {res_time:.2f} ' \
f'{self._strings["sec"]}\r\n' \
f'{self._strings["avg_speed"]}:' \
f' {self.calc_current_speed()} ' \
f'{self._strings["speed"]}\r\n' \
f'{self._strings["err"]}: ' \
f'{user_input.error_count}\r\n' \
f'{self._strings["delta"]}: ' \
f'{finish_time - self.enemy_finish:.2f} ' \
f'{self._strings["sec"]}'
return s
def current_state_string(self, user_input):
s = f'{colored(user_input.correct_text(), "green")}' \
f'{colored(user_input.get_incorrect_symbol(), "red")}' \
f'{user_input.get_blank_text()}\r\n' \
f'{colored(user_input.correct_input, "green")}' \
f'{colored(user_input.incorrect_text, "red")}\r\n' \
f'{self._strings["cur_speed"]}: ' \
f'{self.calc_current_speed()} ' \
f'{self._strings["speed"]}\r\n' \
f'{self._strings["err"]}: ' \
f'{self.user_input.error_count}\r'
return s
def current_state(self, enemy_res, user_res):
res = user_res
rows = os.get_terminal_size().columns
if enemy_res:
res = f"{enemy_res}\r\n{'-' * rows}\r\n{user_res}"
return res
def current_enemy_state(self, user_input):
return '{}{}{}\r\n'.format(
colored(user_input.correct_text(), 'magenta'),
colored(user_input.get_incorrect_symbol(), 'red'),
user_input.get_blank_text(),
)
def __init__(self, label, dir_name=""):
self.text_storage = TextStorage(dir_name)
self.text_name, text = self.text_storage.get_random_string(label)
super().__init__(text)
self.printing_thread = Thread(target=self.print_thread)
self.inp_thread = Thread(target=self.input_thread)
class SimpleGame(Game):
def __init__(self, label, dir_name=""):
self.text_storage = TextStorage(dir_name)
self.text_name, text = self.text_storage.get_random_string(label)
super().__init__(text)
self.printing_thread = Thread(target=self.print_thread)
self.inp_thread = Thread(target=self.input_thread)
def start_game(self):
self.set_timer(self.current_state_string(self.user_input))
self._start_time = timeit.default_timer()
self.inp_thread.start()
self.printing_thread.start()
self.inp_thread.join()
self.printing_thread.join()
if self.is_exit:
self.clear()
sys.exit()
res_time = timeit.default_timer() - self._start_time
if self.is_finished:
self.print_results(self.result_string(self.user_input, res_time))
self.get_label(self.text_storage, self.text_name)
self._user.update_stat(self.user_input, res_time,
self.calc_current_speed())
def calc_current_speed(self):
count = self.user_input.count
curr_time = timeit.default_timer()
res_time = (curr_time - self._start_time) / 60
return int(count // res_time)
def result_string(self, user_input, res_time):
self.clear()
s = f'{colored(user_input.text, "green")}\r\n' \
f'{self._strings["acc"]}:{user_input.accurate:.2%}' \
f'\r\n\r{self._strings["time"]}:' \
f'{res_time:.2f} {self._strings["sec"]}\r\n' \
f'{self._strings["avg_speed"]}: ' \
f'{self.calc_current_speed()} ' \
f'{self._strings["speed"]}' \
f'\r\n\r{self._strings["err"]}: {user_input.error_count}'
return s
def current_state_string(self, user_input):
s = f'{colored(user_input.correct_text(), "green")}' \
f'{colored(user_input.get_incorrect_symbol(), "red")}' \
f'{user_input.get_blank_text()}\r\n' \
f'{colored(user_input.correct_input, "green")}' \
f'{colored(user_input.incorrect_text, "red")}\r\n' \
f'{self._strings["cur_speed"]}: ' \
f'{self.calc_current_speed()}' \
f' { self._strings["speed"]}\r\n' \
f'{self._strings["err"]}: {self.user_input.error_count}\r'
return s
def print_thread(self):
while not self.user_input.is_done():
if not self.inp_thread.is_alive():
break
self.print_results(self.current_state_string(self.user_input))
time.sleep(0.5)
def input_thread(self):
while not self.user_input.is_done():
symbol = self.get_user_input()
if symbol == '\x03':
self.is_exit = True
break
if symbol is None:
self.is_finished = False
break
self.user_input.update(symbol)
self.print_results(self.current_state_string(self.user_input))
def test_create(self):
storage = TextStorage()
self.assertEqual(storage.path, "")
self.assertEqual(storage.all_js_path,
f'{PATH}/texts/texts_/all_texts.json')
def test_get_names(self):
storage = TextStorage(f'{PATH}/tests/test/')
storage.add_label('test1', 'test')
d = {'*': ['test1', 'test2'], "test": ['test1']}
self.assertDictEqual(d, storage.get_texts_names())
def test_get(self):
storage = TextStorage(f'{PATH}/tests/test/')
storage.add_label('test1', 'test')
self.assertIn('test1', storage.get_text_by_label('test'))
def test_add(self):
storage = TextStorage(f'{PATH}/tests/test/')
storage.add_label('test1', 'test')
self.assertIn('*', storage.get_all_labels())
self.assertIn('test', storage.get_all_labels())
def test_labels(self):
storage = TextStorage(f'{PATH}/tests/test/')
self.assertEqual(storage.path, 'test')
self.assertEqual(storage.all_js_path,
f'{PATH}/texts/texts_test/all_texts.json')
self.assertIn('*', storage.get_all_labels())