utils.py

"""Utility functions for the Asteroids game."""
from typing import List, Tuple, Optional, Callable
import math
import random
import pygame
from constants import WIDTH, HEIGHT, WHITE

def draw_text(surface: pygame.Surface, text: str, font_size: int, x: int, y: int,
             color: Tuple[int, int, int] = WHITE) -> None:
    """Render text on the given surface.

    Args:
        surface: The pygame surface to draw on
        text: The text to render
        font_size: Size of the font
        x: X position of the text
        y: Y position of the text
        color: RGB color tuple for the text
    """
    font = pygame.font.Font(None, font_size)
    text_surface = font.render(text, True, color)
    text_rect = text_surface.get_rect()
    text_rect.topleft = (x, y)
    surface.blit(text_surface, text_rect)

def create_starfield(num_stars: int) -> List[Tuple[int, int, int]]:
    """Create a starfield with randomly positioned stars.

    Args:
        num_stars: Number of stars to create

    Returns:
        List of tuples containing (x, y, size) for each star
    """
    stars = []
    for _ in range(num_stars):
        x = random.randint(0, WIDTH)
        y = random.randint(0, HEIGHT)
        size = random.randint(1, 3)
        stars.append((x, y, size))
    return stars

def distance(pos1: Tuple[float, float], pos2: Tuple[float, float]) -> float:
    """Calculate Euclidean distance between two points.

    Args:
        pos1: First position (x, y)
        pos2: Second position (x, y)

    Returns:
        Distance between the points
    """
    dx = pos1[0] - pos2[0]
    dy = pos1[1] - pos2[1]
    return math.sqrt(dx * dx + dy * dy)

def wrap_position(position: List[float]) -> None:
    """Wrap a position around the screen edges (in-place).

    Args:
        position: [x, y] position to wrap
    """
    position[0] = position[0] % WIDTH
    position[1] = position[1] % HEIGHT

def timer(duration: int) -> Callable[[Optional[int]], bool]:
    """Create a timer function that counts down from a specified duration.

    Args:
        duration: Duration in frames

    Returns:
        Timer function that returns True when completed
    """
    remaining = duration

    def timer_func(decrement: Optional[int] = 1) -> bool:
        nonlocal remaining
        remaining -= decrement
        return remaining <= 0

    return timer_func