README.md aktualisiert

README.md

@@ -7,5 +7,21 @@ Man hat einen Ritter der in der Mitte des Spielfelds startet und sich mit seinem
 #09.09.2026
 Heute habe ich relativ viel geschafft. Ich habe es hinbekommen der Spieler zu bewegen und habe außerdem noch mehrere Grafiken eingebaut wie zum Beispiel ein Herz für die Lebensanzeige und einen Kobold als Gegener. Jetzt probiere ich den Kobold zum Spieler gehen zu lassen. Jedoch läuft der Kobold noch aus dem Spielfeld heraus. Dies probiere ich nächste Woche zu verbessern.
 
+#22.09.2026
+Mein Plan für heute ist es, dass mein Spieler nicht sofort alle Leben verliert sobald er vom Gegner getroffen wird.
 
+#29.09.2026
+Heute möchte ich einfügen, dass sobald der Spieler getroffen wird das Leben in der oberen rechten Ecke auch wirklich verschwindet. Die Lösung dafür war eigentlich zeimlich simpel. Ich musste einfach nur in der Range Schleife die 3 durch die Variable Leben ändern.
+
+#30.09.2026
+Heute ist es mein Ziel, eine Hitbox für den Gegner zu machen damit ich es schaffe, dass man diesen töten kann mit einer Attacke vom Spieler. Dafür glaube ich, werde ich mit einem rectangle ein dreieck um den gegner machen und dieses etwas größer machen als der spieler selbst damit man den gegner schon vorher treffen kann und nicht erst wenn er direkt in einem steht. Ich bae dies gut umgesetzt bekommen. Der Spieler kann nu den Gegner töten und ich habe sogar es noch geschafft einzufügen, dass neue Gegner spawnen diese schneller werden und der Spieler das Speilfeld nicht verlassen kann.
+
+#06.10.2026
+Heute möchte ich es schaffen,dass man nach einer bestimmten Anzahl an getöteten Gegnern mehrere spawnen also zum Beispiel nach 10 getöteten Gegnern spawnen anstatt 1 nun 2 Gegner. Ich habe zwar probiert diese Idee umzusetzen, jedoch ist diese zu komplex, weshalb ertsmal davon absehe und probiere in der nächsten Stunde eine GameOver Screen zu machen.
+
+#07.10.2026
+Heute möchte ich einen GameOver Screen einfügen und vielleicht wenn ich es schaffe auch noch einen Starbildschrim.
+
+#28.10.2026
+Ich habe in den Ferien weiter an meinem Spiel gearbeite, sodass es nun den Vorgaben der Objektbasiertenprogrammierung entspricht. Jedoch habe ich noch nicht alles so umgesetzt bekommen wie vorher. Beispielsweise habe ich die Lebensanzeige noch nicht implementiert und der Gegner zieht dem Spieler auch noch zu schnell die Leben ab. Also ich habe es zwar hinbekommen, dass die Lebensanzeige oben in der rechten Ecke erscheint jedoch zieht der Gegner dem Spieler immernoch zu schnell die Leben ab.
 # Bildquellen:

meinspiel.py

@@ -1,23 +1,134 @@
-import copy
 import pygame
-
-Startpositionx = (2)
-Startpositiony = (2)
-
+import copy
+import random
+import sys
+q = -1
+o = -1
 class MeinSpiel:
-    bilder = ["Bilder/steinboden.png","Bilder/Grass.jpg","Bilder/Ritter2.png"]
-    spielfeld = [] 
+    # 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[5][5] = 0
+        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):
-        if pygame.K_w == taste:
-            print(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

starten.py

@@ -1,121 +1,55 @@
+# Importieren u. initialisieren der Pygame-Bibliothek
 from meinspiel import MeinSpiel
 import pygame
 from pygame.locals import *
-import random
-
 pygame.init()
 
-Spielerfigur = pygame.image.load("Bilder/Ritter2.png")
-Gegner = pygame.image.load("Bilder/Goblin.png")
-Herzen = pygame.image.load("Bilder/Herz.png")
 
-spielerX = 6
-spielerY = 6
-HerzX = -1
-
-GegnerX = (random.uniform(0,13))
-GegnerY = (random.uniform(0,13))
-Gegnerbewegung = 0.1
-
-print(GegnerY)
-print(GegnerX)
-
-# Variablen/KONSTANTEN
+# Variablen/KONSTANTEN setzen
 Breite, Hoehe = 840, 840
 Pixel = 60
 FelderX, FelderY = int(Breite / Pixel), int(Hoehe / Pixel)
-FPS = 60
-
-SCHWARZ = (0, 0, 0)
-WEISS = (255, 255, 255)
-
+FPS  = 60 
+SCHWARZ = ( 0, 0, 0)
+WEISS   = ( 255, 255, 255)
 pyGameBilder = []
 
-# Mein Spiel erstellen
+# Bilder aus meinSpiel werden für pygame vorbereitet
 meinSpiel = MeinSpiel(FelderX, FelderY)
-
-# Bilder laden
 for fname in meinSpiel.bilder:
     pyGameBilder.append(pygame.image.load(fname))
 
-# Anfangskonfiguration
+#Anfangskonfiguration für das Spielfeld wird geladen
 meinSpiel.anfangsKonfiguration()
 
-print(GegnerX)
-# Fenster
+# Definieren und Öffnen eines neuen Fensters
 fenster = pygame.display.set_mode((Breite, Hoehe))
 pygame.display.set_caption("Medival Goblin Dungeon")
-
 clock = pygame.time.Clock()
 
-# Hauptschleife
+# Schleife Hauptprogramm
 while True:
-
-    # Ereignisse überprüfen
+    # Überprüfen, ob Nutzer eine Aktion durchgeführt hat
     for event in pygame.event.get():
-
-        # Beenden
-        if event.type == QUIT:
+        # Beenden bei [ESC] oder [X]
+        if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE):
             pygame.quit()
             exit()
 
-        if event.type == KEYDOWN:
-
-            if event.key == K_ESCAPE:
-                pygame.quit()
-                exit()
-
-            # Bewegung
-            if event.key == K_w:
-                spielerY -= 1
-
-            if event.key == K_s:
-                spielerY += 1
-
-            if event.key == K_a:
-                spielerX -= 1
-
-            if event.key == K_d:
-                spielerX += 1
-
+    # Spiellogik
+        if event.type==KEYDOWN:
             meinSpiel.tasteGedrueckt(event.key)
 
-    # Spielfeld zeichnen
-    
+    # Gegner bewegen, Leben prüfen (neu: wird jeden Durchlauf aufgerufen)
+    meinSpiel.update()
 
+    # Spielfeld löschen
     for x in range(FelderX):
         for y in range(FelderY):  
-            fenster.blit(
-                pyGameBilder[meinSpiel.spielfeld[x][y]],
-                (x * Pixel, y * Pixel)
-            )
-    # Lebensanzeige
-    for Herzposition in range(3):
-        fenster.blit(
-        Herzen,
-        (HerzX + Herzposition * 60, 0)
-    )
+            fenster.blit(pyGameBilder[meinSpiel.spielfeld[x][y]],(x*Pixel,y*Pixel))
 
-    #Gegner Logik
-    GegnerY += Gegnerbewegung
-    GegnerX += Gegnerbewegung
-    if GegnerY < 13 or GegnerY > 0:
-        Gegnerbewegung *= -1
-    if GegnerX < 13 or GegnerX > 0:
-        Gegnerbewegung *= -1
+    # Spielfeld/figuren zeichnen
 
-    # Spielfigur und Gegner zeichnen
-    
-
-    fenster.blit(
-        Spielerfigur,
-        (spielerX * Pixel, spielerY * Pixel)
-    )
-    fenster.blit(
-        Gegner,
-        (GegnerX * Pixel, GegnerY * Pixel)
-    )
     # Fenster aktualisieren
     pygame.display.flip()
-
     clock.tick(FPS)