Python :: Aufgabe #268

2 Lösungen Lösungen öffentlich

Galgenraten (hangman)

Anfänger - Python von JKooP - 18.04.2020 um 12:18 Uhr
Erstelle ein Konsolenspiel in der Form „Galgenraten“.

Spieler 1 gibt verdeckt ein zu erratenes Wort ein.
Regeln: Buchstaben a-z, keine Zahlen, ä = ae, ö = oe, ü = ue, ß = ss

Spieler 2 muss versuchen die richtigen Buchstaben zu erraten.
Dazu wird am Anfang des Spiels jeder Buchstabe des Lösungsworts als „Unterstrich“ dargestellt.
Errät Spieler 2 einen Buchstaben, wird der Unterstrich an allen Positionen an der sich der gefundene Buchstabe befindet durch den jeweiligen Buchstaben ersetzt.
Es sollen am Ende des Spiels die benötigte Zeit und die Anzahl der Versuche ausgegeben werden.
Die Anzahl der Versuche soll ähnlich wie beim Galgenraten begrenzt werden.

Varianten:
Der Spieler 2 kann auch das Lösungswort eingeben. Ist das Wort falsch, wird es als 2 Fehlversuche gewertet.
Als Hilfe könnten die bereits genutzten Buchstaben angezeigt werden.
Aus der Anzahl der benötigten Versuche und der Zeit könnten Gewinnpunkte generiert werden.

Viel Spaß

Lösungen:

vote_ok
von satn1241 (3090 Punkte) - 24.04.2020 um 12:58 Uhr
Quellcode ausblenden Python-Code
def choose_game_mode():
    print("Möchtest du gegen den Computer spielen? Drücke (1)")
    print("Möchtest du gegen eine/n Freund/in spielen? Drücke (2)")
    game_mode = ""
    while game_mode != "1":
        game_mode = input("> ")
        if game_mode == "2":
            break
        print("Falsche Eingabe: Drücke (1) für vs. PC oder (2) für P1 vs. P2")

    if game_mode == 1:
        print("Spiel gegen den PC gewählt")
    elif game_mode == 2:
        print("Spiel gegen eine/n Freund/in gewählt")
    return game_mode  # 1 or 2


def game_pc():
    import random
    wortliste_pc = ['Akquise', 'nichtsdestotrotz', 'Burgverlies', 'Ouvertuere', 'Chrysantheme', 'Portemonnaie',
                    'Dekollete',
                    'Quarzuhr', 'Einfaltspinsel', 'Rueckgrat', 'brillant', 'Bredouille', 'Fronleichnam',
                    'Schlafittchen',
                    'Galionsfigur', 'Terrasse', 'hanebuechen', 'unentgeltlich', 'Incentive', 'Verlies', 'Jackett',
                    'weismachen', 'Kernspintomografie', 'Xanthippe', 'lizenzieren', 'Yuccapalme', 'Mischpoke',
                    'Zucchini']

    i = random.randint(0, len(wortliste_pc))
    wort = wortliste_pc[i].lower()
    #print(wort)
    return wort


def game_player():
    print("Gib bitte ein Wort ein")
    from string import ascii_lowercase
    erlaubte_buchstaben = list(ascii_lowercase)
    while True:
        wort = input("> ").lower()
        zeichen_checker = 0
        for i in wort:
            zeichen_checker += erlaubte_buchstaben.count(i)
        if zeichen_checker == len(wort):
            break
        else:
            print("keine Umlaute, Zahlen oder Sonderzeichen erlaubt. Gib ein neues Wort ein")
    return wort


def tippen():
    global fehlversuche
    print(f"Du hast schon {fehlversuche} von max. {fehlversuche_max}")
    tipp = input("Gib bitte einen Tipp ab: > ")
    return tipp


def eingabe_check(tipp):
    from string import ascii_lowercase
    erlaubte_buchstaben = list(ascii_lowercase)
    check = 0
    for i in tipp:
        check += erlaubte_buchstaben.count(i)
    if check == len(tipp):
        return True
    else:
        print("keine Umlaute, Zahlen oder Sonderzeichen erlaubt.")
    return False


# Einzelbuchstabe Check auf wiederholte eingabe
def wiederholung_check(tipp):
    global alle_buchstaben
    if alle_buchstaben.count(tipp) > 0:
        print("Buchstabe wurden schon eingegeben")
        return False
    else:
        return True


def wort_eingabe_check(wort, tipp):
    global fehlversuche
    global zeit_start
    if wort == tipp:
        zeit_ende = default_timer()
        print(f"Richtig gelöst! Das Wort war \"{wort}\"")
        print(f"Du hast {fehlversuche} Fehlversuche benötigt")
        print(f"Du hast zum Lösen {round(zeit_ende - zeit_start, 1)}s benötigt")
        return True
    else:
        print("Das war falsch! Du erhälst zwei Fehlversuche")
        fehlversuche += 2

        return False


def buchstabe_eingabe_check(tipp, wort):
    global raster
    global falsche_buchstaben
    global fehlversuche
    for i in range(0, len(wort)):
        if wort[i] == tipp:
            raster[i] = tipp
            return True
    falsche_buchstaben.append(tipp)
    fehlversuche +=1
    print(f"Der Buchstabe {tipp} kommt nicht im Wort vor")
    return False


# Spiel
game_mode = choose_game_mode()
# Wort festlegen
if int(game_mode) == 1:
    wort = game_pc()
elif int(game_mode) == 2:
    wort = game_player()


# Tippen
raster = ["_"] * len(wort)
from timeit import default_timer
zeit_start = default_timer()
alle_buchstaben = []
falsche_buchstaben = []
stop = False
fehlversuche_max = 8
fehlversuche = 0


while not stop:
    # a) tippen und tipp auf Eingaberegeln prüfen
    status = False
    while not status:
        print(raster)
        print(f"falsche Buchstaben: {falsche_buchstaben}")
        tipp = tippen()
        if eingabe_check(tipp):
            if len(tipp) == 1:
                if wiederholung_check(tipp):
                    status = True
            elif len(tipp) > 1:
                status = True

    # b) abgleichen:
    if len(tipp) == 1:
        alle_buchstaben.append(tipp)
        if buchstabe_eingabe_check(tipp, wort):
            if raster.count("_") == 0:
                zeit_ende = default_timer()
                print(f"Richtig gelöst! Das Wort war \"{wort}\"")
                print(f"Du hast {fehlversuche} Fehlversuche benötigt")
                print(f"Du hast zum Lösen {round(zeit_ende-zeit_start,1)}s benötigt")
                stop = True
    elif len(tipp) > 1:
        if wort_eingabe_check(wort, tipp):
            stop = True

    # c) verlieren
    if fehlversuche ==8:
        print("Leider verloren! - Maximale Fehlversuche erreicht")
        print(f"Das richtige Wort war \"{wort}\"")
        stop = True
vote_ok
von daVinci (320 Punkte) - 20.05.2020 um 19:57 Uhr
Quellcode ausblenden Python-Code
###########################################################################################
# Aufgabe #268 - Galgenraten / Hangman -- GAME
###########################################################################################
#     ___________________________________
#____|  A u f g a b e n s t e l l u n g  |_________________________________________________
#
#       Erstelle ein Konsolenspiel in der Form „Galgenraten“.
#
#       Regeln: Buchstaben a-z, keine Zahlen, ä = ae, ö = oe, ü = ue, ß = ss
#
#     - Spieler 1 gibt verdeckt ein zu erratenes Wort ein.
#     - Spieler 2 muss versuchen die richtigen Buchstaben zu erraten.
#
#     - Dazu wird am Anfang des Spiels jeder Buchstabe des Lösungsworts als
#       „Unterstrich“ dargestellt.
#       Errät Spieler 2 einen Buchstaben, wird der Unterstrich an allen Positionen an
#       der sich der gefundene Buchstabe befindet durch den jeweiligen Buchstaben ersetzt.
#
#     - Es sollen am Ende des Spiels die benötigte Zeit und die Anzahl der Versuche
#       ausgegeben werden.
#
#     - Die Anzahl der Versuche soll ähnlich wie beim Galgenraten begrenzt werden.
#
#       Varianten:
#       Der Spieler 2 kann auch das Lösungswort eingeben.
#       Ist das Wort falsch, wird es als 2 Fehlversuche gewertet.
#       Als Hilfe könnten die bereits genutzten Buchstaben angezeigt werden.
#       Aus der Anzahl der benötigten Versuche und der Zeit könnten
#       Gewinnpunkte generiert werden.
#     _____________________________
#____|  I n f o r m a t i o n e n  |_______________________________________________________
#
#       -/-
#
###########################################################################################
#=========================================================================| code by daVinci
###########################################################################################
# Importe
from getpass import getpass
from time import sleep
import datetime as dt
import os, sys
#------------------------------------------------------------------------------------------
# Funktion für Falschen Lösungsversuch
def falschgeraten():
    # Leeren des Bildschirminhaltes  
    try:
        os.system("cls")
    except:
        os.system("clear") 
    # Meldungsausgabe
    print("\n================================================================================")
    print("Leider ist Ihre Eingabe nicht identisch mit dem gesuchten Lösungswort.")
    print("Für diesen Lösungsversuch werden Ihnen 2 FEHLVERSUCHE angerechnet!")
    print("================================================================================\n")
    # Eingabeaufforderung zum Weiterspielen
    input("Drücken Sie eine beliebige Taste um Fortzufahren....")
#------------------------------------------------------------------------------------------
# Funktion für Punkteauswertung
def auswertung(versuche, timestart, schwierigkeit):
    # Stoppen und Auswertung des Timer´s
    timestop = dt.datetime.now()
    zeit = ((timestop - timestart).seconds / 60)
    #--------------------------------------------------------------------------------------
    # Variablen und Werte
    if schwierigkeit == 1:
        sgrad = "LEICHT" 
        vversuche = 30
    elif schwierigkeit == 2:
        sgrad = "MITTEL"
        vversuche = 20
    elif schwierigkeit == 3:
        sgrad = "SCHWER"
        vversuche = 10
    #--------------------------------------------------------------------------------------
    # Benötigte Versuche
    bversuche = vversuche - versuche
    #--------------------------------------------------------------------------------------
    # Berechnung Punkte ZEIT
    if (zeit >= 0 and zeit <= 0.30):
        zeitpunkte = 10
    elif (zeit > 0.30 and zeit <= 1.00):
        zeitpunkte = 9.5
    elif (zeit > 1.00 and zeit <= 2.30):
        zeitpunkte = 8
    elif (zeit > 2.30 and zeit <= 3.30):
        zeitpunkte = 6.5
    elif (zeit > 3.30 and zeit <= 5.00):
        zeitpunkte = 5
    elif zeit > 5.00:
        zeitpunkte = 0
    # Berechnung Punkte VERSUCHE
    if (bversuche >= 0 and bversuche <= 2):
        versuchpunkte = 10
    elif (bversuche > 2 and bversuche <= 4):
        versuchpunkte = 8
    elif (bversuche > 4 and bversuche <= 10):
        versuchpunkte = 5
    elif (bversuche > 10 and bversuche <= 20):
        versuchpunkte = 2.5
    elif (bversuche > 20 and bversuche <= 30):
        versuchpunkte = 1
    elif bversuche > 30:
        versuchpunkte = 0
    #--------------------------------------------------------------------------------------
    # Leeren des Bildschirminhaltes
    try:
        os.system("cls")
    except:
        os.system("clear") 
    #--------------------------------------------------------------------------------------
    # Ausgabe von Werten
    print("=================================================================================")
    print("               - - -- ---  A  U  S  W  E  R  T  U  N  G  --- -- - -")
    print("=================================================================================\n")
    print("SCHWIERIGKEITSGRAD:          ", sgrad)
    print("ANZAHL VERFÜGBARER VERSUCHE: ", vversuche)
    print("BENÖTIGTE VERSUCHE:          ", bversuche)
    print("ÜBRIGE VERSUCHE:             ", versuche)
    print("BENÖTIGTE ZEIT:              ", zeit, "Minuten")
    print("--------------------------------------------------------------------------------")
    print("P U N K T E R E C H N U G:\n")
    print("Zeitauswertung:______________  00:00 - 00:30    =    10,00 Punkte")
    print("                             | 00:31 - 01:00    =    09,50 Punkte")
    print("                             | 01:01 - 02:30    =    08,00 Punkte")
    print("                             | 02:31 - 03:30    =    06,50 Punkte")
    print("                             | 03:31 - 05:00    =    05,00 Punkte")
    print("                             |       > 05:00    =    00,00 Punkte\n")
    print("Versuchsauswertung:__________|    00 -    02    =    10,00 Punkte")
    print("                             |    03 -    04    =    08,00 Punkte")
    print("                             |    05 -    10    =    05,00 Punkte")
    print("                             |    11 -    20    =    02,50 Punkte")
    print("___________________          |    21 -    30    =    01,00 Punkte")
    print("IHRE PUNKTEWERTUNG |------------------------------------------------------------\n")
    print("Zeitauswertung:         PUNKTE  =  ", zeitpunkte)
    print("Versuchsauswertung:     PUNKTE  =  ", versuchpunkte, "\n")
    print("GESAMTPUNKTE:           PUNKTE  =  ", zeitpunkte + versuchpunkte, "\n")
    print("___________________________________________________________")
    input("DRÜCKEN SIE EINE BELEIBIGE TASTE UM DAS SPIEL ZU BEENDEN...")
    #--------------------------------------------------------------------------------------
    # ENDE DES SPIELS (Programm schließen)
    exit()
#------------------------------------------------------------------------------------------ 
# START - Programmstart
print("\n================================================================================")
print("                     H A N G M A N - Das kleine Galgenratespiel")
print("================================================================================\n")
print("REGELN:")
print("--------------------------------------------------------------------------------")
print("SPIELER_01 legt das Lösungswort fest.")
print("                [ Buchstaben a-z, keine Zahlen, ä = ae, ö = oe, ü = ue, ß = ss ]")
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n")
print("SPIELER_02 versucht danach das Wort von SPIELER_01 zu erraten.")
print("Vorab wird ein Schwierigkeitsgrad gewählt, dieser legt die Anzahl der")
print("Versuche fest, die SPIELER_02 zum erraten des Wortes maximal zur Verfügung hat.")
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n")
print("In jeder Runde wählt SPIELER_02 einen Buchstaben aus. Ist dieser im Lösungswort")
print("enthalten, wird der Buchstabe Angezeigt.")
print("SPIELER_02 hat auch die Möglichkeit das Lösungswort direkt zu erraten und")
print("einzugeben. Ist dieses jedoch Falsch werden dem Spieler 2 Fehlversuche")
print("angerechnet.")
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n")
print("Anhand der benötigten Zeit und der Anzahl der benötigten Versuche das Wort zu")
print("erraten, werden im nachhinein die Gewinnpunkte festgelegt.\n")
print("================================================================================\n")
print("                         L  O  S    G  E  H  T  '  S  !")
# Festlegen/Eingabe des Lösungswortes
print("================================================================================")
print("SPIELER_01, legen Sie jetzt das Lösungswort fest.")
print("Bitte beachten! Nur Buchstaben a-z, keine Zahlen, ä = ae, ö = oe, ü = ue, ß = ss\n")
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n")
#------------------------------------------------------------------------------------------
# Erlaubte Zeichen
erlaubte_zeichen = set("abcdefghijklmnopqrstuvwxyz")
# Eingabe des zu eratenden Wortes und Prüfung der eingegebenen Zeichen
while True:
       eingabe_pruefen = getpass("Bitte das zu erratende Wort eingeben: ")
       if eingabe_pruefen and erlaubte_zeichen.issuperset(eingabe_pruefen):
           # Nach erfolgreicher Prüfung wird das Lösungswort in einer Variable abgelegt
           loesungswort = eingabe_pruefen
           break
       print("\nFEHLER! - Unerlaubte Zeichen verwendet! Bitte Überprüfen Sie Ihre Eingabe!\n")
#------------------------------------------------------------------------------------------
# Leeren des Bildschirminhaltes
try:
     os.system("cls")
except:
     os.system("clear") 
#------------------------------------------------------------------------------------------     
# Meldung für Erfolgreich festgelegtes Lösungswort
print("================================================================================")
print("SPIELER_01 hat das Loesungswort erfolgreich festgelegt!")
print("================================================================================\n")
# Festlegen des Schwierigkeitsgrades (Anzahl der Versuche)
print("================================================================================")
print("SPIELER_02, legen Sie jetzt den Schwierigkeitsgrad fest:\n")
print("[1]     =     LEICHT       (30 Versuche)")
print("[2]     =     MITTEL       (20 Versuche)")
print("[3]     =     SCHWER       (10 Versuche)")
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ")
# Prüfung der Eingabe und Festlegung der Anzahl der Versuche
while True:
    try:
        schwierigkeit = eval(input("Geben Sie eine Zahl zwischen 1-3 für den Schwierigkeitsgrad an: "))
    # Eingabe/Fehlerprüfung
    except NameError:
        print("\nFEHLER! - Bitte eine (ZAHL) eingeben!\n")
        continue
    # Überprüfung Schwierigkeitsgrad
    if (schwierigkeit <= 0 or schwierigkeit > 3):
        print("\nFEHLER! - Bitte eine Zahl zwischen 1-3 Eingeben!\n")
        continue
    elif schwierigkeit == 3:
        versuche = 10
        break
    elif schwierigkeit == 2:
        versuche = 20
        break
    elif schwierigkeit == 1:
        versuche = 30
        break
#------------------------------------------------------------------------------------------
# Zerlegen des Lösungswortes und Konvertierung in Liste
loesungsbuchstaben = list(loesungswort)
#------------------------------------------------------------------------------------------
# Starten des Timer´s
timestart = dt.datetime.now()
#------------------------------------------------------------------------------------------
# Deklarieren der Variable für bereits verwendete Zeichen
verwendete_zeichen = ""
#============================================================================================
# SPIELFELD (Spielablauf)
# Ende bei 0 Versuchen.
# Setzen der Variablen für erratene Zeichen
erraten = 0
while versuche > 0:
    # Leeren des Bildschirminhaltes
    try:
        os.system("cls")
    except:
        os.system("clear") 
    # Spielfeld wird erstellt/generiert
    print("=================================================================================")
    print("                     -  - - -- H  A  N  G  M  A  N -- - -  -")
    print("=================================================================================\n")
    print("ANZAHL DER BUCHSTABEN: ", len(loesungswort), " Buchstaben im Lösungswort.")
    print("VERBLEIBENDE VERSUCHE: ", versuche, "verbleiben zum raten.\n")
    print("VERWENDETE BUCHSTABEN: ", verwendete_zeichen, "\n")
    print("*HINWEIS: Ein Fehler im Versuch das Lösungswort zu erraten, wird mit")
    print("          2 Fehlversuchen gewertet!")
    print("---------------------------------------------------------------------------------\n\n")
    # Optische Darstellung des zu erratenden Wortes
    for w in loesungsbuchstaben:
        if w in verwendete_zeichen:
            print(" ", w, " ", end=" ")
        else:
            print(" _ ", end=" ")
    print("\n")
    # Eingabe von SPIELER_02 (Buchstabeneingabe)
    eingabe = input("Geben Sie einen BUCHSTABEN oder das LÖSUNGSWORT ein: ")
    # Vergleichsvariable auf FALSE zurücksetzen
    vorkommen = False
    #--------------------------------------------------------------------------------------
    print("---------------------------------------------------------------------------------\n")
    #--------------------------------------------------------------------------------------
    # Lösungswort Eingabe prüfen
    if len(eingabe) > 1:
        if eingabe == loesungswort:
            # Leeren des Bildschirminhaltes
            try:
                os.system("cls")
            except:
                os.system("clear") 
            # Gewinnermeldung    
            print("=================================================================================")
            print("                - - -- ---  W   I   N   N   I   N   G  --- -- - -            ")
            print("=================================================================================")
            print("Sie haben das Lösungswort erraten! Das Lösungswort war:")
            print("              ==> ", loesungswort)
            print("=================================================================================")
            # Sprung zur Punkteauswertung
            sleep(2)
            auswertung(versuche, timestart, schwierigkeit)
        else:
            falschgeraten()
            versuche -= 2
            continue
    #--------------------------------------------------------------------------------------
    # Prüfen ob "Eingabe" im Lösungswort enthalten ist
    for i in loesungsbuchstaben:
        # Wenn ja, schalten die Variable auf TRUE um keinen Fehlversuch gewertet zu bekommen
        if i == eingabe:
            vorkommen = True
            erraten += 1
            # Weitere Prüfung ob sich die "Eingabe" in den bereits verwendeten Zeichen befindet
            for ii in verwendete_zeichen:
                # Wenn ja, zurückschalten der variable für Versuchs"abzug"
                if ii == eingabe:
                    vorkommen = False
                    erraten -= 1
    # Wenn nicht, Abzug eines Versuches    
    if vorkommen == False:
        versuche -= 1
    # Leeren des Bildschirminhaltes  
    try:
        os.system("cls")
    except:
        os.system("clear") 
    #--------------------------------------------------------------------------------------    
    # Hinzufügen der Eingabe zu verwendeten Zeichen
    verwendete_zeichen = verwendete_zeichen + "|" + eingabe
    #--------------------------------------------------------------------------------------
    # Lösungsprüfung
    if len(loesungswort) == erraten:
        print("=================================================================================")
        print("                - - -- ---  W   I   N   N   I   N   G  --- -- - -            ")
        print("=================================================================================")
        print("Sie haben das Lösungswort erraten! Das Lösungswort war:")
        print("              ==> ", loesungswort)
        print("=================================================================================")
        # Sprung zur Punkteauswertung
        sleep(2)
        auswertung(versuche, timestart, schwierigkeit)
#------------------------------------------------------------------------------------------    
# Niederlage! Bei Schleifenabbruch versuche == 0
print("=================================================================================")
print("             - - -- ---  G   A   M   E     O   V   E   R  --- -- - -          ")
print("=================================================================================")
print("Leider gaben Sie das Lösungswort nicht erraten können!") 
print("Das Lösungswort lautete:")
print("                 ==> ", loesungswort)
print("=================================================================================")
# Sprung zur Punkteauswertung
sleep(2)
auswertung(versuche, timestart, schwierigkeit)



###########################################################################################
###################################################################################### ENDE