219 lines
8.5 KiB
Python
219 lines
8.5 KiB
Python
## TO DO: NUR DIE SCHON ABGESCHOSSENEN FELDER ANZEIGEN LASSEN
|
|
|
|
import random
|
|
|
|
matrixgr = 7
|
|
|
|
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 1 2 3 4 5 6 7")
|
|
NZeile = 'A'
|
|
for i in spielerFeld:
|
|
zeile = ''
|
|
for n in i:
|
|
if n == [0]:
|
|
zeile+=' [ ] ' # Feld ist leer
|
|
elif n== [1]:
|
|
zeile+=' [ . ] ' # Feld wurde abgeschossen
|
|
elif n==[2]:
|
|
if modus == 'a': # Zeige ALLE Felder an
|
|
zeile+=' [ ■ ] ' # Auf dem Feld ist ein ungetroffenes Schiff
|
|
elif modus == 't': # Zeige NUR TREFFER an
|
|
zeile+=' [ ] '
|
|
elif n==[3]:
|
|
zeile+=' [ X ] ' # Das Schiff auf dem Feld wurde getroffen
|
|
print ('\n' + NZeile + ' ' + 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
|
|
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 checkUmfeld (spielerFeld, zeile, spalte):
|
|
if getFeld (spielerFeld, zeile, spalte) != 0:
|
|
return False
|
|
summe = 0
|
|
if zeile < matrixgr and spalte <matrixgr and zeile >= 0 and spalte >= 0:
|
|
if zeile+1 < matrixgr:
|
|
if getFeld (spielerFeld, zeile+1, spalte) == 0:
|
|
summe += 1
|
|
else:
|
|
summe+= 1
|
|
|
|
if spalte+1 < matrixgr:
|
|
if getFeld (spielerFeld, zeile, spalte+1) == 0:
|
|
summe += 1
|
|
else:
|
|
summe+= 1
|
|
|
|
if zeile-1 >= 0:
|
|
if getFeld (spielerFeld, zeile-1, spalte) == 0:
|
|
summe += 1
|
|
else:
|
|
summe+= 1
|
|
|
|
if spalte-1 >= 0:
|
|
if getFeld (spielerFeld, zeile, spalte-1) == 0:
|
|
summe += 1
|
|
else:
|
|
summe+= 1
|
|
|
|
if summe < 4:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
|
|
def setSchiff (spielerFeld, groesse):
|
|
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)
|
|
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
|
|
for i in range (len(reihe)-1, len(reihe)-groesse-1,-1): #mindestens so lang ist wie das Schiff sein soll, kann weitergemacht werden.
|
|
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)
|
|
else:
|
|
setFeld (spielerFeld, i, spitze[1], 2)
|
|
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):
|
|
for i in range (1):
|
|
setSchiff (Feld, 4)
|
|
|
|
for i in range (2):
|
|
setSchiff (Feld, 3)
|
|
|
|
for i in range (2):
|
|
setSchiff (Feld, 2)
|
|
|
|
for i in range (3):
|
|
setSchiff (Feld, 1)
|
|
|
|
|
|
def feldWahl (spielerFeld):
|
|
feld = str(input("Wähle das Feld, das abgeschossen werden soll! "))
|
|
if len(feld) != 2:
|
|
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):
|
|
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)
|
|
return 0 # Rückgabe, damit die Funktion nicht mit falschem Wert weiterläuft
|
|
|
|
setFeld (spielerFeld, feld[0],feld[1], wert + 1) # Treffer wird eingetragen
|
|
printFeld (spielerFeld, 't')
|
|
|
|
|
|
if wert+1 == 3:
|
|
print ("TREFFER! \n Es darf direkt ein neues Feld gewählt werden!")
|
|
feldWahl (spielerFeld)
|
|
else:
|
|
print ("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)
|
|
|
|
print ("Das gegnerische Feld wurde generiert!\nDieses wurde für dich zufällig generiert: ")
|
|
akzeptiert = False
|
|
eing = ''
|
|
while eing != ('J' or 'j'):
|
|
if eing != '':
|
|
print ("Neues Feld wird generiert. Das kann etwas dauern...")
|
|
eigenFeld = makeFeld ()
|
|
fuellFeld (eigenFeld)
|
|
while summeFeld (eigenFeld) != 34:
|
|
eigenFeld= makeFeld ()
|
|
fuellFeld (eigenFeld)
|
|
printFeld (eigenFeld, 'a')
|
|
eing = str(input("Ist dieses Feld akzeptabel? [J: Ja / Irgendwas: Nein, Neues!] "))
|
|
|
|
def start ():
|
|
# SchwierigkeitsWahl ()
|
|
Initialisiere ()
|
|
print ("So sieht das gegnerische Feld aus:")
|
|
printFeld (gegnerFeld, 't')
|
|
while True:
|
|
feldWahl (gegnerFeld)
|
|
|
|
start () |