def wordPlay(self):
lev4 = Hangman(self._lives)
playerChoice = input(
"Ertu tilbúin í lokaþraut þína í Hogwarts? (já/nei): \n")
if playerChoice == "já":
print(
"Þú byrjar 3 með \"líf\" eða eins og Dumbledore kallar það \"tækifæri\". Good luck...\n"
)
puzzle = lev4.wordPuzzle()
while puzzle == "still alive":
self.readyInput()
puzzle = lev4.wordPuzzle()
if puzzle == "loss":
self.readyInput()
self.looseLevel()
print(
"\nThe end! Takk fyrir að spila leikinn Haraldur Pottur og félagar í háska, vertu velkominn aftur!"
)
sys.exit()
elif playerChoice == "nei":
print(
"Hér í Hogwarts er ekki liðinn aumingjaskapur svo þú ert hér með gerð/ur brottrækur!"
)
time.sleep(3)
self.looseLevel()
else:
sentence = self.inputWrong(0)
print(sentence)
self.wordPlay()
def test_board_gen(self):
test_game = Hangman()
test_game.word = 'LOGAN\n'
test_game.delimiter = '*'
d = test_game.delimiter
expected = d + ' ' + d + ' ' + d + ' ' + d + ' ' + d
self.assertEqual(test_game.board_gen(), expected)
def test_stop(self, _: unittest.mock.MagicMock) -> None: """Game can be stopped""" game = Hangman(wordlist=['one']).start() self.assertTrue(game.active) game.stop() self.assertTrue(game.inactive) self.assertEqual(game.rounds, [GameState(0.0, 0.0, GameStatus.ACTIVE, 'ONE', [], 6)])
class HangmanTest(unittest.TestCase):
def setUp(self):
self.hm = Hangman()
self.hm.word = list("testing")
self.hm.remain = self.hm.word.copy()
self.hm.guessed = [0] * len(self.hm.word)
self.hm.games = 0
self.hm.missed = 0
# Testing attributes
self.idx = 0
self.char = self.hm.word[self.idx]
def test_already_guessed(self):
self.assertEqual(
self.hm.already_guessed(self.idx, self.char),
False
)
self.hm.guessed[self.idx] = self.char
self.assertEqual(
self.hm.already_guessed(self.idx, self.char),
True
)
def test_all_guessed(self):
self.assertEqual(
self.hm.all_guessed(),
not 0 in self.hm.guessed
)
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
finished = False
hangman = Hangman()
maxTries = hangman.getLife()
while guess.numTries < maxTries:
display = hangman.get(maxTries - guess.numTries)
print(display)
guess.display()
guessedChar = input('Select a letter: ')
if len(guessedChar) != 1:
print('One character at a time!')
continue
if guessedChar in guess.guessedChars:
print('You already guessed \"' + guessedChar + '\"')
continue
finished = guess.guess(guessedChar)
if finished == True:
break
if finished == True:
print('Success')
else:
print(hangman.get(0))
print('word [' + guess.secretWord + ']')
print('guess [' + guess.currentWord + ']')
print('Fail')
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
finished = False
hangman = Hangman()
maxTries = hangman.getLife()
while guess.numTries < maxTries:
display = hangman.get(maxTries - guess.numTries)
print(display)
guess.display()
guessedChar = input('Select a letter: ')
finished = guess.guess(guessedChar)
if finished:
break
if finished:
print('Success')
else:
print(hangman.get(0))
print('word [' + guess.word + ']')
print("Guess:", end=" ")
for i in range(len(guess.current)):
print(guess.current[i], end=" ")
print()
print('Fail')
def show_game():
hangman = Hangman()
has_guessed = hangman.has_guessed_word()
return render_template('game.html',
word=hangman.public_word,
guesses=hangman.guesses,
has_guessed=has_guessed)
class HangmanGame:
def __init__(self):
self.hangman = Hangman()
def play(self):
while True:
print(f'Pozostała liczba szans: {self.hangman.get_chances()}')
print(self.hangman.get_word_to_guess())
letter = input('Podaj literę lub słowo: ')
if self.hangman.is_it_word_to_find(letter):
self.win()
break
try:
self.hangman.guess_letter(letter)
except ChancesError:
self.lose()
break
if self.hangman.are_all_letters_found():
self.win()
break
def lose(self):
print('\nSłabiaku!!!!!')
self.print_word_to_find()
def win(self):
print('\nGratulacje!!!')
self.print_word_to_find()
def print_word_to_find(self):
print(f'Szukane słowo to: {self.hangman.get_word_to_find()}')
def __init__(self, langue="fr"):
"""
Cette méthode initialise le jeu.
On y ouvre notamment le dictionnaire français.
"""
self.mistakes = 0 # Sert dans l'affichage des différents dessins en ascii lorsque le joueur se trompe de lettre (self.game())
self.al = [
] # Liste dans la quelle on va implémenter les lettres déjà essayées (voir self.already())
self.streak = [
] # Liste pour implémenter tous les mots déjà trouvés en cas de série de victoire
self.all = [
0
] # Liste pour enregistrer les points de chaque mots trouvés
self.allstreak = [
0
] # Liste pour enregistrer les maximums de points globaux en une série de victoire
self.allwords = [''] # Liste pour enregistrer tous les mots joués
self.d = 0 # Instanciation des points de base, soit 0
Hangman.__init__(self) # Instanciation du module Hangman joint au TP
#Début du jeu:
print('Bien, que le pendu commence !')
time.sleep(2)
# Ici on choisit le dictionnaire (la langue du jeu):
with io.open('fr_dic.txt', encoding='utf8') as f:
self.content = f.readlines()
print(self.title2) # Utilisation des titres en ascii du fichier annexe
Hangman_game.word_choice(self)
Hangman_game.game(self)
def test_end_game_loose_not_win():
hangman = Hangman()
hangman.user_mistakes = ATTEMPTS
hangman.gamer_word = list(hangman.secret_word)
assert hangman.end_game()
assert not hangman.is_won
assert hangman.is_lost
def test_check_letter_success():
hangman = Hangman()
hangman.check_letter(hangman.secret_word[0].capitalize())
letter_lower = hangman.secret_word[0].lower()
assert letter_lower in hangman.used_letters
assert hangman.gamer_word[0] == letter_lower
assert hangman.user_mistakes == 0
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
hangman = Hangman()
maxTries = hangman.getLife()
while (maxTries - guess.numTries):
display = hangman.get(maxTries - guess.numTries)
print(display)
guess.display()
guessedChar = input("Select a letter:")
if len(guessedChar) != 1:
print("One character at a time!")
continue
if guessedChar in guess.guessedChars:
print("You already guessed \' %c \' " % (guessedChar))
continue
if guess.guess(guessedChar) == True:
print("Success!")
break
if guess.guess(guessedChar) == False:
print(hangman.get(0))
print("word [ %s ]" % (guess.secretWord))
print("guess [ %s ]" % (guess.currentStatus))
print('Fail')
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB()) # 랜덤하게 단어선택
finished = False
hangman = Hangman()
maxTries = hangman.getLife() # 목숨의 개수를 초기화 시킴
while guess.numTries < maxTries: # 목숨이 몇개 남았는지 체크해줌
display = hangman.get(maxTries - guess.numTries)
print(display)
guess.display()
guessedChar = input('Select a letter: ')
if len(guessedChar) != 1: # 한글자가 아니면
print('One character at a time!')
continue
if guessedChar in guess.guessedChars: # 이미 사용한 문자라면
print('You already guessed \"' + guessedChar + '\"')
continue
finished = guess.guess(guessedChar)
if finished == True:
break
if finished == True:
print('Success')
print('word : ' + guess.secretWord)
else:
print(hangman.get(0))
print('word [' + guess.secretWord + ']')
print('guess [' + guess.currentStatus + ']')
print('Fail')
def test_show_game_board_image(self):
# testing the game board image
game = Hangman()
image = Hangman.hangman_board_image
guess = game.show_game_board_image(image, 'abd')
# showing the image after 3 wrong guesses, and the incorrect letters
self.assertTrue('abc', guess)
def test_game_lost(self) -> None:
"""Game is stopped when the user is out of lives"""
game = Hangman(lives=1, wordlist=['abc']).start()
self.assertEqual(game.guess_letter('A'), 1)
self.assertEqual(game.lives, 1)
self.assertEqual(game.guess_letter('z'), 0)
self.assertTrue(game.lost)
def start_game():
"""Main function"""
try:
hangman = Hangman(window, HEIGHT, words)
except Exception:
messagebox.showinfo("Победа", "Все слова отгаданы")
window.quit()
def key_press(arg):
"""
the function reads data from the keyboard,
processes it, and outputs the result.
Contains functions: check_letter(),status()
"""
letter = arg.char.lower()
print(hangman.secret_word)
# Check input letter, processes the result of the check
hangman.check_letter(letter, canvas)
# Monitores the gameplay
hangman.status(canvas)
# write used_word to file
hangman.write_to_file()
# binds keyboard events to key_press агтс
window.bind("<KeyPress>", key_press)
class HangmanGame:
def __init__(self):
self.hangman = Hangman()
def play(self):
while True:
print(f'Chances left: {self.hangman.get_chances()}')
print(self.hangman.get_word_to_guess())
letter = input('Give a letter or word: ')
if self.hangman.is_it_word_to_find(letter):
self.win()
break
try:
self.hangman.guess_letter(letter)
except ChancesError:
self.lose()
break
if self.hangman.are_all_letters_found():
self.win()
break
def lose(self):
print('\nLoser!!!!')
self.print_word_to_find()
def win(self):
print('\nCongrats!!!')
self.print_word_to_find()
def print_word_to_find(self):
print(f'A word to find: {self.hangman.get_word_to_find()}')
def play_game():
# Save the list of available words.
words = actions.obtain_words(FILE)
# Creates a Hangman object with a random word from words list.
hg = Hangman(random.choice(words))
# Prints the instructions and the hidden word length
actions.print_rules_info()
hg.print_guessed_letters()
# Loops until the chances are equal to 0.
while hg.chances >= 1:
if not hg.word_found:
letter = actions.obtain_letter()
hg.search_letter(letter)
hg.current_state()
else:
break
# Runs when the user ends all opportunities.
# Prints the hidden word
if hg.chances == 0:
print('\nGAME OVER!')
print('The hidden word was:')
hg.print_hidden_word()
def test_return_a_if_a_is_correctly_guessed(self):
game = Hangman('a')
game.guess_letter('a')
hint = game.render_hint()
self.assertEqual(hint, 'a')
def initialise(self):
self.hangman = Hangman(self)
self.my_word = StringVar()
self.my_word.set(
"Word: " +
self.hangman.word_of_underlines(len(self.hangman.word_to_guess)))
self.tried_so_far = StringVar()
self.tried_so_far.set('Letters tried so far: ')
self.guesses_left = StringVar()
self.update_no_of_guesses()
self.geometry('{}x{}'.format(545, 400))
self.grid()
word = Label(self, textvariable=self.my_word)
word.grid(column=1, row=7, sticky=W)
tried = Label(self, textvariable=self.tried_so_far)
tried.grid(column=1, row=8, sticky=W)
no_guesses = Label(self, textvariable=self.guesses_left)
no_guesses.grid(column=1, row=9, sticky=W)
turtle_canvas = Canvas(self, width=300, height=450)
self.th = TurtleHangman(turtle_canvas)
turtle_canvas.grid(column=1, row=10, rowspan=8, columnspan=3)
infotext = 'Hangman v1.0 by AML'
info = Label(self, text=infotext)
info.grid(column=4, row=12, columnspan=2)
class Display:
def __init__(self, word, images):
self.hangman = Hangman(images)
self.word = Word(word)
self.letter_buttons = LetterButtons()
def is_letter_not_in_word(self, ltr):
if ltr not in self.word.get_word():
self.hangman.set_hangman_status()
def mouse_click(self, mouse_x, mouse_y):
letters = self.letter_buttons.get_letters()
for letter in letters:
if letter.get_visible():
distance = math.sqrt((letter.get_x() - mouse_x)**2 +
(letter.get_y() - mouse_y)**2)
if distance < RADIUS:
self.letter_buttons.if_inside_button(letter)
self.is_letter_not_in_word(letter.get_letter())
def draw_window(self):
WINDOW.fill(WHITE)
self.word.draw(self.letter_buttons.get_guessed())
self.letter_buttons.draw()
self.hangman.draw()
pygame.display.update()
def is_won(self):
for letter in self.word.get_word():
if letter not in self.letter_buttons.get_guessed():
return False
return True
def is_lost(self):
return self.hangman.get_hangman_status() == 6
def test_game_is_NOT_lost_when_guessed_incorrectly_for_10_times(self):
game = Hangman('a')
for _ in range(10):
game.guess_letter('b')
self.assertEqual(game.get_status(), 'Running')
def test_no_wordlist(self) -> None: """Ensure error when no words loaded""" # Empty wordlist with self.assertRaises(ValueError): Hangman() with self.assertRaises(ValueError): Hangman(wordlist=[])
def test_ignored_wordlist(self) -> None: """Empty wordlist is allowable""" game = Hangman(allow_empty=True) self.assertEqual(game.word, '') game.start() self.assertEqual(game.word, '') self.assertFalse(game.used_words)
def test_visible_word(self) -> None:
"""Visible word contains guessed letters"""
game = Hangman(wordlist=['ECHO LOCATION']).start()
self.assertEqual(game.guess_letter('O'), 3)
self.assertEqual(game.visible_word, '___O _O____O_')
self.assertEqual(game.guess_word('ECHO LOCATION'), 9)
self.assertEqual(game.guess_count, 2)
self.assertTrue(game.won)
def play_game(self, id):
if id == self.HANGMAN_GAME_ID:
print('Play Hangman!\n')
self.hm = Hangman()
self.hm.start_game()
elif id == self.OTHER_GAME_ID:
print('Other games coming soon!')
else:
print('Exiting game')
def test_inactive(self) -> None:
"""Is properly set to inactive"""
with self.assertRaises(HangmanOver):
Hangman(wordlist=['one']).guess_letter('o')
with self.assertRaises(HangmanOver):
Hangman(allow_empty=True).start().guess_letter('o')
self.assertTrue(Hangman(allow_empty=True).inactive)
def startGame(self):
self.hangman = Hangman()
self.guess = Guess(self.word.randFromDB())
self.gameOver = False
self.hangmanWindow.setPlaceholderText(self.hangman.currentShape())
self.currentWord.setText(self.guess.displayCurrent())
self.guessedChars.setText(self.guess.displayGuessed())
self.message.clear()
def setUp(self):
self.hm = Hangman()
self.hm.word = list("testing")
self.hm.remain = self.hm.word.copy()
self.hm.guessed = [0] * len(self.hm.word)
self.hm.games = 0
self.hm.missed = 0
# Testing attributes
self.idx = 0
self.char = self.hm.word[self.idx]
class Game:
def __init__(self):
self.puzzle = Puzzles()
self.hangman = Hangman(self.puzzle.random_word)
self.game_loop()
def game_loop(self):
self.draw()
while True:
self.hangman.input_letter()
os.system("clear")
self.draw()
if self.lost_game_condition():
os.system("clear")
self.draw()
print("You lost! Hidden word: " + self.hangman.hidden_word)
break
if self.won_game_condition():
print("You won!")
break
def draw(self):
self.hangman.draw_word()
self.hangman.draw_failed_letters()
self.hangman.draw_gallows()
def lost_game_condition(self):
return self.hangman.miss >= self.hangman.CHANCES
def won_game_condition(self):
return self.hangman.is_won()
def gameMain():
'''게임 구동 과정'''
# 파일에 있는 단어 정리 및 갯수 알려주기
word = Word('aabbcc.txt')
# 파일안에 있는 단어 랜덤적으로 가져온다.
guess = Guess(word.randFromDB())
# 처음에는 단어가 완성이 안돼있으니 False 출력
finished = False
# 목숨갯수(maxTries = 6)초기화
hangman = Hangman()
maxTries = hangman.getLife()
# numTries(현재 남은 목숨갯수)가 6보다 크거나 같을 때가지 실행
while guess.numTries < maxTries:
# 시각적으로 행맨을 보여준다 (남은 목숨갯수에 맞게)
# 6 -> 0
display = hangman.get(maxTries - guess.numTries)
print(display)
guess.display()
guessedChar = input('Select a letter: ')
# 알파벳 한개만 적기 #
if len(guessedChar) != 1:
print('One character at a time!')
continue
# guessedChars는 이미적은 알파벳을 모아 놓은 곳
if guessedChar in guess.guessedChars:
print('You already guessed \"' + guessedChar + '\"')
continue
# 입력된 알파벳이 랜덤단어안에 있는지 확인
# 단어가 완성 되었는지
finished = guess.guess(guessedChar)
if finished == True:
break
# 알파벳이 존재한다면 성공
if finished == True:
print('Success')
# 만약 제안된 기회 안에 단어를 완성하지못했다면
else:
# 매달린 남자 보여주기
print(hangman.get(0))
#사용한 알파벳, 기회가용횟수, 실패
print('word was [' + guess.secretWord + ']')
print('guess [' + guess.currentStatus + ']')
print('Fail')
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 __init__(self, channel, nickname, server, port=6667, password=None):
print "Initializing"
irc.bot.SingleServerIRCBot.__init__(self, [(server, port, password)], nickname, nickname)
self.channel = channel
database = CardDatabase("cardtext.csv")
self.HangmanController = Hangman(database.data)
class Sce_Hangman(Scene):
'''
classdocs
'''
def __init__(self, director, background_hangman):
'''
Constructor
'''
Scene.__init__(self, director, background_hangman)
self.hangman = Hangman()
self.scene_winner = Sce_Winner(director, 'winner', HANGMAN_SCENE)
for buttom in self.common_buttoms.itervalues():
buttom.is_visible = True
def on_update(self):
self.time = self.director.time
self.update()
if not self.hangman.lose:
word = ''
self.is_complete = word.join(self.hangman.exposed) == self.hangman.word
self.hangman.lose = self.hangman.intent == self.hangman.intents
else:
self.hangman.paused = True
def on_event(self, event):
self.event(event)
if event.type == pygame.KEYDOWN:
if not self.hangman.paused and ((event.unicode.lower() in ("abcdefghijklmnopqrstuvwxyz")) or (event.key == pygame.K_SPACE and ' ' in self.hangman.word)):
key = event.unicode.lower()
#print "Tecla: "+key
if (key in self.hangman.word.lower()) and (key not in self.hangman.typeds):
self.hangman.put_char(key)
else:
self.hangman.intent += 1
def on_draw(self, screen):
self.draw(screen)
self.hangman.draw(screen)
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 __init__(self, director, background_hangman):
'''
Constructor
'''
Scene.__init__(self, director, background_hangman)
self.hangman = Hangman()
self.scene_winner = Sce_Winner(director, 'winner', HANGMAN_SCENE)
for buttom in self.common_buttoms.itervalues():
buttom.is_visible = True
def setUp(self):
self.hm = Hangman()
self.hm.word = list("testing")
self.hm.remain = self.hm.word.copy()
self.hm.guessed = [0] * len(self.hm.word)
self.hm.games = 0
self.hm.missed = 0
# Testing attributes
self.idx = 0
self.char = self.hm.word[self.idx]
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_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_initially_9_failures_are_allowed(self):
game = Hangman('foo')
self.assertEqual(game.get_status(), hangman.STATUS_ONGOING)
self.assertEqual(game.remaining_guesses, 9)
class Hangmanemone(irc.bot.SingleServerIRCBot):
def __init__(self, channel, nickname, server, port=6667, password=None):
print "Initializing"
irc.bot.SingleServerIRCBot.__init__(self, [(server, port, password)], nickname, nickname)
self.channel = channel
database = CardDatabase("cardtext.csv")
self.HangmanController = Hangman(database.data)
def on_nicknameinuse(self, c, e):
c.nick(c.get_nickname() + "_")
def log_event(self, e):
if DEBUG:
print e.type
print e.source
print e.target
print e.arguments
print ""
def on_welcome(self, c, e):
self.log_event(e)
c.execute_delayed(1, c.join, (self.channel,))
def on_namreply(self, c, e):
self.log_event(e)
def on_endofnames(self, c, e):
self.log_event(e)
def on_join(self, c, e):
self.log_event(e)
def on_pubmsg(self, c, e):
self.log_event(e)
message = e.arguments[0]
env = {}
env["message"] = message
env["user"] = e.source.split("!", 1)[0]
env["channel"] = e.target
if message.startswith("!newcard"):
self.HangmanController.pick_mystery(c, env)
elif message.startswith("!addclue"):
self.HangmanController.add_clue(c, env)
elif message.startswith("!hangman"):
try:
num = int(message.split()[1])
self.HangmanController.num_mysteries += num
self.HangmanController.pick_mystery(c, env)
except ValueError:
pass
else:
self.HangmanController.mystery_solved(c, env)
def on_privmsg(self, c, e):
self.log_event(e)
def on_pubnotice(self, c, e):
self.log_event(e)
def on_privnotice(self, c, e):
self.log_event(e)
def on_error(self, c, e):
self.log_event(e)
def on_ping(self, c, e):
self.log_event(e)
def on_pong(self, c, e):
self.log_event(e)
def on_mode(self, c, e):
self.log_event(e)
def on_disconnect(self, c, e):
self.log_event(e)
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_initially_no_letters_are_guessed(self):
game = Hangman('foo')
self.assertEqual(game.get_masked_word(), '___')
"""
Returns a list of valid words. Words are strings of lowercase letters.
Depending on the size of the word list, this function may
take a while to finish.
"""
print "Loading word list from file..."
# inFile: file
inFile = open(WORDLIST_FILENAME, 'r', 0)
# line: string
line = inFile.readline()
# wordlist: list of strings
wordlist = string.split(line)
print " ", len(wordlist), "words loaded."
return wordlist
def choose_word(wordlist):
"""
wordlist (list): list of words (strings)
Returns a word from wordlist at random
"""
return random.choice(wordlist)
# end of helper code
# -----------------------------------
words = load_words()
word = choose_word(words)
hangman = Hangman(word)
hangman.start()
