paul/SchiffeVersenken
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wrapping

Browse Source
This commit is contained in:
Paul Martin
2023-08-07 23:10:34 +02:00
parent ed562ad1ea
commit 70d9f2aab3
1 changed files with 254 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
schiffe-versenken.py
View File

@ -1,9 +1,13 @@
import random, time import random, time
matrixgr = 7 # Größe des Spielfeldes (7x7) matrixgr = 7 # Größe des Spielfeldes (7x7)
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 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 return feld
@ -12,58 +16,63 @@ def makeFeld ():
def printFelder(): def printFelder():
# Von Feld1 werden nur die abgeschossenen Felder gezeigt, von Feld2 alle. # Von Feld1 werden nur die abgeschossenen Felder gezeigt, von Feld2 alle.
output = [[gegnerFeld [matrixgr]],[' ' + eigenFeld [matrixgr]]] # In die Liste Output werden die auszugebenden Elemente eingetragen, damit sie am Ende alle gleichzeitig nebeneinander ausgegeben werden können output = [[gegnerFeld[matrixgr]], [
' ' + eigenFeld[matrixgr]]]
# In die Liste Output werden die auszugebenden Elemente eingetragen,
# damit sie am Ende alle gleichzeitig nebeneinander ausgegeben werden können
for i in output: for i in output:
i+= [" 1 2 3 4 5 6 7 "] i += [" 1 2 3 4 5 6 7 "]
felder = [gegnerFeld, eigenFeld] felder = [gegnerFeld, eigenFeld]
for f in range (2): # f als erstes 0, dann 1 for f in range(2): # f als erstes 0, dann 1
NZeile = 'A' # Bezeichner für die Zeile NZeile = 'A' # Bezeichner für die Zeile
for i in felder[f]: for i in felder[f]:
zeile = '' zeile = ''
for n in i: for n in i:
if n == [0]: if n == [0]:
if f == 1: # Zeige ALLE Felder an if f == 1: # Zeige ALLE Felder an
zeile+=' [ ] ' # Feld ist leer zeile += ' [ ] ' # Feld ist leer
elif f==0: # Zeige NUR TREFFER an, ~ um vom eigenen Feld zu differenzieren elif f == 0:
zeile+=' [ ~ ] ' zeile += ' [ ~ ] '
elif n== [1]: # Zeige NUR TREFFER an, ~ um vom eigenen Feld zu differenzieren
zeile+=' [ . ] ' # Feld wurde abgeschossen elif n == [1]:
elif n==[2]: zeile += ' [ . ] ' # Feld wurde abgeschossen
if f == 1: # Zeige ALLE Felder an elif n == [2]:
zeile+=' [ ■ ] ' # Auf dem Feld ist ein ungetroffenes Schiff if f == 1: # Zeige ALLE Felder an
elif f== 0: # Zeige NUR TREFFER an zeile += ' [ ■ ] '
zeile+=' [ ~ ] ' # Auf dem Feld ist ein ungetroffenes Schiff
elif n==[3]: elif f == 0: # Zeige NUR TREFFER an
zeile+=' [ X ] ' # Das Schiff auf dem Feld wurde getroffen zeile += ' [ ~ ] '
elif n == [3]:
zeile += ' [ X ] '
# Das Schiff auf dem Feld wurde getroffen
if ord(NZeile.lower())-97 < matrixgr: if ord(NZeile.lower()) - 97 < matrixgr:
output [f] += [NZeile + ' ' + zeile] output[f] += [NZeile + ' ' + zeile]
else: else:
output [f] += [' ' + zeile] output[f] += [' ' + zeile]
NZeile = chr(ord(NZeile)+1) NZeile = chr(ord(NZeile) + 1)
for i in range (0, len(output[0])): for i in range(0, len(output[0])):
print (output [0][i], ' ' + output [1][i]) print(output[0][i], ' ' + output[1][i])
print ("") print("")
def setFeld (spielerFeld, zeile, spalte, wert): 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: if wert == 5:
wert = getFeld (spielerFeld, zeile, spalte) +1 # Um den Wert im Feld um eins zu erhöhen wert = getFeld(spielerFeld, zeile,
spielerFeld [zeile][spalte][0] = wert spalte) + 1 # Um den Wert im Feld um eins zu erhöhen
spielerFeld[zeile][spalte][0] = wert
def getFeld (spielerFeld, zeile, spalte): def getFeld(spielerFeld, zeile, spalte):
#zeile = ord(zeile.lower())-97 # zeile = ord(zeile.lower())-97
#return spielerFeld [zeile][spalte-1][0] # return spielerFeld [zeile][spalte-1][0]
return spielerFeld [zeile][spalte][0] return spielerFeld[zeile][spalte][0]
def summeFeld (spielerFeld): def summeFeld(spielerFeld):
summe = 0 summe = 0
for i in spielerFeld: for i in spielerFeld:
for e in i: for e in i:
@ -72,7 +81,7 @@ def summeFeld (spielerFeld):
return summe return summe
def zweicheck (spielerFeld): def zweicheck(spielerFeld):
for i in spielerFeld: for i in spielerFeld:
for e in i: for e in i:
for n in e: for n in e:
@ -80,34 +89,37 @@ def zweicheck (spielerFeld):
return True return True
def checkUmfeld (spielerFeld, zeile, spalte): def checkUmfeld(spielerFeld, zeile, spalte):
if getFeld (spielerFeld, zeile, spalte) == 2: # Wenn auf dem Feld schon ein Schiff ist, kann der Check direkt abgebrochen werden if getFeld(spielerFeld, zeile,
spalte) == 2:
# Wenn auf dem Feld schon ein Schiff ist, kann der Check
# direkt abgebrochen werden
return False return False
summe = 0 summe = 0
if matrixgr > zeile >= 0 and matrixgr > spalte >= 0: if matrixgr > zeile >= 0 and matrixgr > spalte >= 0:
if zeile+1 < matrixgr: if zeile + 1 < matrixgr:
if getFeld (spielerFeld, zeile+1, spalte) != 2: if getFeld(spielerFeld, zeile + 1, spalte) != 2:
summe += 1 summe += 1
else: else:
summe+= 1 summe += 1
if spalte+1 < matrixgr: if spalte + 1 < matrixgr:
if getFeld (spielerFeld, zeile, spalte+1) !=2: if getFeld(spielerFeld, zeile, spalte + 1) != 2:
summe += 1 summe += 1
else: else:
summe+= 1 summe += 1
if zeile-1 >= 0: if zeile - 1 >= 0:
if getFeld (spielerFeld, zeile-1, spalte) !=2: if getFeld(spielerFeld, zeile - 1, spalte) != 2:
summe += 1 summe += 1
else: else:
summe+= 1 summe += 1
if spalte-1 >= 0: if spalte - 1 >= 0:
if getFeld (spielerFeld, zeile, spalte-1) !=2: if getFeld(spielerFeld, zeile, spalte - 1) != 2:
summe += 1 summe += 1
else: else:
summe+= 1 summe += 1
if summe < 4: if summe < 4:
return False return False
@ -115,257 +127,299 @@ def checkUmfeld (spielerFeld, zeile, spalte):
return True return True
def setSchiff (spielerFeld, groesse, belegFeld): def setSchiff(spielerFeld, groesse, belegFeld):
feldsumme = summeFeld(spielerFeld) feldsumme = summeFeld(spielerFeld)
versuch = 0 versuch = 0
while summeFeld(spielerFeld) != feldsumme + groesse*2 : while summeFeld(spielerFeld) != feldsumme + groesse * 2:
if versuch < 25: if versuch < 25:
spitze = [random.randint(0, matrixgr-1), random.randint(0, matrixgr-1)] spitze = [random.randint(0, matrixgr - 1),
if checkUmfeld(spielerFeld, spitze[0], spitze[1]): #spitze[0] ZEILE, spitze[1] SPALTE random.randint(0, matrixgr - 1)]
if checkUmfeld(spielerFeld, spitze[0], spitze[1]):
# spitze[0] ZEILE, spitze[1] SPALTE
if groesse == 1: if groesse == 1:
setFeld (spielerFeld, spitze[0], spitze[1], 2) setFeld(spielerFeld, spitze[0], spitze[1], 2)
setFeld (belegFeld, spitze [0], spitze [1], 1) # Damit später abgerufen werden kann, wie groß das Schiff auf dem Feld ist. setFeld(belegFeld, spitze[0], spitze[1], 1)
# Damit später abgerufen werden kann,
# wie groß das Schiff auf dem Feld ist.
else: else:
reihe = [] reihe = []
counter = 0 counter = 0
#Jetzt wird entschieden, ob das Schiff vertikal oder horizontal ausgerichtet sein soll. # Jetzt wird entschieden, ob das Schiff vertikal oder
orientierung = random.randint (0,1) #0: horizontal, 1: vertikal # horizontal ausgerichtet sein soll.
orientierung = random.randint(0, 1)
# 0: horizontal, 1: vertikal
if orientierung == 0: if orientierung == 0:
orig = spitze [1] orig = spitze[1]
spitze [1] = counter spitze[1] = counter
counterind = 1 #damit der Counter noch bearbeitet werden kann counterind = 1
# damit der Counter noch bearbeitet werden kann
else: else:
orig = spitze [0] orig = spitze[0]
spitze [0] = counter spitze[0] = counter
counterind = 0 counterind = 0
while spitze [counterind] < matrixgr: #Ab jetzt wird überprüft, ob in der ausgewählten Reihe überhaupt das Schiff hinpasst. while spitze[
counterind] < matrixgr:
# Ab jetzt wird überprüft, ob in der ausgewählten Reihe überhaupt das Schiff
# hinpasst
if checkUmfeld(spielerFeld, spitze[0], spitze[1]): if checkUmfeld(spielerFeld, spitze[0], spitze[1]):
reihe += [spitze[counterind]] reihe += [spitze[counterind]]
else: else:
reihe = [] reihe = []
summe = 0 summe = 0
if len(reihe) >= groesse and reihe.count(orig)==1: #.count zählt, wie oft die mitgegebene Zahl in der Liste vorkommt. Wenn sie vorkommt und die Liste if len(reihe) >= groesse and reihe.count(
for i in range (len(reihe)-1, len(reihe)-groesse-1,-1): #mindestens so lang ist wie das Schiff sein soll, kann weitergemacht werden. orig) == 1:
# .count zählt, wie oft die mitgegebene Zahl in der Liste vorkommt. Wenn
# sie vorkommt und die Liste mindestens so lang ist wie das Schiff sein
# soll, kann weitergemacht werden
for i in range(len(reihe) - 1,
len(reihe) - groesse - 1,
-1):
if orientierung == 0: if orientierung == 0:
if checkUmfeld (spielerFeld, spitze[0], i): if checkUmfeld(spielerFeld, spitze[0], i):
summe += 1 summe += 1
else: else:
if checkUmfeld (spielerFeld, i, spitze[1]): if checkUmfeld(spielerFeld, i, spitze[1]):
summe += 1 summe += 1
if summe == groesse: if summe == groesse:
for i in range (len(reihe)-1, len(reihe)-groesse-1,-1): for i in range(len(reihe) - 1,
len(reihe) - groesse - 1, -1):
if orientierung == 0: if orientierung == 0:
setFeld (spielerFeld, spitze[0], i, 2) setFeld(spielerFeld, spitze[0], i, 2)
setFeld (belegFeld, spitze[0], i, groesse) # Damit später abgerufen werden kann, wie groß das Schiff auf dem Feld ist. setFeld(belegFeld, spitze[0], i,
groesse)
# Damit später abgerufen werden kann, wie groß das Schiff auf dem Feld ist
else: else:
setFeld (spielerFeld, i, spitze[1], 2) setFeld(spielerFeld, i, spitze[1], 2)
setFeld (belegFeld, i, spitze[1], groesse) # Damit später abgerufen werden kann, wie groß das Schiff auf dem Feld ist. setFeld(belegFeld, i, spitze[1],
groesse)
if summe != groesse: if summe != groesse:
spitze [counterind] += 1 spitze[counterind] += 1
versuch += 1 versuch += 1
else: else:
spielerFeld = makeFeld () spielerFeld = makeFeld()
versuch = 0 versuch = 0
if summeFeld(spielerFeld) != feldsumme + groesse*2 : if summeFeld(spielerFeld) != feldsumme + groesse * 2:
spielerFeld = makeFeld () spielerFeld = makeFeld()
setSchiff (spielerFeld, groesse) setSchiff(spielerFeld, groesse)
def fuellFeld (Feld, belegFeld): def fuellFeld(Feld, belegFeld):
for i in range (1): for i in range(1):
setSchiff (Feld, 4, belegFeld) setSchiff(Feld, 4, belegFeld)
for i in range (2): for i in range(2):
setSchiff (Feld, 3, belegFeld) setSchiff(Feld, 3, belegFeld)
for i in range (2): for i in range(2):
setSchiff (Feld, 2, belegFeld) setSchiff(Feld, 2, belegFeld)
for i in range (3): for i in range(3):
setSchiff (Feld, 1, belegFeld) setSchiff(Feld, 1, belegFeld)
def schiffVersenkt (spielerFeld, belegFeld, treffer): def schiffVersenkt(spielerFeld, belegFeld, treffer):
gr = getFeld (belegFeld, treffer [0], treffer [1]) gr = getFeld(belegFeld, treffer[0], treffer[1])
if gr == 1: if gr == 1:
for i in range (-1, 2, 2): for i in range(-1, 2, 2):
if 0 <= treffer [0] + i < matrixgr: if 0 <= treffer[0] + i < matrixgr:
setFeld (spielerFeld, treffer [0]+i, treffer [1], 1) setFeld(spielerFeld, treffer[0] + i, treffer[1], 1)
for i in range (-1, 2, 2): for i in range(-1, 2, 2):
if 0 <= treffer [1] + i < matrixgr: if 0 <= treffer[1] + i < matrixgr:
setFeld (spielerFeld, treffer [0], treffer [1]+i, 1) setFeld(spielerFeld, treffer[0], treffer[1] + i, 1)
return True return True
schiff = [treffer] schiff = [treffer]
for i in range (-1, 2, 2): for i in range(-1, 2, 2):
if 0 <= treffer [0] + i < matrixgr: if 0 <= treffer[0] + i < matrixgr:
if getFeld(belegFeld, treffer [0] + i, treffer [1]) == gr: if getFeld(belegFeld, treffer[0] + i, treffer[1]) == gr:
e = 1 e = 1
while 0<= treffer [0] + e*i < matrixgr and getFeld (belegFeld, treffer [0] + e*i, treffer [1]) == gr: while 0 <= treffer[0]+e*i<matrixgr and getFeld(belegFeld,
schiff += [[treffer[0]+e*i, treffer [1]]] treffer[
0]+e*i,
treffer[
1])==gr:
schiff += [[treffer[0] + e * i, treffer[1]]]
e += 1 e += 1
for i in range (-1, 2, 2): for i in range(-1, 2, 2):
if 0 <= treffer [1] + i < matrixgr: if 0 <= treffer[1] + i < matrixgr:
if getFeld(belegFeld, treffer [0], treffer [1] + i) == gr: if getFeld(belegFeld, treffer[0], treffer[1] + i) == gr:
e = 1 e = 1
while 0<= treffer [1] + e*i < matrixgr and getFeld (belegFeld, treffer [0], treffer [1] + e*i) == gr: while 0 <= treffer[1]+e*i<matrixgr and getFeld(belegFeld,
schiff += [[treffer[0], treffer [1]+e*i]] treffer[0],
treffer[
1]+e*i)==gr:
schiff += [[treffer[0], treffer[1] + e * i]]
e += 1 e += 1
for i in schiff: for i in schiff:
if getFeld (spielerFeld, i[0], i[1]) == 2: if getFeld(spielerFeld, i[0], i[1]) == 2:
return False return False
for i in schiff: for i in schiff:
for e in range (-1,2,2): for e in range(-1, 2, 2):
if 0 <= i[0] + e < matrixgr: if 0 <= i[0] + e < matrixgr:
if getFeld (spielerFeld, i[0]+e, i[1]) != 3: if getFeld(spielerFeld, i[0] + e, i[1]) != 3:
setFeld (spielerFeld, i[0]+e, i[1], 1) setFeld(spielerFeld, i[0] + e, i[1], 1)
for e in range (-1,2,2): for e in range(-1, 2, 2):
if 0 <= i[1] + e < matrixgr: if 0 <= i[1] + e < matrixgr:
if getFeld (spielerFeld, i[0], i[1]+e) != 3: if getFeld(spielerFeld, i[0], i[1] + e) != 3:
setFeld (spielerFeld, i[0], i[1]+e, 1) setFeld(spielerFeld, i[0], i[1] + e, 1)
return True return True
def feldWahl(spielerFeld, belegSpFeld):
def feldWahl (spielerFeld, belegSpFeld):
feld = str(input("Wähle das Feld, das abgeschossen werden soll! ")) feld = str(input("Wähle das Feld, das abgeschossen werden soll! "))
feld.replace (" ", "") if (len(feld) != 2) or (not feld[0].isalpha()) or (not feld[1].isdigit()):
if (len(feld) != 2 ) or (not feld[0].isalpha ()) or (not feld[1].isdigit()): print(
print ("Fehlerhafte Eingabe! \n Ein Feld wird beispielsweise folgendermaßen angegeben:\n A1 [Enter]") "Fehlerhafte Eingabe! \n Ein Feld wird beispielsweise "
feldWahl (spielerFeld, belegSpFeld) "folgendermaßen angegeben:\n A1 [Enter]")
return 0 # Rückgabe, damit die Funktion nicht mit falschem Wert weiterläuft feldWahl(spielerFeld, belegSpFeld)
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')
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):
print("Dieses Feld existiert nicht! Bitte ein anderes wählen!")
feldWahl(spielerFeld)
return 0 # Rückgabe, damit die Funktion nicht
# mit falschem Wert weiterläuft
if not (0 <= feld [0] <= matrixgr-1 and 0 <= feld [1] <= matrixgr-1): wert = getFeld(spielerFeld, feld[0], feld[1])
print ("Dieses Feld existiert nicht! Bitte ein anderes wählen!")
feldWahl (spielerFeld)
return 0 # Rückgabe, damit die Funktion nicht mit falschem Wert weiterläuft
wert = getFeld (spielerFeld,feld[0],feld[1])
if wert == 1 or wert == 3: if wert == 1 or wert == 3:
print ("Dieses Feld wurde schon abgeschossen! Bitte ein anderes wählen!") print("Dieses Feld wurde schon abgeschossen! Bitte ein anderes wählen!")
feldWahl (spielerFeld, belegSpFeld) feldWahl(spielerFeld, belegSpFeld)
return 0 # Rückgabe, damit die Funktion nicht mit falschem Wert weiterläuft return 0 # Rückgabe, damit die Funktion nicht mit falschem Wert
# weiterläuft
setFeld (spielerFeld, feld[0],feld[1], 5) # Treffer wird eingetragen setFeld(spielerFeld, feld[0], feld[1], 5) # Treffer wird eingetragen
printFelder() printFelder()
if wert + 1 == 3:
if wert+1 == 3: if not zweicheck(spielerFeld):
if not zweicheck (spielerFeld): print("GRATULATION! Du hast gewonnen!!!")
print ("GRATULATION! Du hast gewonnen!!!")
return 0 return 0
vers = '' vers = ''
if schiffVersenkt (spielerFeld, belegSpFeld, feld): if schiffVersenkt(spielerFeld, belegSpFeld, feld):
print ("\n\n\n") print("\n\n\n")
printFelder() printFelder()
vers = "Das ganze Schiffe wurde versenkt!" vers = "Das ganze Schiffe wurde versenkt!"
print ("["+chr(feld[0]+65)+str(feld[1]+1)+"]","TREFFER!", vers, "\nEs darf direkt ein neues Feld gewählt werden!") print("[" + chr(feld[0] + 65) + str(feld[1] + 1) + "]", "TREFFER!",
feldWahl (spielerFeld, belegSpFeld) vers, "\nEs darf direkt ein neues Feld gewählt werden!")
feldWahl(spielerFeld, belegSpFeld)
else: else:
print ("["+chr(feld[0]+65)+str(feld[1]+1)+"]","Leider kein Treffer! Der Bot zieht nun...") print("[" + chr(feld[0] + 65) + str(feld[1] + 1) + "]",
"Leider kein Treffer! Der Bot zieht nun...")
def Initialisiere (): # Erstellt die beiden Felder
def Initialisiere(): # Erstellt die beiden Felder
global gegnerFeld, eigenFeld, belegEigFeld, belegGegFeld global gegnerFeld, eigenFeld, belegEigFeld, belegGegFeld
gegnerFeld= makeFeld () gegnerFeld = makeFeld()
belegGegFeld = makeFeld () belegGegFeld = makeFeld()
fuellFeld (gegnerFeld, belegGegFeld) fuellFeld(gegnerFeld, belegGegFeld)
while summeFeld (gegnerFeld) != 34: while summeFeld(gegnerFeld) != 34:
gegnerFeld= makeFeld () gegnerFeld = makeFeld()
fuellFeld (gegnerFeld, belegGegFeld) fuellFeld(gegnerFeld, belegGegFeld)
gegnerFeld += ['Gegnerisches Feld:'] gegnerFeld += ['Gegnerisches Feld:']
print ("Das gegnerische Feld wurde generiert!") print("Das gegnerische Feld wurde generiert!")
eing = '' eing = ''
while eing.lower () != ('j'): while eing.lower() != ('j'):
eigenFeld = makeFeld () eigenFeld = makeFeld()
belegEigFeld = makeFeld () belegEigFeld = makeFeld()
fuellFeld (eigenFeld, belegEigFeld) fuellFeld(eigenFeld, belegEigFeld)
while summeFeld (eigenFeld) != 34: while summeFeld(eigenFeld) != 34:
belegEigFeld = makeFeld () belegEigFeld = makeFeld()
eigenFeld= makeFeld () eigenFeld = makeFeld()
fuellFeld (eigenFeld, belegEigFeld) fuellFeld(eigenFeld, belegEigFeld)
eigenFeld += ['Eigenes Feld:'] eigenFeld += ['Eigenes Feld:']
printFelder() printFelder()
eing = str(input("Ist dieses Feld akzeptabel? [J: Ja / Irgendwas: Nein, Neues!] ")) eing = str(input(
print ("\n\n\n") "Ist dieses Feld akzeptabel? [J: Ja / Irgendwas: Nein, Neues!] "))
print("\n\n\n")
def SchwierigkeitsWahl (): def SchwierigkeitsWahl():
try: try:
diff = float(input("Bitte wähle die Schwierigkeit von 0-sehr einfach bis 10-sehr schwer! [0-10] ")) diff = float(input(
"Bitte wähle die Schwierigkeit von 0-sehr einfach bis "
"10-sehr schwer! [0-10] "))
except: except:
print ("Keine valide Eingabe!") print("Keine valide Eingabe!")
SchwierigkeitsWahl () SchwierigkeitsWahl()
return 0 return 0
if not (0<=diff<= 10): if not (0 <= diff <= 10):
print ("Der Schwierigkeitsgrad muss zwischen 0 und 10 sein!") print("Der Schwierigkeitsgrad muss zwischen 0 und 10 sein!")
SchwierigkeitsWahl () SchwierigkeitsWahl()
return 0 return 0
return diff return diff
def botwahl (spielerFeld, belegSpFeld, diff): def botwahl(spielerFeld, belegSpFeld, diff):
diff *= 10 diff *= 10
wurf = random.randint (-5, 105) wurf = random.randint(-5, 105)
feld = [random.randint (0, matrixgr-1), random.randint (0, matrixgr-1)] feld = [random.randint(0, matrixgr-1), random.randint(0, matrixgr-1)]
treffer = False treffer = False
if diff >= wurf: if diff >= wurf:
while getFeld(spielerFeld, feld [0], feld [1]) != 2: while getFeld(spielerFeld, feld[0], feld[1]) != 2:
feld = [random.randint (0, matrixgr-1), random.randint (0, matrixgr-1)] feld = [random.randint(0, matrixgr - 1),
random.randint(0, matrixgr - 1)]
treffer = True treffer = True
else: else:
while getFeld(spielerFeld, feld [0], feld [1]) != 0: while getFeld(spielerFeld, feld[0], feld[1]) != 0:
feld = [random.randint (0, matrixgr-1), random.randint (0, matrixgr-1)] feld = [random.randint(0, matrixgr - 1),
random.randint(0, matrixgr - 1)]
setFeld (spielerFeld, feld[0], feld[1], 5) setFeld(spielerFeld, feld[0], feld[1], 5)
printFelder() printFelder()
if treffer: if treffer:
if not zweicheck (spielerFeld): if not zweicheck(spielerFeld):
print ("Schade! Der Bot hat gewonnen!") print("Schade! Der Bot hat gewonnen!")
return 0 return 0
if schiffVersenkt (spielerFeld, belegSpFeld, feld): if schiffVersenkt(spielerFeld, belegSpFeld, feld):
print ("\n\n\n") print("\n\n\n")
printFelder () printFelder()
print ("["+chr(feld[0]+65)+str(feld[1]+1)+"]","Der Bot hat getroffen! Er darf noch ein Feld wählen!") print("[" + chr(feld[0] + 65) + str(feld[1] + 1) + "]",
time.sleep (1) "Der Bot hat getroffen! Er darf noch ein Feld wählen!")
botwahl (spielerFeld, belegSpFeld, diff/10.25) time.sleep(1)
botwahl(spielerFeld, belegSpFeld, diff / 10.25)
else: else:
print ("["+chr(feld[0]+65)+str(feld[1]+1)+"]","Der Bot hat nicht getroffen! Du bist nun dran!") print("[" + chr(feld[0] + 65) + str(feld[1] + 1) + "]",
"Der Bot hat nicht getroffen! Du bist nun dran!")
def start():
startzeit = time.time()
level = SchwierigkeitsWahl()
def start (): Initialisiere()
startzeit = time.time () printFelder()
level = SchwierigkeitsWahl ()
Initialisiere ()
printFelder ()
while True: while True:
feldWahl (gegnerFeld, belegGegFeld) feldWahl(gegnerFeld, belegGegFeld)
if not zweicheck (gegnerFeld): if not zweicheck(gegnerFeld):
break break
time.sleep (1) time.sleep(1)
botwahl (eigenFeld, belegEigFeld, level) botwahl(eigenFeld, belegEigFeld, level)
if not zweicheck (eigenFeld): if not zweicheck(eigenFeld):
break break
print ("Das Spiel hat", int((time.time()-startzeit)//60), "Minuten", int(((time.time()-startzeit)%60)//1), "Sekunden gedauert.") print("Das Spiel hat", int((time.time() - startzeit) // 60), "Minuten",
w = str (input ("Noch eine Runde? [J: Ja/Irgendwas: Nein] ")) int(((time.time() - startzeit) % 60) // 1), "Sekunden gedauert.")
w = str(input("Noch eine Runde? [J: Ja/Irgendwas: Nein] "))
if w.lower() == 'j': if w.lower() == 'j':
start () start()
start()