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
