426 lines
15 KiB
Python
426 lines
15 KiB
Python
import random, time
|
|
|
|
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
|
|
return feld
|
|
|
|
|
|
# RAUS :
|
|
# noinspection PyTypeChecker
|
|
def printFelder():
|
|
# 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
|
|
|
|
for i in output:
|
|
i += [" 1 2 3 4 5 6 7 "]
|
|
|
|
felder = [gegnerFeld, eigenFeld]
|
|
for f in range(2): # f als erstes 0, dann 1
|
|
NZeile = 'A' # Bezeichner für die Zeile
|
|
for i in felder[f]:
|
|
zeile = ''
|
|
for n in i:
|
|
if n == [0]:
|
|
if f == 1: # Zeige ALLE Felder an
|
|
zeile += ' [ ] ' # Feld ist leer
|
|
elif f == 0:
|
|
zeile += ' [ ~ ] '
|
|
# Zeige NUR TREFFER an, ~ um vom eigenen Feld zu differenzieren
|
|
elif n == [1]:
|
|
zeile += ' [ . ] ' # Feld wurde abgeschossen
|
|
elif n == [2]:
|
|
if f == 1: # Zeige ALLE Felder an
|
|
zeile += ' [ ■ ] '
|
|
# Auf dem Feld ist ein ungetroffenes Schiff
|
|
elif f == 0: # Zeige NUR TREFFER an
|
|
zeile += ' [ ~ ] '
|
|
elif n == [3]:
|
|
zeile += ' [ X ] '
|
|
# Das Schiff auf dem Feld wurde getroffen
|
|
|
|
if ord(NZeile.lower()) - 97 < matrixgr:
|
|
output[f] += [NZeile + ' ' + zeile]
|
|
else:
|
|
output[f] += [' ' + zeile]
|
|
NZeile = chr(ord(NZeile) + 1)
|
|
|
|
for i in range(0, len(output[0])):
|
|
print(output[0][i], ' ' + output[1][i])
|
|
print("")
|
|
|
|
|
|
def setFeld(spielerFeld, zeile, spalte, wert):
|
|
if wert == 5:
|
|
wert = getFeld(spielerFeld, zeile,
|
|
spalte) + 1 # Um den Wert im Feld um eins zu erhöhen
|
|
spielerFeld[zeile][spalte][0] = wert
|
|
|
|
|
|
def getFeld(spielerFeld, zeile, spalte):
|
|
# zeile = ord(zeile.lower())-97
|
|
# return spielerFeld [zeile][spalte-1][0]
|
|
return spielerFeld[zeile][spalte][0]
|
|
|
|
|
|
def summeFeld(spielerFeld):
|
|
summe = 0
|
|
for i in spielerFeld:
|
|
for e in i:
|
|
for n in e:
|
|
summe += n
|
|
return summe
|
|
|
|
|
|
def zweicheck(spielerFeld):
|
|
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) == 2:
|
|
# Wenn auf dem Feld schon ein Schiff ist, kann der Check
|
|
# direkt abgebrochen werden
|
|
return False
|
|
summe = 0
|
|
if matrixgr > zeile >= 0 and matrixgr > spalte >= 0:
|
|
if zeile + 1 < matrixgr:
|
|
if getFeld(spielerFeld, zeile + 1, spalte) != 2:
|
|
summe += 1
|
|
else:
|
|
summe += 1
|
|
|
|
if spalte + 1 < matrixgr:
|
|
if getFeld(spielerFeld, zeile, spalte + 1) != 2:
|
|
summe += 1
|
|
else:
|
|
summe += 1
|
|
|
|
if zeile - 1 >= 0:
|
|
if getFeld(spielerFeld, zeile - 1, spalte) != 2:
|
|
summe += 1
|
|
else:
|
|
summe += 1
|
|
|
|
if spalte - 1 >= 0:
|
|
if getFeld(spielerFeld, zeile, spalte - 1) != 2:
|
|
summe += 1
|
|
else:
|
|
summe += 1
|
|
|
|
if summe < 4:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
|
|
def setSchiff(spielerFeld, groesse, belegFeld):
|
|
feldsumme = summeFeld(spielerFeld)
|
|
versuch = 0
|
|
while summeFeld(spielerFeld) != feldsumme + groesse * 2:
|
|
if versuch < 25:
|
|
spitze = [random.randint(0, matrixgr - 1),
|
|
random.randint(0, matrixgr - 1)]
|
|
if checkUmfeld(spielerFeld, spitze[0], spitze[1]):
|
|
# spitze[0] ZEILE, spitze[1] SPALTE
|
|
if groesse == 1:
|
|
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.
|
|
else:
|
|
reihe = []
|
|
counter = 0
|
|
# Jetzt wird entschieden, ob das Schiff vertikal oder
|
|
# horizontal ausgerichtet sein soll.
|
|
orientierung = random.randint(0, 1)
|
|
# 0: horizontal, 1: vertikal
|
|
if orientierung == 0:
|
|
orig = spitze[1]
|
|
spitze[1] = counter
|
|
counterind = 1
|
|
# damit der Counter noch bearbeitet werden kann
|
|
else:
|
|
orig = spitze[0]
|
|
spitze[0] = counter
|
|
counterind = 0
|
|
|
|
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]):
|
|
reihe += [spitze[counterind]]
|
|
else:
|
|
reihe = []
|
|
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 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 checkUmfeld(spielerFeld, spitze[0], i):
|
|
summe += 1
|
|
else:
|
|
if checkUmfeld(spielerFeld, i, spitze[1]):
|
|
summe += 1
|
|
if summe == groesse:
|
|
for i in range(len(reihe) - 1,
|
|
len(reihe) - groesse - 1, -1):
|
|
if orientierung == 0:
|
|
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
|
|
else:
|
|
setFeld(spielerFeld, i, spitze[1], 2)
|
|
setFeld(belegFeld, i, spitze[1],
|
|
groesse)
|
|
|
|
if summe != groesse:
|
|
spitze[counterind] += 1
|
|
versuch += 1
|
|
else:
|
|
spielerFeld = makeFeld()
|
|
versuch = 0
|
|
|
|
if summeFeld(spielerFeld) != feldsumme + groesse * 2:
|
|
spielerFeld = makeFeld()
|
|
setSchiff(spielerFeld, groesse)
|
|
|
|
|
|
def fuellFeld(Feld, belegFeld):
|
|
for i in range(1):
|
|
setSchiff(Feld, 4, belegFeld)
|
|
|
|
for i in range(2):
|
|
setSchiff(Feld, 3, belegFeld)
|
|
|
|
for i in range(2):
|
|
setSchiff(Feld, 2, belegFeld)
|
|
|
|
for i in range(3):
|
|
setSchiff(Feld, 1, belegFeld)
|
|
|
|
|
|
def schiffVersenkt(spielerFeld, belegFeld, treffer):
|
|
gr = getFeld(belegFeld, treffer[0], treffer[1])
|
|
|
|
if gr == 1:
|
|
for i in range(-1, 2, 2):
|
|
if 0 <= treffer[0] + i < matrixgr:
|
|
setFeld(spielerFeld, treffer[0] + i, treffer[1], 1)
|
|
for i in range(-1, 2, 2):
|
|
if 0 <= treffer[1] + i < matrixgr:
|
|
setFeld(spielerFeld, treffer[0], treffer[1] + i, 1)
|
|
return True
|
|
|
|
schiff = [treffer]
|
|
|
|
for i in range(-1, 2, 2):
|
|
if 0 <= treffer[0] + i < matrixgr:
|
|
if getFeld(belegFeld, treffer[0] + i, treffer[1]) == gr:
|
|
e = 1
|
|
while 0 <= treffer[0]+e*i<matrixgr and getFeld(belegFeld,
|
|
treffer[
|
|
0]+e*i,
|
|
treffer[
|
|
1])==gr:
|
|
schiff += [[treffer[0] + e * i, treffer[1]]]
|
|
e += 1
|
|
|
|
for i in range(-1, 2, 2):
|
|
if 0 <= treffer[1] + i < matrixgr:
|
|
if getFeld(belegFeld, treffer[0], treffer[1] + i) == gr:
|
|
e = 1
|
|
while 0 <= treffer[1]+e*i<matrixgr and getFeld(belegFeld,
|
|
treffer[0],
|
|
treffer[
|
|
1]+e*i)==gr:
|
|
schiff += [[treffer[0], treffer[1] + e * i]]
|
|
e += 1
|
|
|
|
for i in schiff:
|
|
if getFeld(spielerFeld, i[0], i[1]) == 2:
|
|
return False
|
|
|
|
for i in schiff:
|
|
for e in range(-1, 2, 2):
|
|
if 0 <= i[0] + e < matrixgr:
|
|
if getFeld(spielerFeld, i[0] + e, i[1]) != 3:
|
|
setFeld(spielerFeld, i[0] + e, i[1], 1)
|
|
|
|
for e in range(-1, 2, 2):
|
|
if 0 <= i[1] + e < matrixgr:
|
|
if getFeld(spielerFeld, i[0], i[1] + e) != 3:
|
|
setFeld(spielerFeld, i[0], i[1] + e, 1)
|
|
|
|
return True
|
|
|
|
|
|
def feldWahl(spielerFeld, belegSpFeld):
|
|
feld = str(input("Wähle das Feld, das abgeschossen werden soll! "))
|
|
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, 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')
|
|
|
|
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
|
|
|
|
wert = getFeld(spielerFeld, feld[0], feld[1])
|
|
|
|
if wert == 1 or wert == 3:
|
|
print("Dieses Feld wurde schon abgeschossen! Bitte ein anderes wählen!")
|
|
feldWahl(spielerFeld, belegSpFeld)
|
|
return 0 # Rückgabe, damit die Funktion nicht mit falschem Wert
|
|
# weiterläuft
|
|
|
|
setFeld(spielerFeld, feld[0], feld[1], 5) # Treffer wird eingetragen
|
|
printFelder()
|
|
|
|
if wert + 1 == 3:
|
|
if not zweicheck(spielerFeld):
|
|
print("GRATULATION! Du hast gewonnen!!!")
|
|
return 0
|
|
vers = ''
|
|
if schiffVersenkt(spielerFeld, belegSpFeld, feld):
|
|
print("\n\n\n")
|
|
printFelder()
|
|
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!")
|
|
feldWahl(spielerFeld, belegSpFeld)
|
|
else:
|
|
print("[" + chr(feld[0] + 65) + str(feld[1] + 1) + "]",
|
|
"Leider kein Treffer! Der Bot zieht nun...")
|
|
|
|
|
|
def Initialisiere(): # Erstellt die beiden Felder
|
|
global gegnerFeld, eigenFeld, belegEigFeld, belegGegFeld
|
|
gegnerFeld = makeFeld()
|
|
belegGegFeld = makeFeld()
|
|
fuellFeld(gegnerFeld, belegGegFeld)
|
|
while summeFeld(gegnerFeld) != 34:
|
|
gegnerFeld = makeFeld()
|
|
fuellFeld(gegnerFeld, belegGegFeld)
|
|
gegnerFeld += ['Gegnerisches Feld:']
|
|
print("Das gegnerische Feld wurde generiert!")
|
|
eing = ''
|
|
while eing.lower() != ('j'):
|
|
eigenFeld = makeFeld()
|
|
belegEigFeld = makeFeld()
|
|
fuellFeld(eigenFeld, belegEigFeld)
|
|
while summeFeld(eigenFeld) != 34:
|
|
belegEigFeld = makeFeld()
|
|
eigenFeld = makeFeld()
|
|
fuellFeld(eigenFeld, belegEigFeld)
|
|
eigenFeld += ['Eigenes Feld:']
|
|
printFelder()
|
|
eing = str(input(
|
|
"Ist dieses Feld akzeptabel? [J: Ja / Irgendwas: Nein, Neues!] "))
|
|
print("\n\n\n")
|
|
|
|
|
|
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, belegSpFeld, 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)
|
|
printFelder()
|
|
if treffer:
|
|
if not zweicheck(spielerFeld):
|
|
print("Schade! Der Bot hat gewonnen!")
|
|
return 0
|
|
if schiffVersenkt(spielerFeld, belegSpFeld, feld):
|
|
print("\n\n\n")
|
|
printFelder()
|
|
print("[" + chr(feld[0] + 65) + str(feld[1] + 1) + "]",
|
|
"Der Bot hat getroffen! Er darf noch ein Feld wählen!")
|
|
time.sleep(1)
|
|
botwahl(spielerFeld, belegSpFeld, diff / 10.25)
|
|
else:
|
|
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()
|
|
Initialisiere()
|
|
printFelder()
|
|
while True:
|
|
feldWahl(gegnerFeld, belegGegFeld)
|
|
if not zweicheck(gegnerFeld):
|
|
break
|
|
time.sleep(1)
|
|
botwahl(eigenFeld, belegEigFeld, level)
|
|
if not zweicheck(eigenFeld):
|
|
break
|
|
|
|
print("Das Spiel hat", int((time.time() - startzeit) // 60), "Minuten",
|
|
int(((time.time() - startzeit) % 60) // 1), "Sekunden gedauert.")
|
|
w = str(input("Noch eine Runde? [J: Ja/Irgendwas: Nein] "))
|
|
if w.lower() == 'j':
|
|
start()
|
|
|
|
|
|
start()
|