funktioniert komplett

schiffe-versenken.py

@@ -1,6 +1,6 @@
-## TO DO: NUR DIE SCHON  ABGESCHOSSENEN FELDER ANZEIGEN LASSEN
+## TO DO: AUSGABE VERBESSERN
 
-import random
+import random, time
 
 matrixgr = 7
 
@@ -8,7 +8,9 @@ def makeFeld ():
     feld = [[[0] for i in range(matrixgr)] for e in range(matrixgr)]        # Erzeugt ein  mit Nullen befülltes Feld, was bedeutet, dass dort weder ein (zerstörtes) Schiff ist, noch ein fehlgeschlagener Angriff stattgefunden hat
     return feld 	           
 
+
 def printFeld (spielerFeld, modus):
+    print ("\n"+ spielerFeld [matrixgr])
     print ("\n       1      2      3      4      5      6      7")
     NZeile = 'A'
     for i in spielerFeld:
@@ -25,13 +27,21 @@ def printFeld (spielerFeld, modus):
                     zeile+=' [   ] '
             elif n==[3]:
                 zeile+=' [ X ] '    # Das Schiff auf dem Feld wurde getroffen
-        print ('\n' + NZeile + '   ' + zeile)
+        
+        if ord(NZeile.lower())-97 < matrixgr:
+            print ('\n' + NZeile + '   ' + zeile)
+        else:
+            print ('\n' + '   ' + zeile)
+
         NZeile = chr(ord(NZeile)+1)
     print ('\n')
 
+
 def setFeld (spielerFeld, zeile, spalte, wert):
     #zeile = ord(zeile.lower())-97                           # Weil die Zeilen traditionell nach Buchstaben benannt werden, muss erst der Buchstabe in seinen ASCII-Wert umgewandelt werden und dann um 97 verringer (ASCII 97 = 'a')
     #spielerFeld [zeile][spalte-1][0] = wert                 # Weil die Nummerierung der Spalten bei 1 anfangen soll hier -1
+    if wert == 5:                                           
+        wert = getFeld (spielerFeld, zeile, spalte) +1       # Um den Wert im Feld um eins zu erhöhen
     spielerFeld [zeile][spalte][0] = wert
 
 
@@ -48,6 +58,15 @@ def summeFeld (spielerFeld):
                 summe += n
     return summe
 
+
+def zweicheck (spielerFeld): #Super dumm, kann optimiert werden
+    for i in spielerFeld:                   
+        for e in i:
+            for n in e:
+                if n == 2:
+                    return True
+                
+
 def checkUmfeld (spielerFeld, zeile, spalte):
     if getFeld (spielerFeld, zeile, spalte) != 0:
         return False
@@ -153,12 +172,15 @@ def fuellFeld (Feld):
 
 
 def feldWahl (spielerFeld):
+    printFeld (spielerFeld, 't')
     feld = str(input("Wähle das Feld, das abgeschossen werden soll! "))
-    if len(feld) != 2:
+    feld.replace (" ", "")
+    if (len(feld) != 2 ) or (not feld[0].isalpha ()) or (not feld[1].isdigit()):
         print ("Fehlerhafte Eingabe! \n Ein Feld wird beispielsweise folgendermaßen angegeben:\n A1 [Enter]")
         feldWahl (spielerFeld)
         return 0        # Rückgabe, damit die Funktion nicht mit falschem Wert weiterläuft
     
+
     feld = [ord(feld[0].lower())-97, int(feld[1])-1]         # Weil die Zeilen traditionell nach Buchstaben benannt werden, muss erst der Buchstabe in seinen ASCII-Wert umgewandelt werden und dann um 97 verringert (ASCII 97 = 'a')
     
     if not (0 <= feld [0] <= matrixgr-1 and 0 <= feld [1] <= matrixgr-1):
@@ -173,7 +195,7 @@ def feldWahl (spielerFeld):
         feldWahl (spielerFeld)
         return 0        # Rückgabe, damit die Funktion nicht mit falschem Wert weiterläuft
     
-    setFeld (spielerFeld, feld[0],feld[1], wert + 1) # Treffer wird eingetragen
+    setFeld (spielerFeld, feld[0],feld[1], 5) # Treffer wird eingetragen
     printFeld (spielerFeld, 't')
 
    
@@ -181,19 +203,17 @@ def feldWahl (spielerFeld):
         print ("TREFFER! \n Es darf direkt ein neues Feld gewählt werden!")
         feldWahl (spielerFeld)
     else:
-        print ("Der Bot zieht nun...")
+        print ("Leider kein Treffer! Der Bot zieht nun...")
-
 
 
 def Initialisiere ():
     global gegnerFeld, eigenFeld
-    print ("Gegnerisches Feld wird generiert...\n\n")
     gegnerFeld= makeFeld () 
     fuellFeld (gegnerFeld)
     while summeFeld (gegnerFeld) != 34:
         gegnerFeld= makeFeld () 
         fuellFeld (gegnerFeld)
-
+    gegnerFeld += ['Gegnerisches Feld:']
     print ("Das gegnerische Feld wurde generiert!\nDieses wurde für dich zufällig generiert: ")
     akzeptiert = False
     eing = ''
@@ -205,15 +225,60 @@ def Initialisiere ():
         while summeFeld (eigenFeld) != 34:
             eigenFeld= makeFeld () 
             fuellFeld (eigenFeld)
+        eigenFeld += ['Eigenes Feld:']
         printFeld (eigenFeld, 'a')
         eing = str(input("Ist dieses Feld akzeptabel? [J: Ja / Irgendwas: Nein, Neues!] "))
 
+
+def SchwierigkeitsWahl ():
+    try:
+        diff = float(input("Bitte wähle die Schwierigkeit von 0-sehr einfach bis 10-sehr schwer! [0-10] "))
+    except:
+        print ("Keine valide Eingabe!")
+        SchwierigkeitsWahl ()
+        return 0
+    if not (0<=diff<= 10):
+        print ("Der Schwierigkeitsgrad muss zwischen 0 und 10 sein!")
+        SchwierigkeitsWahl ()
+        return 0
+    
+    return diff
+
+
+def botwahl (spielerFeld, diff):
+    diff *= 10
+    wurf = random.randint (-5, 105)
+    feld = [random.randint (0, matrixgr-1), random.randint (0, matrixgr-1)]
+    treffer = False
+    if diff >= wurf:
+        while getFeld(spielerFeld, feld [0], feld [1]) != 2:
+            feld = [random.randint (0, matrixgr-1), random.randint (0, matrixgr-1)]
+        treffer = True
+    else:
+        while  getFeld(spielerFeld, feld [0], feld [1]) != 0:
+            feld = [random.randint (0, matrixgr-1), random.randint (0, matrixgr-1)]
+    
+    setFeld (spielerFeld, feld[0], feld[1], 5)
+    printFeld (spielerFeld, 'a')
+    if treffer:
+        print ("Der Bot hat getroffen! Er darf noch ein Feld wählen!")
+        time.sleep (1)
+        botwahl (spielerFeld, diff/11)
+    else:
+        print ("Der Bot hat nicht getroffen! Du bist nun dran!")
+
+
+    
+
+
 def start ():
-    # SchwierigkeitsWahl ()
+    level = SchwierigkeitsWahl ()
     Initialisiere ()
-    print ("So sieht das gegnerische Feld aus:")
+    while zweicheck (eigenFeld) and zweicheck (gegnerFeld):
-    printFeld (gegnerFeld, 't')
-    while True:
         feldWahl (gegnerFeld)
+        time.sleep (1)
+        botwahl (eigenFeld, level)
+        time.sleep (2)
+
 
 start ()