basic wave timer implemented

game.py

@@ -22,6 +22,8 @@
 
 ui_image = pygame.image.load(UI_IMAGE).convert_alpha()
 
+wave_break_time = 15000
+
 background_pos = [0, 0]
 
 player_rect = player_animations[player_direction][player_frame].get_rect(center=(WIN_WIDTH // 2, WIN_HEIGHT // 2))
@@ -41,10 +43,21 @@ def spawn_enemies(num_enemies):
 
 def handle_wave(wave_number):
     print(f"Wave {wave_number} starting")
+
+    # Wait for 3 seconds before starting the next wave
+    wave_start_time = pygame.time.get_ticks()
+    wave_delay = 3000  # 3000 milliseconds = 3 seconds
+
+    while pygame.time.get_ticks() - wave_start_time < wave_delay:
+        clock.tick(60)
+
     enemies = spawn_enemies(wave_number + wave_number // 2)
     print(f"Number of enemies: {len(enemies)}")
+
     return enemies
 
+
+
 class SparksParticleSystem:
     def __init__(self, position, num_particles, burst_radius, duration):
         self.particles = []
@@ -196,19 +209,25 @@ def update(self, player_position):
 wave_number = 1
 enemies = handle_wave(wave_number)
 
+last_wave_end_time = pygame.time.get_ticks()
+
 while True:
     clock.tick(60)
-
+    current_time = pygame.time.get_ticks()
     screen.blit(background_image, background_pos)
 
+    if current_time - last_wave_end_time >= wave_break_time:
+        wave_number += 1
+        enemies = handle_wave(wave_number)
+        last_wave_end_time = current_time
+
+
     for i, spark in sorted(enumerate(sparks), reverse=True):
         spark.move(1)
         spark.draw(screen)
         if not spark.alive:
             sparks.pop(i)
 
-
-
     #static particle settings and handling
     for system in particle_systems:
         if system.duration > 0:

rain.py

@@ -61,3 +61,62 @@ def draw(self, surf, offset=[0, 0]):
                 ]
             pygame.draw.polygon(surf, self.color, points)
 
+
+
+class HeavyRain():
+    def __init__(self, loc, angle, speed, color, scale=1):
+        self.loc = loc
+        self.angle = angle
+        self.speed = speed
+        self.scale = scale
+        self.color = color
+        self.alive = True
+
+    def point_towards(self, angle, rate):
+        rotate_direction = ((angle - self.angle + math.pi * 3) % (math.pi * 2)) - math.pi
+        try:
+            rotate_sign = abs(rotate_direction) / rotate_direction
+        except ZeroDivisionError:
+            rotate_sing = 1
+        if abs(rotate_direction) < rate:
+            self.angle = angle
+        else:
+            self.angle += rate * rotate_sign
+
+    def calculate_movement(self, dt):
+        return [math.cos(self.angle) * self.speed * dt, math.sin(self.angle) * self.speed * dt]
+
+
+    # gravity and friction
+    def velocity_adjust(self, friction, force, terminal_velocity, dt):
+        movement = self.calculate_movement(dt)
+        movement[1] = min(terminal_velocity, movement[1] + force * dt)
+        movement[0] *= friction
+        self.angle = math.atan2(movement[1], movement[0])
+        # if you want to get more realistic, the speed should be adjusted here
+
+    def move(self, dt):
+        movement = self.calculate_movement(dt)
+        self.loc[0] += movement[0]
+        self.loc[1] += movement[1]
+
+        # a bunch of options to mess around with relating to angles...
+        #self.point_towards(math.pi / 2, 0.02)
+        #self.velocity_adjust(0.975, 0.2, 8, dt)
+        #self.angle += 0.1
+
+        self.speed -= 0.1
+
+        if self.speed <= 0:
+            self.alive = False
+
+    def draw(self, surf, offset=[0, 0]):
+        if self.alive:
+            points = [
+                [self.loc[0] + math.cos(self.angle) * self.speed * self.scale, self.loc[1] + math.sin(self.angle) * self.speed * self.scale],
+                [self.loc[0] + math.cos(self.angle + math.pi / 2) * self.speed * self.scale * 0.3, self.loc[1] + math.sin(self.angle + math.pi / 2) * self.speed * self.scale * 0.3],
+                [self.loc[0] - math.cos(self.angle) * self.speed * self.scale * 3.5, self.loc[1] - math.sin(self.angle) * self.speed * self.scale * 3.5],
+                [self.loc[0] + math.cos(self.angle - math.pi / 2) * self.speed * self.scale * 0.3, self.loc[1] - math.sin(self.angle + math.pi / 2) * self.speed * self.scale * 0.3],
+                ]
+            pygame.draw.polygon(surf, self.color, points)
+