Merge branch 'main' of git-iit.fh-joanneum.at:swd25-bootcamp/silent-fh into feat/shop-system

src/desk.py

@@ -11,7 +11,7 @@ class Desk:
         self.rect = pygame.Rect(self.x, self.y, DESK_WIDTH, DESK_HEIGHT)
 
         try:
-            self.image = pygame.image.load("assets/furniture/desk.png").convert_alpha()
+            self.image = pygame.image.load("assets/furniture/table.png").convert_alpha()
             # scale the sprite to match collision rect
             self.image = pygame.transform.scale(self.image, (DESK_WIDTH, DESK_HEIGHT))
         except Exception as e:
@@ -23,8 +23,15 @@ class Desk:
         return self.rect.colliderect(player_rect)
 
     # draw table - use sprite and as fallback a brown rect
-    def draw(self, screen):
+    def draw(self, screen: pygame.Surface, cam_x: int = 0, cam_y: int = 0):
+        # Kamera Offset beim zeichnen abziehen
+        draw_rect = pygame.Rect(
+            self.rect.x - cam_x,
+            self.rect.y - cam_y,
+            self.rect.width,
+            self.rect.height
+        )
         if self.image:
-            screen.blit(self.image, self.rect)
+            screen.blit(self.image, draw_rect)
         else:
-            pygame.draw.rect(screen, (193, 69, 19), self.rect)
+            pygame.draw.rect(screen, (193, 69, 19), draw_rect)

src/highscore.json

@@ -0,0 +1,38 @@
+[
+    {
+        "name": "Niklas",
+        "ects": 55,
+        "time": "02:00",
+        "won": true
+    },
+    {
+        "name": "Anna",
+        "ects": 48,
+        "time": "01:35",
+        "won": true
+    },
+    {
+        "name": "Kevin",
+        "ects": 42,
+        "time": "01:58",
+        "won": true
+    },
+    {
+        "name": "Lena",
+        "ects": 35,
+        "time": "01:44",
+        "won": false
+    },
+    {
+        "name": "Lukas",
+        "ects": 20,
+        "time": "00:58",
+        "won": false
+    },
+    {
+        "name": "Max",
+        "ects": 12,
+        "time": "00:30",
+        "won": false
+    }
+]

src/highscore.py

@@ -0,0 +1,92 @@
+import json
+
+class Highscore:
+    def __init__(self):
+        # fix path to json file with highscores
+        self.path = "./highscore.json"
+
+        # check if file already exists, otherwise create it
+        try:
+            with open(self.path, "r") as f:
+                pass
+        except FileNotFoundError:
+            self.save_scores([])
+
+    def load_scores(self):
+        """
+        Will load the highscore json file.
+        :return: All scores form json file.
+        """
+        with open(self.path, "r") as f:
+            return json.load(f)
+
+    def save_scores(self, scores):
+        """
+        Write score data into json file. File will be overwritten.
+        :param scores: Scores to store in json highscore file.
+        :return: None.
+        """
+        # save scores to file
+        with open(self.path, "w") as file:
+            json.dump(scores, file, indent=4)
+
+    def add_score(self, player_name, score_ects, time_survived, won):
+        """
+        Add a new score to the list of existing scores from highscore file. The
+        number of entries is limited to 50.
+        :param player_name: Name of the player.
+        :param score_ects: Scored ECTS in game.
+        :param time_survived: Time survived in game.
+        :param won: Game won/lose.
+        :return: None.
+        """
+        # load existing scores from file
+        scores = self.load_scores()
+
+        # assign values from new score and append to existing scores
+        new_score = {
+            "name": player_name,
+            "ects": score_ects,
+            "time": time_survived,
+            "won": won
+        }
+        scores.append(new_score)
+
+        # sort by ects descending
+        scores.sort(key=lambda score: score["ects"], reverse=True)
+
+        # keep only top 50 elements
+        scores = scores[:50]
+
+        self.save_scores(scores)
+
+    def get_top_scores(self):
+        """
+        Get top 5 scores from highscore file.
+        :return: Return top 5 scores as list.
+        """
+        scores = self.load_scores()
+        scores.sort(key=lambda score: score["ects"], reverse=True)
+        return scores[:5]
+
+    def get_top_scores_formatted(self):
+        """
+        Get top 5 scores from highscore file in nice format.
+        :return: Return top 5 scores as formatted string in list.
+        """
+        top_scores = self.get_top_scores()
+        formatted_scores = []
+
+        for index, score in enumerate(top_scores):
+            result = "PASSED" if score["won"] else "FAILED"
+
+            line = (
+                f"{index + 1}. {score['name']} | "
+                f"ECTS: {score['ects']} | "
+                f"Time: {score['time']} | "
+                f"Result: {result}"
+            )
+
+            formatted_scores.append(line)
+
+        return formatted_scores

src/map.py

@@ -1,4 +1,6 @@
 import pygame
+from src.desk import Desk
+from src.settings import DESK_WIDTH, DESK_HEIGHT
 
 # Fenstergröße und Tile Größe (Felder)
 tile_size = 30
@@ -54,6 +56,24 @@ class Map:
             (49, 13, "Room 105")
         ]
 
+        # die Räume als Pixel-Rechtecke, Spalte und Zeile aus der Map * tile_size
+        # die Reihenfolge ist: x - y - breite - höhe | in Pixel
+        self.rooms: dict[str, pygame.Rect] = {
+            "Room 102": pygame.Rect(2 * tile_size, 2 * tile_size, 15 * tile_size, 10 * tile_size),
+            "Room 103": pygame.Rect(27 * tile_size, 2 * tile_size, 15 * tile_size, 10 * tile_size),
+            "Room 105": pygame.Rect(44 * tile_size, 2 * tile_size, 15 * tile_size, 10 * tile_size),
+        }
+
+        # soll automatisch einen Tisch ind er MItte des Raumes erstellen
+        self.desks: dict[str, list[Desk]] = {}
+        for room_name, room_rect in self.rooms.items():
+            # berechnet die Mitte des Raumes, zieht die Tischgröße ab, damit er wirklich zentriert ist
+            center_x = room_rect.centerx - DESK_WIDTH // 2
+            center_y = room_rect.centery - DESK_HEIGHT // 2
+
+            # erstell einen Tisch pro Raum und speichert ihn
+            self.desks[room_name] = [Desk(center_x, center_y)]
+
 
 
     def get_tile(self, column: int, row: int):
@@ -66,7 +86,7 @@ class Map:
 
     def is_accessible(self, column: int, row: int) -> bool:
         # gibt True zurück, wenn der Spieler das Tile betreten darf
-        return self.get_tile(column, row) in ("R", "D,", "H", "S")
+        return self.get_tile(column, row) in ("R", "D", "H", "S")
 
 
     # Funktion, um die Map zu erstellen
@@ -121,6 +141,50 @@ class Map:
             # blit() fixiert den Text auf dem Bildschirm
             surface.blit(font.render(text, True, color_text), (px, py))
 
+        # Desks werden gezeichnet
+        for desk_list in self.desks.values():
+            for desk in desk_list:
+                desk.draw(surface, cam_x, cam_y)
+
+
+
+    # Gibt ein Raum Rechteck zurück - zum Prüfen, ob eine gegebene Position im Raum ist
+    def get_room_rect(self, column: int, row: int):
+        # rechnet Tile Koordinaten in Pixel um
+        pixel_x = column * tile_size
+        pixel_y = row * tile_size
+
+        for room_rect in self.rooms.values():
+
+            # collidepoint prüft ob der Pixel-Punkt im Rechteck ist
+            if room_rect.collidepoint(pixel_x, pixel_y):
+                return room_rect
+
+        # return None, wenn Punkt in keinem Raum liegt (z.B. im Gang)
+        return None
+
+    # Gibt alle Tische im Raum zurück, damit keine Item-Spawns auf Tischen stattfinden
+    def get_desks_for_room(self, room_rect: pygame.Rect) -> list[Desk]:
+
+        for room_name, rect in self.rooms.items():
+            if rect == room_rect:
+                return self.desks[room_name]
+
+        # kein passender Raum gefunden
+        return []
+
+    # Gibt das Raum-Rechteck zurück, in dem sich der Spieler gerade befindet
+    # Gilt um zu wissen, ob der Spieler im Raum ist wegen den Item spawns
+    def get_current_room(self, player_rect: pygame.Rect) -> pygame.Rect:
+
+        for room_rect in self.rooms.values():
+            if room_rect.colliderect(player_rect):
+                return room_rect
+
+        # Spieler ist im Gang
+        return None
+
+
 
 if __name__ == "__main__":
 

src/settings.py

@@ -1,12 +1,11 @@
-# --- DESK ---
 from typing import Mapping, Literal, Tuple
 
 from src.map import tile_size
 
+# --- DESK ---
 DESK_WIDTH = 70
 DESK_HEIGHT = 40
 
-
 # --- DOOR ---
 DOOR_WIDTH = 20
 DOOR_HEIGHT = 100
@@ -14,14 +13,15 @@ DOOR_BORDER_WIDTH = 3
 
 COLOR_DOOR_BEIGE = (245, 245, 220)
 COLOR_DOOR_BORDER = (100, 90, 80)
-COLOR_HP_BAR_GREEN = (0, 255, 0)
-COLOR_HP_BAR_BG = (50, 50, 50)
 
+
+# --- PLAYER ---
 # Players Constants / Settings
 # Valid movement/animation directions.
 Direction = Literal["down", "left", "right", "up"]
 
 
+# --- SPRITE ---
 # Sprite files are grouped by direction.
 # Example: "down" uses sprite_01.png, sprite_02.png, sprite_03.png.
 DIRECTION_FRAMES: Mapping[Direction, Tuple[int, int, int]] = {
@@ -31,11 +31,11 @@ DIRECTION_FRAMES: Mapping[Direction, Tuple[int, int, int]] = {
     "up": (10, 11, 12),
 }
 
-
 # Default drawing size and animation speed.
 DEFAULT_SPRITE_HEIGHT: int = 138
 DEFAULT_FRAME_TIME: float = 0.16
 
+
 # --- ECTS ---
 START_ECTS_VALUE = 1        # how many ECTS are generated at the beginning
 ECTS_UPDATE_INTERVAL = 1000     # time in ms (1000 = 1 sec)
@@ -50,17 +50,19 @@ COLOR_BUTTON_HOVER = (200, 255, 0)
 
 
 # --- STARTSCREEN ---
-COLOR_STARTSCREEN_BACKGROUND = ((0, 0, 0))
+COLOR_STARTSCREEN_BACKGROUND = (0, 0, 0)
 COLOR_STARTSCREEN_FONT_TITLE = (0, 255, 0)
 COLOR_STARTSCREEN_FONT_LABEL = (0, 255, 255)
 
+
 # --- ENDSCREEN ---
-COLOR_ENDSCREEN_BACKGROUND = ((0, 0, 0))
+COLOR_ENDSCREEN_BACKGROUND = (0, 0, 0)
 COLOR_ENDSCREEN_TEXT = (255, 255, 255)
 COLOR_ENDSCREEN_WIN = (0, 255, 0)
 COLOR_ENDSCREEN_LOSE = (255, 0, 0)
 FONT_ENDSCREEN = "Arial"
 
+
 # --- COFFEE ---
 COFFEE_COST = 30
 COFFEE_HEAL_VALUE = 30

src/tower.py

@@ -0,0 +1,157 @@
+import pygame
+import random
+import math
+from src.settings import TOWER_COST, PROJECTILE_DMG, PROJECTILE_SPEED, COLOR_PROJECTILE, TOWER_TIMER
+
+tower_size = 30
+projectile_size = 8
+fire_interval = 1000        # ms zwischen Schüssen
+respawn_delay = 10000       # ms bis neues Feld spawnt
+
+
+
+class Tower:
+    def __init__(self) -> None:
+        # Feld und Tower -> None wenn nicht aktiv
+        self.field_rect: pygame.Rect = None
+        self.tower_rect: pygame.Rect = None
+        self.projectiles: list[dict] = []
+        self.tower_start: int = None
+        self.despawn_timer: int = None
+        self.last_shot: int = 0
+
+        # Sprite laden für den Tower
+        try:
+            self.tower_image = pygame.image.load("assets/items/tower.png").convert_alpha()
+            self.tower_image = pygame.transform.scale(self.tower_image, (tower_size, tower_size))
+        except Exception as e:
+            print(f"Error loading tower sprite: {e}")
+            self.tower_image = None
+
+    def field_spawn(self, room_rect: pygame.Rect, blocked_rects: list[pygame.Rect]):
+        # soll Tower Feld an zufälliger freier Position im Raum spawnen
+        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)
+            rect = pygame.Rect(x, y, tower_size, tower_size)
+
+            # freie Position finden - nicht auf dem Tisch oder blockierten Rects
+            if not any(rect.colliderect(b) for b in blocked_rects):
+                self.field_rect = rect
+                return
+
+    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
+            if not self.field.rect or self.tower.rect:
+                return False
+            if not (self.field_rect.colliderect(player_rect) and keys[pygame.K_e] and ects.balance >= TOWER_COST):
+                return False
+
+            ects.balance -= TOWER_COST
+            self.tower_rect = self.field_rect
+            self.field_rect = None
+            self.tower_start = pygame.time.get_ticks()
+            return True
+
+    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
+
+        self.try_build(player_rect, keys, ects)
+
+        # schießen dann, wenn Tower und Monster vorhanden sind
+        if self.tower_rect and monster_rect:
+            if now - self.last_shot >= fire_interval:
+                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
+                self.projectiles.append({
+                    "x": float(self.tower_rect.centerx),
+                    "y": float(self.tower_rect.centery),
+                    "vel_x": (dx / distance) * PROJECTILE_SPEED,
+                    "vel_y": (dy / distance) * PROJECTILE_SPEED,
+                })
+
+                self.last_shot = now
+
+        # Bewegung der Projektile und Kollision mit Monster prüfen
+        for p in self.projectiles[:]:
+            p["x"] += p["vel_x"]
+            p["y"] += p["vel_y"]
+
+            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)
+
+        # wenn der Tower abgelaufen ist, soll er despawnen und ein Timer starten
+        if self.tower_rect and self.tower_start and now - self.tower_start >= TOWER_TIMER:
+            self.tower_rect = None
+            self.despawn_time = now
+            self.projectiles = []
+
+        # 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.despawn_time = None
+
+        return total_damage
+
+
+    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:
+            r = pygame.Rect(self.field_rect.x - cam_x, self.field_rect.y - cam_y, tower_size, tower_size)
+            pygame.draw.rect(surface, (160,120,30), r)
+            pygame.draw.rect(surface, (220,180,60), r, 2)
+            surface.blit(font.render("T", True, (255, 255, 255)), (r.x + 12, r.y + 10))
+
+        # Tower Zeichnen mit Sprite - als Fallback grünes Rechteck
+        if self.tower_rect and self.tower_start:
+            r = pygame.Rect(self.tower_rect.x - cam_x, self.tower_rect.y - cam_y, tower_size, tower_size)
+
+            # berechnet die verbleibende Zeit in Sekunden
+            sec = max(0, TOWER_TIMER - (pygame.time.get_ticks() - self.tower_start)) // 1000
+
+            if self.tower_image:
+                surface.blit(self.tower_image, r)
+            else:
+                pygame.draw.rect(surface, (40, 160, 80), r)
+                pygame.draw.rect(surface, (80, 220, 120), r, 2)
+
+            # Restzeit der Tower über dem Sprite anzeigen
+            surface.blit(font.render(str(sec), True, (255, 255, 255)), (r.x + 8, r.y - 18))
+
+        # alle aktiven Projektile zeichnen
+        for p in self.projectiles:
+            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
+            self.tower_rect = None
+            self.projectiles = []
+            self.despawn_timer = None
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+