particle.py

"""Particle system for visual effects."""
from typing import List, Tuple, Union, Optional
import random
import pygame
from constants import WIDTH, HEIGHT

class Particle:
    """A single particle in the particle system."""

    def __init__(self,
                 pos: Tuple[float, float],
                 velocity: Tuple[float, float],
                 color: Tuple[int, int, int],
                 size: float,
                 lifetime: int,
                 shape: str = "circle"):
        """Initialize a particle.

        Args:
            pos: Initial position (x, y)
            velocity: Velocity vector (vx, vy)
            color: RGB color tuple
            size: Size of the particle
            lifetime: How many frames the particle will live
            shape: Shape of the particle ("circle" or "rect")
        """
        self.position: List[float] = list(pos)
        self.velocity: List[float] = list(velocity)
        self.color: Tuple[int, int, int] = color
        self.size: float = size
        self.lifetime: int = lifetime
        self.initial_lifetime: int = lifetime
        self.shape: str = shape
        self.alpha: int = 255

    def update(self) -> None:
        """Update the particle position and lifetime."""
        # Update position based on velocity
        self.position[0] += self.velocity[0]
        self.position[1] += self.velocity[1]

        # Apply screen wrapping
        self.position[0] = self.position[0] % WIDTH
        self.position[1] = self.position[1] % HEIGHT

        # Decrease lifetime
        self.lifetime -= 1

        # Update alpha for fading effect
        if self.lifetime > 0:
            self.alpha = int(255 * (self.lifetime / self.initial_lifetime))
        else:
            self.alpha = 0

    def draw(self, surface: pygame.Surface) -> None:
        """Draw the particle on the given surface.

        Args:
            surface: Pygame surface to draw on
        """
        if self.alpha <= 0:
            return

        # Create a temporary surface with per-pixel alpha
        temp_surface = pygame.Surface((self.size * 2, self.size * 2), pygame.SRCALPHA)

        # Draw the appropriate shape
        if self.shape == "circle":
            pygame.draw.circle(
                temp_surface,
                self.color + (self.alpha,),
                (self.size, self.size),
                self.size
            )
        elif self.shape == "rect":
            pygame.draw.rect(
                temp_surface,
                self.color + (self.alpha,),
                pygame.Rect(0, 0, self.size * 2, self.size * 2)
            )

        # Blit the temporary surface to the main surface
        surface.blit(temp_surface, (int(self.position[0] - self.size), int(self.position[1] - self.size)))

    def is_alive(self) -> bool:
        """Check if the particle is still alive.

        Returns:
            True if the particle's lifetime is greater than 0
        """
        return self.lifetime > 0


class ParticleSystem:
    """System for managing multiple particles."""

    def __init__(self):
        """Initialize an empty particle system."""
        self.particles: List[Particle] = []

    def emit(self,
             pos: Tuple[float, float],
             velocity: Tuple[float, float],
             color: Tuple[int, int, int],
             size: float,
             lifetime: int,
             count: int = 1,
             shape: str = "circle",
             spread: float = 0.2) -> None:
        """Emit particles from a position.

        Args:
            pos: Position to emit from (x, y)
            velocity: Base velocity vector (vx, vy)
            color: RGB color tuple
            size: Size of particles
            lifetime: How many frames particles will live
            count: Number of particles to emit
            shape: Shape of particles ("circle" or "rect")
            spread: How much to randomize the velocity
        """
        for _ in range(count):
            # Calculate randomized velocity
            vel_x = velocity[0]
            vel_y = velocity[1]

            # Add random variation to velocity
            if velocity[0] != 0:
                vel_x += random.uniform(-spread, spread) * abs(velocity[0])
            else:
                vel_x += random.uniform(-spread, spread)

            if velocity[1] != 0:
                vel_y += random.uniform(-spread, spread) * abs(velocity[1])
            else:
                vel_y += random.uniform(-spread, spread)

            # Create the particle and add it to the system
            self.particles.append(Particle(pos, (vel_x, vel_y), color, size, lifetime, shape))

    def update(self) -> None:
        """Update all particles in the system."""
        # Use a copy of the list to safely remove items during iteration
        for particle in self.particles[:]:
            particle.update()
            if not particle.is_alive():
                self.particles.remove(particle)

    def draw(self, surface: pygame.Surface) -> None:
        """Draw all particles on the given surface.

        Args:
            surface: Pygame surface to draw on
        """
        for particle in self.particles:
            particle.draw(surface)

    def clear(self) -> None:
        """Remove all particles from the system."""
        self.particles.clear()

    def is_empty(self) -> bool:
        """Check if the particle system is empty.

        Returns:
            True if there are no particles in the system
        """
        return len(self.particles) == 0