Question

can this code be provided?

Project #3

Introduction

As you wrap up with JavaScript, let's put together everything you've learned to make the classic game "Hangman" in a webpage.

If you are unfamiliar with the rules of Hangman, the game works like this:

A gallows is drawn on a surface, and Player 1 chooses a word that player 2 must guess.

Empty dashes for each letter in the word are drawn next to the gallows (so a 7-letter word means 7 dashes)

Each round, player 2 guesses a letter that might belong in the word

If the word contains one or more instances of the guessed letter, the dashes corresponding to the guessed letter are replaced with the guessed letter

If the word contains no instances of the guessed letter, a limb of a person is drawn on the gallows. This is a "strike", and the letter is recorded as such

When a complete stick-figure person is drawn on the gallows, player 2 loses and player 1 wins. If the word is guessed completely before that happens, player 2 wins.

The number of strikes allowed is typically 6, for each body part of the hanged man (1 head, 1 body, 2 arms, 2 legs)

Instructions

Instructor Note: you are stongly encouraged to work with your fellow students on this project. Don't be afraid to ask questions, and don't hesitate to give an answer if you know it!

Download the template for the project, Hangman.zip and extract it.

First, create an HTML page, "hangman.html" as follows:

The page should be divided into four sections:

A gallows section that will display a picture of the gallows and hanged man in stages

A strikes section that will display incorrect guesses

A word section that will show the word to guess as it is slowly revealed

A guess section that will contain a form where the player can type in their guess each round.

Note that the template comes with 7 images you can use for the gallows section, corresponding to the number of Strikes accrued

Make sure the elements in hangman.html have IDs that will make them easier to select with CSS and JavaScript later - this game will be driven by event management and DOM manipulation.

The logic for this game will be fairly complex compared to everything you've done so far, but all of it should be familiar.

The first thing you'll need to do in your JavaScript is create some variables that will track the game's state (and we can grab the word to guess at the same time!).

let word = prompt("Welcome to Hangman! Player 1, please enter a word for Player 2 to guess.").toUpperCase();

// note the switch toUpperCase(), we want to always work in upper case letters to avoid confusing 'a' and 'A' as unequal.

let revealedLetters = new Array(word.length); // creates an array with as many elements as word has characters. Each index of revealedLetters will correspond to a character in word, and if revealedLetters[n] is truthy, then word[n] has been correctly guessed.

revlealedLetters.fill(false);

const maxStrikes = 6;

let strikes = 0; // the number of incorrect guesses made so far

let strikeLetters = new Array(maxStrikes); // this will contain every letter that has been incorrectly guessed.

Now, it may seem like you're skipping ahead here, but it will be easiest to do this step now. Create the following functions:

drawWordProgress(); // run this now, to draw the empty word at the start of the game.

// Manipulates the DOM to write all the strike letters to the appropriate section in hangman.html

function drawStrikeLetters() {

// your DOM manipulation code here

// should create a String from strikeLetters and put that into the content of some element.

}

// Manipulates the DOM to write the successfully guessed letters of the word, replacing them with dashes if not yet guessed

function drawWordProgress() {

// your DOM manipulation code here

// should iterate over revealedLetters, and if the value at each index is truthy, print the corresponding letter from word. Otherwise, it should print a -.

}

// Manipulates the DOM to update the image of the gallows for the current game state.

function drawGallows() {

// your DOM manipulation code here

// should update an <img> element in the appropriate hangman.html section to point to "images/strike-"+strikes+".png"

}

Next you'll need to attach an event listener to the <form> element in hangman.html. When the form is submitted, you'll need to invoke a function named "processGuess()":

function processGuess() {

let guess = // the value of the <form>'s <input> element, toUpperCase()!

if (strikes < maxStrikes) {

// game logic goes here

} else

alert("The game is over!");

}

Now what should this game logic be?

First, you'll want to check to see if the word includes() the guessed letter.

If it does...

You'll need to loop over word. If the letter at a given index in word matches the guess, set the corresponding index of revealedLetters to a truthy value.

Then you'll need to invoke drawWordProgress() to show the updated word

If it doesn't...

Increment the number of strikes

Add the guessed letter to strikeLetters.

invoke drawGallows() and drawStrikeLetters()

Now you need to check if player 2 won. To do that, iterate over revealedLetters. If none of the values are false, player 2 wins!

These instructions are obviously not comprehensive, and you will of course have to fill in the gaps on your own (or with your peers). One of the things that makes programming fun and addictive is that you can always make improvements somewhere!

Answer 1

# Problem Set 2, hangman.py

# Name:

# Collaborators:

# Time spent:

# Hangman Game

# -----------------------------------

# Helper code

# You don't need to understand this helper code,

# but you will have to know how to use the functions

# (so be sure to read the docstrings!)

import random

import string

WORDLIST_FILENAME = "words.txt"

def load_words():

    """

    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')

    # line: string

    line = inFile.readline()

    # wordlist: list of strings

    wordlist = line.split()

    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

# -----------------------------------

# Load the list of words into the variable wordlist

# so that it can be accessed from anywhere in the program

wordlist = load_words()

def is_word_guessed(secret_word, letters_guessed):

    '''

    secret_word: string, the word the user is guessing; assumes all letters are

      lowercase

    letters_guessed: list (of letters), which letters have been guessed so far;

      assumes that all letters are lowercase

    returns: boolean, True if all the letters of secret_word are in letters_guessed;

      False otherwise

    '''

    for i in secret_word:

        if i not in letters_guessed:

            return False

        else:

            return True

def get_guessed_word(secret_word, letters_guessed):

    '''

    secret_word: string, the word the user is guessing

    letters_guessed: list (of letters), which letters have been guessed so far

    returns: string, comprised of letters, underscores (_), and spaces that represents

      which letters in secret_word have been guessed so far.

    '''

    hangman_text = ""

    for wub in secret_word:

        if wub in letters_guessed:

            hangman_text += wub

        else:

            hangman_text += "_ "

    return hangman_text

    

def get_available_letters(letters_guessed):

    '''

    letters_guessed: list (of letters), which letters have been guessed so far

    returns: string (of letters), comprised of letters that represents which letters have not

      yet been guessed.

    '''

    alphabits = "abcdefghijklmnopqrstuvwxyz"

    unguessed = ""

    for i in alphabits:

        if i not in letters_guessed:

            unguessed += i

        else:

            continue

    print (unguessed)

    return unguessed

        

    

    

    

def hangman(secret_word):

    '''

    secret_word: string, the secret word to guess.

    

    Starts up an interactive game of Hangman.

    

    * At the start of the game, let the user know how many

      letters the secret_word contains and how many guesses s/he starts with.

      

    * The user should start with 6 guesses

    * Before each round, you should display to the user how many guesses

      s/he has left and the letters that the user has not yet guessed.

    

    * Ask the user to supply one guess per round. Remember to make

      sure that the user puts in a letter!

    

    * The user should receive feedback immediately after each guess

      about whether their guess appears in the computer's word.

    * After each guess, you should display to the user the

      partially guessed word so far.

    

    Follows the other limitations detailed in the problem write-up.

    '''

    letters_guessed = []

    alphabits = "abcdefghijklmnopqrstuvwxyz"

    vowel = "aeiou"

    warnings = 3

    guesses_left = 6

    print ("You have ", guesses_left, " guesses_left")

    print ("I am thinking of a word that is ", len(secret_word), " letters long.")

    while is_word_guessed(secret_word, letters_guessed) == False:

        print ("You have ", guesses_left, " guesses_left")

        get_available_letters(letters_guessed)

        guess = str(input("Guess a letter. "))

        if guess not in alphabits:

            warnings -= 1

            print ("Your guess should be a letter and lowercase. You have lost a warning.")

        letters_guessed = letters_guessed.append(guess)

        if guess in secret_word:

            print ("Good guess")

            print (get_guessed_word(secret_word, letters_guessed))

            return get_guessed_word(secret_word, letters_guessed)

        if guess in letters_guessed:

            print ("You already guessed that, silly buns. You lose 1 warning.")

            warnings -=1

        else:

            print ("That letter is not in the word. You lose 1 turn.")

            guesses_left -= 1

            if guess in vowel:

                print ("...and another")

                guesses_left -=1

        if warnings == 0:

            print ("You have lost a turn due to non compliance. ")

            guesses_left -= 1

            warnings = 3

        if guesses_left == 0:

            print ("Game Over ")

            print (secret_word)

            exit

        print ("-----------")

        

        

    

# When you've completed your hangman function, scroll down to the bottom

# of the file and uncomment the first two lines to test

#(hint: you might want to pick your own

# secret_word while you're doing your own testing)

# -----------------------------------

def match_with_gaps(my_word, other_word):

    '''

    my_word: string with _ characters, current guess of secret word

    other_word: string, regular English word

    returns: boolean, True if all the actual letters of my_word match the

        corresponding letters of other_word, or the letter is the special symbol

        _ , and my_word and other_word are of the same length;

        False otherwise:

    '''

    # FILL IN YOUR CODE HERE AND DELETE "pass"

    pass

def show_possible_matches(my_word):

    '''

    my_word: string with _ characters, current guess of secret word

    returns: nothing, but should print out every word in wordlist that matches my_word

             Keep in mind that in hangman when a letter is guessed, all the positions

             at which that letter occurs in the secret word are revealed.

             Therefore, the hidden letter(_ ) cannot be one of the letters in the word

             that has already been revealed.

    '''

    # FILL IN YOUR CODE HERE AND DELETE "pass"

    pass

def hangman_with_hints(secret_word):

    '''

    secret_word: string, the secret word to guess.

    

    Starts up an interactive game of Hangman.

    

    * At the start of the game, let the user know how many

      letters the secret_word contains and how many guesses s/he starts with.

      

    * The user should start with 6 guesses

    

    * Before each round, you should display to the user how many guesses

      s/he has left and the letters that the user has not yet guessed.

    

    * Ask the user to supply one guess per round. Make sure to check that the user guesses a letter

      

    * The user should receive feedback immediately after each guess

      about whether their guess appears in the computer's word.

    * After each guess, you should display to the user the

      partially guessed word so far.

      

    * If the guess is the symbol *, print out all words in wordlist that

      matches the current guessed word.

    

    Follows the other limitations detailed in the problem write-up.

    '''

    # FILL IN YOUR CODE HERE AND DELETE "pass"

    pass

# When you've completed your hangman_with_hint function, comment the two similar

# lines above that were used to run the hangman function, and then uncomment

# these two lines and run this file to test!

# Hint: You might want to pick your own secret_word while you're testing.

if __name__ == "__main__":

    #pass

    # To test part 2, comment out the pass line above and

    # uncomment the following two lines.

    

    secret_word = choose_word(wordlist)

    hangman(secret_word)

###############

    

    # To test part 3 re-comment out the above lines and

    # uncomment the following two lines.

    

    #secret_word = choose_word(wordlist)

    #hangman_with_hints(secret_word)