def generate_menu():
while True:
menu_items = [
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['play'].capitalize()} standard boggle",
key='0',
function=GameLogic.run_game,
args=(StandardBoggle, )),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['play'].capitalize()} Battle boggle",
key='1',
function=GameLogic.run_game,
args=(BattleBoggle, )),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['play'].capitalize()} Foggle boggle",
key='2',
function=GameLogic.run_game,
args=(FoggleBoggle, )),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['settings'].capitalize()}",
key='s',
function=MenuParser.generate_settings),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['quit'].capitalize()}",
key='q',
function=exit),
]
HostIO.display_main_menu(menu_items)
def settings_standard_bool(input_text, key):
val = HostIO.get_input(
f"Set {input_text} (should be 1, true, True, 0, false or False): ")
if val in ['1', 'true', 'True']:
SettingsParser.set_setting(key=key, value=1)
elif val in ['0', 'false', 'False']:
SettingsParser.set_setting(key=key, value=0)
else:
HostIO.print("Input is not a bool")
def write_player(player_id, out):
if not PlayerIO.mockup:
HostNetworking.player_write(
player_id,
out + ('' if out != '' and out[-1] == '\n' else '\n'))
else:
HostIO.print(f'From player {player_id}\'s terminal: \"{out}\"',
clear_screen=False,
direct_continue=True)
def generate_settings():
exit_command = [False]
while not exit_command[0]:
menu_items = [
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['language'].capitalize()} "
f"{SettingsParser.get_setting('language')}",
key='l',
function=MenuParser.settings_standard,
args=("language", "language")),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['board size'].capitalize()} "
f"{SettingsParser.get_setting('board_size')}x{SettingsParser.get_setting('board_size')}",
key='b',
function=MenuParser.board_size_setting,
args=("board size", "board_size")),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['show solution'].capitalize()} "
f"{SettingsParser.get_setting('show_solution')}",
key='s',
function=MenuParser.settings_standard_bool,
args=("show solutions", "show_solution")),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['number of players'].capitalize()} "
f"{SettingsParser.get_setting('number_players')}",
key='n',
function=MenuParser.settings_standard_int,
args=("number of players", "number_players")),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['seconds per game'].capitalize()} "
f"{SettingsParser.get_setting('game_time')}",
key='t',
function=MenuParser.settings_standard_int,
args=("seconds per game", "game_time")),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['generous'].capitalize()} boggle "
f"{SettingsParser.get_setting('generous_boggle')}",
key='g',
function=MenuParser.settings_standard_int,
args=("generous boggle", "generous_boggle")),
MenuItem(
text=
f"{DictionaryParser.get_dict_meta('actions')['save'].capitalize()}",
args=(exit_command, ),
key='q',
function=MenuParser.settings_main_menu),
]
HostIO.display_settings_menu(menu_items)
def test_get_word_list(self):
standard_setup()
load_minimal_language()
HostIO.set_terminal_output(True)
standard_boggle = StandardBoggle(number_of_boards=2, board_size=4)
standard_boggle.set_board_value(position=(0, 0), value='w')
standard_boggle.set_board_value(position=(0, 1), value='o')
standard_boggle.set_board_value(position=(0, 2), value='r')
standard_boggle.set_board_value(position=(0, 3), value='d')
standard_boggle.game_paralell_process()
self.assertCountEqual(standard_boggle.get_words_in_board(), ['word'])
def connect_to_clients(number_of_connections, on_connect, args=None):
try:
HostNetworking.open_socket()
while len(HostNetworking.connections) < number_of_connections:
connection, _ = HostNetworking.server_socket.accept()
HostNetworking.connections.append(connection)
if args is not None:
on_connect(len(HostNetworking.connections) - 1, args)
else:
on_connect(len(HostNetworking.connections) - 1)
except PermissionError:
HostIO.print(
"Unable to bind to socket. Permission denied. Try running as sudo"
)
exit(6)
def settings_standard_int(input_text, key, set=True):
try:
val = int(HostIO.get_input(f"Set {input_text}: "))
except ValueError:
print("Input is not an int")
return
if set:
SettingsParser.set_setting(key=key, value=val)
else:
return val
def settings_standard(input_text, key):
SettingsParser.set_setting(
key=key, value=HostIO.get_input(f"Set {input_text}: "))
def on_client_connect(key):
HostIO.print(f"player {key} joined", direct_continue=True)
HostNetworking.player_write(key, f"Welcome player {key}\n")
def run_game(boggle_class,
mockup=False,
moves=None,
predefined_boggle_instance=None):
if SettingsParser.get_setting('number_players') < 2:
if not mockup:
HostIO.print(
"To few player for a game. The minimal number of players are 2.",
clear_screen=True)
HostIO.get_input("Press any key to end\n")
return -1
PlayerIO.mockup = mockup
if not mockup:
HostIO.print(
f"The game is {boggle_class.get_name()}!\nWaiting for players",
direct_continue=True,
clear_screen=True)
HostNetworking.connect_to_clients(
number_of_connections=SettingsParser.get_setting(
'number_players'),
on_connect=GameLogic.on_client_connect)
HostIO.print("All players registered. Begin game.")
HostIO.clear()
boggle_instance, \
base_manager, \
players, \
processes = GameLogic.generate_game(boggle_class, moves, predefined_boggle_instance)
try:
for i in range(SettingsParser.get_setting('game_time'), 0, -1):
HostIO.print(f'Time left: {i}',
clear_screen=True,
direct_continue=True)
sleep(1)
except KeyboardInterrupt:
HostIO.print("\nTerminated")
return GameLogic.terminate_game(boggle_instance, base_manager, players,
processes, mockup)
def standard_setup():
SettingsParser.load_settings()
DictionaryParser.load_dictionary(language=SettingsParser.get_setting('language'))
SettingsParser.set_setting('generous_boggle', False)
HostIO.set_terminal_output(False)