README.md aktualisiert

README.md

@@ -21,4 +21,7 @@ Heute möchte ich es schaffen,dass man nach einer bestimmten Anzahl an getötete
 
 #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
-
+import copy
-Startpositionx = (2)
+import random
-Startpositiony = (2)
+import sys
-
+q = -1
+o = -1
 class MeinSpiel:
-    bilder = ["H:\git\E-To-Linus-Hasenspiel\Bilder/steinboden.png"]
+    # Die Nummer in der Liste ist die Zahl, die im Spielfeld gespeichert wird:
-    spielfeld = [] 
+    # 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:
+        kontrollfeld = copy.deepcopy(self.spielfeld)
-            print(taste)    
+
+        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,210 +1,55 @@
+# Importieren u. initialisieren der Pygame-Bibliothek
 from meinspiel import MeinSpiel
 import pygame
 from pygame.locals import *
-import random
-import time
-import sys
-
 pygame.init()
 
-Spielerfigur = pygame.image.load("H:\git\E-To-Linus-Hasenspiel\Bilder/Ritter1.png")
-Gegner = pygame.image.load("H:\git\E-To-Linus-Hasenspiel\Bilder/Goblin.png")
-Herzen = pygame.image.load("H:\git\E-To-Linus-Hasenspiel\Bilder/Herz.png")
 
-font = pygame.font.Font(None, 74)
+# Variablen/KONSTANTEN setzen
-text = font.render ("GAME OVER", True, (255,255, 255))
-
-spielerX = 6
-spielerY = 6
-HerzX = -1
-Leben = 3
-letzter_treffer = 0
-treffbar = False
-GegnerLebt = True
-GegnerGetötet = 0
-Spawnanzahl = 1
-Gegneranzahl = 1
-Spielend = True
-
-Getroffen = False
-GegnerX = random.randint(0,13)
-GegnerY = random.randint(0,13)
-
-LetzteBewegung = 0
-BewegungsPause = 500  # Millisekunden
-
-
-# Variablen/KONSTANTEN
 Breite, Hoehe = 840, 840
 Pixel = 60
 FelderX, FelderY = int(Breite / Pixel), int(Hoehe / Pixel)
 FPS  = 60 
-
+SCHWARZ = ( 0, 0, 0)
-SCHWARZ = (0, 0, 0)
+WEISS   = ( 255, 255, 255)
-WEISS = (255, 255, 255)
-Rot = ()
-
 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()
 
-# 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:
-
+    # Überprüfen, ob Nutzer eine Aktion durchgeführt hat
-    # Ereignisse überprüfen
     for event in pygame.event.get():
-
+        # Beenden bei [ESC] oder [X]
-        # Beenden
+        if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE):
-        if event.type == QUIT:
             pygame.quit()
             exit()
 
-        if event.type == KEYDOWN:
+    # Spiellogik
-
+        if event.type==KEYDOWN:
-            if event.key == K_ESCAPE:
-                pygame.quit()
-                exit()
-
-            # Gegner treffen und töten und wieder einen neuen Spawnen
-            if event.key == K_SPACE and treffbar == True:
-                GegnerLebt = False
-                print("Attacke")
-                GegnerX = random.randint(0, 13)
-                GegnerY = random.randint(0, 13)
-                GegnerLebt = True
-                BewegungsPause -= 15
-                GegnerGetötet += 1
-
-            
-            # 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
-
             meinSpiel.tasteGedrueckt(event.key)
 
-            # Attacke
+    # Gegner bewegen, Leben prüfen (neu: wird jeden Durchlauf aufgerufen)
+    meinSpiel.update()
 
-    # Spielfeld zeichnen
+    # Spielfeld löschen
-    if Spielend:
     for x in range(FelderX):
         for y in range(FelderY):  
-                fenster.blit(
+            fenster.blit(pyGameBilder[meinSpiel.spielfeld[x][y]],(x*Pixel,y*Pixel))
-                    pyGameBilder[meinSpiel.spielfeld[x][y]],
-                    (x * Pixel, y * Pixel)
-                )
-    # Lebensanzeige
-    for Herzposition in range(Leben):
-        fenster.blit(
-        Herzen,
-        (HerzX + Herzposition * 60, 0)
-    )
 
+    # Spielfeld/figuren zeichnen
 
-    # Gegner folgt dem Spieler
-    Jetzt = pygame.time.get_ticks()
-
-    if Jetzt - LetzteBewegung > BewegungsPause:
-
-        if GegnerX < spielerX:
-            GegnerX += 1
-        elif GegnerX > spielerX:
-            GegnerX -= 1
-        elif GegnerY < spielerY:
-            GegnerY += 1
-        elif GegnerY > spielerY:
-            GegnerY -= 1
-
-        LetzteBewegung = Jetzt
-
-    # Spielfigur und Gegner zeichnen
-    if Leben == 0:
-        Spielend = False
-        fenster.fill(SCHWARZ)
-        fenster.blit(text, (250, 250))
-        
-    if Spielend:
-        fenster.blit(
-            Spielerfigur,
-            (spielerX * Pixel, spielerY * Pixel)
-    )
-    if GegnerLebt and Spielend:        
-        for i in range(Gegneranzahl):
-            fenster.blit(
-            Gegner,
-            (GegnerX * Pixel, GegnerY * Pixel)
-
-    )
-    
-    # Berührung prüfen
-    spieler_rect = pygame.Rect(
-    spielerX * Pixel + 10,
-    spielerY * Pixel + 10,
-    40,
-    40
-    )
-    if GegnerLebt and Spielend:
-        gegner_rect = pygame.Rect(
-        GegnerX * Pixel + 10,
-        GegnerY * Pixel + 10,
-        40,
-        40
-        )   
-    if GegnerLebt:    
-        gegner_rect_hitbox = pygame.Rect(
-        GegnerX * Pixel - 20,
-        GegnerY * Pixel - 20,
-        120,
-        120
-        )   
-
-    #Hitbox Logik für den Gegner
-
-    if GegnerLebt and spieler_rect.colliderect(gegner_rect_hitbox):
-        print("In der Hitbox")
-        treffbar = True
-    else:
-        treffbar = False
-
-    # Lebensabzug
-    if spieler_rect.colliderect(gegner_rect):
-        if Jetzt - letzter_treffer > 1000:  
-            Leben -= 1
-            letzter_treffer = Jetzt
-            print("Leben", Leben)
-    #Gegner kann nicht das Spielfeld verlassen
-    if spielerX == -1:
-        spielerX += 1
-    if spielerX == 14:
-        spielerX -= 1
-    if spielerY == -1:
-        spielerY += 1
-    if spielerY == 14:
-        spielerY -= 1
     # Fenster aktualisieren
     pygame.display.flip()
-
     clock.tick(FPS)
-