Lesson 12: Capstone Part 1: Design & Core Loop

Work on one to-do at a time and run the game after each. If all three lives vanish at once, the hit code is running every frame while the asteroid overlaps: check that you set player.invulnerable and test player.invulnerable <= 0 first. If asteroids never appear, print game["spawn_timer"] once per frame: it should fall toward 0, then jump back up. If normalize() raises "Can't normalize Vector of length zero", the length_squared() > 0 check is missing.

If your instructor hands you the lab file, you will see a few extra lines marked lab runtime near the top and and frame_budget() in the loop. They let the instructor's checker run the program automatically for a fixed number of frames; when you run it yourself they do nothing. You never need to write them.

"""Space Salvage, Part 1: Intro Lesson 12 capstone core loop (solution).

Fly the salvage ship with the arrow keys or WASD, collect the crates for
points, and dodge the asteroids. Three hits and the run is over. In
Part 2 you add animation, sound, a title screen and a restart.

Art: Kenney (www.kenney.nl), CC0. See CREDITS.md.
"""
import random
from pathlib import Path

import pygame


# --- Tuning: every number you might want to change lives here ----------------
WIDTH, HEIGHT = 960, 540
FPS = 60
PLAYER_SPEED = 320            # pixels per second
PLAYER_RADIUS = 20            # collision circle, a little smaller than the art
START_LIVES = 3
INVULNERABLE_TIME = 1.5       # seconds of blinking safety after a hit
SALVAGE_ON_SCREEN = 3
SALVAGE_POINTS = 10
ASTEROID_MIN_SPEED = 110      # pixels per second
ASTEROID_MAX_SPEED = 210
FIRST_SPAWN_GAP = 1.2         # seconds between asteroids at the start
MIN_SPAWN_GAP = 0.35          # the gap never gets shorter than this
GAP_SHRINK = 0.015            # the gap shrinks this much per second survived
STAR_COUNT = 90

ASSETS = Path(__file__).parent / "assets"
BG_COLOR = (10, 12, 26)
TEXT_COLOR = (235, 235, 245)
ACCENT_COLOR = (255, 200, 80)
KILL_MARGIN = 150             # asteroids this far off screen are removed


def clamp_color(value):
    """Keep a computed color channel inside 0-255."""
    return max(0, min(255, int(value)))


def load_image(name):
    """Load an image from the assets folder, or a pink placeholder if it is missing."""
    try:
        return pygame.image.load(ASSETS / name).convert_alpha()
    except (FileNotFoundError, pygame.error):
        print(f"Missing assets/{name}: using a placeholder circle.")
        surface = pygame.Surface((40, 40), pygame.SRCALPHA)
        pygame.draw.circle(surface, (255, 0, 200), (20, 20), 20)
        return surface


def load_assets():
    """Load every image once, after the window exists (convert_alpha needs it)."""
    ship = load_image("ship.png")
    return {
        "ship": ship,
        "life_icon": pygame.transform.smoothscale_by(ship, 0.45),
        "meteors": [load_image(f"meteor_{n}.png") for n in range(1, 5)],
        "salvage": [load_image(f"salvage_{n}.png") for n in range(1, 4)],
    }


class Player(pygame.sprite.Sprite):
    def __init__(self, image, pos):
        super().__init__()
        self.base_image = image                 # the unrotated ship, nose up
        self.image = image
        self.pos = pygame.Vector2(pos)          # float position
        self.rect = self.image.get_frect(center=self.pos)
        self.radius = PLAYER_RADIUS             # used by collide_circle
        self.angle = 0.0                        # degrees clockwise from "up"
        self.invulnerable = 0.0                 # seconds of safety left

    def update(self, dt, direction):
        if direction.length_squared() > 0:
            direction = direction.normalize()   # diagonals are not faster
            self.pos += direction * PLAYER_SPEED * dt
            self.angle = pygame.Vector2(0, -1).angle_to(direction)
        self.pos.x = max(PLAYER_RADIUS, min(WIDTH - PLAYER_RADIUS, self.pos.x))
        self.pos.y = max(PLAYER_RADIUS, min(HEIGHT - PLAYER_RADIUS, self.pos.y))
        self.image = pygame.transform.rotate(self.base_image, -self.angle)
        self.rect = self.image.get_frect(center=self.pos)
        self.invulnerable = max(0.0, self.invulnerable - dt)

    def draw(self, screen):
        # Blink while invulnerable: skip drawing on every other tenth of a second.
        if self.invulnerable > 0 and int(self.invulnerable * 10) % 2 == 0:
            return
        screen.blit(self.image, self.rect)


class Asteroid(pygame.sprite.Sprite):
    def __init__(self, image, pos, velocity, spin):
        super().__init__()
        self.base_image = image
        self.image = image
        self.pos = pygame.Vector2(pos)
        self.velocity = pygame.Vector2(velocity)   # pixels per second
        self.spin = spin                           # degrees per second
        self.angle = 0.0
        self.radius = image.get_width() * 0.42
        self.rect = self.image.get_frect(center=self.pos)

    def update(self, dt):
        self.pos += self.velocity * dt
        self.angle = (self.angle + self.spin * dt) % 360
        self.image = pygame.transform.rotate(self.base_image, self.angle)
        self.rect = self.image.get_frect(center=self.pos)
        if not (-KILL_MARGIN < self.pos.x < WIDTH + KILL_MARGIN
                and -KILL_MARGIN < self.pos.y < HEIGHT + KILL_MARGIN):
            self.kill()                            # far off screen: forget it


class Salvage(pygame.sprite.Sprite):
    def __init__(self, image, pos):
        super().__init__()
        self.image = image
        self.pos = pygame.Vector2(pos)
        self.rect = self.image.get_frect(center=self.pos)
        self.radius = 18


def spawn_asteroid(assets, rng):
    """Make an asteroid just outside a random edge, aimed across the screen."""
    size = rng.randint(40, 90)
    image = pygame.transform.smoothscale(rng.choice(assets["meteors"]), (size, size))
    edge = rng.choice(("top", "bottom", "left", "right"))
    if edge == "top":
        pos = pygame.Vector2(rng.uniform(0, WIDTH), -size)
    elif edge == "bottom":
        pos = pygame.Vector2(rng.uniform(0, WIDTH), HEIGHT + size)
    elif edge == "left":
        pos = pygame.Vector2(-size, rng.uniform(0, HEIGHT))
    else:
        pos = pygame.Vector2(WIDTH + size, rng.uniform(0, HEIGHT))
    target = pygame.Vector2(rng.uniform(WIDTH * 0.2, WIDTH * 0.8),
                            rng.uniform(HEIGHT * 0.2, HEIGHT * 0.8))
    speed = rng.uniform(ASTEROID_MIN_SPEED, ASTEROID_MAX_SPEED)
    velocity = (target - pos).normalize() * speed
    return Asteroid(image, pos, velocity, rng.uniform(-90, 90))


def fill_salvage(game, assets, rng):
    """Top the salvage back up to SALVAGE_ON_SCREEN, away from the player."""
    while len(game["salvage"]) < SALVAGE_ON_SCREEN:
        for _ in range(20):
            pos = pygame.Vector2(rng.uniform(60, WIDTH - 60), rng.uniform(60, HEIGHT - 60))
            if pos.distance_to(game["player"].pos) > 150:
                break
        game["salvage"].add(Salvage(rng.choice(assets["salvage"]), pos))


def spawn_gap(elapsed):
    """Seconds between asteroids: shrinks as the run goes on, down to a floor."""
    return max(MIN_SPAWN_GAP, FIRST_SPAWN_GAP - GAP_SHRINK * elapsed)


def new_game(assets, rng):
    """Everything that changes during one run, in one dictionary."""
    game = {
        "player": Player(assets["ship"], (WIDTH / 2, HEIGHT / 2)),
        "asteroids": pygame.sprite.Group(),
        "salvage": pygame.sprite.Group(),
        "score": 0,
        "lives": START_LIVES,
        "time": 0.0,
        "spawn_timer": FIRST_SPAWN_GAP,
    }
    fill_salvage(game, assets, rng)
    return game


def read_direction(keys):
    """Turn the arrow keys and WASD into a direction vector (not yet normalized)."""
    x = (keys[pygame.K_RIGHT] or keys[pygame.K_d]) - (keys[pygame.K_LEFT] or keys[pygame.K_a])
    y = (keys[pygame.K_DOWN] or keys[pygame.K_s]) - (keys[pygame.K_UP] or keys[pygame.K_w])
    return pygame.Vector2(x, y)


def update_game(game, dt, direction, assets, rng):
    """Advance one frame of play. Returns a list of what happened this frame."""
    events = []
    game["time"] += dt
    player = game["player"]
    player.update(dt, direction)
    game["asteroids"].update(dt)

    # Spawn asteroids on a timer: subtract, keep the remainder.
    game["spawn_timer"] -= dt
    while game["spawn_timer"] <= 0:
        game["asteroids"].add(spawn_asteroid(assets, rng))
        game["spawn_timer"] += spawn_gap(game["time"])

    # Collect: touching salvage removes it (dokill=True) and scores.
    for crate in pygame.sprite.spritecollide(player, game["salvage"], True,
                                             pygame.sprite.collide_circle):
        game["score"] += SALVAGE_POINTS
        events.append("collect")
    fill_salvage(game, assets, rng)

    # Dodge: an asteroid costs a life, then a short blinking safety window.
    if player.invulnerable <= 0 and pygame.sprite.spritecollideany(
            player, game["asteroids"], pygame.sprite.collide_circle):
        game["lives"] -= 1
        player.invulnerable = INVULNERABLE_TIME
        events.append("hit")
        if game["lives"] <= 0:
            events.append("game_over")
    return events


def make_stars(rng):
    """Background stars as [x, y, speed] lists; faster stars are brighter."""
    return [[rng.uniform(0, WIDTH), rng.uniform(0, HEIGHT), rng.uniform(15, 70)]
            for _ in range(STAR_COUNT)]


def update_stars(stars, dt):
    for star in stars:
        star[1] += star[2] * dt
        if star[1] > HEIGHT:
            star[1] -= HEIGHT


def draw_stars(screen, stars):
    for x, y, speed in stars:
        shade = clamp_color(60 + speed * 2.6)
        screen.fill((shade, shade, clamp_color(shade + 20)), (x, y, 2, 2))


def draw_centered(screen, font, text, y, color=TEXT_COLOR):
    label = font.render(text, True, color)
    screen.blit(label, label.get_rect(center=(WIDTH / 2, y)))


def draw_hud(screen, game, font, assets):
    screen.blit(font.render(f"Score: {game['score']}", True, TEXT_COLOR), (14, 10))
    screen.blit(font.render(f"Time: {game['time']:.0f}s", True, TEXT_COLOR), (14, 40))
    icon = assets["life_icon"]
    for i in range(game["lives"]):
        screen.blit(icon, (WIDTH - 14 - (i + 1) * (icon.get_width() + 6), 14))


def draw_world(screen, game, stars, fonts, assets):
    screen.fill(BG_COLOR)
    draw_stars(screen, stars)
    game["salvage"].draw(screen)
    game["asteroids"].draw(screen)
    game["player"].draw(screen)
    draw_hud(screen, game, fonts["small"], assets)


def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Space Salvage")
    clock = pygame.time.Clock()
    fonts = {"small": pygame.font.Font(None, 32), "big": pygame.font.Font(None, 84)}
    assets = load_assets()
    rng = random.Random()
    stars = make_stars(rng)
    game = new_game(assets, rng)
    game_over = False

    running = True
    while running:
        dt = min(clock.tick(FPS) / 1000, 0.05)  # seconds; capped after a stall

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False

        update_stars(stars, dt)
        if not game_over:
            happened = update_game(game, dt, read_direction(pygame.key.get_pressed()), assets, rng)
            if "game_over" in happened:
                game_over = True

        draw_world(screen, game, stars, fonts, assets)
        if game_over:
            draw_centered(screen, fonts["big"], "GAME OVER", HEIGHT / 2 - 30, ACCENT_COLOR)
            draw_centered(screen, fonts["small"], "Close the window to quit", HEIGHT / 2 + 30)
        pygame.display.flip()

    pygame.quit()
    print(f"Space Salvage closed. Score: {game['score']}, lives left: {game['lives']}.")


if __name__ == "__main__":
    main()