Advertisement
Guest User

Untitled

a guest
Nov 24th, 2014
207
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 5.43 KB | None | 0 0
  1.  
  2. def get_secret_word():
  3.     '''
  4.    This function gets a valid secret word from the user and returns it.
  5.    The word is valid if it does not contain question marks and whitespace.
  6.    '''
  7.     while True:
  8.         try:
  9.             secret_word = input(('Please enter a word to be guessed\n'
  10.             'that does not contain ? or white space: ')).lower()
  11.         except:
  12.             pass
  13.         if any([i == '?' or i == ' ' or i == '\t' or i == '\n' for i in secret_word]):
  14.             continue
  15.         break
  16.     print('\n'*30)
  17.     return secret_word
  18. #end get_secret_word
  19.  
  20. def is_game_over(display_guesses, num_of_incorrect_guesses, turns, guesses, secret_word, hidden_str):
  21.     '''
  22.    @returns: True if the game is over
  23.    and false otherwise
  24.    '''
  25.     if correct_guess(hidden_str, secret_word):
  26.         return True
  27.     elif max_guesses_reached(num_of_incorrect_guesses, secret_word):
  28.         return True
  29.     else:
  30.         return False
  31.        
  32. #end is_game_over
  33.  
  34. def correct_guess(hidden_str, secret_word):
  35.     hidden_word = list(hidden_str)
  36.     for i, letter in enumerate(hidden_word):
  37.         if letter is not '?':
  38.             print('You correctly guessed the secret word:', secret_word)
  39.             return True
  40.         else:
  41.             return False
  42. #end correct_guess
  43.  
  44. def max_guesses_reached(num_of_incorrect_guesses, secret_word):
  45.     if int(num_of_incorrect_guesses) == 7:
  46.         print('You failed to guess the secret word:', secret_word)
  47.         return True
  48.     else:
  49.         return False
  50. #end max_guesses_reached
  51.    
  52. def display_hangman(num_of_incorrect_guesses):
  53.     '''
  54.    displays the current figure of hangman
  55.    first wrong guess corresponds to the rope
  56.    @returns: body part
  57.    '''
  58.     num_of_incorrect_guesses = int(num_of_incorrect_guesses)
  59.     if num_of_incorrect_guesses == 0:
  60.         print('\n')
  61.     if num_of_incorrect_guesses >= 1:
  62.         print(' | ', end = '\n')
  63.     if num_of_incorrect_guesses >= 2:
  64.         print(' 0 ', end = '\n')
  65.     if num_of_incorrect_guesses >= 3:
  66.         print('/',end = '')
  67.     if num_of_incorrect_guesses >= 4:
  68.         print('|', end = '')
  69.     if num_of_incorrect_guesses >= 5:
  70.         print('\\', end = '\n')
  71.     if num_of_incorrect_guesses >= 6:
  72.         print('/',end = ' ')
  73.     if num_of_incorrect_guesses >= 7:
  74.         print('\\', end = '\n')
  75.     else:
  76.         pass
  77. #end display_hangman
  78.  
  79. def display_guesses(guesses):
  80.     '''
  81.    displays the guesses the user has made in alphabetical order
  82.    @returns: guessed letters
  83.    '''
  84.     sorted_guesses = sorted(guesses)
  85.     print('So far you have guessed:', ', '.join(sorted_guesses))
  86.    
  87. #end display_guesses
  88.  
  89. def check_guess(guesses, secret_word, hidden_str, num_of_incorrect_guesses):
  90.     '''
  91.    checks whether a guess is right or wrong
  92.    returns True when right
  93.    false otherwise
  94.    '''
  95.     hidden_word = list(secret_word)
  96.     while 0 <= int(num_of_incorrect_guesses) <= 7:
  97.         for i, letter in enumerate(hidden_word):
  98.             if letter in guesses:
  99.                 return True
  100.             if letter not in guesses:
  101.                 return False
  102.                
  103. #end check_guess
  104.  
  105. def hidden_word(check_guess, secret_word, guesses):
  106.     '''
  107.    displays the word with letters and/or ?'s as needed
  108.    '''
  109.     hidden_word = list(secret_word)
  110.     if check_guess is True:
  111.         for i, letter in enumerate(hidden_word):
  112.             if letter in guesses:
  113.                 hidden_word[i] = secret_word[i]
  114.                 hidden_str = ''.join(hidden_word)              
  115.     else:
  116.         for i, letter in enumerate(hidden_word):
  117.             if letter not in guesses:
  118.                 hidden_word[i] = '?'
  119.                 hidden_str = ''.join(hidden_word)
  120.     print('\n'+hidden_str)
  121. #end hidden_word
  122.  
  123. def num_of_wrong_guesses(check_guess, num_of_incorrect_guesses):
  124.     '''
  125.    counts the number of wrong guesses
  126.    '''
  127.     if check_guess is False:
  128.         return num_of_incorrect_guesses + 1
  129.        
  130. #end num_of_wrong_guesses
  131.  
  132. def get_guess(secret_word, guesses, turns):
  133.     '''
  134.    get a valid guess from the user
  135.    '''
  136.     while True:
  137.         try:
  138.             guess = input('Please enter your next guess: ').lower().strip()
  139.         except:
  140.             pass
  141.         if any([i == '?' for i in secret_word]):
  142.             print('You must enter a guess.')
  143.             continue
  144.         if guess in guesses:
  145.             print('You already guessed the character:', guess)
  146.             continue
  147.         if len(guess) > 1:
  148.             print('You can only guess a single character.')
  149.             continue
  150.         else:
  151.             guesses = guesses.append(guess)
  152.             break
  153.     return guesses
  154. #end get_guess
  155.  
  156. def main():
  157.     guesses = []
  158.     turns = 1
  159.     num_of_incorrect_guesses = 0
  160.     secret_word = get_secret_word()
  161.     hidden_str = []
  162.     while not is_game_over(display_guesses, num_of_incorrect_guesses, turns, guesses, secret_word, hidden_str):
  163.         check_guess(guesses, secret_word, hidden_str, num_of_incorrect_guesses)
  164.         num_of_wrong_guesses(check_guess, num_of_incorrect_guesses)
  165.         display_hangman(num_of_incorrect_guesses)
  166.         hidden_word(check_guess, secret_word, guesses)
  167.         display_guesses(guesses)
  168.         print(num_of_incorrect_guesses)
  169.         get_guess(secret_word, guesses, turns)
  170.         turns += 1
  171.        
  172. #end main
  173.  
  174. if __name__ == '__main__': #if this is the main program run
  175.   main() #run the main function
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement