def main(): list_of_all_words = hangman_helper.load_words(file='words.txt') run_single_game(list_of_all_words) ans = hangman_helper.get_input() while ans[0] == hangman_helper.PLAY_AGAIN and ans[1]: run_single_game(list_of_all_words) ans = hangman_helper.get_input()
def main(): words_list = hangman_helper.load_words() run_single_game(words_list) status, input_t = hangman_helper.get_input() while status == hangman_helper.PLAY_AGAIN and input_t: run_single_game(words_list) status, input_t = hangman_helper.get_input()
def main(): """runs full hangman game""" words_list = hangman_helper.load_words() run_single_game(words_list) new_game = hangman_helper.get_input() while new_game[1] == True: run_single_game(words_list) new_game = hangman_helper.get_input()
def main(): """This function handle running the game more than once according to the user input, and uses the load_words function to load the words into the run_single_game funcction""" words_list = hangman_helper.load_words() run_single_game(words_list) type_input, value_input = hangman_helper.get_input() while type_input == 3 and value_input : run_single_game(words_list) type_input, value_input = hangman_helper.get_input()
def main(): """A function that generates the game 'hangman' using the function- run_single_game""" words_list = hangman_helper.load_words() run_single_game(words_list) input1 = hangman_helper.get_input() while input1[0] == hangman_helper.PLAY_AGAIN and input1[1]: run_single_game(words_list) input1 = hangman_helper.get_input()
def main(): """This function loads a lists of words and uses that list in order to start a new game. At the end of the game asks if the player wants to start a new game or not, and proceeds suitable with the player's choice""" new_words_list = hangman_helper.load_words() run_single_game(new_words_list) wants_to_play = hangman_helper.get_input() while wants_to_play[1] == True: run_single_game(new_words_list) wants_to_play = hangman_helper.get_input()
def main(): """This function start a game. While the player want to keep playing, new game will start.""" words_lst = hangman_helper.load_words() run_single_game(words_lst) move = hangman_helper.get_input() while move[0] == hangman_helper.PLAY_AGAIN and move[1]: run_single_game(words_lst) move = hangman_helper.get_input()
def main(): """The spine of hangman - start single game im the first time and every time the player asks to play again""" # load the word index words_list = hangman_helper.load_words('words.txt') run_single_game(words_list) key, value = hangman_helper.get_input() # evaluates whether or not to play again if key == hangman_helper.PLAY_AGAIN: while value: run_single_game(words_list) key, value = hangman_helper.get_input()
def run_single_game(words_list): """runs the game, with any word from the given words_list""" data = init_game(words_list) # setup game data = game_loop(data) # The Game is ON!!! endgame(data) # endgame # Play again? - insert coin: 10...9...8... user_input = list(h.get_input()) # loop until the user makes up their mind while user_input[0] != h.PLAY_AGAIN: user_input = list(h.get_input()) # run new game if requested, otherwise end. if user_input[1] is True: run_single_game(words_list)
def the_game(ask_play, error_count, msg, pattern, the_word, wrong_guess_lst, words_list): """This function check if the player want to guess a letter or to ask for a hint. If the player guessed a letter, the function check if it is a valid letter. If he want a hint, it gives him one.""" hangman_helper.display_state(pattern, error_count, wrong_guess_lst, msg, ask_play) move = hangman_helper.get_input() # If the player chose to put a letter in - if move[0] == hangman_helper.LETTER: letter = move[1] if len(letter) == 1 and letter.islower(): error_count, pattern, msg = good_letter(error_count, letter, pattern, the_word, wrong_guess_lst) else: msg = hangman_helper.NON_VALID_MSG # If the player ask for a hint elif move[0] == hangman_helper.HINT: filter_list = filter_words_list(words_list, pattern, wrong_guess_lst) hint = choose_letter(filter_list, pattern) msg = hangman_helper.HINT_MSG + hint return error_count, pattern, msg
def main(): """ Launching the game until the user click on no more :return: """ # Launching the first game words_list = hangman_helper.load_words() # Loading words run_single_game(words_list) # Running the game with those words input_from_user = hangman_helper.get_input() # Playing again while input_from_user[COMMAND_INDEX] == hangman_helper.PLAY_AGAIN \ and input_from_user[VALUE_INDEX]: # While the input is play # again choice and it's true run_single_game(words_list) # Running the game input_from_user = hangman_helper.get_input()
def run_single_game(words_list): """ parm: list of words The function choose one of them and run a single game of hangman""" # choose a word among the words_list word = hangman_helper.get_random_word(words_list) error_count = 0 wrong_guess_lst = [] msg = hangman_helper.DEFAULT_MSG ask_play = False pattern = UNIT_PATTERN * len(word) while pattern != word and error_count < hangman_helper.MAX_ERRORS: hangman_helper.display_state(pattern, error_count, wrong_guess_lst, msg, ask_play) choice, letter_player = hangman_helper.get_input() if choice == hangman_helper.HINT: # player want hint words_list_hint = filter_words_list(words_list, pattern, wrong_guess_lst) hint = choose_letter(words_list_hint, pattern) msg = hangman_helper.HINT_MSG + hint if choice == hangman_helper.LETTER: # player enter a letter if len(letter_player) != LENGTH_LETTER \ or not letter_player.islower(): # no valid type -> display the message msg = hangman_helper.NON_VALID_MSG elif letter_player in wrong_guess_lst or letter_player\ in pattern: # letter already taken -> display the message msg = hangman_helper.ALREADY_CHOSEN_MSG + letter_player elif letter_player in word: # the letter is in the word # update the pattern and the message pattern = update_word_pattern(word, pattern, letter_player) msg = hangman_helper.DEFAULT_MSG else: # the letter isn't in the word # update error_count, wrong_guess_list and the message error_count += INCREASE wrong_guess_lst.append(letter_player) msg = hangman_helper.DEFAULT_MSG # check if the player win or loss if pattern == word: msg = hangman_helper.WIN_MSG else: msg = hangman_helper.LOSS_MSG + word # ask if he want to play and other game hangman_helper.display_state(pattern, error_count, wrong_guess_lst, msg, ask_play=True)
def main(): """This function allows to run the program.""" # load the game words_list = hangman_helper.load_words() run_single_game(words_list) # answer of the user about if he want to play more or not user_input = hangman_helper.get_input() # rerun a game if he want to play more while user_input[0] == hangman_helper.PLAY_AGAIN and user_input[1]: words_list = hangman_helper.load_words() run_single_game(words_list) user_input = hangman_helper.get_input()
def run_single_game(words_list): """This function runs one game. It includes distinguishing between the different input from the player - whether it's a request for a hint or a guess of a letter. When getting a guess, verifying it's validity and then check if it's on the pattern and so on. Then, finally it sums up the single run in a case of a win or a loss """ word = hangman_helper.get_random_word(words_list) wrong_guesses_list = [] current_pattern = '_' * len(word) msg = hangman_helper.DEFAULT_MSG while len(wrong_guesses_list) < hangman_helper.MAX_ERRORS and current_pattern.count('_') > 0: hangman_helper.display_state(current_pattern, len(wrong_guesses_list), wrong_guesses_list, msg) type_input, value_input = hangman_helper.get_input() if type_input == 2: if len(value_input) > 1 or value_input.islower() is False: msg = hangman_helper.NON_VALID_MSG elif wrong_guesses_list.count(value_input) > 0 or current_pattern.count(value_input) > 0: msg = hangman_helper.ALREADY_CHOSEN_MSG + value_input elif value_input in word: current_pattern = update_word_pattern(word, current_pattern, value_input) msg = hangman_helper.DEFAULT_MSG else: wrong_guesses_list.append(value_input) msg = hangman_helper.DEFAULT_MSG elif type_input == 1: matching_words = filter_words_list(words_list, current_pattern, wrong_guesses_list) hint_letter = choose_letter(matching_words, current_pattern) msg = hangman_helper.HINT_MSG + hint_letter hangman_helper.display_state(current_pattern, len(wrong_guesses_list), wrong_guesses_list, msg) if len(wrong_guesses_list) == hangman_helper.MAX_ERRORS: msg = hangman_helper.LOSS_MSG + word elif current_pattern.count('_') == 0: msg = hangman_helper.WIN_MSG hangman_helper.display_state(current_pattern, len(wrong_guesses_list), wrong_guesses_list, msg, ask_play=True)
def run_single_round(words_list, word, pattern, wrong_guesses, score, message): """ Run a single round - one guess and its outcome """ # Display games stats and message and reset message hangman_helper.display_state(pattern, wrong_guesses, score, message) message = "" # Get player input guess_type, guess = hangman_helper.get_input() score -= 1 # Input is a letter if guess_type == hangman_helper.LETTER: round_stats = guessed_a_letter(word, pattern, guess, score, wrong_guesses, message) pattern, score, wrong_guesses, message = round_stats # Input is a word elif guess_type == hangman_helper.WORD: pattern, score = guessed_a_word(word, pattern, guess, score) # Input is a hint elif guess_type == hangman_helper.HINT: hangman_helper.show_suggestions( filter_words_list(words_list, pattern, wrong_guesses)) return pattern, score, wrong_guesses, message
def main(): """Runs the game, repeat if user wants to""" the_word_list = hangman_helper.load_words() run_another_game = True while run_another_game: run_single_game(the_word_list) run_another_game = hangman_helper.get_input()[1]
def main(): """main function""" words_list = hangman_helper.load_words(file='words.txt') run_single_game(words_list) options, letter = hangman_helper.get_input() while options == hangman_helper.PLAY_AGAIN and letter == True: """runs another turn""" run_single_game(words_list)
def run_single_game(words_list): random_word = hangman_helper.get_random_word(words_list) #random_word = "debug" wrong_guess_lst, guess = [], [] error_count = 0 pattern = functools.reduce( lambda x, y: x + y, ['_' if char != ' ' else ' ' for char in random_word]) PLAY = True msg = hangman_helper.DEFAULT_MSG while error_count < hangman_helper.MAX_ERRORS: hangman_helper.display_state(pattern, error_count, wrong_guess_lst, msg) input_type, value = hangman_helper.get_input() if input_type == hangman_helper.LETTER: if len(value) == 0 or value > 'z' or value < 'a': msg = hangman_helper.NON_VALID_MSG else: if value in guess: msg = hangman_helper.ALREADY_CHOSEN_MSG else: guess.append(value) msg = hangman_helper.DEFAULT_MSG if value in random_word: pattern = update_word_pattern(random_word, value, pattern) else: wrong_guess_lst.append(value) error_count += 1 if input_type == hangman_helper.HINT: msg = hangman_helper.HINT_MSG + choose_letter( filter_words_list(words_list, pattern, wrong_guess_lst), pattern) msg = hangman_helper.WIN_MSG if pattern == random_word else hangman_helper.LOSS_MSG + random_word hangman_helper.display_state(pattern, error_count, wrong_guess_lst, msg, True) input_type, value = hangman_helper.get_input() if input_type == hangman_helper.PLAY_AGAIN: return value return False
def main(): """This function activate the game""" words_list = hangman_helper.load_words( "words.txt") # load words list from an external file wanna_play = True while wanna_play: run_single_game(words_list) # runs the game # every time a game is finished the user gets a screen that offers a new game input_type, wanna_play = hangman_helper.get_input()
def main(): """this function load word from word list(from hangman_helper). this function start the game and when the game end the function suggest to play again""" word_list = hangman_helper.load_words() while True: run_single_game(word_list) user_decision, second_choice = hangman_helper.get_input() if not second_choice: break
def define_input(): """define if the input is a hint, a letter or a 'play again'.""" input_kind, input_val = hangman_helper.get_input() if input_kind == hangman_helper.HINT: return HINT elif (input_kind == hangman_helper.LETTER) and (check_valid_letter(input_val)): return input_val elif input_kind == hangman_helper.PLAY_AGAIN: return input_val return BAD_INPUT
def main(): ''' Executes main function. Iterates over the game as long as player asks to play again. ''' WORDS_LIST = hangman_helper.load_words('words.txt') play_again = True while play_again: run_single_game(WORDS_LIST) play_again = hangman_helper.get_input()[1]
def main(): """ the function start a hangman game till the user do not want to continue . """ words_list = hh.load_words() # loads words from words.txt continue_game = True # play a game till the user choose not to while continue_game: run_single_game(words_list) # checking if the user wants to continue playing continue_game = hh.get_input()[1]
def main(): """ The main/root function of the file """ # Initialize words from specific file words_list = hangman_helper.load_words() # Run single game with given word list to choose from run_single_game(words_list) # Ask the user if he would like to play again request = hangman_helper.get_input() if request[INPUT_TYPE] == hangman_helper.PLAY_AGAIN: if request[INPUT_VALUE]: run_single_game(words_list)
def run_single_game(words_list): ''' A function that receives a list of word and started the game ''' error_count = 0 wrong_guess_lst = [] msg = hangman_helper.DEFAULT_MSG ask_play = False random_word = hangman_helper.get_random_word(words_list) word_pattern = convert_to_pattern(random_word) list_letters = [] for i in range(97, 123): list_letters.append(chr(i)) while len(wrong_guess_lst) < hangman_helper.MAX_ERRORS and Dash in list( word_pattern): hangman_helper.display_state(word_pattern, error_count, wrong_guess_lst, msg, ask_play) letter = hangman_helper.get_input() if letter[1] in list_letters: if letter[1] in list(random_word): if letter[1] in word_pattern: msg = hangman_helper.ALREADY_CHOSEN_MSG + letter[1] else: word_pattern = update_word_pattern(random_word, word_pattern, letter[1]) msg = hangman_helper.DEFAULT_MSG else: if letter[1] not in wrong_guess_lst: msg = hangman_helper.DEFAULT_MSG wrong_guess_lst.append(letter[1]) error_count = error_count + 1 else: msg = hangman_helper.ALREADY_CHOSEN_MSG + letter[1] elif letter[0] == hangman_helper.HINT: words_list = filter_words_list(words_list, word_pattern, wrong_guess_lst) hintletter = choose_letter(words_list, word_pattern) msg = hangman_helper.HINT_MSG + hintletter else: msg = hangman_helper.NON_VALID_MSG if Dash not in list(word_pattern): msg = hangman_helper.WIN_MSG else: msg = hangman_helper.LOSS_MSG + random_word ask_play = True hangman_helper.display_state(word_pattern, error_count, wrong_guess_lst, msg, ask_play)
def main(): """ responsible of the running of the game. """ a = True words_lst = hangman_helper.load_words() while a: run_single_game(words_lst) user_input_type, user_input = hangman_helper.get_input() if user_input_type == hangman_helper.PLAY_AGAIN: 'input is either true (user wants to play another game) or false' if not user_input: a = False
def game_iteration(error_count, msg, pattern, right_guess_lst, word, words_list, wrong_guess_lst): """ for every user action, a new iteration begins. this func checks if the user input is a letter or hint request and acts accordingly. """ user_input_type, user_input = hangman_helper.get_input() if user_input_type == hangman_helper.LETTER: 'input is a letter' pattern, error_count, wrong_guess_lst, msg, right_guess_lst = input_is_letter(error_count, pattern, right_guess_lst, word, wrong_guess_lst, user_input) elif user_input_type == hangman_helper.HINT: 'input is a hint request' msg = input_is_hint(words_list, pattern, wrong_guess_lst, right_guess_lst) return error_count, msg, pattern, wrong_guess_lst
def game_loop(data): """repeats game process for every input until game is over""" while not data["game_over"]: display(data) data["msg"] = h.DEFAULT_MSG # wait for next input data["user_input"] = list(h.get_input()) if data["user_input"][0] == h.HINT: # the player wants a hint data = hint(data) # the player hazards a single letter guess elif data["user_input"][0] == h.LETTER and \ len(data["user_input"][1]) == 1: data = guess(data) else: # human input error data["msg"] = h.NON_VALID_MSG return data
def run_single_game(words_list): """A function that receives a list of words, randomly choosing one and runs the game 'hangman' on the chosen word:""" word = hangman_helper.get_random_word(words_list) pattern = "_" * len(word) wrong_guess_list = [] msg = hangman_helper.DEFAULT_MSG num_errors = 0 while num_errors < hangman_helper.MAX_ERRORS and pattern != word: # a loop that will run until the gamer had manged to discover the word # or had made too many mistakes hangman_helper.display_state(pattern, num_errors, wrong_guess_list, msg) input1 = hangman_helper.get_input() chosen_letter = input1[1] if input1[0] == hangman_helper.LETTER: # checks if the gamer entered a letter if len(chosen_letter) != 1 or not chosen_letter.islower(): # checks if the chosen letter is valid msg = hangman_helper.NON_VALID_MSG continue elif chosen_letter in wrong_guess_list or chosen_letter in pattern: # checks if the chosen letter has already been used msg = hangman_helper.ALREADY_CHOSEN_MSG + chosen_letter elif chosen_letter in word: # checks if the chosen letter is in the word, which means we # want to put her in the pattern pattern = update_word_pattern(word, pattern, chosen_letter) msg = hangman_helper.DEFAULT_MSG else: # or else the chosen letter is wrong wrong_guess_list.append(chosen_letter) num_errors += 1 msg = hangman_helper.DEFAULT_MSG elif input1[0] == hangman_helper.HINT: # checks if the gamer asked for a hint and gives a hint new_list_words = filter_words_list(words_list, pattern, wrong_guess_list) letter = choose_letter(new_list_words, pattern) msg = hangman_helper.HINT_MSG + letter if pattern == word: hangman_helper.display_state(pattern, num_errors, wrong_guess_list, hangman_helper.WIN_MSG, True) else: hangman_helper.display_state(pattern, num_errors, wrong_guess_list, hangman_helper.LOSS_MSG + word, True)
def run_single_round(error_count, msg, pattern, word, wrong_guess_lst): """This function runs a single round of the game """ # if the user didnt go wrong 6 times or didnt win the game continues while (pattern != word) and (error_count < hangman_helper.MAX_ERRORS): # sets the game the game with the right default values hangman_helper.display_state(pattern, error_count, wrong_guess_lst, msg, ask_play=False) input_type, input_value = hangman_helper.get_input( ) # input function from an imported graphic class # if the user puted in a char if user_entered_letter(input_type): guess_letter = input_value # updates the guess to this letter # checks if the char is a valid letter for this game if letter_is_valid(guess_letter): msg = hangman_helper.NON_VALID_MSG # if it isnt a valid char the user gets a message # if the guess is already chosen the user gets an appropiate message elif already_chosen(guess_letter, pattern, wrong_guess_lst): msg = hangman_helper.ALREADY_CHOSEN_MSG + guess_letter # if the guess is right and the user tried it for the first time it revealed elif guess_letter in word: pattern = update_word_pattern(word, pattern, guess_letter) msg = hangman_helper.DEFAULT_MSG # the only left option is that the guess is wrong so the error list & counter updated and the user else: error_count += 1 wrong_guess_lst.append(guess_letter) msg = hangman_helper.DEFAULT_MSG # case when the user pressed on the hint buttom elif input_type == hangman_helper.HINT: msg = get_hint(error_count, msg, pattern, wrong_guess_lst) return error_count, pattern