Arcade Dodge — Player, Enemy & Game

Jullie bouwen samen een arcade dodge/shooter met drie classes, verdeeld over twee kanten. Een Player beweegt onderin en schiet; Enemy-objecten vallen van boven; Bullet-objecten vliegen omhoog; en één Game-object bundelt de hele spelstaat. De meegeleverde game_engine.py tekent alles en draait de game-loop — jullie schrijven alleen de classes.

Verdeel deze twee rollen onderling. Installeer eenmalig pygame in je venv uit sprint 1 (pip install pygame) en zet game_engine.py naast je script.

Benodigd bestand: game_engine.py

De engine krijg je kant-en-klaar mee — die pas je niet aan. Download game_engine.py en zet hem in dezelfde map als je script. Kun je niet downloaden? Klap dan de code hieronder uit en kopieer hem naar een bestand game_engine.py.

"""
game_engine.py - Arcade-engine voor Sprint 6 (v1, ATTRIBUUT-gebaseerd). NIET AANPASSEN.

Jij schrijft de classes; deze engine opent het venster, draait de game-loop,
leest de ATTRIBUTEN van jouw objecten en tekent ze als rechthoeken. Jouw classes
zijn dus pure data; de engine verzorgt alle beweging en het tekenwerk.

--------------------------------------------------------------------------
HET CONTRACT - wat de engine van jouw objecten verwacht:

  player  - een object met:
      x, y      (int)    positie van de linkerbovenhoek
      width     (int)    breedte in pixels
      height    (int)    hoogte in pixels
      color     (tuple)  RGB, bijvoorbeeld (0, 200, 255)
      speed     (int)    pixels die de speler per toetsstap opschuift
      health    (int)    OPTIONEEL - levens; bij 0 stopt het spel

  enemies - een LIJST objecten, elk met:
      x, y, width, height, color   (zoals hierboven)
      speed     (int)    pixels die deze enemy per frame ZAKT

  world   - OPTIONEEL (US4 + project) - een object met:
      player, enemies, bullets, score, width, height

  bullet_factory(player) -> bullet   - OPTIONEEL, een gewone functie die een
      nieuw bullet-object teruggeeft met: x, y, width, height, color, speed
      (speed = pixels die de kogel per frame OMHOOG gaat)

  y telt naar BENEDEN: y groter = lager op het scherm. Vijanden vallen dus met
  een POSITIEVE speed; kogels gaan omhoog. Kleuren zijn RGB-tuples, geen strings.
--------------------------------------------------------------------------
"""

import random
import pygame


def _overlap(a, b):
    """True als twee rechthoeken (objecten met x/y/width/height) elkaar raken."""
    return (a.x < b.x + b.width and a.x + a.width > b.x and
            a.y < b.y + b.height and a.y + a.height > b.y)


def run_game(player, enemies, width=480, height=640, fps=60,
             world=None, bullet_factory=None):
    pygame.init()
    screen = pygame.display.set_mode((width, height))
    pygame.display.set_caption("Sprint 6 - Arcade Dodge")
    clock = pygame.time.Clock()
    font = pygame.font.SysFont(None, 28)

    bullets = getattr(world, "bullets", []) if world is not None else []

    running = True
    while running:
        # 1) Vensterknop / afsluiten en schieten
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
                if bullet_factory is not None:
                    bullets.append(bullet_factory(player))

        # 2) Toetsen lezen -> speler-attribuut aanpassen
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            player.x -= player.speed
        if keys[pygame.K_RIGHT]:
            player.x += player.speed
        player.x = max(0, min(player.x, width - player.width))

        # 3) Vijanden laten vallen; onderaan -> herspawnen bovenaan
        for enemy in enemies:
            enemy.y += enemy.speed
            if enemy.y > height:
                enemy.y = -enemy.height
                enemy.x = random.randint(0, width - enemy.width)
                if world is not None:
                    world.score += 1

        # 4) Kogels omhoog; buiten beeld -> weg
        for bullet in bullets:
            bullet.y -= bullet.speed
        bullets[:] = [b for b in bullets if b.y + b.height > 0]

        # 5) Botsing - kogel raakt vijand
        for bullet in bullets:
            for enemy in enemies:
                if _overlap(bullet, enemy):
                    enemy.y = -enemy.height
                    enemy.x = random.randint(0, width - enemy.width)
                    bullet.y = -100
                    if world is not None:
                        world.score += 5

        # 6) Botsing - vijand raakt speler
        for enemy in enemies:
            if _overlap(player, enemy):
                enemy.y = -enemy.height
                enemy.x = random.randint(0, width - enemy.width)
                if hasattr(player, "health"):
                    player.health -= 1
                    if player.health <= 0:
                        running = False

        # 7) Tekenen (alles als rechthoek, op basis van attributen)
        screen.fill((15, 15, 22))
        pygame.draw.rect(screen, player.color,
                         (player.x, player.y, player.width, player.height))
        for enemy in enemies:
            pygame.draw.rect(screen, enemy.color,
                             (enemy.x, enemy.y, enemy.width, enemy.height))
        for bullet in bullets:
            pygame.draw.rect(screen, bullet.color,
                             (bullet.x, bullet.y, bullet.width, bullet.height))

        score = getattr(world, "score", 0) if world is not None else 0
        hp = getattr(player, "health", None)
        text = f"Score: {score}" + (f"    HP: {hp}" if hp is not None else "")
        screen.blit(font.render(text, True, (240, 240, 240)), (10, 10))

        pygame.display.flip()
        clock.tick(fps)

    pygame.quit()


def run_world(world, bullet_factory=None):
    """Voor US4 + project: geef je hele Game/World-object mee."""
    run_game(world.player, world.enemies,
             width=world.width, height=world.height,
             world=world, bullet_factory=bullet_factory)

User stories

• Als speler wil ik mijn schip met links/rechts kunnen besturen, zodat ik vallende vijanden kan ontwijken.
• Als speler wil ik dat mijn schip verplicht op een startpositie ontstaat, zodat het nooit halfleeg in het spel verschijnt.
• Als ontwikkelaar wil ik elke vijand als eigen object met eigen x/y/speed, zodat een golf vijanden niet uit parallelle lijsten hoeft te komen.
• Als ontwikkelaar wil ik een hele golf vijanden in één lijst beheren, zodat ik er met één for doorheen kan.
• Als speler wil ik kogels kunnen afvuren die omhoog vliegen, zodat ik vijanden kan raken.
• Als ontwikkelaar wil ik speler, vijanden, kogels en score in één Game-object, zodat mijn spel niet op globals draait.
• Als team wil ik één vaste engine-afspraak (de attribuutnamen), zodat onze objecten meteen door de engine getekend worden.
• Als team wil ik één onderlinge afspraak (constructor-signaturen en game.bullets), zodat we parallel kunnen bouwen en de code aan het eind gewoon samenpast.

De drie classes op hoofdlijnen

Naast de attributen die de engine tekent, laat je de constructor ook attributen zélf berekenen uit de andere waarden. En de Game-constructor doet echt werk: hij bouwt de vijandengolf op uit een data-lijst WAVE — een lijst met (x, speed) per vijand — en berekent daaruit overzichtswaarden.

Planning maken

Maak vóór jullie beginnen sámen een bestand project_plan.md. Beschrijf daarin:

• Wie bouwt welke class(es)?
• Op welk moment spreken jullie het contract definitief af, en wanneer plannen jullie de integratiestap in?
• Welke losse globals uit een game-script (denk aan US4) worden nu een attribuut, en welke een methode — en bij welke class hoort dat?
• Hoelang schat elke rol zijn eigen bouwstappen in, en welke fase lijkt jullie het lastigst?

Dit bestand lever je samen in met je code.

Beantwoord deze vragen sámen, vóórdat er één regel code staat. Teken beide kanten eerst op papier.

① Player en Enemy: data die de engine tekent

De engine tekent een object als rechthoek zolang het x, y, width, height en color heeft. Bepaal per class welke waarden uit de constructor komen en welke een vaste startwaarde krijgen. Bedenk ook per class één of twee berekende attributen (bv. Player.center_x = x + width // 2, of Enemy.points = speed * 10). Let op: y telt naar beneden, en color is een RGB-tuple zoals (0, 200, 255).

② Bullet en spawn_bullet (speler-team)

1. Bullet — welke attributen heeft een kogel, en wat is een logische speed (die hem omhoog laat gaan)?
2. spawn_bullet(player) is een gewone functie. Welke twee attributen van de speler heb je nodig om de kogel in het midden-boven te laten starten? Wat geeft de functie terug?

③ De Game-constructor die de golf uit data opbouwt (wereld-team)

De constructor doet echt werk. Ontwerp:

1. Welke attributen zet je rechtstreeks (self.player, self.bullets, self.score, self.width/self.height)?
2. Hoe loop je met een for door de WAVE-data (x, speed) en maak je per regel een Enemy? Hoe geef je elke volgende vijand een iets hogere start-y (gestaffeld), zodat ze niet allemaal tegelijk binnenvallen?
3. Welke overzichtswaarden bereken je ná het opbouwen van de golf (bv. total_enemies en de hardest_speed met een tweede lus), en waarom moet dat ná het vullen van self.enemies staan?

④ Het contract vastleggen

Vul samen twee tabellen definitief in. Laag A is de vaste engine-afspraak (extern, niemand wijkt hiervan af):

Laag B is de afspraak tussen jullie twee (intern):

Speler-team en wereld-team bouwen na stap 1 grotendeels parallel — jullie hoeven niet op elkaar te wachten tot de integratiestap. Houd na élke stap een werkend, testbaar stukje code.

Startpunt

De classes bouwen jullie zelf op volgens de stappen hierboven en de tabellen uit Opdracht en Ontwerpen. Je begint met de import van de engine en je golf-data:

import random
from game_engine import run_game, run_world

WIDTH, HEIGHT = 480, 640

# De vijandengolf als data: (start-x, snelheid) per vijand.
# Een level aanpassen = deze lijst aanpassen.
WAVE = [(60, 3), (140, 4), (220, 2), (300, 5), (380, 3), (440, 4)]

Doeloutput (voorbeeld)

Een venster opent. Onderin staat je speler (bestuur met de pijltjes).
Van boven vallen gekleurde vijanden; met de spatiebalk schiet je kogels omhoog.
Raak je een vijand, dan stijgt de score. Botst een vijand tegen je speler,
dan daalt je HP; bij 0 sluit het spel.

Schrijf je eigen testcode met assert, net als bij het testbestand uit sprint 5. Zet de tests vóór de run_world-aanroep of achter __main__ — nooit erna, want de game-loop keert pas terug als je het venster sluit.

Alle tests komen in één bestand test_game.py dat je samen inlevert. Ieder team schrijft de tests voor zijn eigen classes; geen enkele test hoeft een venster te openen.

Eigen tests (parallel, ieder ~15 min — geen venster nodig)

Speler-team — schrijf per punt minstens één assert-regel:

• Player en Bullet hebben alle attributen die de engine leest.
• Het berekende attribuut klopt (bv. Player(100, 500).center_x == 120).
• spawn_bullet(player) geeft een Bullet terug met x in het midden van de speler en y net erboven.

Wereld-team — voor deze tests hoef je geen venster te openen:

• Een verse Game heeft score == 0, een Player als player, een lege bullets-lijst en meerdere vijanden.
• game.player is echt een Player-object (object-in-object).
• Een Enemy berekent zijn points en valid correct uit de snelheid (test een geldige en een te snelle vijand).

Denk terug aan sprint 5: elke assert krijgt een foutmelding die zegt wat er verwacht werd, zodat je meteen weet wat er misging als een test faalt.

Contracttest (samen — bewijs dat het contract werkt)

Laat het speler-team een Player van het speler-team gebruiken en het wereld-team een Game daaromheen bouwen, en controleer dat game.player precies de attributen heeft die de engine leest. Zo weet je zeker dat beide kanten via dezelfde afspraak werken, vóór je het venster opent.

Live testronde met de engine (samen)

Speel het samengevoegde spel. Bewijs met een screenshot of filmpje dat de speler beweegt, vijanden vallen en herspawnen, kogels raken, de score oploopt en het spel bij 0 HP stopt.

Loop deze criteria langs. Voldoet alles → inleveren.

Wat lever je in?

• Eén gezamenlijk Python-bestand met alle drie de classes plus spawn_bullet.
• test_game.py met de assert-tests van beide teams.
• project_plan.md met jullie planning én het ingevulde contract.
• Een schermafbeelding of videofragment van een geslaagde speelronde.

Reflectie — vier vragen

Beantwoord samen kort onderaan je project_plan.md:

1. Welk onderdeel van het contract (een naam, een retourwaarde, een moment) veranderde nog tijdens het bouwen, en waarom?
2. Wat ging er mis toen jullie de twee kanten voor het eerst samenvoegden in stap 7 — en hoe loste je dat op?
3. Welk deel van het werk voelde eerlijk verdeeld, en welk deel niet? Wat zouden jullie de volgende keer anders verdelen?
4. Stel dat er een derde teamlid bijkwam met een eigen class — welke data en welk gedrag zou die krijgen, en met welke van de bestaande classes zou hij een contract moeten afspreken?

Klaar met de basis? Kies één uitbreiding. Ze bouwen voort op de classes die jullie net hebben gemaakt, met alleen wat je al kent.

1. Meerdere levels als data

Definieer twee of drie golven als losse data-lijsten (WAVE_1, WAVE_2, …), elk met meer of snellere vijanden. Laat de constructor tellen hoeveel punten er in een golf te halen zijn (som van alle enemy.points) en bewaar dat als self.max_points. Zo maak je met alleen data een moeilijker level.

2. Rijkere objecten

Geef je classes meer berekende attributen: een Player.right_x (de rechterrand), een Enemy.is_fast (snelheid boven een grens), of een Bullet.tip_y (de punt van de kogel). Print ze voor een paar objecten en controleer de berekening.

3. Breid je testbestand uit

Voeg aan test_game.py extra assert-regels toe die de randgevallen afdekken: een vijand met snelheid 1 en met snelheid 10 (grenswaarden van valid), en een speler op x = 0. Elke assert krijgt een duidelijke foutmelding.