@Mosrod/

Hangman

Python

Advanced, configurable, hangman game created in Python

fork
loading
Files
  • main.py
  • englishwordslowercase.txt
  • hangmanpresets.txt

This Plugin Crashed!

Error: Error: must not create an existing file {"type":"CREATE_FILE","wid":"0.7500430394003206","path":"main.py","file":{"path":"main.py","content":{"asEncoding":{"base64":"# Created By Mosrod (Nathan R)
# (C) 2019 Nathan R, [ALL RIGHTS RESERVED]

# WIP SET/APPEND WORDLIST
# CONTAINS BROKEN

import random  # Imports random module for choosing a random word
import sys  # Imports sys module for loading
import os  # Imports os module for testing if a file exists

wordlistpath = 'englishwordslowercase.txt'

if os.path.isfile(wordlistpath):  # If wordlistpath is a file
    with open(wordlistpath, 'r') as f:  # Open text file that stores the words
        wordlist = [line.strip() for line in f]  # Add every line of the file to a list
else:
    print('Wordlist Not Found')  # Tell the user that the wordlist is not found


if not os.path.isfile('hangmanpresets.txt'):  # If hangmanpresets.txt is not a file
    with open('hangmanpresets.txt', 'w+') as f:  # Create hangmanpresets.txt
        pass

with open('hangmanpresets.txt', 'r') as f:  # Open text file with presets
    presets = [line.strip() for line in f]  # Add every line of the file to a list


print("""
COMMANDS:
1 : Exits the program
2 : Generates a new word
PRESET:
1 : Use a preset in hangmanpresets.txt
OPTIONS:
1 : Allow words to have periods
2 : Allow words to have numbers
3 : Allow words to have spaces
4 : Turn the vowel required to false
5 : Turn on notifications if a word in a wordlist fails a check
6 : Set the most repeating characters in a word
7 : Set the most total repeating characters in a word
8 : Set/append/turn off strings allowed in words
9 : Set the length
10 : Set the min length
11 : Set the max length
12 : Make the first letter of the word equal to the set letter
13 : Set the word list
14 : Make sure all words contain the letters specified
""")  # Informs the user about what the options do

# [a,d,g,h,i,j,k,m,q,u,z]

print("""
COMMANDS:
1 : Exit
2 : New
PRESETS:
1 : Use Preset (ON) [-o(name)]
OPTIONS:
1 : Periods (ON) [-p]
2 : Numbers (ON) [-n]
3 : Spaces (ON) [-s]
4 : Vowels Required (OFF) [-v]
5 : WordList Notifications (ON) [-y]
6 : Max Repeating Characters (SET) [-r(num)] {4}
7 : Max Total Repeating Characters (SET) [-t(num)] {10}
8 : Valid Strings (OFF/SET/APPEND) [-x(o)] [-x({s/a}[string,string)]
9 : Length (SET) [-l(num)] {0}
10 : Min Length (SET) [-b(num)] {3}
11 : Max Length (SET) [-e(num)] {15}
12 : First Letter (SET) [-f(letter)]
13 : Word List (SET) [-w([word,word])] [-w[#filename.txt])
14 : Contains (SET) [-c([letter,letter])]
""")  # Informs the user about the options


options = input('Options: ').lower()  # Takes options from the user

presetname = ''  # Sets presetname to an empty string
if options != '':  # If options is not empty
    presetname = input('Preset: ').lower()  # Set user input to the preset name

repeat = 4  # Sets repeat to 4
repeat_total = 10  # Sets repeat_total to 10
length = 0  # Sets length to 0
beginning = 3  # Sets beginning to 3
ending = 15  # Sets ending to 15

optionslist = options.split('-')  # Split options by '-'
optionslist = optionslist[1:]  # Remove the first value from optionslist

for i in range(0, len(optionslist)):  # Repeat for the length of optionslist
    optionslist[i] = '-' + optionslist[i]  # Add a - before every value in the list

presettrue = 1
for r in range(0, len(presets)):  # Repeat for the length of presets
    preset = presets[r]  # Set preset to the preset in line r
    vbar = preset.find('|')  # Find a pipe in preset
    namepreset = preset[:vbar]  # Split preset to before the bar and set namepreset to it

    if presetname == namepreset:  # If the presetname is namepreset
        print('Preset Name Already Exists')  # Tell the suer that the preset name already exists
        presettrue = 0  # Set presettrue to 0

if presetname != '' and presettrue == 1:  # If the presetname is not empty and presettrue is 1
    with open('hangmanpresets.txt', 'a') as f:  # Open the presets file as append mode
        f.write('{}|{}\n'.format(presetname, options))  # Write the preset name and code to a newline

optionlistlen = len(optionslist)  # Set optionlistlen to the length of optionslist
optionlistjoin = ''.join(optionslist)  # Join the list with no seperator

presetnamecheck = 0  # Set presetnamecheck to 0

while '-o' in optionlistjoin:  # While -o is in optionlistjoin
    optionlistjoin = ''.join(optionslist)  # Join the list with no seperator
    optionslist = optionlistjoin.split('-')  # Split the list with a - seperator
    optionslist = optionslist[1:]  # Remove the first string in the optionslist

    for i in range(0, len(optionslist)):  # For the length of optionslist
        option = optionslist[i]  # Set option to the ith value of optionslist
        if option[0] != '-':  # If the first character of option is not a dash
            optionslist[i] = '-' + optionslist[i]  # Add a dash before option

    for i in range(0, len(optionslist)):  # For the length of optionslist
        option = optionslist[i]  # Set option to the ith value of optionslist

        if '-o' in option:  # If -o is in option
            option = option[2:]  # Remove the first two characters

            for r in range(0, len(presets)):  # Repeat for the length of presets
                preset = presets[r]  # Set preset to the preset in line r
                vbar = preset.find('|')  # Find a pipe in preset
                namepreset = preset[:vbar]  # Split preset to before the bar and set namepreset to it

                if namepreset == option:  # If the chosen preset name matches the one found
                    optionpreset = preset[vbar + 1:]  # Split preset to after the bar and set optionpreset to it
                    optionsnew = optionpreset.split('-')  # Split optionpreset by a -
                    optionsnew = optionsnew[1:]  # Remove the first character from optionsnew
                    optionfind = '-o{}'.format(namepreset)  # Set optionfind to -o(preset name)
                    optionslist.pop(i)  # Remove -o from the list

                    for d in range(0, len(optionsnew)):  # For the length of optionsnew
                        optionnew = optionsnew[d]  # Set optionnew to the d part of optionsnew

                        if optionnew[0] != '-':  # If the first character of optionnew is not a dash
                            optionnew = '-' + optionnew  # Add a dash before optionnew

                        optionslist.insert(i+d, optionnew)  # Insert optionnew to the optionslist after the previous
                    presetnamecheck = 1  # Set presetnamecheck to 1

            if presetnamecheck == 0:  # If presetnamecheck is 0
                print('Preset not found')  # Tell the user that the preset has not been found
                optionslist = ''  # Set optionslist to an empty string

options = optionlistjoin  # Set options to optionlistjoin

containslist = ''  # Set containlist to an empty string

firstletter = ''  # Set firstletter to an empty string

validmode = ''    # Set validmode to an empty string

validslist = ''  # Set validslist to an empty string

if '-w' in options:
    wordlistall = []  # Set wordlistall to an empty list
else:
    wordlistall = wordlist  # Set wordlistall to wordlist


for i in range(0, len(optionslist)):
    if '-l' in optionslist[i]:  # If the value of optionslist has '-l' in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        beginning = number  # Set beginning to number
        ending = number  # Set ending to number

    elif '-b' in optionslist[i] and '-l' not in optionslist[i]:  # If the value of optionslist
        #  has '-' in it and does not contain '-l'
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        beginning = number  # Set beginning to number

    elif '-e' in optionslist[i] and '-l' not in optionslist[i]:  # If the value of optionslist
        #  has '-b' in it and does not contain '-l'
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        ending = number  # Set ending to number

    elif '-r' in optionslist[i]:  # If the value of optionslist has -r in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        repeat = number  # Set repeat to number

    elif '-t' in optionslist[i]:  # If the value of optionslist has -t in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2]  # Remove the first-second values from optionspick
        number = int(optionsnum)  # Set number to integer optionsnum
        repeat_total = number  # Set repeat_total to number

    elif '-x' in optionslist[i]:  # If the value of optionslist has -x in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        validmode = optionpick[2]  # Remove the first-second values from optionpick
        validlist = optionpick[4:-1]  # Slice the list of characters from optionpick
        validslist = validlist.split(',')  # Create a list from validlist

    elif '-f' in optionslist[i]:  # If the value of optionslist has -f in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        letter = optionsnum  # Set letter to integer optionsnum
        firstletter = letter  # Set repeat_total to letter

    elif '-w' in optionslist[i]:  # If the value of optionslist has -w in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        words = optionpick[3:-1]  # Remove the first-third and last value from optionpick

        if words[0] == '#':  # If the first character is a hashtag
            filename = words[1:]  # Remove the first character from words and set that to filename

            if os.path.isfile(filename):  # If the filename specified is a real file
                with open(filename, 'r') as f:  # Open text file that stores the words
                    wordlist = [line.strip() for line in f]  # Add every line of the file to a list

            else:  # If the filename specified is not a real file
                print('File Does Not Exist')  # Tell the user that the file does not exist

        else:  # If the first character is not a hashtag
            wordslist = words.split(',')  # Split words by ,
            wordlist = wordslist  # Set wordlist to wordslist

        for r in range(0, len(wordlist)):  # Repeat for the length of wordlist
            wordlistall.append(wordlist[r])  # Append the word to wordlistall

    elif '-c' in optionslist[i]:  # If the value of optionslist has -w in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        contain = optionpick[3:-1]  # Remove the first value from optionspick
        containlist = contain.split(',')  # Split contain by ,
        containslist = containlist  # Set containslist to containlist

wordlist = wordlistall  # Sets wordlist to wordlistall

optionslistjoin = ','.join(optionslist)  # Join optionslist by , and set it to optionslistjoin

lengthlist = []  # Creates a list for putting the words that are the same length as requested
customlist = []  # Creates a list for putting the words that fit between beginning and ending
truelist = []  # Creates a list for true words

wordlistadd = 0  # Set wordlistadd to 0
wordlistaddround = 0  # Set wordlistaddround to 0
wordlistcount = 0  # Set wordlistcount to 0

vowels = ['a', 'e', 'i', 'o', 'u', 'y']  # List of vowels to check in a word

valid_string = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                's', 't', 'u', 'v', 'w', 'x', 'y', 'z']  # List of valid string



if '-n' in options:  # If the user enabled numbers
    valid_string.append(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'])  # Allow numbers

if '-p' in options:  # If the user enabled periods
    valid_string.append('.')  # Allow periods

if '-s' in options:  # If the user enabled spaces
    valid_string.append(' ')  # Allow spaces

if '-x' in options:  # If the user configured valid strings
    if validmode == 'a':  # If the validmode is a
        valid_string = valid_string + validslist
    elif validmode == 's':
        valid_string = validslist
    else:
        print('Invalid Mode')


for i in range(0, len(wordlist)):  # Repeats this until at the end of wordlist
    testsfailed = []  # List of tests failed

    word = wordlist[i]  # Splits the wordlist to i, and assigns it to word
    word = word.lower()  # Makes the word lowercase

    if i > wordlistaddround-1 and 10-wordlistcount != 0:  # If i is greater than the value needed to
        # replace a - with a + and 10-the amount of = is not 0
        wordlistcount += 1  # Add 1 to wordlistcount
        plus = '+'*wordlistcount  # Times + by the amount of times the if statement ran
        minus = '-'*(10-wordlistcount)  # Times - by 10 minus the amount of plus's
        loading = plus + minus  # Combine both plus and minus strings
        sys.stdout.write("\r[{}]".format(loading))  # Notify the user of progress
        sys.stdout.flush()  # Flush the buffer
        wordlistadd += len(wordlist)/10  # Add the length of wordlist/10 to wordlistadd
        wordlistaddround = round(wordlistadd)  # Set wordlistaddround to wordlistadd rounded

    trueword = 0  # Set trueword to 0

    for r in range(0, len(vowels)):  # Loop for the length of the vowels list

        if vowels[r] in word and '-v' not in options:  # If the vowel is not in the word
            trueword = 1  # Set trueword to 1
            break  # Break out of the for loop

    if trueword == 0:  # If trueword is 0
        testsfailed.append('vowels')  # Append vowels to the testsfailed list

    if '-n' not in str(options):  # If numbers are off

        for r in range(len(word)):  # For the length of the word

            if word[r] in '1234567890':  # See if the string is a number
                trueword = 0  # Set trueword to 0
                testsfailed.append('numbers')  # Append numbers to the testsfailed list
                break  # Break out of the for loop

    if len(word) < beginning or len(word) > ending:  # If the word is less than beginning or greator than ending
        trueword = 0  # Set trueword to 0
        testsfailed.append('length')   # Append length to the testsfailed list

    if '-f' in options and word[0] != firstletter:  # If -f is in options and If the first character of the
        # word is not equal to firstletter
        trueword = 0  # Set trueword to 0
        testsfailed.append('firstletter')  # Append firstletter to the testsfailed list

    truecontains = 0  # Set truecontains to 0

    if '-c' in options:  # If the user configured contains

        for r in range(0, len(word)):  # For the length of word

            if word[r] in containslist:  # If word[r] is in containslist
                truecontains = 1  # Set truecontains to 1

        if truecontains == 0:  # If truecontains is 0
            trueword = 0  # Set trueword to 0
            testsfailed.append('configured')  # Append configured to the testsfailed list

    if validmode != 'o':  # If validmode is not o
        for r in range(0, len(word)):  # For the length of word
            if word[r] not in valid_string:  # If the character is not in the valid_string list
                trueword = 0  # Set trueword to 0
                testsfailed.append('valid string')  # Append valid string to the testsfailed list

    if trueword == 0:  # If trueword is 0
        if '-y' in optionslistjoin:  # If -y is in optionlistjoin
            print('')  # Print a newline
            print('NOTICE: {} has failed {} check(s)'.format(word, testsfailed))  # Tell the user that
            # the word has failed a check
        continue  # Skip the rest of the loop

    if '.' in word and '-p' not in str(options):  # If a dot is in the word and the periods option is turned off

        for r in range(0, word.count('.')):  # Repeat for the amount of periods in the word
            upper = word[0:word.find('.')]  # Split the word before the period
            lower = word[word.find('.') + 1:]  # Split the word after the period
            word = upper + lower  # Combine the upper and lower parts

    if ' ' in word and '-s' not in str(options):  # If a space is in the word and the space option is turned off
        for r in range(0, word.count(' ')):  # Repeat for the amount of spaces in the word
            upper = word[0:word.find(' ')]  # Split the word before the space
            lower = word[word.find(' ') + 1:]  # Split the word after the space
            word = upper + lower  # Combine the upper and lower parts

    wordchar = []  # Creates a list called wordchar

    for r in range(0, len(word)):  # Loop for the length of the word
        partlist = word[r]  # Splits word into letter

        if r+repeat > len(word):  # If the section it is cutting out involves characters
            # after the end of the word
            break  # Ends the loop

        reptest = word[r:r+repeat]  # Splits word from r to r + repeat
        replist = []  # Creates a list called replist

        for t in range(0, len(reptest)):  # Loop for the length of reptest
            replist.append(reptest[t])  # Split reptest into a character and then append it

        replistlen = len(replist)  # Set replistlen to the length of replist
        repset = set(replist)  # Creates a set from replist
        repsetlen = len(repset)  # Set repsetlen to the length of repset

        if (replistlen - repsetlen) + 1 >= repeat:  # If the difference between replistlen and repsetlen
            trueword = 0  # Sets trueword to 0
            testsfailed.append('repeat')  # Append repeat to the testsfailed list

        wordchar.append(word[r])  # Adds the character to the wordchar list

    lettersdone = []  # Creates a list called lettersdone

    for r in range(0, len(wordchar)):  # Loop for the length of wordchar

        if wordchar[r] not in lettersdone:  # If the character is not in lettersdone
            wordcharduplicate = wordchar.count(wordchar[r])  # Count how many of the characters are in the word
            lettersdone.append(wordchar[r])  # Append the character to lettersdone

            if wordcharduplicate >= repeat_total:  # If the character count is greator than repeat_total
                trueword = 0  # Set trueword to 0
                testsfailed.append('repeat total')  # Append repeat total to the testsfailed list

    if trueword == 0:  # If trueword is 0
        if '-y' in optionslistjoin:  # If -y is in optionlistjoin
            print('')  # Print a newline
            print('NOTICE: {} has failed {} check(s)'.format(word, testsfailed))  # Tell the user that
            # the word has failed a check

    if int(beginning) <= len(str(word)) <= int(ending) and trueword == 1:  # If the length of the word is between the
        # beginning and ending
        customlist.append(word)  # Append the word to customlist


sys.stdout.write("\rPROCESSING DATA COMPLETE")  # Notifies the user that the data processing is complete
sys.stdout.flush()  # Flush the buffer

chooselist = []  # Create a list for picking random words out of it

print('')  # Print a new line

if '-b' in options or '-e' in options or '-l' in options:  # If beginning, end, or length customized
    chooselist = customlist  # Set chooselist equal to customlist

else:  # If the length is 0 or less
    chooselist = customlist  # Set chooselist equal to customlist

if len(chooselist) == 0:  # If the list has no words
    print('No Words Avaliable')  # Tell the user that there is no words avaliable
    exit()  # Exit the program

run = 0  # Set run to 0

usednums = []  # Set usednums to an empty list

word_pic = ''  # Set word_pic to an empty string

wordrange = range(0, len(chooselist))  # Set wordrange to a range from 0 to the length of chooselist

wordrange = list(wordrange)  # Convert wordrange to a list


while run == 0:  # While run is 0

    if not wordrange:  # If wordrange is empty
        print('All Words Used')  # Tell the user that all words are used
        run = 1  # Set run to 1
        break  # Break out of the while loop

    word_ran = random.choice(wordrange)  # Picks a random number based on the file length

    wordrange.pop(wordrange.index(word_ran))  # Remove the number from the wordrange list

    word_pic = chooselist[word_ran]  # Slices the list to the random number, thus getting a random word

    guessed = 0  # Setting the variable, that ends the while loop when the word is guessed

    usedletters = []  # Creates a list to store letters that are used, so the tries don't go up

    word_pic_mod = '-' * (len(word_pic))  # Used to display guesses, and as a seperator

    word_pic_list = list(word_pic_mod)  # Converts every character of word_pic_mod to a list

    wordguessjoin = ''.join(word_pic_list)  # Used as a seperator between guesses

    if ' ' in word_pic and '-s' in options:  # If a space is in word_pic and spaces is turned on
        usedletters.append(' ')  # Append a space to usedletters
        for i in range(0, word_pic.count(' ')):  # Repeat for how many spaces in the word chosen
            emptyindex = word_pic.find(' ')  # Set emptyindex to the index of the first instance of a space found
            word_pic_list[emptyindex] = ' '  # Change the dash to a space in word_pic_list

    if '-s' in options:  # If -s is in options
        valid_string.pop(valid_string.index(' '))  # Remove space from the valid_string list

    tries = 0  # Set the amount of tries to 0

    wordprint = word_pic_list  # This variable shows what you guessed, and what is left every time you guess

    while guessed == 0:  # Code repeats until word is guessed

        print(wordguessjoin)  # Prints a seperator to organise each attempt
        letter = input('Letter: ').lower()  # Inputs the letter that you choose and makes it lowercase

        if letter == 'exit':  # If a user puts exit
            exit()  # Exit the program

        if letter == 'new':  # If a user puts new
            print(word_pic)  # Print the word
            guessed = 1  # Set guessed to 1
            break  # Break the program

        if letter not in valid_string and validmode != 'o':  # If the letter is not a valid string
            print('Please enter a valid string')  # Tell the user to input a valid string
            print(''.join(wordprint))  # Combines what you guess and what is left to guess, and prints it
            continue  # Skips the rest of the loop

        if letter in usedletters:  # If the letter is already used
            print('Letter Used')  # Sends a message that the letter is used
            print(''.join(wordprint))  # Combines what you guess and what is left to guess, and prints it
            continue  # Skips the rest of the loop

        elif letter not in word_pic and (letter in valid_string or validmode == 'o'):  # If the letter
            # is not in the word and the letter is not a valid string or validmode is o
            tries += 1  # Add 1 to the tries counter
            usedletters.append(letter)  # Adds the letter to the used letters list
            print('Try Again')  # Send a message to try again with a different letter
            print(''.join(wordprint))  # Combines what you guess and what is left to guess, and prints it

        elif letter in word_pic and letter != '':  # If letter is in wordpic and not blank
            tries += 1  # Add 1 to the tries counter
            wordcount = word_pic.count(letter)  # Find how many times the chosen letter is in the word
            print('{0} is in the word {1} times!'.format(letter, wordcount))  # Prints the letter
            # and number of times is in the word
            usedletters.append(letter)  # Adds the letter to the used letters list
            letterlocation = word_pic.find(letter)  # Find where the letter is in the word
            all_match = True  # Sets all_match to True, so the player matches all of the letters, he wins
            wordprint = []  # Clears the wordprint list

            for i in range(0, len(word_pic)):  # Repeats this for the length of the word

                if word_pic[i] in usedletters:  # If the split character is already guessed
                    print(word_pic[i], end='')  # Print the split character
                    wordprint.append(word_pic[i])  # Add the split character to wordprint, so it is shown
                    # in future guesses

                else:  # If the split character is not in used letters
                    all_match = False  # Set all_match to false
                    print('-', end='')  # Print a placeholder dash
                    wordprint.append('-')  # Add the split character to wordprint, so it is shown
                    # in future guesses

            print('')  # Prints a new line
            if all_match:  # If all of the characters match
                print('You won in {0} tries!'.format(tries))  # Tells the user that they won with the
                guessed = 1  # Sets guessed to 1

        if guessed == 1:  # If guessed is 1
            gme = 0  # Set gme to 0
            while gme == 0:  # While gme is 0
                newgame = input('New Game?[y/n]: ').lower()  # Ask the user if they want to play a new game
                if newgame in ['y', 'yes']:  # If they say y or yes
                    gme = 1  # Set gme to 1
                    run = 0  # Set run to 0
                elif newgame in ['n', 'no']:  # If they say n or no
                    gme = 1  # Set gme to 1
                    run = 1  # Set run to 0
                else:  # If the input is not y, yes, n, or no
                    print('Try Again')  # Tells the user to try again
                    gme = 0  # Set gme to 0"},"asBuffer":null},"loaded":true}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
# Created By Mosrod (Nathan R)
# (C) 2019 Nathan R, [ALL RIGHTS RESERVED]

# WIP SET/APPEND WORDLIST
# CONTAINS BROKEN

import random  # Imports random module for choosing a random word
import sys  # Imports sys module for loading
import os  # Imports os module for testing if a file exists

wordlistpath = 'englishwordslowercase.txt'

if os.path.isfile(wordlistpath):  # If wordlistpath is a file
    with open(wordlistpath, 'r') as f:  # Open text file that stores the words
        wordlist = [line.strip() for line in f]  # Add every line of the file to a list
else:
    print('Wordlist Not Found')  # Tell the user that the wordlist is not found


if not os.path.isfile('hangmanpresets.txt'):  # If hangmanpresets.txt is not a file
    with open('hangmanpresets.txt', 'w+') as f:  # Create hangmanpresets.txt
        pass

with open('hangmanpresets.txt', 'r') as f:  # Open text file with presets
    presets = [line.strip() for line in f]  # Add every line of the file to a list


print("""
COMMANDS:
1 : Exits the program
2 : Generates a new word
PRESET:
1 : Use a preset in hangmanpresets.txt
OPTIONS:
1 : Allow words to have periods
2 : Allow words to have numbers
3 : Allow words to have spaces
4 : Turn the vowel required to false
5 : Turn on notifications if a word in a wordlist fails a check
6 : Set the most repeating characters in a word
7 : Set the most total repeating characters in a word
8 : Set/append/turn off strings allowed in words
9 : Set the length
10 : Set the min length
11 : Set the max length
12 : Make the first letter of the word equal to the set letter
13 : Set the word list
14 : Make sure all words contain the letters specified
""")  # Informs the user about what the options do

# [a,d,g,h,i,j,k,m,q,u,z]

print("""
COMMANDS:
1 : Exit
2 : New
PRESETS:
1 : Use Preset (ON) [-o(name)]
OPTIONS:
1 : Periods (ON) [-p]
2 : Numbers (ON) [-n]
3 : Spaces (ON) [-s]
4 : Vowels Required (OFF) [-v]
5 : WordList Notifications (ON) [-y]
6 : Max Repeating Characters (SET) [-r(num)] {4}
7 : Max Total Repeating Characters (SET) [-t(num)] {10}
8 : Valid Strings (OFF/SET/APPEND) [-x(o)] [-x({s/a}[string,string)]
9 : Length (SET) [-l(num)] {0}
10 : Min Length (SET) [-b(num)] {3}
11 : Max Length (SET) [-e(num)] {15}
12 : First Letter (SET) [-f(letter)]
13 : Word List (SET) [-w([word,word])] [-w[#filename.txt])
14 : Contains (SET) [-c([letter,letter])]
""")  # Informs the user about the options


options = input('Options: ').lower()  # Takes options from the user

presetname = ''  # Sets presetname to an empty string
if options != '':  # If options is not empty
    presetname = input('Preset: ').lower()  # Set user input to the preset name

repeat = 4  # Sets repeat to 4
repeat_total = 10  # Sets repeat_total to 10
length = 0  # Sets length to 0
beginning = 3  # Sets beginning to 3
ending = 15  # Sets ending to 15

optionslist = options.split('-')  # Split options by '-'
optionslist = optionslist[1:]  # Remove the first value from optionslist

for i in range(0, len(optionslist)):  # Repeat for the length of optionslist
    optionslist[i] = '-' + optionslist[i]  # Add a - before every value in the list

presettrue = 1
for r in range(0, len(presets)):  # Repeat for the length of presets
    preset = presets[r]  # Set preset to the preset in line r
    vbar = preset.find('|')  # Find a pipe in preset
    namepreset = preset[:vbar]  # Split preset to before the bar and set namepreset to it

    if presetname == namepreset:  # If the presetname is namepreset
        print('Preset Name Already Exists')  # Tell the suer that the preset name already exists
        presettrue = 0  # Set presettrue to 0

if presetname != '' and presettrue == 1:  # If the presetname is not empty and presettrue is 1
    with open('hangmanpresets.txt', 'a') as f:  # Open the presets file as append mode
        f.write('{}|{}\n'.format(presetname, options))  # Write the preset name and code to a newline

optionlistlen = len(optionslist)  # Set optionlistlen to the length of optionslist
optionlistjoin = ''.join(optionslist)  # Join the list with no seperator

presetnamecheck = 0  # Set presetnamecheck to 0

while '-o' in optionlistjoin:  # While -o is in optionlistjoin
    optionlistjoin = ''.join(optionslist)  # Join the list with no seperator
    optionslist = optionlistjoin.split('-')  # Split the list with a - seperator
    optionslist = optionslist[1:]  # Remove the first string in the optionslist

    for i in range(0, len(optionslist)):  # For the length of optionslist
        option = optionslist[i]  # Set option to the ith value of optionslist
        if option[0] != '-':  # If the first character of option is not a dash
            optionslist[i] = '-' + optionslist[i]  # Add a dash before option

    for i in range(0, len(optionslist)):  # For the length of optionslist
        option = optionslist[i]  # Set option to the ith value of optionslist

        if '-o' in option:  # If -o is in option
            option = option[2:]  # Remove the first two characters

            for r in range(0, len(presets)):  # Repeat for the length of presets
                preset = presets[r]  # Set preset to the preset in line r
                vbar = preset.find('|')  # Find a pipe in preset
                namepreset = preset[:vbar]  # Split preset to before the bar and set namepreset to it

                if namepreset == option:  # If the chosen preset name matches the one found
                    optionpreset = preset[vbar + 1:]  # Split preset to after the bar and set optionpreset to it
                    optionsnew = optionpreset.split('-')  # Split optionpreset by a -
                    optionsnew = optionsnew[1:]  # Remove the first character from optionsnew
                    optionfind = '-o{}'.format(namepreset)  # Set optionfind to -o(preset name)
                    optionslist.pop(i)  # Remove -o from the list

                    for d in range(0, len(optionsnew)):  # For the length of optionsnew
                        optionnew = optionsnew[d]  # Set optionnew to the d part of optionsnew

                        if optionnew[0] != '-':  # If the first character of optionnew is not a dash
                            optionnew = '-' + optionnew  # Add a dash before optionnew

                        optionslist.insert(i+d, optionnew)  # Insert optionnew to the optionslist after the previous
                    presetnamecheck = 1  # Set presetnamecheck to 1

            if presetnamecheck == 0:  # If presetnamecheck is 0
                print('Preset not found')  # Tell the user that the preset has not been found
                optionslist = ''  # Set optionslist to an empty string

options = optionlistjoin  # Set options to optionlistjoin

containslist = ''  # Set containlist to an empty string

firstletter = ''  # Set firstletter to an empty string

validmode = ''    # Set validmode to an empty string

validslist = ''  # Set validslist to an empty string

if '-w' in options:
    wordlistall = []  # Set wordlistall to an empty list
else:
    wordlistall = wordlist  # Set wordlistall to wordlist


for i in range(0, len(optionslist)):
    if '-l' in optionslist[i]:  # If the value of optionslist has '-l' in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        beginning = number  # Set beginning to number
        ending = number  # Set ending to number

    elif '-b' in optionslist[i] and '-l' not in optionslist[i]:  # If the value of optionslist
        #  has '-' in it and does not contain '-l'
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        beginning = number  # Set beginning to number

    elif '-e' in optionslist[i] and '-l' not in optionslist[i]:  # If the value of optionslist
        #  has '-b' in it and does not contain '-l'
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        ending = number  # Set ending to number

    elif '-r' in optionslist[i]:  # If the value of optionslist has -r in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        number = int(optionsnum)  # Set number to integer optionsnum
        repeat = number  # Set repeat to number

    elif '-t' in optionslist[i]:  # If the value of optionslist has -t in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2]  # Remove the first-second values from optionspick
        number = int(optionsnum)  # Set number to integer optionsnum
        repeat_total = number  # Set repeat_total to number

    elif '-x' in optionslist[i]:  # If the value of optionslist has -x in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        validmode = optionpick[2]  # Remove the first-second values from optionpick
        validlist = optionpick[4:-1]  # Slice the list of characters from optionpick
        validslist = validlist.split(',')  # Create a list from validlist

    elif '-f' in optionslist[i]:  # If the value of optionslist has -f in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        optionsnum = optionpick[2:]  # Remove the first-second values from optionpick
        letter = optionsnum  # Set letter to integer optionsnum
        firstletter = letter  # Set repeat_total to letter

    elif '-w' in optionslist[i]:  # If the value of optionslist has -w in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        words = optionpick[3:-1]  # Remove the first-third and last value from optionpick

        if words[0] == '#':  # If the first character is a hashtag
            filename = words[1:]  # Remove the first character from words and set that to filename

            if os.path.isfile(filename):  # If the filename specified is a real file
                with open(filename, 'r') as f:  # Open text file that stores the words
                    wordlist = [line.strip() for line in f]  # Add every line of the file to a list

            else:  # If the filename specified is not a real file
                print('File Does Not Exist')  # Tell the user that the file does not exist

        else:  # If the first character is not a hashtag
            wordslist = words.split(',')  # Split words by ,
            wordlist = wordslist  # Set wordlist to wordslist

        for r in range(0, len(wordlist)):  # Repeat for the length of wordlist
            wordlistall.append(wordlist[r])  # Append the word to wordlistall

    elif '-c' in optionslist[i]:  # If the value of optionslist has -w in it
        optionpick = optionslist[i]  # Set optionpick to the value of optionslist
        contain = optionpick[3:-1]  # Remove the first value from optionspick
        containlist = contain.split(',')  # Split contain by ,
        containslist = containlist  # Set containslist to containlist

wordlist = wordlistall  # Sets wordlist to wordlistall

optionslistjoin = ','.join(optionslist)  # Join optionslist by , and set it to optionslistjoin

lengthlist = []  # Creates a list for putting the words that are the same length as requested
customlist = []  # Creates a list for putting the words that fit between beginning and ending
truelist = []  # Creates a list for true words

wordlistadd = 0  # Set wordlistadd to 0
wordlistaddround = 0  # Set wordlistaddround to 0
wordlistcount = 0  # Set wordlistcount to 0

vowels = ['a', 'e', 'i', 'o', 'u', 'y']  # List of vowels to check in a word

valid_string = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                's', 't', 'u', 'v', 'w', 'x', 'y', 'z']  # List of valid string



if '-n' in options:  # If the user enabled numbers
    valid_string.append(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'])  # Allow numbers

if '-p' in options:  # If the user enabled periods
    valid_string.append('.')  # Allow periods

if '-s' in options:  # If the user enabled spaces
    valid_string.append(' ')  # Allow spaces

if '-x' in options:  # If the user configured valid strings
    if validmode == 'a':  # If the validmode is a
        valid_string = valid_string + validslist
    elif validmode == 's':
        valid_string = validslist
    else:
        print('Invalid Mode')


for i in range(0, len(wordlist)):  # Repeats this until at the end of wordlist
    testsfailed = []  # List of tests failed

    word = wordlist[i]  # Splits the wordlist to i, and assigns it to word
    word = word.lower()  # Makes the word lowercase

    if i > wordlistaddround-1 and 10-wordlistcount != 0:  # If i is greater than the value needed to
        # replace a - with a + and 10-the amount of = is not 0
        wordlistcount += 1  # Add 1 to wordlistcount
        plus = '+'*wordlistcount  # Times + by the amount of times the if statement ran
        minus = '-'*(10-wordlistcount)  # Times - by 10 minus the amount of plus's
        loading = plus + minus  # Combine both plus and minus strings
        sys.stdout.write("\r[{}]".format(loading))  # Notify the user of progress
        sys.stdout.flush()  # Flush the buffer
        wordlistadd += len(wordlist)/10  # Add the length of wordlist/10 to wordlistadd
        wordlistaddround = round(wordlistadd)  # Set wordlistaddround to wordlistadd rounded

    trueword = 0  # Set trueword to 0

    for r in range(0, len(vowels)):  # Loop for the length of the vowels list

        if vowels[r] in word and '-v' not in options:  # If the vowel is not in the word
            trueword = 1  # Set trueword to 1
            break  # Break out of the for loop

    if trueword == 0:  # If trueword is 0
        testsfailed.append('vowels')  # Append vowels to the testsfailed list

    if '-n' not in str(options):  # If numbers are off

        for r in range(len(word)):  # For the length of the word

            if word[r] in '1234567890':  # See if the string is a number
                trueword = 0  # Set trueword to 0
                testsfailed.append('numbers')  # Append numbers to the testsfailed list
                break  # Break out of the for loop

    if len(word) < beginning or len(word) > ending:  # If the word is less than beginning or greator than ending
        trueword = 0  # Set trueword to 0
        testsfailed.append('length')   # Append length to the testsfailed list

    if '-f' in options and word[0] != firstletter:  # If -f is in options and If the first character of the
        # word is not equal to firstletter
        trueword = 0  # Set trueword to 0
        testsfailed.append('firstletter')  # Append firstletter to the testsfailed list

    truecontains = 0  # Set truecontains to 0

    if '-c' in options:  # If the user configured contains

        for r in range(0, len(word)):  # For the length of word

            if word[r] in containslist:  # If word[r] is in containslist
                truecontains = 1  # Set truecontains to 1

        if truecontains == 0:  # If truecontains is 0
            trueword = 0  # Set trueword to 0
            testsfailed.append('configured')  # Append configured to the testsfailed list

    if validmode != 'o':  # If validmode is not o
        for r in range(0, len(word)):  # For the length of word
            if word[r] not in valid_string:  # If the character is not in the valid_string list
                trueword = 0  # Set trueword to 0
                testsfailed.append('valid string')  # Append valid string to the testsfailed list

    if trueword == 0:  # If trueword is 0
        if '-y' in optionslistjoin:  # If -y is in optionlistjoin
            print('')  # Print a newline
            print('NOTICE: {} has failed {} check(s)'.format(word, testsfailed))  # Tell the user that
            # the word has failed a check
        continue  # Skip the rest of the loop

    if '.' in word and '-p' not in str(options):  # If a dot is in the word and the periods option is turned off

        for r in range(0, word.count('.')):  # Repeat for the amount of periods in the word
            upper = word[0:word.find('.')]  # Split the word before the period
            lower = word[word.find('.') + 1:]  # Split the word after the period
            word = upper + lower  # Combine the upper and lower parts

    if ' ' in word and '-s' not in str(options):  # If a space is in the word and the space option is turned off
        for r in range(0, word.count(' ')):  # Repeat for the amount of spaces in the word
            upper = word[0:word.find(' ')]  # Split the word before the space
            lower = word[word.find(' ') + 1:]  # Split the word after the space
            word = upper + lower  # Combine the upper and lower parts

    wordchar = []  # Creates a list called wordchar

    for r in range(0, len(word)):  # Loop for the length of the word
        partlist = word[r]  # Splits word into letter

        if r+repeat > len(word):  # If the section it is cutting out involves characters
            # after the end of the word
            break  # Ends the loop

        reptest = word[r:r+repeat]  # Splits word from r to r + repeat
        replist = []  # Creates a list called replist

        for t in range(0, len(reptest)):  # Loop for the length of reptest
            replist.append(reptest[t])  # Split reptest into a character and then append it

        replistlen = len(replist)  # Set replistlen to the length of replist
        repset = set(replist)  # Creates a set from replist
        repsetlen = len(repset)  # Set repsetlen to the length of repset

        if (replistlen - repsetlen) + 1 >= repeat:  # If the difference between replistlen and repsetlen
            trueword = 0  # Sets trueword to 0
            testsfailed.append('repeat')  # Append repeat to the testsfailed list

        wordchar.append(word[r])  # Adds the character to the wordchar list

    lettersdone = []  # Creates a list called lettersdone

    for r in range(0, len(wordchar)):  # Loop for the length of wordchar

        if wordchar[r] not in lettersdone:  # If the character is not in lettersdone
            wordcharduplicate = wordchar.count(wordchar[r])  # Count how many of the characters are in the word
            lettersdone.append(wordchar[r])  # Append the character to lettersdone

            if wordcharduplicate >= repeat_total:  # If the character count is greator than repeat_total
                trueword = 0  # Set trueword to 0
                testsfailed.append('repeat total')  # Append repeat total to the testsfailed list

    if trueword == 0:  # If trueword is 0
        if '-y' in optionslistjoin:  # If -y is in optionlistjoin
            print('')  # Print a newline
            print('NOTICE: {} has failed {} check(s)'.format(word, testsfailed))  # Tell the user that
            # the word has failed a check

    if int(beginning) <= len(str(word)) <= int(ending) and trueword == 1:  # If the length of the word is between the
        # beginning and ending
        customlist.append(word)  # Append the word to customlist


sys.stdout.write("\rPROCESSING DATA COMPLETE")  # Notifies the user that the data processing is complete
sys.stdout.flush()  # Flush the buffer

chooselist = []  # Create a list for picking random words out of it

print('')  # Print a new line

if '-b' in options or '-e' in options or '-l' in options:  # If beginning, end, or length customized
    chooselist = customlist  # Set chooselist equal to customlist

else:  # If the length is 0 or less
    chooselist = customlist  # Set chooselist equal to customlist

if len(chooselist) == 0:  # If the list has no words
    print('No Words Avaliable')  # Tell the user that there is no words avaliable
    exit()  # Exit the program

run = 0  # Set run to 0

usednums = []  # Set usednums to an empty list

word_pic = ''  # Set word_pic to an empty string

wordrange = range(0, len(chooselist))  # Set wordrange to a range from 0 to the length of chooselist

wordrange = list(wordrange)  # Convert wordrange to a list


while run == 0:  # While run is 0

    if not wordrange:  # If wordrange is empty
        print('All Words Used')  # Tell the user that all words are used
        run = 1  # Set run to 1
        break  # Break out of the while loop

    word_ran = random.choice(wordrange)  # Picks a random number based on the file length

    wordrange.pop(wordrange.index(word_ran))  # Remove the number from the wordrange list

    word_pic = chooselist[word_ran]  # Slices the list to the random number, thus getting a random word

    guessed = 0  # Setting the variable, that ends the while loop when the word is guessed

    usedletters = []  # Creates a list to store letters that are used, so the tries don't go up

    word_pic_mod = '-' * (len(word_pic))  # Used to display guesses, and as a seperator

    word_pic_list = list(word_pic_mod)  # Converts every character of word_pic_mod to a list

    wordguessjoin = ''.join(word_pic_list)  # Used as a seperator between guesses

    if ' ' in word_pic and '-s' in options:  # If a space is in word_pic and spaces is turned on
        usedletters.append(' ')  # Append a space to usedletters
        for i in range(0, word_pic.count(' ')):  # Repeat for how many spaces in the word chosen
            emptyindex = word_pic.find(' ')  # Set emptyindex to the index of the first instance of a space found
            word_pic_list[emptyindex] = ' '  # Change the dash to a space in word_pic_list

    if '-s' in options:  # If -s is in options
        valid_string.pop(valid_string.index(' '))  # Remove space from the valid_string list

    tries = 0  # Set the amount of tries to 0

    wordprint = word_pic_list  # This variable shows what you guessed, and what is left every time you guess

    while guessed == 0:  # Code repeats until word is guessed

        print(wordguessjoin)  # Prints a seperator to organise each attempt
        letter = input('Letter: ').lower()  # Inputs the letter that you choose and makes it lowercase

        if letter == 'exit':  # If a user puts exit
            exit()  # Exit the program

        if letter == 'new':  # If a user puts new
            print(word_pic)  # Print the word
            guessed = 1  # Set guessed to 1
            break  # Break the program

        if letter not in valid_string and validmode != 'o':  # If the letter is not a valid string
            print('Please enter a valid string')  # Tell the user to input a valid string
            print(''.join(wordprint))  # Combines what you guess and what is left to guess, and prints it
            continue  # Skips the rest of the loop

        if letter in usedletters:  # If the letter is already used
            print('Letter Used')  # Sends a message that the letter is used
            print(''.join(wordprint))  # Combines what you guess and what is left to guess, and prints it
            continue  # Skips the rest of the loop

        elif letter not in word_pic and (letter in valid_string or validmode == 'o'):  # If the letter
            # is not in the word and the letter is not a valid string or validmode is o
            tries += 1  # Add 1 to the tries counter
            usedletters.append(letter)  # Adds the letter to the used letters list
            print('Try Again')  # Send a message to try again with a different letter
            print(''.join(wordprint))  # Combines what you guess and what is left to guess, and prints it

        elif letter in word_pic and letter != '':  # If letter is in wordpic and not blank
            tries += 1  # Add 1 to the tries counter
            wordcount = word_pic.count(letter)  # Find how many times the chosen letter is in the word
            print('{0} is in the word {1} times!'.format(letter, wordcount))  # Prints the letter
            # and number of times is in the word
            usedletters.append(letter)  # Adds the letter to the used letters list
            letterlocation = word_pic.find(letter)  # Find where the letter is in the word
            all_match = True  # Sets all_match to True, so the player matches all of the letters, he wins
            wordprint = []  # Clears the wordprint list

            for i in range(0, len(word_pic)):  # Repeats this for the length of the word

                if word_pic[i] in usedletters:  # If the split character is already guessed
                    print(word_pic[i], end='')  # Print the split character
                    wordprint.append(word_pic[i])  # Add the split character to wordprint, so it is shown
                    # in future guesses

                else:  # If the split character is not in used letters
                    all_match = False  # Set all_match to false
                    print('-', end='')  # Print a placeholder dash
                    wordprint.append('-')  # Add the split character to wordprint, so it is shown
                    # in future guesses

            print('')  # Prints a new line
            if all_match:  # If all of the characters match
                print('You won in {0} tries!'.format(tries))  # Tells the user that they won with the
                guessed = 1  # Sets guessed to 1

        if guessed == 1:  # If guessed is 1
            gme = 0  # Set gme to 0
            while gme == 0:  # While gme is 0
                newgame = input('New Game?[y/n]: ').lower()  # Ask the user if they want to play a new game
                if newgame in ['y', 'yes']:  # If they say y or yes
                    gme = 1  # Set gme to 1
                    run = 0  # Set run to 0
                elif newgame in ['n', 'no']:  # If they say n or no
                    gme = 1  # Set gme to 1
                    run = 1  # Set run to 0
                else:  # If the input is not y, yes, n, or no
                    print('Try Again')  # Tells the user to try again
                    gme = 0  # Set gme to 0