Sprint 7 Project — Arcade Dodge v2: methodes

Wat ga je bouwen?

±30 min · samen

Jullie bouwen samen je sprint-6-game om tot een methode-gebaseerde versie. In sprint 6 deed de engine alle actie op basis van attributen; nu bepalen jouw classes zelf hoe ze bewegen, schieten, schade oplopen, sneller worden en herspawnen — via methodes. De nieuwe game_engine.py (v2) roept die methodes aan en laat de uitkomsten zien.

De kern: gedrag verhuist naar je classes. De regel die vroeger in de engine stond, staat nu in jouw class als methode. player.x -= player.speed wordt Player.move(...); enemy.y += enemy.speed wordt Enemy.update(); de kogel-fabriek wordt Player.shoot(); de score wordt Game.add_score(n). Start je spel met run_world(game) — de speler maakt zijn kogels nu zelf.

Zo speel je het spel

Bij het starten verschijnt eerst een startscherm met deze uitleg. Het spel begint pas als je op SPATIE drukt. Lees het scherm dus eerst, anders ben je zó game over.

Wat	Hoe
Bewegen	Pijltje links en pijltje rechts. Je blijft binnen het scherm.
Schieten	Houd de spatiebalk ingedrukt. Na elk schot moet je even wachten: bovenin staat Kanon: laden… of Kanon: klaar.
Doel	Ontwijk de rode blokken, of schiet ze neer.
Punten	+1 voor elk blok dat je mist (het valt onderaan weg). +5 voor elk blok dat je raakt met een kogel.
Levens	Je begint met 5 levens (`HP`). Raakt een blok jou, dan verlies je er één. Bij 0 is het game over.
Levels	Elke 20 punten gaat het level omhoog. Dan verschijnt LEVEL n in beeld en worden alle blokken sneller.
Game over	Je ziet een scherm met jouw rapport: score, level, aantal schoten, treffers en nauwkeurigheid. Het scherm blijft staan tot je op SPATIE, ENTER of ESC drukt (of het venster sluit).

Tip voor de eerste keer. Beweeg eerst een paar seconden en schiet pas daarna. Zie je een fout als AttributeError? Dan mist er een methode of klopt een naam niet — kijk dan in het contract hieronder.

Wat is nieuw ten opzichte van sprint 6?

Je ziet in het spel	Dat komt van jouw methode
Kanon: klaar / laden…, en je kunt niet sneller schieten dan de pauze	`Player.can_shoot()`, `Player.update()`, `Player.shoot()`
LEVEL 2, LEVEL 3… en snellere vijanden	`Game.level()` en `Enemy.speed_up()`
Het game-over-scherm met score, schoten, treffers en percentage	`Game.record_shot()`, `Game.record_hit()`, `Game.summary()`
Het startscherm met uitleg	geen methode: dat doet de engine

Rol	Bouwt	Kernvraag
Speler-team	`bullet.py` + `player.py`: `Bullet`- en `Player`-methodes	Hoe beweegt, schiet (met pauze) en incasseert de speler via methodes die de engine aanroept?
Wereld-team	`enemy.py` + `game.py`: `Enemy`-methodes en `Game` met score, level en rapport	Hoe laat elke vijand zichzelf vallen, melden, herspawnen en versnellen, en houdt `Game` score, level en statistieken bij?
Samen	`settings.py`, `main.py`, `test_game.py` + overstap naar engine v2	Passen jullie methodes op het engine-contract?

Bestandsindeling

Elke class krijgt een eigen bestand. Zo kan ieder team aan eigen bestanden werken zonder dat jullie elkaars code overschrijven. Alle bestanden staan in dezelfde map, samen met game_engine.py.

Bestand	Van wie	Bevat
`settings.py`	Samen	`WIDTH`, `HEIGHT` en de `WAVE`-data
`bullet.py`	Speler-team	de class `Bullet`
`player.py`	Speler-team	de class `Player`
`enemy.py`	Wereld-team	de class `Enemy`
`game.py`	Wereld-team	de class `Game`
`main.py`	Samen	start het spel met `run_world(game)`
`test_game.py`	Samen	de `assert`-tests van beide teams

Een bestand gebruikt een class uit een ander bestand met een import, bijvoorbeeld from bullet import Bullet bovenaan player.py. Je kent dit uit sprint 5 en 6 en deed het al in een aantal opdrachten van deze sprint. Start het spel met python main.py en de tests met python test_game.py.

Benodigd bestand: game_engine.py (v2)

Voor sprint 7 gebruik je de nieuwe engine die methodes aanroept. Download game_engine.py (v2) en zet hem in dezelfde map als main.py (vervang de v1 uit sprint 6). Kun je niet downloaden? Klap de code hieronder uit en kopieer hem naar een bestand game_engine.py.

Toon de code van game_engine.py (v2)

"""
game_engine.py - Arcade-engine voor Sprint 7 (v2, METHODE-gebaseerd). NIET AANPASSEN.

In sprint 6 muteerde deze engine ZELF de attributen van je objecten (player.x -= ...).
Nu roept de engine METHODES aan op jouw objecten. Jouw classes bepalen zelf hoe ze
bewegen, schieten, schade oplopen, sneller worden en hun eigen rapport maken. De engine
leest alleen nog attributen om te TEKENEN (x, y, width, height, color) en om botsingen
te bepalen. De engine toont ook een startscherm met uitleg en een game-over-scherm.

--------------------------------------------------------------------------
HET CONTRACT - welke METHODES de engine aanroept:

  game.player  - naast de teken-attributen x, y, width, height, color, health:
      move(direction, width)  direction is -1 (links), 0, of +1 (rechts); de speler
                              verschuift zichzelf EN houdt zich binnen [0, width-breedte]
      update()                wordt elk frame aangeroepen (bijv. om de schietpauze te laten aflopen)
      can_shoot()  -> bool    True als de speler nu mag schieten
      shoot()      -> bullet  geeft een NIEUW bullet-object terug, boven de speler,
                              en start de schietpauze
      take_damage(n)          verlaagt de eigen health met n
      is_dead()    -> bool    True als de speler geen leven meer heeft

  game.enemies - een LIJST; elke enemy heeft de teken-attributen EN:
      update()                laat zichzelf een stap vallen
      off_screen(height) -> bool   True als de vijand onder het scherm is
      respawn(width)          zet zichzelf weer bovenaan, op een nieuwe x
      speed_up()              wordt bij elk nieuw level aangeroepen: de vijand wordt sneller

  game.bullets - een LIJST; elke bullet heeft de teken-attributen EN:
      update()                beweegt zichzelf omhoog
      off_screen() -> bool    True als de kogel boven het scherm verdwenen is

  game         - het spelobject met:
      player, enemies, bullets, score, width, height   (attributen)
      add_score(n)            telt n bij de score op
      level()      -> int     het huidige level (begint op 1)
      record_shot()           de engine meldt: er is een kogel afgevuurd
      record_hit()            de engine meldt: een kogel heeft een vijand geraakt
      summary()    -> str     tekst voor het game-over-scherm (mag uit meerdere regels bestaan)

  y telt naar BENEDEN. Kleuren zijn RGB-tuples. De engine tekent, leest toetsen,
  detecteert botsingen en beheert de kogellijst; jouw METHODES doen de rest.
--------------------------------------------------------------------------
"""

import pygame

BACKGROUND = (15, 15, 22)
WHITE = (240, 240, 240)
GRAY = (150, 150, 160)
CYAN = (0, 200, 255)
YELLOW = (255, 220, 0)
RED = (255, 80, 80)
GREEN = (80, 220, 120)


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 _text(screen, font, text, color, y):
    """Tekent een regel horizontaal gecentreerd op hoogte y."""
    image = font.render(text, True, color)
    screen.blit(image, ((screen.get_width() - image.get_width()) // 2, y))


def _wait_screen(screen, clock, fonts, title, title_color, lines, footer, keys, ignore_frames=0):
    """Toont een scherm en wacht op een toets uit keys. Toetsen in de eerste ignore_frames
    frames tellen niet mee, zodat een speler die nog toetsen vasthoudt het scherm niet per
    ongeluk wegdrukt. Geeft False terug als het venster wordt gesloten."""
    big, font, small = fonts
    pygame.event.clear()
    frames = 0
    while True:
        frames += 1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return False
            if event.type == pygame.KEYDOWN and frames > ignore_frames and event.key in keys:
                return True
        screen.fill(BACKGROUND)
        _text(screen, big, title, title_color, 70)
        y = 160
        for line in lines:
            _text(screen, font, line, WHITE, y)
            y += 30
        _text(screen, small, footer, YELLOW, screen.get_height() - 70)
        pygame.display.flip()
        clock.tick(30)


START_LINES = [
    "Pijltjes links / rechts: bewegen",
    "Spatiebalk (ingedrukt houden): schieten",
    "",
    "Rode blokken vallen naar beneden.",
    "Ontwijk ze: +1 punt voor elk blok dat je mist.",
    "Schiet ze neer: +5 punten.",
    "Raakt een blok jou? Dan verlies je een leven.",
    "",
    "Elke 20 punten ga je een level omhoog.",
    "Hoger level = snellere vijanden.",
]


def run_world(game):
    """Start het spel. Geef je hele Game-object mee."""
    pygame.init()
    screen = pygame.display.set_mode((game.width, game.height))
    pygame.display.set_caption("Sprint 7 - Arcade Dodge (methode-gebaseerd)")
    clock = pygame.time.Clock()
    fonts = (pygame.font.SysFont(None, 56), pygame.font.SysFont(None, 26), pygame.font.SysFont(None, 22))
    big, font, small = fonts

    # Startscherm: uitleg, en wachten tot de speler klaar is.
    if not _wait_screen(screen, clock, fonts, "ARCADE DODGE", CYAN, START_LINES,
                        "Druk op SPATIE om te starten", {pygame.K_SPACE, pygame.K_RETURN}):
        pygame.quit()
        return

    last_level = game.level()
    banner = 0            # aantal frames dat de LEVEL-melding nog zichtbaar is
    window_closed = False
    running = True
    while running:
        # 1) Vensterknop
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
                window_closed = True

        keys = pygame.key.get_pressed()

        # 2) De speler ververst zichzelf; ingedrukte spatie -> de SPELER maakt zelf een kogel
        game.player.update()
        if keys[pygame.K_SPACE] and game.player.can_shoot():
            game.bullets.append(game.player.shoot())
            game.record_shot()

        # 3) Toetsen -> direction; de SPELER beweegt en klemt zichzelf
        direction = 0
        if keys[pygame.K_LEFT]:
            direction -= 1
        if keys[pygame.K_RIGHT]:
            direction += 1
        game.player.move(direction, game.width)

        # 4) Elke vijand valt zichzelf; onderaan -> zichzelf herspawnen
        for enemy in game.enemies:
            enemy.update()
            if enemy.off_screen(game.height):
                enemy.respawn(game.width)
                game.add_score(1)

        # 5) Elke kogel beweegt zichzelf; buiten beeld -> uit de lijst
        for bullet in game.bullets:
            bullet.update()
        game.bullets[:] = [b for b in game.bullets if not b.off_screen()]

        # 6) Botsing kogel x vijand (engine detecteert; objecten reageren)
        for bullet in game.bullets:
            for enemy in game.enemies:
                if _overlap(bullet, enemy):
                    enemy.respawn(game.width)
                    bullet.y = -100          # markeer voor opruimen (volgende frame)
                    game.add_score(5)
                    game.record_hit()

        # 7) Botsing vijand x speler
        for enemy in game.enemies:
            if _overlap(game.player, enemy):
                enemy.respawn(game.width)
                game.player.take_damage(1)
                if game.player.is_dead():
                    running = False

        # 8) Nieuw level? Dan worden alle vijanden sneller.
        level = game.level()
        if level > last_level:
            last_level = level
            banner = 90
            for enemy in game.enemies:
                enemy.speed_up()

        # 9) Tekenen op basis van attributen (net als in sprint 6)
        screen.fill(BACKGROUND)
        p = game.player
        pygame.draw.rect(screen, p.color, (p.x, p.y, p.width, p.height))
        for enemy in game.enemies:
            pygame.draw.rect(screen, enemy.color,
                             (enemy.x, enemy.y, enemy.width, enemy.height))
        for bullet in game.bullets:
            pygame.draw.rect(screen, bullet.color,
                             (bullet.x, bullet.y, bullet.width, bullet.height))

        hud = f"Score: {game.score}    Level: {level}    HP: {game.player.health}"
        screen.blit(font.render(hud, True, WHITE), (10, 10))
        ready = game.player.can_shoot()
        screen.blit(small.render("Kanon: klaar" if ready else "Kanon: laden...", True,
                                 GREEN if ready else GRAY), (10, 38))
        if banner > 0:
            _text(screen, big, f"LEVEL {level}", YELLOW, game.height // 2 - 30)
            banner -= 1
        _text(screen, small, "Pijltjes: bewegen    Spatie: schieten", GRAY, game.height - 18)

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

    # Game-over-scherm met het rapport van jouw Game-object.
    if not window_closed:
        # SPATIE telt hier niet mee: die is al "schieten" en wordt vaak nog ingedrukt.
        _wait_screen(screen, clock, fonts, "GAME OVER", RED, str(game.summary()).splitlines(),
                     "Druk op ENTER of ESC om af te sluiten",
                     {pygame.K_RETURN, pygame.K_ESCAPE}, ignore_frames=45)

    pygame.quit()

User stories

Als speler wil ik mijn schip met links/rechts besturen via move(direction, width), zodat ik zelf binnen het scherm blijf.
Als speler wil ik met de spatiebalk een kogel afvuren via shoot(), met een schietpauze die can_shoot() bewaakt, zodat mijn speler zelf beslist wanneer hij mag schieten.
Als speler wil ik dat mijn schip schade oploopt via take_damage(n) en met is_dead() game-over aangeeft, zodat de engine niet zelf aan mijn health zit.
Als ontwikkelaar wil ik dat elke vijand zichzelf laat vallen via update(), zodat de beweging bij de vijand hoort.
Als ontwikkelaar wil ik dat een vijand met off_screen(height) zelf meldt of hij eruit is, zodat de engine die beslissing niet hoeft te kennen.
Als ontwikkelaar wil ik dat een vijand zichzelf herstart via respawn(width) en sneller wordt via speed_up(), zodat dit gedrag van de vijand is.
Als ontwikkelaar wil ik dat het Game-object score, level en statistieken bijhoudt via add_score(n), level(), record_shot() en record_hit(), zodat er geen zwevende variabelen meer zijn.
Als speler wil ik na afloop een rapport zien via summary(), zodat ik weet hoe ik heb gespeeld.
Als team wil ik dat elke methode die iets moet melden een waarde teruggeeft, zodat de engine erop kan reageren.

Planning maken

Maak vóór jullie beginnen sámen een bestand project_plan.md. Beschrijf: wie bouwt welke methodes (en in welk bestand); wanneer leggen jullie het contract v2 vast en wanneer integreren jullie; welke engine-regel uit sprint 6 wordt welke methode. Dit lever je samen in met je code.

Structuur uitdenken

±45 min · samen

Leg samen het contract v2 vast vóórdat je codeert. Laag A is de vaste afspraak met de engine: welke methodes hij aanroept, met welke argumenten en returnwaarden.

Object	Methode	Args	Geeft terug
`player`	`move(direction, width)`	direction −1/0/+1, breedte	— (klemt zichzelf)
	`update()`	—	— (elk frame)
	`can_shoot()`	—	`bool`
	`shoot()`	—	nieuwe `Bullet`
	`take_damage(n)`	schade	—
	`is_dead()`	—	`bool`
elke `enemy`	`update()`	—	—
	`off_screen(height)`	hoogte	`bool`
	`respawn(width)`	breedte	—
	`speed_up()`	—	—
elke `bullet`	`update()`	—	—
elke `bullet`	`off_screen()`	—	`bool`
`game`	`add_score(n)`	punten	—
	`level()`	—	`int`
	`record_shot()`	—	—
	`record_hit()`	—	—
	`summary()`	—	`str` (mag uit meerdere regels bestaan)

De engine blijft de teken-attributen lezen (x, y, width, height, color en player.health). Laag B is de afspraak tussen jullie: Player(x, y)- en Enemy(x, y, speed)-signaturen (als sprint 6), kogels leven in game.bullets, WAVE = lijst (x, speed), en shoot() geeft een Bullet terug die het speler-team definieert. Laag C is de indeling in bestanden: welk bestand importeert welk ander bestand.

Ontwerpvragen

move(direction, width) — hoe combineer je de twee sprint-6-takken (links én rechts) tot één regel met direction, en hoe klemt de speler zichzelf binnen 0 en width - self.width?
Schietpauze — welk attribuut onthoudt hoeveel frames de speler nog moet wachten? Welke methode telt dat elk frame terug (update), welke beantwoordt de vraag "mag ik schieten?" (can_shoot) en welke start de pauze (shoot)?
off_screen(height)/is_dead()/can_shoot() — waarom geven deze een bool terug in plaats van zelf iets te doen? Wie neemt de beslissing?
respawn(width) en speed_up() — waar zet de vijand zichzelf terug, welke waarde is willekeurig, en waarom is een maximumsnelheid verstandig?
level() — uit welke waarde reken je het level uit, en waarom slaan we het niet apart op?
summary() — waarom geeft hij een tekst terug in plaats van te printen? En wat gaat er mis bij een nauwkeurigheid als je nog niet geschoten hebt (delen door nul)? Welke guard lost dat op?
Bestanden — player.py heeft Bullet nodig. Welk bestand importeert dan welk bestand? Wat gaat er mis als bullet.py óók player.py importeert?

Elke methode die iets moet melden, gebruikt return. Een methode die alleen print, geeft None terug — daar kan de engine niets mee. is_dead(), off_screen() en can_shoot() moeten een echte True/False teruggeven, en summary() een echte tekst.

Bouwen: stap voor stap

±130 min

Speler-team en wereld-team bouwen na stap 1 grotendeels parallel. Houd na élke stap een werkend, testbaar stukje code.

Stap 1 — Contract v2 vastleggen 20 min · samen

Vul de methodetabel (laag A) en de interne afspraken (laag B en C) in. Zet de bestanden klaar in één map.

Test: jullie kunnen per methode zeggen wie hem aanroept en wat hij teruggeeft.

Stap 2 — Player-beweging 25 min · Speler-team

Schrijf in player.py de methode move(direction, width) met de klem binnen het scherm.

Test: p = Player(0, 580); p.move(-1, 480) laat p.x == 0.

Stap 3 — Schieten met een pauze 30 min · Speler-team

Schrijf in player.py update(), can_shoot() en shoot(). Schrijf in bullet.py de class Bullet met update() en off_screen().

Test: direct na p.shoot() geeft p.can_shoot() False; na genoeg keer p.update() weer True. shoot() geeft elke keer een nieuwe Bullet.

Stap 4 — Schade 10 min · Speler-team

Schrijf in player.py take_damage(n) en is_dead().

Test: na p.take_damage(1) is de health één lager; bij 0 is p.is_dead() True.

Stap 5 — Enemy-gedrag 30 min · Wereld-team

Schrijf in enemy.py update(), off_screen(height), respawn(width) en speed_up() (met een maximumsnelheid).

Test: na e.update() is e.y met speed gestegen; e.off_screen(640) klopt op de rand; na respawn(480) staat e.y < 0; speed_up() verhoogt de snelheid maar nooit boven het maximum.

Stap 6 — Game bundelt, score en level 25 min · Wereld-team

Bouw in game.py Game.__init__ (uit WAVE, gestaffeld), add_score(n) en level(). Het level begint op 1 en gaat elke 20 punten omhoog.

Test: verse Game heeft score == 0, level() == 1 en gevulde enemies; bij score 20 is het level 2.

Stap 7 — Het rapport 25 min · Wereld-team

Laat Game schoten en treffers tellen met record_shot() en record_hit(). Schrijf een methode die de nauwkeurigheid berekent (treffers als percentage van de schoten) en summary() die een tekst met score, level, schoten, treffers en nauwkeurigheid teruggeeft.

Test: zonder schoten geeft de nauwkeurigheid 0 (geen fout); na 2 schoten en 1 treffer is het 50. summary() bevat de score als tekst.

Stap 8 — Eigen tests 20 min · beide teams, parallel

Schrijf test_game.py met assert-regels voor je eigen methodes (geen venster). Haal je classes binnen met een import, zoals from player import Player.

Test: alle asserts draaien groen.

Stap 9 — Overstap naar engine v2 + integratie 25 min · samen

Vervang v1 door v2 en zet run_world(game) in main.py. Start met python main.py.

Test: het startscherm verschijnt en na SPATIE is het spel speelbaar; werkt het niet, controleer eerst de méthodenamen tegen laag A — een verkeerd gespelde respawn/off_screen is de meest voorkomende integratiebug.

Stap 10 — Speltest en controle 15 min · samen

Speel het spel en loop de lijst bij Testen langs. Elke methode die iets moet melden gebruikt return; alle gedrag zit in methodes, en de engine is onaangeraakt.

Startpunt

Je begint met deze twee bestanden. De classes en methodes in de andere bestanden bouw je zelf op. main.py werkt pas als jullie game.py hebben.

settings.py

WIDTH, HEIGHT = 480, 640

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

main.py

from game_engine import run_world
from game import Game
from settings import WIDTH, HEIGHT, WAVE

if __name__ == "__main__":
    game = Game(WIDTH, HEIGHT, WAVE)
    run_world(game)

Bouw op, herschrijf niet. Neem je sprint-6-classes over, zet elke class in zijn eigen bestand en verplaats het bekende gedrag naar methodes. Zet de speler op health = 5 en geef de speler een schietpauze van ongeveer 20 frames. Verzin er geen nieuw spelconcept bij: dan blijft het testbaar.

Testgevallen

±40 min

Alle tests komen in één bestand test_game.py dat je samen inlevert. Ieder team test zijn eigen methodes; geen enkele test opent een venster. Dat kan omdat test_game.py alleen de classes importeert (from player import Player) en niet main.py.

Speler-team (parallel, ~20 min)

Na Player(0, 580).move(-1, WIDTH) blijft x == 0 (klemt links); rechts klemt bij WIDTH - width.
can_shoot() is True bij een nieuwe speler, False direct na shoot() en weer True nadat update() de pauze heeft laten aflopen.
shoot() geeft een nieuwe Bullet boven de speler; twee aanroepen geven twee verschillende objecten.
Na take_damage(1) is de health één lager; na genoeg schade is is_dead() True.
Bullet.update() beweegt omhoog; off_screen() klopt boven het scherm.

Wereld-team (parallel, ~20 min)

Na Enemy(100,0,3).update() is y == 3.
off_screen(HEIGHT) klopt op de onderrand; na respawn(WIDTH) staat de vijand weer boven het scherm op een geldige x.
speed_up() verhoogt de snelheid met één en stopt bij het maximum.
Verse Game heeft score == 0, level() == 1 en een lege bullets; na add_score(20) is het level 2.
De nauwkeurigheid is 0 zonder schoten en 50 na twee schoten en één treffer; summary() geeft een tekst terug.

Contracttest (samen)

Laat de engine v2 het samengevoegde spel draaien met alle methodes. Werkt het niet meteen, lees de AttributeError: die noemt exact de ontbrekende of verkeerd gespelde methode.

Speltest (samen, ~10 min)

Speel een ronde en vink af:

Het startscherm verschijnt en het spel begint pas na SPATIE.
Je kunt niet sneller schieten dan de pauze; bovenin wisselt Kanon: klaar en Kanon: laden….
Bij 20 punten verschijnt LEVEL 2 en vallen de blokken sneller.
Bij 0 levens zie je het game-over-scherm met een rapport dat klopt met wat je deed (tel je schoten eens na).

Test zonder venster. Omdat het gedrag in methodes zit, test je elke methode met assert zonder een venster te openen — en zonder op elkaar te wachten. Zet de run-code in main.py achter if __name__ == "__main__": zodat importeren (en dus testen) veilig blijft.

Opleveren: klaar?

±20 min · samen

Loop deze criteria langs. Voldoet alles → inleveren.

Acceptatiecriteria

Speler-team

Player heeft move, update, can_shoot, shoot, take_damage en is_dead.
Bullet heeft update en off_screen.
shoot() retourneert een correct geplaatste Bullet en start de schietpauze.

Wereld-team

Enemy heeft update, off_screen, respawn en speed_up (met maximum).
Game bundelt player/enemies/bullets/score/width/height en heeft add_score, level, record_shot, record_hit en summary.
De nauwkeurigheid geeft 0 zonder schoten en deelt nooit door nul.
self.player is een echt Player-object.

Samen

Het spel draait via run_world(game): startscherm, schietpauze, levels en game-over-rapport werken.
Elke methode die iets moet melden gebruikt return.
Elke class staat in zijn eigen bestand en de imports lopen één kant op.
test_game.py draait groen; de run-code in main.py staat achter if __name__ == "__main__":.

Wat lever je in?

De zeven bestanden: settings.py, bullet.py, player.py, enemy.py, game.py, main.py en test_game.py.
project_plan.md met jullie planning én het ingevulde contract.
Een schermafbeelding van het game-over-scherm met jullie rapport.

Waar staan jullie nu? Je classes hebben gedrag gekregen: methodes met parameters, returnwaarden, guards en queries, die de engine aanroept. Je speler beweegt en schiet zichzelf (met pauze), je vijanden vallen, herspawnen en worden sneller, en je game houdt score, level en statistieken bij.

En dan? In sprint 8 maak je de toestand van je objecten veiliger: je verbergt gevoelige attributen en laat ze alleen via nette methodes aanpassen (encapsulatie). Bewaar dit project goed — je bouwt er in de volgende sprint op voort.

Extra — verder gaan?

±45 min

Klaar met de basis? Kies één uitbreiding, met alleen wat je al kent.

1. Schutterrang

Laat Game een methode rank() hebben die op basis van de nauwkeurigheid een titel teruggeeft (bijvoorbeeld "Rookie" bij minder dan 5 schoten, anders "Sharpshooter", "Gunner" of "Spray and pray"). Zet de rang in summary(), dan staat hij op het game-over-scherm.

2. Combo-score

Laat Game een combo-teller bijhouden: raak je snel achter elkaar meerdere vijanden, dan geeft add_score bonuspunten.

3. Uitgebreider testbestand

Dek in test_game.py de grenswaarden af: move precies op beide randen, is_dead bij health 0 en 1, level() bij 19 en 20 punten — elk met een duidelijke foutmelding.

Acceptatiecriteria (kies er één)

summary() toont een rang die klopt met de nauwkeurigheid, via een eigen methode.
Of: add_score geeft bonuspunten bij een combo.
Of: test_game.py dekt de grenswaarden af met duidelijke foutmeldingen.

Nieuwe techniek nodig? Nee — classes, methodes met parameters en returnwaarden, if, for en assert ken je al.

Arcade Dodge v2 — Player, Enemy & Game leren bewegen

Wat ga je bouwen?

Zo speel je het spel

Wat is nieuw ten opzichte van sprint 6?

Bestandsindeling

Benodigd bestand: game_engine.py (v2)

User stories

Planning maken

Structuur uitdenken

Ontwerpvragen

Bouwen: stap voor stap

Stap 1 — Contract v2 vastleggen 20 min · samen

Stap 2 — Player-beweging 25 min · Speler-team

Stap 3 — Schieten met een pauze 30 min · Speler-team

Stap 4 — Schade 10 min · Speler-team

Stap 5 — Enemy-gedrag 30 min · Wereld-team

Stap 6 — Game bundelt, score en level 25 min · Wereld-team

Stap 7 — Het rapport 25 min · Wereld-team

Stap 8 — Eigen tests 20 min · beide teams, parallel

Stap 9 — Overstap naar engine v2 + integratie 25 min · samen

Stap 10 — Speltest en controle 15 min · samen

Startpunt

Testgevallen

Speler-team (parallel, ~20 min)

Wereld-team (parallel, ~20 min)

Contracttest (samen)

Speltest (samen, ~10 min)

Opleveren: klaar?

Wat lever je in?

Extra — verder gaan?

1. Schutterrang

2. Combo-score

3. Uitgebreider testbestand