From 16ceb11df9111872674bf1073bc702b4af1e4550 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 14:45:59 +0200 Subject: [PATCH 01/17] rooms in px - desk in the room center --- src/map.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/map.py b/src/map.py index c0881fa..88cca0a 100644 --- a/src/map.py +++ b/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, 17 * tile_size, 10 * tile_size), + "Room 103": pygame.Rect(21 * tile_size, 2 * tile_size, 17 * tile_size, 10 * tile_size), + "Room 105": pygame.Rect(40 * tile_size, 2 * tile_size, 17 * 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.center_x - DESK_WIDTH // 2 + center_y = room_rect.center_y - 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): From b9c300a47a659e90404ce42f27f89f7a5400eae5 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 14:52:55 +0200 Subject: [PATCH 02/17] check if pixel point is in room --- src/map.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/map.py b/src/map.py index 88cca0a..bfbe9bb 100644 --- a/src/map.py +++ b/src/map.py @@ -141,6 +141,24 @@ class Map: # blit() fixiert den Text auf dem Bildschirm surface.blit(font.render(text, True, color_text), (px, py)) + # 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 + + + + if __name__ == "__main__": From c9d719fdd4ee8555220bb5c601a0f295d288769a Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 14:56:49 +0200 Subject: [PATCH 03/17] list of desks in the room for item spawns collision --- src/map.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/map.py b/src/map.py index bfbe9bb..08310a5 100644 --- a/src/map.py +++ b/src/map.py @@ -156,7 +156,15 @@ class Map: # 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 [] From 2fe4235fa56e65d23fe8d073eb0eb7f4416e23a6 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 14:59:46 +0200 Subject: [PATCH 04/17] check if player is in room --- src/map.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/map.py b/src/map.py index 08310a5..4c28231 100644 --- a/src/map.py +++ b/src/map.py @@ -166,6 +166,17 @@ class Map: # 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__": From b1f8b56b039b8b95300f1431ecbaad2740525918 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 15:22:24 +0200 Subject: [PATCH 05/17] troubleshooting, adding desks in the map --- src/desk.py | 15 +++++++++++---- src/map.py | 19 +++++++++++++------ 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/src/desk.py b/src/desk.py index 83e57ff..fbb8edd 100644 --- a/src/desk.py +++ b/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) \ No newline at end of file + pygame.draw.rect(screen, (193, 69, 19), draw_rect) \ No newline at end of file diff --git a/src/map.py b/src/map.py index 4c28231..20420ff 100644 --- a/src/map.py +++ b/src/map.py @@ -59,17 +59,17 @@ class Map: # 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, 17 * tile_size, 10 * tile_size), - "Room 103": pygame.Rect(21 * tile_size, 2 * tile_size, 17 * tile_size, 10 * tile_size), - "Room 105": pygame.Rect(40 * tile_size, 2 * tile_size, 17 * tile_size, 10 * tile_size), + "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.center_x - DESK_WIDTH // 2 - center_y = room_rect.center_y - DESK_HEIGHT // 2 + 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)] @@ -86,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 @@ -141,6 +141,13 @@ 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 From a9df61e9bc0fa1f9fa41f1dcca40d8f4a3820508 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 15:51:41 +0200 Subject: [PATCH 06/17] initial commit --- src/tower.py | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 src/tower.py diff --git a/src/tower.py b/src/tower.py new file mode 100644 index 0000000..1665921 --- /dev/null +++ b/src/tower.py @@ -0,0 +1,9 @@ +import pygame +import random +import math +from src.settings import TOWER_COST, PROJECTILE_DMG, PROJECTILE_SPEED, COLOR_PROJECTILE, TOWER_TIMER + +tower_size = 30 +prjectile_size = 8 +fire_interval = 1000 # ms zwischen Schüssen +respawn_delay = 10000 # ms bis neues Feld spawnt From b9a1bff5e431b25192d0a5e3be00bda361a8cf42 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 16:00:50 +0200 Subject: [PATCH 07/17] random spawn of tower field --- src/tower.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/tower.py b/src/tower.py index 1665921..32df5b5 100644 --- a/src/tower.py +++ b/src/tower.py @@ -7,3 +7,26 @@ tower_size = 30 prjectile_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] = None + self.tower_start: int = None + self.despawn_timer: int = None + self.last_shot: int = 0 + + 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 \ No newline at end of file From 3c8e0a9b9a3721adae17750f0308eefcaf5fa71a Mon Sep 17 00:00:00 2001 From: Kevin Baumgartner Date: Fri, 8 May 2026 16:04:12 +0200 Subject: [PATCH 08/17] feat(highscore): create basic structure for highscore --- src/highscore.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 src/highscore.py diff --git a/src/highscore.py b/src/highscore.py new file mode 100644 index 0000000..14f6564 --- /dev/null +++ b/src/highscore.py @@ -0,0 +1,17 @@ +import json + +class Highscore: + def __init__(self): + self.path = "./highscore.json" + + def load_scores(self): + pass + + def save_scores(self, scores): + pass + + def add_score(self, player_name, score_ects, time_survived, won): + pass + + def get_top_scores(self, number_of_top_scores): + pass \ No newline at end of file From 7a42484dede60a296992277de2ff5e9edda1f1ed Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 16:16:55 +0200 Subject: [PATCH 09/17] tower building check function --- src/tower.py | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/tower.py b/src/tower.py index 32df5b5..04baaad 100644 --- a/src/tower.py +++ b/src/tower.py @@ -9,6 +9,7 @@ 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 @@ -29,4 +30,22 @@ class Tower: # 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 \ No newline at end of file + 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 + + + + From 7846bfa04209cf2b9dd6b9a4f03fa8cad40b4caa Mon Sep 17 00:00:00 2001 From: Kevin Baumgartner Date: Fri, 8 May 2026 16:18:25 +0200 Subject: [PATCH 10/17] feat(highscore): add methods for highscore handling --- src/highscore.py | 40 +++++++++++++++++++++++++++++++++++----- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/src/highscore.py b/src/highscore.py index 14f6564..16fae15 100644 --- a/src/highscore.py +++ b/src/highscore.py @@ -2,16 +2,46 @@ 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): - pass + with open(self.path, "r") as f: + return json.load(f) def save_scores(self, scores): - pass + with open(self.path, "w") as file: + json.dump(scores, file, indent=4) def add_score(self, player_name, score_ects, time_survived, won): - pass + # load existing scores from file + scores = self.load_scores() - def get_top_scores(self, number_of_top_scores): - pass \ No newline at end of file + # 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): + scores = self.load_scores() + scores.sort(key=lambda score: score["ects"], reverse=True) + return scores[:5] \ No newline at end of file From 665e852ed9cf90cbc8f7f94ca224289e7a29b7e2 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 16:28:33 +0200 Subject: [PATCH 11/17] tower shooting function --- src/tower.py | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/src/tower.py b/src/tower.py index 04baaad..0e30247 100644 --- a/src/tower.py +++ b/src/tower.py @@ -32,7 +32,7 @@ class Tower: self.field_rect = rect return - def try_build(self, player_rect: pygame.Rect, keys: pygame.key.ScancodeWrapper, ects): + 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: @@ -46,6 +46,34 @@ class Tower: 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 + + + + + + From a9209bb2618839386b544b14fcfa71ab740a7a17 Mon Sep 17 00:00:00 2001 From: Berger Lena Date: Fri, 8 May 2026 16:28:40 +0200 Subject: [PATCH 12/17] chore:cleanup settings.py structure and formatting - remove HP bar colors - fix double parentheses in start and end screen background colors - add section headers for PLAYER and SPRITE - improve spacing and structure between sections --- src/settings.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/src/settings.py b/src/settings.py index 36b11aa..3d4328a 100644 --- a/src/settings.py +++ b/src/settings.py @@ -1,8 +1,8 @@ -# --- DESK --- from typing import Mapping, Literal, Tuple from src.map import tile_size +# --- DESK --- DESK_WIDTH = 70 DESK_HEIGHT = 40 @@ -13,13 +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]] = { @@ -33,6 +35,7 @@ DIRECTION_FRAMES: Mapping[Direction, Tuple[int, int, int]] = { 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 = 1 sec @@ -40,26 +43,31 @@ ECTS_UPDATE_INTERVAL = 1000 # time in ms = 1 sec BEER_BOTTLE_ECTS_VALUE = 2 BEER_COST = 50 + # --- BUTTONS --- COLOR_BUTTON = (0, 255, 0) 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 + # --- TOWER --- TOWER_COST = 150 PROJECTILE_DMG = 15 From 1553630e1c7d694ed80bc6018e45a47dc66617c6 Mon Sep 17 00:00:00 2001 From: Kevin Baumgartner Date: Fri, 8 May 2026 16:36:07 +0200 Subject: [PATCH 13/17] feat(highscore): add method to get formatted top 5 highscores --- src/highscore.py | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/src/highscore.py b/src/highscore.py index 16fae15..6fb57ed 100644 --- a/src/highscore.py +++ b/src/highscore.py @@ -44,4 +44,22 @@ class Highscore: def get_top_scores(self): scores = self.load_scores() scores.sort(key=lambda score: score["ects"], reverse=True) - return scores[:5] \ No newline at end of file + return scores[:5] + + def get_top_scores_formatted(self): + 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 \ No newline at end of file From a1096f3b83ff8337bc110dc6e57fa5f6636897ca Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 16:40:33 +0200 Subject: [PATCH 14/17] projectile movement and tower despawn --- src/tower.py | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/src/tower.py b/src/tower.py index 0e30247..96478ac 100644 --- a/src/tower.py +++ b/src/tower.py @@ -4,7 +4,7 @@ import math from src.settings import TOWER_COST, PROJECTILE_DMG, PROJECTILE_SPEED, COLOR_PROJECTILE, TOWER_TIMER tower_size = 30 -prjectile_size = 8 +projectile_size = 8 fire_interval = 1000 # ms zwischen Schüssen respawn_delay = 10000 # ms bis neues Feld spawnt @@ -69,6 +69,39 @@ class Tower: 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_timer = 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 + + + + + + + + + + + From b466ee3d7ce53b0c940a137efb0e0fe5fa19a942 Mon Sep 17 00:00:00 2001 From: Kevin Baumgartner Date: Fri, 8 May 2026 16:55:58 +0200 Subject: [PATCH 15/17] feat(highscore): add comments and json file --- src/highscore.json | 38 ++++++++++++++++++++++++++++++++++++++ src/highscore.py | 27 +++++++++++++++++++++++++++ 2 files changed, 65 insertions(+) create mode 100644 src/highscore.json diff --git a/src/highscore.json b/src/highscore.json new file mode 100644 index 0000000..7ef8cca --- /dev/null +++ b/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 + } +] \ No newline at end of file diff --git a/src/highscore.py b/src/highscore.py index 6fb57ed..71f443b 100644 --- a/src/highscore.py +++ b/src/highscore.py @@ -13,14 +13,33 @@ class Highscore: 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() @@ -42,11 +61,19 @@ class Highscore: 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 = [] From 3fe002daa93695da51338b7b735b3c25fc55f6f9 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 17:03:06 +0200 Subject: [PATCH 16/17] tower sprite, timer, projectiles, all clear --- src/tower.py | 49 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 47 insertions(+), 2 deletions(-) diff --git a/src/tower.py b/src/tower.py index 96478ac..ff78b27 100644 --- a/src/tower.py +++ b/src/tower.py @@ -15,11 +15,19 @@ class Tower: # Feld und Tower -> None wenn nicht aktiv self.field_rect: pygame.Rect = None self.tower_rect: pygame.Rect = None - self.projectiles: list[dict] = 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/furniture/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): @@ -81,7 +89,7 @@ class Tower: # 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_timer = now + self.despawn_time = now self.projectiles = [] # ein neues Feld soll spawnen nach dem Respawn Delay @@ -93,6 +101,43 @@ class Tower: 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 + From 15f3d0e53b16eedbb1deb311d2f7428a7b14ad01 Mon Sep 17 00:00:00 2001 From: Lukas Kammerhofer Date: Fri, 8 May 2026 17:05:55 +0200 Subject: [PATCH 17/17] sprite path changed --- src/tower.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tower.py b/src/tower.py index ff78b27..8f80a64 100644 --- a/src/tower.py +++ b/src/tower.py @@ -22,7 +22,7 @@ class Tower: # Sprite laden für den Tower try: - self.tower_image = pygame.image.load("assets/furniture/tower.png").convert_alpha() + 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}")