ಪ್ರಾಜೆಕ್ಟ್ 17: ಹ್ಯಾಂಗ್‌ಮನ್ ಆಟ (Hangman Game)

ಈ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಕ್ಲಾಸಿಕ್ "ಹ್ಯಾಂಗ್‌ಮನ್" ಆಟದ ಕಮಾಂಡ್-ಲೈನ್ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ. ಕಂಪ್ಯೂಟರ್ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಒಂದು ಪದವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಆಟಗಾರನು ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಪ್ರಯತ್ನಗಳಲ್ಲಿ ಆ ಪದವನ್ನು ಊಹಿಸಲು ಅಕ್ಷರಗಳನ್ನು ಒಂದೊಂದಾಗಿ ನಮೂದಿಸಬೇಕು. ಪ್ರತಿ ತಪ್ಪು ಊಹೆಗೆ, ಹ್ಯಾಂಗ್‌ಮನ್‌ನ ಚಿತ್ರದ ಒಂದು ಭಾಗವು ಸೇರಿಸಲ್ಪಡುತ್ತದೆ.

ಕಲಿಕೆಯ ಪರಿಕಲ್ಪನೆಗಳು

• random.choice() - ಲಿಸ್ಟ್‌ನಿಂದ ಯಾದೃಚ್ಛಿಕ ಪದವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು.
• ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಲಿಸ್ಟ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್.
• while ಲೂಪ್ - ಮುಖ್ಯ ಆಟದ ಲೂಪ್‌ಗಾಗಿ.
• ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು.
• ಸೆಟ್‌ಗಳು (set) - ಊಹಿಸಿದ ಅಕ್ಷರಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು.
• ಮಲ್ಟಿ-ಲೈನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸಿ ASCII ಆರ್ಟ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುವುದು.

ಕೋಡ್

import random


def get_random_word():
    """ಯಾದೃಚ್ಛಿಕ ಪದಗಳ ಲಿಸ್ಟ್‌ನಿಂದ ಒಂದನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ."""
    words = ['python', 'javascript', 'programming', 'computer', 'developer', 'hangman']
    return random.choice(words).lower()


def display_hangman(tries):
    """ಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆಯನ್ನು ಆಧರಿಸಿ ಹ್ಯಾಂಗ್‌ಮನ್ ಚಿತ್ರವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ."""
    stages = [  # ಅಂತಿಮ ಹಂತ (6 ತಪ್ಪುಗಳು)
        """
           --------
           |      |
           |      O
           |     \\|/
           |      |
           |     / \\
           -
        """,
        # 5 ತಪ್ಪುಗಳು
        """
           --------
           |      |
           |      O
           |     \\|/
           |      |
           |     / 
           -
        """,
        # 4 ತಪ್ಪುಗಳು
        """
           --------
           |      |
           |      O
           |     \\|/
           |      |
           |      
           -
        """,
        # 3 ತಪ್ಪುಗಳು
        """
           --------
           |      |
           |      O
           |     \\|
           |      |
           |     
           -
        """,
        # 2 ತಪ್ಪುಗಳು
        """
           --------
           |      |
           |      O
           |      |
           |      |
           |     
           -
        """,
        # 1 ತಪ್ಪು
        """
           --------
           |      |
           |      O
           |    
           |      
           |     
           -
        """,
        # ಆರಂಭಿಕ ಹಂತ (0 ತಪ್ಪುಗಳು)
        """
           --------
           |      |
           |      
           |    
           |      
           |     
           -
        """
    ]
    return stages[tries]


def play_game():
    """ಹ್ಯಾಂಗ್‌ಮನ್ ಆಟದ ಮುಖ್ಯ ಲಾಜಿಕ್."""
    word_to_guess = get_random_word()
    guessed_letters = set()  # ಈಗಾಗಲೇ ಊಹಿಸಿದ ಅಕ್ಷರಗಳು
    wrong_tries = 6  # ಅನುಮತಿಸಲಾದ ತಪ್ಪು ಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆ

    print("ಹ್ಯಾಂಗ್‌ಮನ್ ಆಟಕ್ಕೆ ಸ್ವಾಗತ!")

    while wrong_tries > 0:
        # ಪದದ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುವುದು
        display_word = ""
        for letter in word_to_guess:
            if letter in guessed_letters:
                display_word += letter + " "
            else:
                display_word += "_ "

        print("\n" + display_hangman(wrong_tries))
        print("ಪದ: ", display_word)
        print(f"ಊಹಿಸಿದ ಅಕ್ಷರಗಳು: {', '.join(sorted(guessed_letters)) if guessed_letters else 'ಯಾವುದೂ ಇಲ್ಲ'}")
        print(f"ಉಳಿದಿರುವ ತಪ್ಪು ಪ್ರಯತ್ನಗಳು: {wrong_tries}")

        # ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಊಹಿಸಿದ್ದರೆ, ಆಟಗಾರ ಗೆಲ್ಲುತ್ತಾನೆ
        if "_" not in display_word:
            print(f"\nಅಭಿನಂದನೆಗಳು! ನೀವ��� '{word_to_guess}' ಪದವನ್ನು ಸರಿಯಾಗಿ ಊಹಿಸಿದ್ದೀರಿ!")
            break

        # ಬಳಕೆದಾರರ ಊಹೆಯನ್ನು ಪಡೆಯುವುದು
        guess = input("ಒಂದು ಅಕ್ಷರವನ್ನು ಊಹಿಸಿ: ").lower()

        # ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣ
        if len(guess) != 1 or not guess.isalpha():
            print("ತಪ್ಪಾದ ಇನ್‌ಪುಟ್. ದಯವಿಟ್ಟು ಒಂದೇ ಒಂದು ಅಕ್ಷರವನ್ನು ನಮೂದಿಸಿ.")
            continue

        if guess in guessed_letters:
            print(f"ನೀವು ಈಗಾಗಲೇ '{guess}' ಅಕ್ಷರವನ್ನು ಊಹಿಸಿದ್ದೀರಿ. ಬೇರೆ ಪ್ರಯತ್ನಿಸಿ.")
            continue

        # ಊಹಿಸಿದ ಅಕ್ಷರವನ್ನು ಸೆಟ್‌ಗೆ ಸೇರಿಸುವುದು
        guessed_letters.add(guess)

        # ಊಹೆ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು
        if guess in word_to_guess:
            print(f"ಒಳ್ಳೆಯ ಊಹೆ! '{guess}' ಪದದಲ್ಲಿದೆ.")
        else:
            print(f"ಕ್ಷಮಿಸಿ, '{guess}' ಪದದಲ್ಲಿಲ್ಲ.")
            wrong_tries -= 1

    # ತಪ್ಪು ಪ್ರಯತ್ನಗಳು ಮುಗಿದಿದ್ದರೆ
    if wrong_tries == 0:
        print(display_hangman(wrong_tries))
        print(f"\nಕ್ಷಮಿಸಿ, ನೀವು ಸೋತಿದ್ದೀರಿ. ಸರಿಯಾದ ಪದ '{word_to_guess}' ಆಗಿತ್ತು.")


def main():
    """ಮುಖ್ಯ ಫಂಕ್ಷನ್."""
    while True:
        play_game()
        play_again = input("\nಮತ್ತೊಮ್ಮೆ ಆಡಬೇಕೇ? (yes/no): ").lower()
        if play_again != 'yes':
            break


if __name__ == "__main__":
    main()

ವಿವರಣೆ

1. display_hangman(tries): ಈ ಫಂಕ್ಷನ್ ಒಂದು ಲಿಸ್ಟ್ ಅನ್ನು ಹೊಂದಿದೆ, ಅದರಲ್ಲಿ ಹ್ಯಾಂಗ್‌ಮನ್ ಚಿತ್ರದ ವಿವಿಧ ಹಂತಗಳಿವೆ (ASCII ಆರ್ಟ್). ಉಳಿದಿರುವ ತಪ್ಪು ಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆಯನ್ನು ಆಧರಿಸಿ, ಇದು ಸೂಕ್ತವಾದ ಚಿತ್ರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
2. play_game():
   • word_to_guess: ಆಟಕ್ಕಾಗಿ ಯಾದೃಚ್ಛಿಕ ಪದವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.
   • guessed_letters = set(): ಬಳಕೆದಾರರು ಊಹಿಸಿದ ಅಕ್ಷರಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ಸೆಟ್ (set) ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಸೆಟ್‌ಗಳು ಡ್ಯೂಪ್ಲಿಕೇಟ್ ಐಟಂಗಳನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ ಮತ್ತು ಒಂದು ಐಟಂ ಸೆಟ್‌ನಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು ಲಿಸ್ಟ್‌ಗಿಂತ ವೇಗವಾಗಿರುತ್ತದೆ.
   • wrong_tries: ಆಟಗಾರನಿಗೆ ಲಭ್ಯವಿರುವ ತಪ್ಪು ಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆ.
3. ಮುಖ್ಯ ಆಟದ ಲೂಪ್ (while wrong_tries > 0):
   • display_word: ಪ್ರತಿ ಸುತ್ತಿನಲ್ಲೂ, ಈ ವೇರಿಯೇಬಲ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಪದದಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರವು guessed_letters ಸೆಟ್‌ನಲ್ಲಿದ್ದರೆ, ಆ ಅಕ್ಷರವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅಂಡರ್‌ಸ್ಕೋರ್ (_) ಅನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
   • ಗೆಲುವಿನ ಷರತ್ತು: display_word ನಲ್ಲಿ ಯಾವುದೇ ಅಂಡರ್‌ಸ್ಕೋರ್‌ಗಳು ಇಲ್ಲದಿದ್ದರೆ, ಆಟಗಾರನು ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಊಹಿಸಿದ್ದಾನೆ ಎಂದರ್ಥ, ಮತ್ತು ಆಟವು ಗೆಲುವಿನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.
   • ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣ: ಬಳಕೆದಾರರು ಒಂದೇ ಒಂದು ಅಕ್ಷರವನ್ನು ನಮೂದಿಸಿದ್ದಾರೆಯೇ ಮತ್ತು ಅದು ಈಗಾಗಲೇ ಊಹಿಸಿದ ಅಕ್ಷರವಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ.
   • ಊಹೆಯ ಪರಿಶೀಲನೆ: ಬಳಕೆದಾರರ ಊಹೆಯು ಪದದಲ್ಲಿದ್ದರೆ, ಅವರಿಗೆ ತಿಳಿಸಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, wrong_tries ಅನ್ನು ಒಂದರಿಂದ ಕಡಿಮೆ ಮಾಡಲಾಗುತ್ತದೆ.
4. ಸೋಲಿನ ಷರತ್ತು: while ಲೂಪ್ ಮುಗಿದ ನ��ತರ wrong_tries ಸೊನ್ನೆ ಆಗಿದ್ದರೆ, ಆಟಗಾರನು ಸೋತಿದ್ದಾನೆ ಎಂದರ್ಥ, ಮತ್ತು ಸರಿಯಾದ ಪದವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
5. main(): ಆಟವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಒಂದು ಆಟ ಮುಗಿದ ನಂತರ ಬಳಕೆದಾರರು ಮತ್ತೊಮ್ಮೆ ಆಡಲು ಬಯಸುತ್ತಾರೆಯೇ ಎಂದು ಕೇಳುತ್ತದೆ.