def test_multiple_same_guesses():
h = Hangman()
h.new_game('defenestrate')
h.guess('e')
h.guess('e')
assert h.guesses == ['e']
print('test_multiple_same_guesses passed!')
def test_winning_on_last_guess_still_counts_as_a_win(self):
game = Hangman('aaa')
for ch in 'bcdefghij':
game.guess(ch)
game.guess('a')
self.assertEqual(game.remaining_guesses, 0)
self.assertEqual(game.get_status(), hangman.STATUS_WIN)
self.assertEqual(game.get_masked_word(), 'aaa')
def test_guessing_entire_word():
h = Hangman()
h.new_game('batman')
h.guess('batman')
assert h.has_guessed_word() is True
assert h.guesses == ['batman']
print('test_guessing_entire_word passed!')
def test_basic_guesses():
h = Hangman()
h.new_game('conscientious')
h.guess('e')
assert h.guesses == ['e']
h.guess('f')
assert h.guesses == ['e', 'f']
print('test_basic_guesses passed!')
def test_winning_on_last_guess_still_counts_as_a_win(self):
game = Hangman('aaa')
for ch in 'bcdefghij':
game.guess(ch)
game.guess('a')
self.assertEqual(game.remaining_guesses, 0)
self.assertEqual(game.get_status(), hangman.STATUS_WIN)
self.assertEqual(game.get_masked_word(), 'aaa')
def guess_text():
text = request.form['guess']
text = text.strip()
if len(text) > 0:
hangman = Hangman()
hangman.guess(text)
hangman.save()
return redirect(url_for('show_game'))
def test_after_10_failures_the_game_is_over(self):
game = Hangman('foo')
for i in range(10):
game.guess('x')
self.assertEqual(game.get_status(), hangman.STATUS_LOSE)
with self.assertRaisesWithMessage(ValueError):
game.guess('x')
def test_after_10_failures_the_game_is_over(self):
game = Hangman('foo')
for _ in range(10):
game.guess('x')
self.assertEqual(game.get_status(), hangman.STATUS_LOSE)
with self.assertRaisesWithMessage(ValueError):
game.guess('x')
def test_after_10_failures_the_game_is_over(self):
game = Hangman('foo')
for i in range(10):
game.guess('x')
self.assertEqual(game.get_status(), hangman.STATUS_LOSE)
with self.assertRaises(ValueError) as err:
game.guess('x')
self.assertEqual(type(err.exception), ValueError)
self.assertEqual(err.exception.args[0], "The game has already ended.")
def test_feeding_a_correct_letter_removes_underscores(self):
game = Hangman('foobar')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
self.assertEqual(game.get_masked_word(), '___b__')
game.guess('o')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
self.assertEqual(game.get_masked_word(), '_oob__')
def test_feeding_a_correct_letter_removes_underscores(self):
game = Hangman('foobar')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
self.assertEqual(game.get_masked_word(), '___b__')
game.guess('o')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
self.assertEqual(game.get_masked_word(), '_oob__')
def test_feeding_a_correct_letter_twice_counts_as_a_failure(self):
game = Hangman('foobar')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
self.assertEqual(game.get_masked_word(), '___b__')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '___b__')
def guess_text():
text = request.form["guess"]
hangman = Hangman()
hangman.guess(text)
hangman.save()
# prediction = guess()
# text = show_game()
# if prediction is None:
# game.append(text)
# pass
#...When you make a guess on a game. Not when you start a new game. Separate URL for that
return redirect(url_for('show_game'))
def test_feeding_a_correct_letter_twice_counts_as_a_failure(self):
game = Hangman('foobar')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
self.assertEqual(game.get_masked_word(), '___b__')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '___b__')
class HangmanTestCase(unittest.TestCase):
def setUp(self):
self.game = Hangman("hello", 10)
self.game2 = Hangman("goodbye", 10)
def test_status(self):
self.assertEqual(self.game2.status(), "???????")
def test_bad_guess(self):
self.assertEqual(self.game.status(), "?????")
self.assertEqual(self.game.guess('x'), 0)
self.assertEqual(self.game.status(), "?????")
def test_good_guess(self):
self.assertEqual(self.game.status(), "?????")
self.assertEqual(self.game.guess('h'), 1)
self.assertEqual(self.game.status(), "h????")
def test_multiple_guess(self):
self.assertEqual(self.game2.status(), "???????")
self.assertEqual(self.game2.guess('o'), 2)
self.assertEqual(self.game2.status(), "?oo????")
def test_more_letters(self):
self.assertEqual(self.game.guess('h'), 1)
self.assertEqual(self.game.status(), "h????")
self.assertEqual(self.game.guess('i'), 0)
self.assertEqual(self.game.status(), "?????")
self.assertEqual(self.game.status(), "h????")
self.assertEqual(self.game.guess('l'), 2)
self.assertEqual(self.game.status(), "h?ll?")
self.assertEqual(self.game.guess('e'), 1)
self.assertEqual(self.game.status(), "hell?")
def play_game():
play = Hangman(get_word())
while not play.game_end():
play.status()
user_input = input('\nEnter a letter: ').lower()
if len(user_input) != 1:
print("Please, enter just a letter")
elif user_input not in "abcdefghijklmnopqrstuvwxyz":
print("Please enter an alphabet")
else:
play.guess(user_input)
if play.win():
print()
print("Great! You got the word right. It was {}".format(play.word))
else:
play.status()
print("\nOoops! You Lost!")
print("The word was {}".format(play.word))
def test_guesses_changing_public_word():
h = Hangman()
h.new_game('encyclopedia')
assert h.public_word == list('____________')
h.guess('e')
assert h.public_word == list('e_______e___')
h.guess('c')
assert h.public_word == list('e_c_c___e___')
h.guess('n')
assert h.public_word == list('enc_c___e___')
h.guess('a')
assert h.public_word == list('enc_c___e__a')
print('test_guesses_changing_public_word passed!')
def test_guessing_word():
h = Hangman()
h.new_game('cat')
h.guess('c')
assert h.has_guessed_word() is False
h.guess('a')
assert h.has_guessed_word() is False
h.guess('t')
assert h.has_guessed_word() is True
print('test_guessing_word passed!')
class Application(tk.Frame):
"""Tkinter application for Hangman """
def __init__(self, master=None):
tk.Frame.__init__(self, master)
self.game = Hangman()
self.create_widgets()
self.grid()
def create_widgets(self):
"""Create all widgets and display them."""
self._add_lives(row=0, column=0)
self._add_display_hangman(row=1, column=0)
self._add_text_input(row=2, column=0)
self._add_button(row=3, column=0)
self._add_attemps(row=4, column=0)
def click(self):
"""Click initialized by "guess button."""
# Get user input
self.user_inp = self.text_input.get().lower()
self.game.guess(self.user_inp)
self.main_text.config(text=self.game.get_masked_word())
self._click_update_attempts()
self._click_update_lives()
self._click_if_endgame()
def _click_update_attempts(self):
"""Update displayed attempts."""
label_text = self.attempts_var.get()
label_text += self.user_inp + " "
self.attempts_var.set(label_text)
def _click_update_lives(self):
"""Update displayed lives."""
label_num = self.lives_var.get()
label_num = f"Lives: {self.game.get_lives()}"
self.lives_var.set(label_num)
def _click_if_endgame(self):
""" Checks if the game has ended """
if self.game.is_guessed():
messagebox.showinfo("CONGRATS!", "You nailed it!")
self.quit()
elif self.game.is_dead():
messagebox.showinfo(
"WASTED!",
f"You've run out of lives. The word was {self.game.get_word()}"
)
self.quit()
def _add_lives(self, row, column):
"""Add widget for displaying lives"""
# Create widget variable for future change
self.lives_var = tk.StringVar()
# Get widget variable value and change it
label_num = self.lives_var.get()
label_num = f"Lives: {self.game.lives}"
# Lock widget variable
self.lives_var.set(label_num)
self.lives = tk.Label(self, textvariable=self.lives_var)
# Display widget variable
self.lives.grid(row=row, column=column)
def _add_attemps(self, row, column):
"""Add widget for displaying attempts"""
# Create widget variable for future change
self.attempts_var = tk.StringVar()
# Get widget variable value and change it
label_text = self.attempts_var.get()
label_text += "Attempts:\n"
# Lock widget variable
self.attempts_var.set(label_text)
self.attempts = tk.Label(self, textvariable=self.attempts_var)
# Display widget variable
self.attempts.grid(row=row, column=column)
def _add_display_hangman(self, row, column):
"""Add widget for displaying words of hangman"""
self.main_text = tk.Label(self,
text=self.game.get_masked_word(),
font=("Kumar One", 50))
self.main_text.grid(row=row, column=column)
def _add_text_input(self, row, column):
"""Add widget for inputing letters or words"""
self.text_input = tk.Entry(self, justify='center')
self.text_input.grid(row=row, column=column)
def _add_button(self, row, column):
"""Add button to initialize "click" function"""
self.guess_button = tk.Button(self,
text='Enter',
command=self.click,
width=21,
highlightcolor='blue')
self.guess_button.grid(row=row, column=column)
def test_getting_all_the_letters_right_makes_for_a_win(self):
game = Hangman('hello')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_____')
game.guess('e')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_e___')
game.guess('l')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_ell_')
game.guess('o')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_ello')
game.guess('h')
self.assertEqual(game.get_status(), hangman.STATUS_WIN)
self.assertEqual(game.get_masked_word(), 'hello')
with self.assertRaises(ValueError) as err:
game.guess('x')
self.assertEqual(type(err.exception), ValueError)
self.assertEqual(err.exception.args[0], "The game has already ended.")
def test_getting_all_the_letters_right_makes_for_a_win(self):
game = Hangman("hello")
game.guess("b")
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), "_____")
game.guess("e")
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), "_e___")
game.guess("l")
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), "_ell_")
game.guess("o")
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), "_ello")
game.guess("h")
self.assertEqual(game.get_status(), hangman.STATUS_WIN)
self.assertEqual(game.get_masked_word(), "hello")
with self.assertRaisesWithMessage(ValueError):
game.guess("x")
def test_getting_all_the_letters_right_makes_for_a_win(self):
game = Hangman('hello')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_____')
game.guess('e')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_e___')
game.guess('l')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_ell_')
game.guess('o')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_ello')
game.guess('h')
self.assertEqual(game.get_status(), hangman.STATUS_WIN)
self.assertEqual(game.get_masked_word(), 'hello')
with self.assertRaisesWithMessage(ValueError):
game.guess('x')
class Game(object):
def __init__(self):
# The session ID of the player who guesses the phrase
self.guesser = PLAYER_NOT_CHOSEN
# Hangman game instance
self.hangman = None
# Dictionary of [session_id:Player] currently connected
self.players = {}
# Screen that the users are on
self.game_state = GameState.TITLE_SCREEN
self.letters_guessed = []
self.phrase_misses = 0
# Reset the whole state
def reset(self):
self.reset_guesser()
self.hangman = None
# Don't reset players since people are still connected as spectators
self.game_state = GameState.TITLE_SCREEN
self.letters_guessed = []
self.phrase_misses = 0
# Keep track of a new player in the game
def add_player(self, sid):
assert sid is not None
assert sid not in self.players
self.players[sid] = Player(sid)
# Remove a player from the game when they disconnect
def remove_player(self, sid):
assert sid is not None
assert sid in self.players
self.players.pop(sid, None)
# Get the number of players currently connected
def count_players(self):
return len(self.players)
# Return True if the current player is a guesser, False if not
def is_guesser(self, sid):
assert sid is not None
return self.guesser == sid
# Return True if someone was chosen as a guesser, False if not
def is_guesser_set(self):
return self.guesser != PLAYER_NOT_CHOSEN
# Set the guesser back to PLAYER_NOT_CHOSEN, returns True if there was a
# guesser previously, False if not
def reset_guesser(self):
# Reset roles in players dictionary
if self.guesser != PLAYER_NOT_CHOSEN:
assert self.guesser in self.players
self.players[self.guesser].make_spectator()
self.guesser = PLAYER_NOT_CHOSEN
return True
return False
# Become the new guesser - assumes guesser was already reset
def set_guesser(self, sid, name):
self.guesser = sid
if (sid == PLAYER_NOT_CHOSEN):
return
self.players[sid].make_guesser()
self.players[sid].set_name(name)
# Become a spectator on the server
def set_spectator(self, sid):
self.players[sid].make_spectator()
# Get the name of the player
def get_name(self, sid):
if (sid == PLAYER_NOT_CHOSEN):
return PLAYER_NOT_CHOSEN
assert sid is not None
assert sid in self.players
return self.players[sid].get_name()
# Set a new name for the player
def set_name(self, sid, name):
assert sid is not None
assert sid in self.players
return self.players[sid].set_name(name)
# Reset the name of the player
def reset_name(self, sid):
assert sid is not None
assert sid in self.players
return self.players[sid].reset_name()
# Set the hangman game
def set_phrase(self, level, debug):
if debug:
phrase = 'HELLO'
else:
phrase = _get_random_phrase(level)
self.hangman = Hangman(phrase)
# Get the current type of the player as a string
def get_player_type(self, sid):
return self.players[sid].get_player_type()
# Determines if guesser have been confirmed
def players_ready(self):
return self.is_guesser_set()
# Returns the phrase in its currently discovered position
def guess_letter(self, letter):
assert self.hangman is not None
self.hangman.guess(letter)
self.letters_guessed.append(letter)
return self.get_currently_discovered_phrase()
# Returns the phrase with underlines for what hasn't been guessed yet
def get_currently_discovered_phrase(self):
if self.hangman is None:
return None
return self.hangman.getCurrentlyDiscoveredPhrase()
# Checks if phrase has been successfully completed
def is_completed(self):
if self.hangman is None:
return False
return self.hangman.isCompleted()
def hit_constrain(self, val):
self.phrase_misses = min(7, max(0, val))
def test_getting_all_the_letters_right_makes_for_a_win(self):
game = Hangman('hello')
game.guess('b')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_____')
game.guess('e')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_e___')
game.guess('l')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_ell_')
game.guess('o')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 8)
self.assertEqual(game.get_masked_word(), '_ello')
game.guess('h')
self.assertEqual(game.get_status(), hangman.STATUS_WIN)
self.assertEqual(game.get_masked_word(), 'hello')
with self.assertRaisesWithMessage(ValueError):
game.guess('x')
class HangmanGame:
"""
Initiate a hangman game
:ivar hangman: Class Hangman
:ivar active: The state of the game
"""
def __init__(self):
print(hascii.logo)
self.hangman = Hangman(self.random_word())
self.active = True
@staticmethod
def random_word():
"""
Select a random word from a text file.
:return: a lower-case word
"""
with open('hangman_words.csv', 'r') as wordlist:
word = choice(wordlist.read().split(','))
return word
def play(self):
"""
Run this method to start the game.
"""
while self.active:
while self.active:
print(self.hangman)
print(f'\nNumber of lives left: {self.hangman.lives}\n')
# user plays
letter = input('Input a letter: ').lower()
if self.is_valid_letter(letter):
self.hangman.guess(letter)
# check winning condition
if self.hangman.is_saved():
print(hascii.figure['saved'])
print('\nYou survived!')
self.active = False
# check losing condition
elif self.hangman.is_hanged():
print(hascii.figure[1])
print('\nYou are hanged!')
print(f'The word was {self.hangman.word}')
self.active = False
print()
self.active = self.replay()
print('\nThank you for playing!')
print(hascii.logo)
@staticmethod
def is_valid_letter(c):
"""
Check if character c is a single English lowercase letter
:param c: a character
:return True if character is valid, else False
"""
if len(c) != 1:
print('You should input a single letter')
return False
if c not in string.ascii_letters:
print('You did not input a valid English letter')
return False
return True
def replay(self):
"""
Ask the user if they want to replay hangman.
:return: True if affirmative, else False
"""
while True:
user_input = input('\nWould you like to [R]eplay or [Q]uit?: ')
if user_input[0].lower() == 'r':
self.hangman = Hangman(self.random_word()) # reset game
return True
elif user_input[0].lower() == 'q':
return False
else:
print('Invalid input')
