import pygame
import copy
import random
import sys
q = -1
o = -1
class MeinSpiel:
    # Die Nummer in der Liste ist die Zahl, die im Spielfeld gespeichert wird:
    # 0 = Boden, 1 = Ritter (Spieler), 2 = Goblin (Gegner), 3 = Herz(Lebensanzeige)
    bilder = [
        "T:\E-To-Linus-Hasenspiel-OOP (1)\e-to-linus-hasenspiel/Bilder/Feld_Boden.png",
        "T:\E-To-Linus-Hasenspiel-OOP (1)\e-to-linus-hasenspiel/Bilder/Feld_Ritter.png",
        "T:\E-To-Linus-Hasenspiel-OOP (1)\e-to-linus-hasenspiel/Bilder/Feld_Goblin.png",
        "T:\E-To-Linus-Hasenspiel-OOP (1)\e-to-linus-hasenspiel/Bilder/Herz.png",
    ]

    def __init__(self, felderX, felderY):
        self.felderX = felderX
        self.felderY = felderY
        self.spielfeld = []
        for x in range(felderX):
            self.spielfeld.append([])
            for y in range(felderY):
                self.spielfeld[x].append(0)

        
        
    def anfangsKonfiguration(self):
        self.spielfeld[6][6] = 1          # Ritter
        self.herzen = [(0, 0), (1, 0), (2, 0)]

        for zeile, spalte in self.herzen:
            self.spielfeld[zeile][spalte] = 3
        self.gegnerSetzen(self.spielfeld)  # Goblin
        self.leben = 3
        self.pause = 500                  # Millisekunden zwischen zwei Goblin-Schritten
        self.letzte_bewegung = 0
        self.schadensPause = 1000  # 1000 Millisekunden = 1 Sekunde
        self.letzterTreffer = -self.schadensPause
    def gegnerSetzen(self, feld):
        # Goblin auf ein zufälliges leeres Feld setzen
        while True:
            x = random.randint(0, self.felderX - 1)
            y = random.randint(0, self.felderY - 1)
            if feld[x][y] == 0:
                feld[x][y] = 2
                return

    def finde(self, zahl):
        # Sucht im Spielfeld nach einer Figur und gibt x und y zurück
        for x in range(len(self.spielfeld)):
            for y in range(len(self.spielfeld[x])):
                if self.spielfeld[x][y] == zahl:
                    return x, y
        

    def treffer(self, feld):
        jetzt = pygame.time.get_ticks()

        if jetzt - self.letzterTreffer >= self.schadensPause:
            self.leben -= 1
            self.letzterTreffer = jetzt

        if self.leben <= 0:
            pygame.quit()
            sys.exit()


    def tasteGedrueckt(self, taste):
        kontrollfeld = copy.deepcopy(self.spielfeld)

        dx, dy = 0, 0
        if taste == pygame.K_w:
            dy = -1
        if taste == pygame.K_s:
            dy = 1
        if taste == pygame.K_a:
            dx = -1
        if taste == pygame.K_d:
            dx = 1


        # Ritter bewegen (Änderungen nur im Kontrollfeld)
        if dx != 0 or dy != 0:
            for x in range(len(self.spielfeld)):
                for y in range(len(self.spielfeld[x])):
                    if self.spielfeld[x][y] == 1:
                        neuX = x + dx
                        neuY = y + dy
                        if 0 <= neuX < self.felderX and 0 <= neuY < self.felderY:
                            gegner_im_weg = kontrollfeld[neuX][neuY] == 2
                            kontrollfeld[x][y] = 0
                            kontrollfeld[neuX][neuY] = 1
                            if gegner_im_weg:
                                self.treffer(kontrollfeld)

        # Angriff mit Leertaste: Goblin muss maximal 1 Feld entfernt sein
        if taste == pygame.K_SPACE:
            rx, ry = self.finde(1)
            gx, gy = self.finde(2)
            if abs(rx - gx) <= 1 and abs(ry - gy) <= 1:
                kontrollfeld[gx][gy] = 0
                self.gegnerSetzen(kontrollfeld)
                self.pause = max(100, self.pause - 15)

        self.spielfeld = kontrollfeld

    def update(self):
        # Anzeige der Leben im Fenstertitel
        pygame.display.set_caption("Medival Goblin Dungeon - Leben: " + str(self.leben))

        # Goblin läuft alle "pause" Millisekunden einen Schritt auf den Ritter zu
        jetzt = pygame.time.get_ticks()
        if jetzt - self.letzte_bewegung > self.pause:
            self.letzte_bewegung = jetzt
            kontrollfeld = copy.deepcopy(self.spielfeld)
            rx, ry = self.finde(1)
            gx, gy = self.finde(2)

            neuX, neuY = gx, gy
            if gx < rx:
                neuX += 1
            elif gx > rx:
                neuX -= 1
            elif gy < ry:
                neuY += 1
            elif gy > ry:
                neuY -= 1

            kontrollfeld[gx][gy] = 0
            if kontrollfeld[neuX][neuY] == 1:
                self.treffer(kontrollfeld)
            else:
                kontrollfeld[neuX][neuY] = 2