## TO DO: NUR DIE SCHON  ABGESCHOSSENEN FELDER ANZEIGEN LASSEN
## TO DO: DIE SCHIFFE AUCH VERTIKAL PLATZIEREN --> FIXEN
## TO DO: CHECKUMFELD FIXEN


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):
    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]:
                zeile+=' [ ■ ] '    # Auf dem Feld ist ein ungetroffenes Schiff
            elif n==[3]:
                zeile+=' [ X ] '    # Das Schiff auf dem Feld wurde getroffen
        print ('\n'+zeile)
    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):
    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 (getFeld (spielerFeld, spitze[0], spitze[1]) == 0) and 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 checkUmfeld (spielerFeld, spitze[0], i):
                                    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: 
            print ("Neuer Versuch...")
            printFeld (spielerFeld)
            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)  


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: \n")
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)
    eing = str(input("Ist dieses Feld akzeptabel? [J: Ja / Irgendwas: Nein, Neues!] "))