Übergang zum nächsten Level hinzugefügt; Level wird automatisch geladen, wenn alle Feinde besiegt sind

editor.py

@@ -1,4 +1,4 @@
-import pygame
+import pygame  # ty: ignore[unresolved-import]
 import sys
 
 from scripts.tilemap import Tilemap

game.py

@@ -2,6 +2,7 @@ import pygame  # ty: ignore[unresolved-import]
 import sys
 import random
 import math
+import os
 from scripts.entities import Enemy, Player
 from scripts.utils import load_image
 from scripts.utils import load_images
@@ -69,16 +70,17 @@ class Game:
             "particles/particle": Animation(
                 load_images(path="particles/particle"), image_duration=6, loop=False
             ),
-            "gun": load_image("gun.png"),
+            "gun": load_image(path="gun.png"),
-            "projectile": load_image("projectile.png"),
+            "projectile": load_image(path="projectile.png"),
         }
         self.player: Player = Player(game=self, pos=(50, 50), size=(8, 15))
 
         self.tilemap: Tilemap = Tilemap(game=self, tile_size=16)
 
-        self.level: int | str = 0
+        self.level: int = 0
 
-        self.load_level(self.level)
+        self.load_level(map_id=self.level)
+        self.screenshake = 0
 
         self.clouds: Clouds = Clouds(cloud_images=self.assets["clouds"], count=16)
         self.isJumping: bool = False
@@ -86,37 +88,53 @@ class Game:
 
     def load_level(self, map_id: str | int):
         try:
-            self.tilemap.load(path="data/maps/" + str(map_id) + ".json")
+            self.tilemap.load(path="data/maps/" + str(object=map_id) + ".json")
         except FileNotFoundError:
             pass
 
         self.leaf_spawners: list[pygame.Rect] = []
         self.enemies: list[Enemy] = []
 
-        for tree in self.tilemap.extract([("large_decor", 2)], keep=True):
+        for tree in self.tilemap.extract(id_pairs=[("large_decor", 2)], keep=True):
             self.leaf_spawners.append(
                 pygame.Rect(4 + tree["pos"][0], 4 + tree["pos"][1], 23, 13)
             )
 
-        for spawner in self.tilemap.extract([("spawners", 0), ("spawners", 1)]):
+        for spawner in self.tilemap.extract(id_pairs=[("spawners", 0), ("spawners", 1)]):
             if spawner["variant"] == 0:
                 self.player.pos = spawner["pos"]
+                self.player.air_time = 0
             else:
-                self.enemies.append(Enemy(self, spawner["pos"], (8, 15)))
+                self.enemies.append(Enemy(game=self, pos=spawner["pos"], size=(8, 15)))
 
         self.particles: list[Particle] = []
         self.projectiles: list = []
         self.sparks: list[Spark] = []
         self.dead: int = 0
         self.scroll: list[float] = [0, 0]
+        self.transition: int = -30
+
+
 
     def run(self) -> None:
         while self.running:
             self.display.blit(self.assets["background"], (0, 0))
             if self.dead:
                 self.dead += 1
+                self.screenshake = max(16, self.screenshake)
                 if self.dead > 40:
+                    self.load_level(map_id=self.level)
+
+
+            self.screenshake = max(0, self.screenshake - 1)
+
+            if not len(self.enemies):
+                self.transition += 1
+                if self.transition > 30:
+                    self.level = min(self.level + 1, len(os.listdir("data/maps")) - 1)
                     self.load_level(self.level)
+            if self.transition < 0:
+                self.transition += 1
 
             self.scroll[0] += (
                 self.player.rect().centerx
@@ -132,7 +150,7 @@ class Game:
 
             for rect in self.leaf_spawners:
                 if random.random() * 49999 < rect.width * rect.height:
-                    pos = (
+                    pos: tuple = (
                         rect.x + random.random() * rect.width,
                         rect.y + random.random() * rect.height,
                     )
@@ -142,7 +160,7 @@ class Game:
                             "leaf",
                             pos,
                             velocity=[-0.1, 0.3],
-                            frame=random.randint(0, 20),
+                            frame=random.randint(a=0, b=20),
                         )
                     )
 
@@ -150,15 +168,15 @@ class Game:
             self.clouds.render(surface=self.display, offset=render_scroll)
             self.tilemap.render(surface=self.display, offset=render_scroll)
             for enemy in self.enemies.copy():
-                kill = enemy.update(self.tilemap, (0, 0))
+                kill = enemy.update(self.tilemap, movement=(0, 0))
-                enemy.render(self.display, offset=render_scroll)
+                enemy.render(surface=self.display, offset=render_scroll)
                 if kill:
                     self.enemies.remove(enemy)
             if not self.dead:
                 self.player.update(
-                    self.tilemap, (self.movement[1] - self.movement[0], 0)
+                    self.tilemap, movement=(self.movement[1] - self.movement[0], 0)
                 )
-                self.player.render(self.display, offset=render_scroll)
+                self.player.render(surface=self.display, offset=render_scroll)
                 
             # [[x, y], direction, timer]
             for projectile in self.projectiles.copy():
@@ -172,7 +190,7 @@ class Game:
                         projectile[0][1] - img.get_height() / 2 - render_scroll[1],
                     ),
                 )
-                if self.tilemap.solid_check(projectile[0]):
+                if self.tilemap.solid_check(pos=projectile[0]):
                     self.projectiles.remove(projectile)
                     for _ in range(4):
                         self.sparks.append(
@@ -267,10 +285,24 @@ class Game:
                     if event.key == pygame.K_m:
                         self.boost = False
 
-            self.screen.blit(
+            if self.transition:
-                pygame.transform.scale(self.display, self.screen.get_size()), (0, 0)
+                transition_surface = pygame.Surface(self.display.get_size())
+                pygame.draw.circle(
+                    transition_surface,
+                    (255, 255, 255),
+                    (self.display.get_width() // 2, self.display.get_height() // 2),
+                    (30 - abs(self.transition)) * 8,
+                )
+                transition_surface.set_colorkey((255, 255, 255))
+                self.display.blit(transition_surface, (0, 0))
+
+            screenshake_offset = (
+                random.random() * self.screenshake - self.screenshake / 2,
+                random.random() * self.screenshake - self.screenshake / 2,
             )
 
+            self.screen.blit(pygame.transform.scale(self.display, self.screen.get_size()), screenshake_offset)
+
             pygame.display.update()
             self.clock.tick(60)
 

scripts/entities.py

@@ -170,6 +170,7 @@ class Enemy(PhysicsEntity):
 
         if abs(self.game.player.dashing) >= 50:
             if self.rect().colliderect(self.game.player.rect()):
+                self.game.screenshake = max(16, self.game.screenshake)
                 for _ in range(30):
                     angle = random.random() * math.pi * 2
                     speed = random.random() * 5
@@ -213,6 +214,11 @@ class Player(PhysicsEntity):
 
         self.air_time += 1
 
+        if self.air_time > 120:
+            if not self.game.dead:
+                self.game.screenshake = max(16, self.game.screenshake)
+            self.game.dead += 1
+
         if self.collisions.bottom:
             self.air_time = 0
             self.jumps = 1