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

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