class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
"""
def __init__(self):
"""
Class constructor itself.
Args:
self(Director): creates an instance of Director.
"""
self._console = Console()
self._keep_playing = True
self._roster = Roster()
self._move = None
self._secret_code = Secret_Code()
def start_game(self):
"""
Initiates the game through a loop (hopefully) controlling the sequence of play as well.
"""
pass
def _prepare_game(self):
"""
Responsible in preparing the game prior to it being initiated (excluding prior to be opened). This will
be getting the names of those players and placing them in a roster type format. This is through the use of
the Roster.py class.
"""
for p in range(2):
name - self.console.read(f'Enter a name for player {n + 1}: ')
player = Player(name)
self._roster.add_player(player)
def _#TODO:
pass
def __init__(self):
"""The class constructor.
Args:
self (Console): an instance of Console.
"""
self._roster = Roster()
self._paint = Paint()
self.stop_game = False
self.__show_menu = True
self.__logo = []
self.__fame = []
self.__rules = []
with open("mastermind/assets/logo.txt") as data:
next(data)
for line in data:
self.__logo.append(line)
with open("mastermind/assets/fame.txt") as data:
next(data)
for line in data:
self.__fame.append(line)
with open("mastermind/assets/rules.txt") as data:
next(data)
for line in data:
self.__rules.append(line)
def __init__(self):
self._board = Board()
self._generate_number = GenerateNumber()
self._roster = Roster()
self._rule_manager = Rule_manager()
self._screen = Screen()
self.keep_playing = True
def __init__(self):
self._passcode = ''
self._player_guess = ''
self._keep_playing = True
self._console = Console()
self._roster = Roster()
self._logic = Logic()
def __init__(self):
super().__init__()
self._roster = Roster()
self._scores = Leaderboard()
self.player = ""
self.__initial = True
self.__quit_menu = False
self.__play_game = True
self.__margin = " " * 5
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._console = Console()
self._keep_playing = True
self._move = Move()
self._roster = Roster()
self._logic = Logic()
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._board = Board()
self._console = Console()
self._keep_playing = True
self._move = None
self._roster = Roster()
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._console = Console()
self._display = Display()
self._keep_playing = True
self._roster = Roster()
self._board = Board()
self._check = Check()
self.guessCounter = 1
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._board = Board()
self._console = Console()
self.keep_playing = True
self.code = self._board.numbers_to_guess
self._moves = [Move(self.code, '----'), Move(self.code, '----')]
self._roster = Roster()
def __init__(self):
"""
The constructor method.
"""
self.roster = Roster()
self._number = 0
self.guess = ''
self.random_number = 0
self.guess1 = '----'
self.guess2 = '----'
self.guesses = []
class Director:
def __init__(self):
self._board = Board()
self._generate_number = GenerateNumber()
self._roster = Roster()
self._rule_manager = Rule_manager()
self._screen = Screen()
self.keep_playing = True
def start_game(self):
self._prepare_game()
while self.keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
def _prepare_game(self):
self.number = self._generate_number.set_number()
print(self.number)
self.players = self._roster.set_name()
self.hints = ["****", "****"]
self.board = self._board.to_string(self.players, self.hints)
self._screen.write(self.board)
def _get_inputs(self):
self.player = self._rule_manager.get_current(self.players)
self.guess = self._generate_number.get_guess(self.player)
def _do_updates(self):
num = (self._rule_manager.next_player() - 1)
guess = self._board.get_guess(self.guess, num)
self.hints[num] = self._rule_manager._get_hint(self.number, guess)
self.board = self._board.to_string(self.players, self.hints)
self.keep_playing = self._rule_manager._game_over(self.number, guess)
def _do_outputs(self):
if not self.keep_playing:
self._screen.write(f"{self.player} won!")
else:
self._screen.write(self.board)
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
board (Hunter): An instance of the class of objects known as Board.
console (Console): An instance of the class of objects known as Console.
keep_playing (boolean): Whether or not the game can continue.
move (Rabbit): An instance of the class of objects known as Move.
roster (Roster): An instance of the class of objects known as Roster.
"""
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._board = Board()
self._console = Console()
self._keep_playing = True
self._move = None
self._roster = Roster()
def start_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
self._prepare_game()
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
def _prepare_game(self):
"""Prepares the game before it begins. In this case, that means getting the player names and adding them to the roster.
Args:
self (Director): An instance of Director.
"""
for n in range(2):
name = self._console.read(f"Enter a name for player {n + 1}: ")
player = Player(name)
self._roster.add_player(player)
def _get_inputs(self):
"""Gets the inputs at the beginning of each round of play. In this case,
that means getting the move from the current player.
Args:
self (Director): An instance of Director.
"""
# display the game board
board = self._board.to_string()
self._console.write(board)
# get next player's move
player = self._roster.get_current()
self._console.write(f"{player.get_name()}'s turn:")
pile = self._console.read_number("What pile to remove from? ")
stones = self._console.read_number("How many stones to remove? ")
move = Move(stones, pile)
player.set_move(move)
def _do_updates(self):
"""Updates the important game information for each round of play. In
this case, that means updating the board with the current move.
Args:
self (Director): An instance of Director.
"""
player = self._roster.get_current()
move = player.get_move()
self._board.apply(move)
def _do_outputs(self):
"""Outputs the important game information for each round of play. In
this case, that means checking if there are stones left and declaring the winner.
Args:
self (Director): An instance of Director.
"""
if self._board.is_empty():
winner = self._roster.get_current()
name = winner.get_name()
print(f"\n{name} won!")
self._keep_playing = False
self._roster.next_player()
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
_board (Board): An instance of the class of objects known as Board.
_console (Console): An instance of the class of objects known as Console.
keep_playing (boolean): Whether or not the game can continue.
code: the code for the game
_moves (Move): Instances of the class of objects known as Move.
_roster (Roster): An instance of the class of objects known as Roster.
"""
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._board = Board()
self._console = Console()
self.keep_playing = True
self.code = self._board.numbers_to_guess
self._moves = [Move(self.code, '----'), Move(self.code, '----')]
self._roster = Roster()
def start_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
self._prepare_game()
while self.keep_playing:
self.print_board()
self.turn()
def _prepare_game(self):
"""Prepares the game before it begins. In this case, that means getting the player names and adding them to the roster.
Args:
self (Director): An instance of Director.
"""
player = [None, None]
for n in range(2):
name = self._console.get_name()
player[n] = Player(name)
self._roster.add_player(player[0], player[1])
def print_board(self):
"""Outputs the important game information for each round of play.
Args:
self (Director): An instance of Director.
"""
# display the game board
board = self._board.to_string(self._roster, self._moves[0], self._moves[1])
self._console.write(board)
def turn(self):
"""Gets input from player, applies input, checks to see if player won, selects next player
Args:
self (Director): An instance of Director.
"""
# get player's move
player = self._roster.get_current()
self._console.write(f"{player.get_name()}'s turn:")
guess = self._console.read_number("What is your guess? ")
self._moves[self._roster.current].update_guess(guess)
player.set_move(self._moves[self._roster.current])
# check for victory
if str(guess) == str(self.code):
self._console.write(f'\n{player.get_name()} won!')
self.keep_playing = False
# next player
self._roster.next_player()
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Attributes:
console (Console): An instance of the class of objects known as Console.
roster (Roster): An instance of the class of objects known as Roster.
"""
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._console = Console()
self._keep_playing = True
self._move = Move()
self._roster = Roster()
self._logic = Logic()
def start_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
self._get_name()
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
def _get_name(self):
"""Prepares the game before it begins. In this case, that means getting the player names and adding them to the roster.
Args:
self (Director): An instance of Director.
"""
for n in range(2):
name = self._console.read(f"Enter a name for player {n + 1}: ")
player = Player(name)
self._roster.add_player(player)
def _get_inputs(self):
"""Gets the inputs at the beginning of each round of play. In this case,
that means getting the move from the current player.
Args:
self (Director): An instance of Director.
"""
# display the game board
self._console._print_board(self._roster._the_roster[0],self._roster._the_roster[1])
# get next player's move
player = self._roster.get_current()
self._console.write(f"{player.player_name}'s turn:")
guess = self._console.read_number("What is your next guess? ")
#could send to player or logic. Who controls the numbers?
self._roster.get_current().guess = guess
def _do_updates(self):
"""Updates the important game information for each round of play. In
this case, that means updating the logic/roster with the current move.
Args:
self (Director): An instance of Director.
"""
player = self._roster.get_current()
self._logic.check_number(str(player.guess), player)
self._roster.get_current().hint = "".join(self._logic.result)
self._move.as_string(str(self._roster.get_current().guess),str(self._roster.get_current().hint))
def _do_outputs(self):
"""Outputs the important game information for each round of play. In
this case, that means checking if there are stones left and declaring the winner.
Args:
self (Director): An instance of Director.
"""
if self._roster.get_current().win:
winner = self._roster.get_current().player_name
print(f"\n{winner} won!")
self._keep_playing = False
self._roster.next_player()
class Menu(Console):
"""The Menu class extends the Console class, to encompass all console prints
and input validation/collection. It prints a menu to the terminal, allowing
players to create/select/delete profiles, view leaderboard rankings, access
a game rules page, start a round of play, or quit.
ATTRIBUTES
player : str
The selected player profile, passed to Director class for gameplay.
initial : bool
Indicates whether class is running for the first time. Used to set logo
animation to a unique "opening game" style
quit_menu : bool
Indicates whether to continue displaying main menu screen.
play_game : bool
Indicates whether game will start after exiting menu.
margin : str
Set number of blank spaces, used for terminal display formatting.
"""
def __init__(self):
super().__init__()
self._roster = Roster()
self._scores = Leaderboard()
self.player = ""
self.__initial = True
self.__quit_menu = False
self.__play_game = True
self.__margin = " " * 5
def main_menu(self) -> bool:
"""
main_menu calls the show_menu method to display the parent menu.
The method loops through menu display until the player exits the game
or starts a round of gameplay.
Returns:
bool: indicates whether to start gameplay or exit the program.
"""
# print(self.__initial)
# print(self.__quit_menu)
# input(self.__play_game)
while not self.__quit_menu:
self.__show_menu()
self.__initial = False
self.clear_screen()
self.__quit_menu = False
self.__initial = True
return self.__play_game
def game_over(self, results: dict) -> None:
self.clear_screen()
self.print_logo()
player, level, strikes, score = list(results.values())
print("\n\n\n")
self.cool_print(f"GAME OVER, {player}.")
print()
self.cool_print("FINAL LEVEL:", newline=False)
self.pause(.2)
print(f" {level}")
self.pause(.4)
self.cool_print("FINAL SCORE:", newline=False)
self.pause(.2)
print(f" {score}")
self.cool_print(f"\n{self.__margin}THANKS FOR PLAYING.")
self.cool_print(f"\n{self.__margin}Press ENTER to continue",
newline=False)
input()
def __show_menu(self) -> None:
"""
__show_menu displays the parent menu.
Depending on the players selection in the menu, this method will adjust
the appropriate class attributes and call other methods to start play,
end the program, or view a sub-menu.
"""
self.clear_screen()
self.print_logo(left=5, cool=self.__initial)
self.__print_player()
select = self.__get_selection()
if select == "start":
self.__quit_menu = True
elif select == "select":
self.player = self._roster.show_roster_menu()
elif select == "rules":
self.__show_rules()
elif select == "scores":
self._scores.show_leaderboard()
elif select == "quit":
self.clear_screen()
self.__quit_menu = True
self.__play_game = False
def __print_player(self) -> None:
"""__print_player prints title text for the main menu."""
if not self.player:
self.cool_print("NO PLAYER SELECTED. SELECT/ADD PLAYER.")
else:
name = self.player.upper()
self.cool_print(f"WELCOME {name}. Select START to begin round.")
self.pause(.2)
print()
def __get_selection(self):
"""
__get_selection displays the interactive menu in __show_menu.
It does so by implementing the imported Inquirer library, which can be
found at https://pypi.org/project/inquirer/
Returns:
str: A string of text indicating the selected option.
"""
p_num = 0
if self._roster.get_players():
p_num = len(self._roster.get_players())
add_text = "Select Player [" + str(p_num) + " registered]"
choice_list = [(add_text, "select"), "Rules",
("Leaderboard", "scores"), "Quit"]
if self.player:
choice_list.insert(0, "START")
questions = [
inquirer.List(
'selection',
message="MENU (Use ↑ and ↓ to select, ENTER to confirm)",
choices=choice_list,
carousel=True,
default="add")
]
return inquirer.prompt(questions)['selection'].lower()
def __show_rules(self):
"""Loads the rules.txt file from assets/ and prints it to terminal."""
self.clear_screen()
self.print_logo()
for line in self.load_asset("rules"):
print(self.__margin + line, end="")
input()
class Director:
"""
A code template for a person who directs the game. The responsibility of
this class of objects is to keep track of the score and control the
sequence of play.
Attributes:
_console = An instance of the Console class
_logic = An instance of the Logic class
_roster = An instance of the Roseter class
_keep_playing (boolean) = Defines whether or not the game loop should continue
_player_guess (string) = Holds the most recent player's guess
_passcode (string) = The code the players are trying to guess. Since this is a static attribute,
it is convient to define it here and use it throughout the program instead of
calling the on the _logic class every time.
"""
def __init__(self):
self._passcode = ''
self._player_guess = ''
self._keep_playing = True
self._console = Console()
self._roster = Roster()
self._logic = Logic()
def start_game(self):
"""
Starts the game loop
"""
self._prepare_game()
while self._keep_playing == True:
self._get_input()
self._do_updates()
self._do_output()
def _prepare_game(self):
"""Prepares the game before it begins.
This entails :
Adding each play to the board
Creating and displaying the intial board
Setting the passcode
Args:
self (Director): An instance of Director.
"""
# A simple loop to identify each player and add them to the roster
self._console.write("Welcome to the H.A.C.K.")
for n in range(2):
name = self._console.read(f"Enter a name for player {n + 1}: ")
player = Player(name)
if n == 0:
self.player1 = player
else:
self.player2 = player
self._roster.add_player(player)
# Creates the board class with the two new players
self._board = Board(self.player1, self.player2)
#Creates the first board and displays it to the terminal
board = self._board.create_board_string()
self._console.write(board)
#Uses the logic class to set the passcode that will be used for the game
self._logic.set_passcode()
def _get_input(self):
"""
Asks the user for their guess each round, also switches the turns before any further actions
"""
#Begins the turn system
self._roster.next_player()
#Retrieves and displays whoever's turn it is
self.current_player = self._roster.get_current()
self._console.write(f"{self.current_player.get_name()}'s guess:")
Thread(target=self._console.timer_for_turn).start()
Thread(target=self._console.read_for_turn).start()
time.sleep(self._console._countdown)
self._player_guess = self._console._answer
def _do_updates(self):
"""
An in depth "if" statement that updates key game information based on the user's input and current player
"""
# If the player is number 1, then the board is updated according to what they entered. The same is true for player 2.
if self._roster.current == 0:
self.player1.set_guess(self._player_guess)
player1_hint = self._logic.get_hint(self._logic.get_passcode(),
self.player1.get_guess())
self.player1.set_hint(player1_hint)
board = self._board.update_board(self.player1.get_guess(),
self.player1.get_hint(),
self.player2.get_guess(),
self.player2.get_hint())
self._console.write(board)
elif self._roster.current == 1:
self.player2.set_guess(self._player_guess)
player2_hint = self._logic.get_hint(self._logic.get_passcode(),
self.player2.get_guess())
self.player2.set_hint(player2_hint)
board = self._board.update_board(self.player1.get_guess(),
self.player1.get_hint(),
self.player2.get_guess(),
self.player2.get_hint())
self._console.write(board)
def _do_output(self):
"""
Determines if the game will continue or end
"""
if self._logic.is_correct(self._player_guess) == True:
self._console.write(
f'{self._roster.get_current().get_name()} Wins!!')
self._console.write("""
___________________ __________ _____________________________________________________________
\__ ___/\_____ \ ______ \ / _____/\_ _____/\_ ___ \______ \_ _____/\__ ___/
| | / | \| ___/ \_____ \ | __)_ / \ \/| _/| __)_ | |
| | / | \ | / \ | \| \___| | \| \ | |
|____| \_______ /____| /_______ //_______ / \______ /____|_ /_______ / |____|
\/ \/ \/ \/ \/ \/
_____ _____________________ _____ .____________
/ _ \ |_____ \_ _____/ / _ \ | ____/_ |
/ /_\ \| _/| __)_ / /_\ \ |____ \ | |
/ | \ | \| \/ | \ / \| |
\____|__ /____|_ /_______ /\____|__ / /______ /|___|
\/ \/ \/ \/ \/
You're in...""")
self._keep_playing = False
elif self._logic.is_correct(self._player_guess) == False:
self._keep_playing == True
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
_board (Board): An instance of the class of objects known as Board.
_console (Console): An instance of the class of objects known as Console.
_keep_playing (boolean): Whether or not the game can continue.
_move (Move): An instance of the class of objects known as Move.
_roster (Roster): An instance of the class of objects known as Roster.
"""
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._board = Board()
self._console = Console()
self._keep_playing = True
self._roster = Roster()
self.num_players = 0
def start_game(self):
"""Starts the game loop to control sequence of play.
Args:
self(Director): an instance of Director.
"""
self._prepare_game()
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
def _prepare_game(self):
"""Prepares game. That means getting player names and adding them
to the roster.
Args:
self (Director): An instance of Director.
"""
prompt = "How many players? (2-6): "
self.num_players = self._console.read_number(prompt)
while True:
if (self.num_players > 6):
self._console.write("Please choose less than 7 players.")
self.num_players = self._console.read_number(prompt)
elif (self.num_players < 2):
self._console.write("Please choose more than 1 player.")
self.num_players = self._console.read_number(prompt)
else:
break
for i in range(self.num_players):
p_name = self._console.read(
f'Player {(i+1)}, please enter your name: ')
p_code = self._board.get_code()
player = Player(p_name, p_code)
self._roster.add_player(player)
def _get_inputs(self):
"""Gets the inputs at the beginning of each round of play. For this
game, gets move from current player.
Args:
self(Director): An instance of Director.
"""
player = self._roster.get_current()
self._console.write(f"{player.get_name()}'s turn")
prompt = "Please enter your guess (1000-9999): "
guess = self._console.read_number(prompt)
while True:
if (guess < 1000):
self._console.write("Please enter a guess over 1000.")
guess = self._console.read_number(prompt)
elif (guess > 9999):
self._console.write("Please enter a guess under 9999.")
guess = self._console.read_number(prompt)
else:
break
move = Move(guess)
player.set_move(move.get_guess())
def _do_updates(self):
"""Updates important game information for each round of play. For
this game, the board is updated with the current guess.
Args:
self(Director): An instance of Director.
"""
player = self._roster.get_current()
move = player.get_move()
code = player.get_code()
self._board.apply(move, code)
player.set_hint(self._board.get_hint())
def _do_outputs(self):
"""Outputs the important game information for each round of play.
For this game, a hint is printed from the board. If the code
matches the guess exactly, a winner is declared.
Args:
self(Director): An instance of Director.
"""
if self._board.matches_code():
winner = self._roster.get_current()
name = winner.get_name()
self._console.write(f'\n{name} won!')
self._keep_playing = False
print()
for _ in range(self.num_players):
self._roster.next_player()
move = self._roster.get_current().get_move()
hint = self._roster.get_current().get_hint()
name = self._roster.get_current().get_name()
text = (f"Player {name}: {move}, {hint}")
self._console.write(text)
self._roster.next_player()
class Console:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Service Provider, Interfacer
Attributes:
roster (Roster): An instance of the class of objects known as Roster.
"""
def __init__(self):
"""The class constructor.
Args:
self (Console): an instance of Console.
"""
self._roster = Roster()
self._paint = Paint()
self.stop_game = False
self.__show_menu = True
self.__logo = []
self.__fame = []
self.__rules = []
with open("mastermind/assets/logo.txt") as data:
next(data)
for line in data:
self.__logo.append(line)
with open("mastermind/assets/fame.txt") as data:
next(data)
for line in data:
self.__fame.append(line)
with open("mastermind/assets/rules.txt") as data:
next(data)
for line in data:
self.__rules.append(line)
def clear_screen(self):
"""Detects OS type and sends appropriate console command to clear screen.
Args:
self (Console): An instance of Console.
"""
os.system('cls' if os.name == 'nt' else 'clear')
def ask_stop_game(self):
"""Returns bool indicating whether game should continue running.
Args:
self (Console): an instance of Console.
"""
return self.stop_game
def restart_menu(self):
"""Returns bool indicating whether game should continue running.
Args:
self (Console): an instance of Console.
"""
self.__show_menu = True
def confirm_start(self, player=str):
"""Returns bool indicating whether game should continue running.
Args:
self (Console): an instance of Console.
player (string): name of player for turn confirmation.
"""
self.clear_screen()
print("\n" * 11)
pass_text = "Pass the device to " + player
print(f"{pass_text : ^100}")
input(f"{'Press ENTER when ready.' : ^100}")
return self.stop_game
def cool_print(self, text=str, newline=True, margin=21, rate=.02):
"""Prints text in typewriter style.
Args:
self (Console): an instance of Console.
text (str): Text to print.
newline (bool): whether to end with carriage return
"""
print(" " * margin, end='')
for letter in text:
sleep(.02)
stdout.write(letter)
stdout.flush()
if newline:
print()
def play_turn(self,
player=str,
code=str,
history=list,
stats=tuple,
redo=False):
"""Displays board and prompts for player guess. Returns tuplet of
guess (string) and time taken to guess in seconds (float).
Args:
self (Console): an instance of Console.
player (string): name of player.
code (string): code to be guessed, for hint generation.
history (list): list of (guess, hint) tuples.
stats (tuple): Tuple of total round points and playtime of player.
redo (bool): whether this is a repeat prompt due to invalid guess.
"""
self.clear_screen()
if redo:
print('\n' * 15)
self.cool_print("KEYCODE IS 4-DIGIT NUMBER BETWEEN 1000 AND 9999")
self.cool_print("PRESS ENTER TO RE-ATTEMPT")
input(" " * 21)
self.clear_screen()
self._paint.paint_screen(player, history, stats)
self.cool_print("RUNNING: d42k_10ckp1ck32.exe")
self.cool_print("ENTER 4-DIGIT KEYCODE:", newline=False)
start = time()
guess = input(" ")
end = time()
elapsed = end - start
return (guess, elapsed)
def show_hint(self, hint=str):
"""Displays hint for player.
Args:
self (Console): an instance of Console.
hint (str).
"""
self.clear_screen()
print('\n' * 15)
self.cool_print("ERROR 210.04-TC6: [KEYCODE INCORRECT]")
self.cool_print("DATA CORRUPTED. ATTEMPTING TO DECRYPT METADATA.")
print()
sleep(.6)
self.cool_print(f"[!] METADATA RECOVERED: {hint}")
print()
self.cool_print("PRESS ENTER TO REATTEMPT", newline=False)
input()
def __print_logo(self, left=5, top=2, bottom=2):
"""Prints logo to screen. Has optional x and y parameters to offset logo
by specified amount of lines and spaces.
Args:
self (Console): An instance of Console.
left (int): Number of spaces to offset logo from left of screen
top (int): Number of lines to offset logo from top of screen
bottom (int): Number of spaces to print below logo
"""
print('\n' * top, end="")
for line in self.__logo:
print((" " * left) + line, end="")
print('\n' * bottom, end="")
def __print_rules(self, left=0):
"""Prints rules to screen. Has optional x and y parameters to offset logo
by specified amount of lines and spaces.
Args:
self (Console): An instance of Console.
left (int): Number of spaces to offset rules from left of screen
"""
for line in self.__rules:
print((" " * left) + line, end="")
def menu(self):
"""Shows menu to start game.
Args:
self (Console): an instance of Console.
"""
while self.__show_menu and not self.stop_game:
p_num = 0
if self._roster.get_roster():
p_num = len(self._roster.get_roster())
add_text = "Add/Remove Players [" + str(p_num) + " registered]"
choice_list = [(add_text, "add"), "Rules",
("Leaderboard", "scores"), "Quit"]
if self._roster.get_roster():
choice_list.insert(0, "START")
questions = [
inquirer.List(
'selection',
message="MENU (Use ↑ and ↓ to select, ENTER to confirm)",
choices=choice_list,
carousel=True,
default="add")
]
self.clear_screen()
self.__print_logo()
selection = inquirer.prompt(questions)['selection'].lower()
if selection == "start":
self.__show_menu = False
return self._roster.get_roster()
elif selection == "add":
self.__add_players()
elif selection == "rules":
self.__show_rules()
elif selection == "scores":
self.__show_scoreboard()
elif selection == "quit":
self.__quit()
def __add_players(self):
"""Asks records player names.
Args:
self (Console): an instance of Console.
"""
players_list = []
players_list.extend([("NEW PLAYER", "**new**")])
players_list.extend(self._roster.get_roster())
players_list.extend([("BACK TO MENU", "**menu**")])
players = [
inquirer.List(
'selection',
message="ADD/REMOVE (Use ↑ and ↓ to select, ENTER to confirm)",
choices=players_list,
default="NEW PLAYER",
carousel=True)
]
self.clear_screen()
self.__print_logo()
selection = inquirer.prompt(players)['selection']
if selection == "**menu**":
pass
elif selection == "**new**":
name = self.__prompt_name()
if name:
self._roster.add_player(name)
else:
delete = inquirer.confirm(f"Do you want to remove '{selection}'?",
default=True)
if delete:
self._roster.remove_player(selection)
input(f"'{selection}' removed. Press ENTER to continue.")
def __prompt_name(self):
"""Prompts for player name,.
Args:
self (Console): an instance of Console.
"""
self.clear_screen()
self.__print_logo()
name = input("[!] Enter new player name and press ENTER:\n\n ")
if not (2 < len(name) < 16):
self.clear_screen()
self.__print_logo()
print("Username must be between 3 and 15 characters.")
input("Press ENTER to return to player menu.")
elif name in self._roster.get_roster():
self.clear_screen()
self.__print_logo()
print("Player already exists.")
input("Press ENTER to return to player menu.")
else:
return name
def __show_rules(self):
"""Asks records player names.
Args:
self (Console): an instance of Console.
"""
self.clear_screen()
self.__print_logo()
self.__print_rules(left=20)
input()
def __show_scoreboard(self):
"""Asks records player names.
Args:
self (Console): an instance of Console.
"""
self.clear_screen()
print('\n' * 2, end="")
for line in self.__fame:
print((" " * 5) + line, end="")
print('\n' * 2, end="")
with open("mastermind/assets/scores.json", "r") as data:
board = list(load(data).items())
space = " " * 11
print(f"{space}RANK {'PLAYER':<30}" +
f"{'TIME':>7} (seconds){'POINTS':>29}\n")
lines_printed = 0
for idx, entry in enumerate(board[:10]):
lines_printed += 1
space = " " * 10
n = idx + 1
year, month, day, time = entry[0].split(" ")
points = entry[1]["points"]
playtime = entry[1]["playtime"]
player = entry[1]["player"]
print(f"{space}{n:>4}. {player:<30}" +
f"{playtime:>7,.2f}{points:>36}/15")
lines = "\n" * (12 - lines_printed)
print(f"{lines}{space}", end="")
sleep(.25)
self.cool_print("Press ENTER to return to player menu.",
newline=False,
margin=0)
input()
def __quit(self):
"""Asks records player names.
Args:
self (Console): an instance of Console.
"""
self.clear_screen()
self.__print_logo()
print('\n' * 3)
self.cool_print("THANKS FOR PLAYING!")
sleep(2)
self.stop_game = True
class Driver:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
_console(Console): reads and writes needed data
_keep_playing(boolean): Determines whether to stay in the game play loop
_roster(Roster): holds and keeps track of players
_board(Board): Keeps track of hints and comparison - manages game-play variables
_check(Check): Validates input and victory
guessCounter(int): Helps determine the next player
"""
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._console = Console()
self._display = Display()
self._keep_playing = True
self._roster = Roster()
self._board = Board()
self._check = Check()
self.guessCounter = 1
def start_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
self._prepare_game()
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
def _prepare_game(self):
"""Prepares the game before it begins. In this case, that means getting the player names and adding them to the roster.
Args:
self (Director): An instance of Director.
"""
for n in range(2):
name = self._console.read(f"Enter a name for player {n + 1}: ")
if n == 0:
self._roster.player1 = name
else:
self._roster.player2 = name
def _get_inputs(self):
"""Gets the inputs at the beginning of each round of play. In this case,
that means getting the move from the current player.
Args:
self (Director): An instance of Director.
"""
# display the game board
# board = self._board.to_string(self._roster) #passes the players list to to_string
display = self._display.displayMain(self._roster, self._board)
self._console.write(display)
# get next player's move
player = self._roster.get_current()
self._console.write(f"\n{player}'s turn:")
guess = self._console.read("What is your guess? ")
self._check.checkGuess(guess)
while self._check._validGuess == False:
self._console.write("Please only enter 4 numbers!")
guess = self._console.read("What is your guess? ")
self._check.checkGuess(guess)
#insert data validation bit here **guess is a string**
self.guessCounter = self.guessCounter + 1 #starts at 1 and goes to 2 before passing once. The % 2 of 2 is 0 so it works
self._board._create_hint(
guess, self.guessCounter) # update hint and guess arrays in board
# player.set_move(move) don't think we need this
def _do_updates(self):
"""Updates the important game information for each round of play. In
this case, that means updating the board with the current move.
Args:
self (Director): An instance of Director.
"""
player = self._roster.get_current()
self._check.checkVictory(self._board)
def _do_outputs(self):
"""Outputs the important game information for each round of play. In
this case, that means checking if there are stones left and declaring the winner.
Args:
self (Director): An instance of Director.
"""
if self._check.player1VictoryCount == 4:
displayWinner = self._roster.player1
elif self._check.player2VictoryCount == 4:
displayWinner = self._roster.player2
else:
displayWinner = ""
if displayWinner == "":
pass
else:
displayText = self._display.displayWinner(displayWinner)
self._console.write(displayText)
self._keep_playing = False
self._roster.next_player()