## 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 ()