Merge branch 'main' into feat/endscreen

src/tower.py

@@ -1,10 +1,12 @@
+from turtledemo.lindenmayer import draw
+
 import pygame
 import random
 import math
 from src.settings import TOWER_COST, PROJECTILE_DMG, PROJECTILE_SPEED, COLOR_PROJECTILE, TOWER_TIMER
 
-tower_size = 30
+tower_size = 30             # Größe Tower Feld in Pixel
-projectile_size = 8
+projectile_size = 8         # Größe Projektil in Pixel
 fire_interval = 1000        # ms zwischen Schüssen
 respawn_delay = 10000       # ms bis neues Feld spawnt
 
@@ -13,11 +15,17 @@ respawn_delay = 10000       # ms bis neues Feld spawnt
 class Tower:
     def __init__(self) -> None:
         # Feld und Tower -> None wenn nicht aktiv
+        # Position interagierbares Feld
         self.field_rect: pygame.Rect = None
+        #Position des gebauten Tower
         self.tower_rect: pygame.Rect = None
+        # Lister aller aktiven Projektile - dict mit Position und Geschwindigkeit
         self.projectiles: list[dict] = []
+        # Zeitpunkt, wann der Tower gebaut wurde
         self.tower_start: int = None
+        # Zeitpunkt, wann Tower despawnt ist
         self.despawn_timer: int = None
+        # Zeitpunkt des letzten Schusses
         self.last_shot: int = 0
 
         # Sprite laden für den Tower
@@ -28,8 +36,17 @@ class Tower:
             print(f"Error loading tower sprite: {e}")
             self.tower_image = None
 
+        # Sprite laden für Projektil
+        try:
+            self.projectile_image = pygame.image.load("assets/items/book.png").convert_alpha()
+            self.projectile_image = pygame.transform.scale(self.projectile_image, (projectile_size, projectile_size))
+        except Exception as e:
+            print(f"Error loading projectile sprite: {e}")
+            self.tower_image = None
+
+    # soll interaktives Tower Feld an zufälliger freier Position im Raum spawnen
     def field_spawn(self, room_rect: pygame.Rect, blocked_rects: list[pygame.Rect]):
-        # soll Tower Feld an zufälliger freier Position im Raum spawnen
+        # versucht bis zu 50 mal, eine nicht belegte Stelle im Raum zu finden
         for i in range(50):
             x = random.randint(room_rect.left + tower_size, room_rect.right - tower_size * 2)
             y = random.randint(room_rect.top + tower_size, room_rect.bottom - tower_size * 2)
@@ -40,34 +57,42 @@ class Tower:
                 self.field_rect = rect
                 return
 
+    # Baut Tower wenn Spieler E drückt, auf Feld steht und genug ects hat
     def try_build(self, player_rect: pygame.Rect, keys: pygame.key.ScancodeWrapper, ects):
 
-            # Baut Tower wenn Spieler E drückt, auf Feld steht und genug ects hat
+            # bricht ab wenn kein Feld vorhanden ist oder ein Tower bereits aktiv ist
-            if not self.field.rect or self.tower.rect:
+            if not self.field_rect or self.tower_rect:
                 return False
+            # prüft alle Bedingungen gleichzeitig
             if not (self.field_rect.colliderect(player_rect) and keys[pygame.K_e] and ects.balance >= TOWER_COST):
                 return False
 
+            # ECTS abziehen und Tower bauen
             ects.balance -= TOWER_COST
             self.tower_rect = self.field_rect
             self.field_rect = None
             self.tower_start = pygame.time.get_ticks()
             return True
 
+    # ruft jeden Frame auf und gibt den Schaden auf Monster zurück
+    # verwaltet Schüsse, Projektile, Tower-Leben und Respawn
     def update(self, player_rect: pygame.Rect, keys: pygame.key.ScancodeWrapper, ects, monster_rect: pygame.Rect, room_rect: pygame.Rect, blocked_rects: list[pygame.Rect]):
 
-        # ruft jeden Frame auf und gibt den Schaden auf Monster zurück
         now = pygame.time.get_ticks()
         total_damage = 0
 
+        # versucht, den Tower zu bauen wenn der Spieler auf dem Feld steht
         self.try_build(player_rect, keys, ects)
 
-        # schießen dann, wenn Tower und Monster vorhanden sind
+        # schießen dann, wenn Tower aktiv und Monster vorhanden sind
         if self.tower_rect and monster_rect:
             if now - self.last_shot >= fire_interval:
+                #berechnet Richtungsvektor vom Tower zum Monster
                 dx = monster_rect.centerx - self.tower_rect.centerx
                 dy = monster_rect.centery - self.tower_rect.centery
                 distance = math.sqrt(dx * dx + dy * dy) or 1
+
+                # fügt neues Projektil mit Startposition und Geschwindigkeit hinzu
                 self.projectiles.append({
                     "x": float(self.tower_rect.centerx),
                     "y": float(self.tower_rect.centery),
@@ -78,10 +103,11 @@ class Tower:
                 self.last_shot = now
 
         # Bewegung der Projektile und Kollision mit Monster prüfen
-        for p in self.projectiles[:]:
+        for p in self.projectiles[:]:       # [:] = Kopie der Liste, dass man sicher löschen kann
             p["x"] += p["vel_x"]
             p["y"] += p["vel_y"]
 
+            # Projektil trifft auf Monster -> Schaden wird addiert und Projektil entfernt
             if monster_rect and pygame.Rect(int(p["x"]), int(p["y"]), projectile_size, projectile_size).colliderect(monster_rect):
                 total_damage += PROJECTILE_DMG
                 self.projectiles.remove(p)
@@ -95,12 +121,13 @@ class Tower:
         # ein neues Feld soll spawnen nach dem Respawn Delay
         if not self.tower_rect and not self.field_rect and self.despawn_time:
             if now - self.despawn_time >= respawn_delay:
-                self.spawn_field(room_rect, blocked_rects)
+                self.field_spawn(room_rect, blocked_rects)
                 self.despawn_time = None
 
         return total_damage
 
 
+    # Zeichnet Feld, Tower und Projektile auf dem Bildschirm
     def draw(self, surface: pygame.Surface, font: pygame.font.Font, cam_x: int = 0, cam_y: int = 0):
         # Feld zeichnen - goldenes Rechteck mit "T" als Hinweis
         if self.field_rect:
@@ -117,20 +144,32 @@ class Tower:
             sec = max(0, TOWER_TIMER - (pygame.time.get_ticks() - self.tower_start)) // 1000
 
             if self.tower_image:
+                # Sprite verfügbar -> zeichnen
                 surface.blit(self.tower_image, r)
             else:
+                # kein Sprite -> Fallback grünes Rechteck
                 pygame.draw.rect(surface, (40, 160, 80), r)
                 pygame.draw.rect(surface, (80, 220, 120), r, 2)
 
-            # Restzeit der Tower über dem Sprite anzeigen
+            # Restzeit der Tower über dem Sprite anzeigen (in Sekunden)
             surface.blit(font.render(str(sec), True, (255, 255, 255)), (r.x + 8, r.y - 18))
 
-        # alle aktiven Projektile zeichnen
+        # alle aktiven Projektile zeichnen als Prite oder Fallback als kleine Rechtecke
         for p in self.projectiles:
+            draw_x = int(p["x"]) - cam_x
+            draw_y = int(p["y"]) - cam_y
+
+            if self.projectile_image:
+                # zeichnet Buch Sprite
+                surface.blit(self.projectile_image, (draw_x, draw_y))
+            else:
+                # Fallback - gelbes Rechteck
                 pygame.draw.rect(surface, COLOR_PROJECTILE,
                     pygame.Rect(int(p["x"]) - cam_x, int(p["y"]) - cam_y, projectile_size, projectile_size))
 
 
+
+
     # alles zurücksetzen, wenn der Raum verlassen wird
     def clear(self) -> None:
         self.field_rect = None