Sprint 6 · De blauwdruk  ·  US4: De Game — alles in één object

Als developer, wil ik de speler, alle vijanden en de score in één Game-object bewaren dat ik in één keer aan de engine meegeef, zodat mijn spel niet meer op losse globals draait en de hele spelstaat overal makkelijk is door te geven.

Taak 3: De toestand in self opslaan

Nu zet je alles bij elkaar: de constructor van je Game bewaart de speler, de lijst vijanden, de kogels en de score als attributen op self. Eén object dat de hele spelstaat draagt — en dat je in één keer aan de engine geeft, zodat je hele spel draait.

Alle toestand in één constructor

Neem als voorbeeld een Session die een verbinding bewaart plus wat status. De constructor zet regel voor regel de attributen op self:

class Session:
    def __init__(self):
        self.connection = Connection()   # een ander object
        self.active = False              # status
        self.duration = 0                # teller
        self.name = "session-1"          # vaste data

Na s = Session() is s één object dat alles bij zich draagt: het verbindings-object én de losse status. Geen zwevende globals meer — alles zit in self.

Dit patroon gebruik je zo in je opdracht.
Precies zo bewaart je eigen wrapper-object straks een extern object plus de losse status (bijvoorbeeld een verbinding, een ja/nee-status en een teller). Eén constructor die de hele staat in één keer opzet.

Zie de constructor het object vullen

Klik op Volgende regel en volg hoe de constructor stap voor stap de attributen op self zet. Rechts vult het object zich.

s = Session()
Nog leeg. Klik "Volgende regel".
>>> Oefenomgeving: Python REPL Simulator

De class Session uit de theorie is gedefinieerd (met self.active = False, self.duration = 0 en self.name = "session-1"). Maak een sessie en bekijk zijn toestand.

  1. s = Session()
  2. s.active en s.duration — de startstatus.
  3. s.name
  4. s.duration = 30 — pas de toestand aan.
  5. s.duration — en nu?
Python 3.11 REPL Simulator · class Session is gedefinieerd.
>>> 
🧩

Jouw opdracht: de Game-constructor

Bouw de constructor van je eigen Game die de hele spelstaat bundelt, en geef hem aan de engine zodat je spel echt draait. Gebruik je Player- en Enemy-classes uit de vorige taken en zet game_engine.py ernaast.

  1. Schrijf een class Game met __init__(self, width, height).
  2. Bewaar in de constructor self.player (een Player-object), self.enemies (een lijst met een paar Enemy-objecten), self.bullets = [], self.score = 0 en self.width/self.height.
  3. Zet je testcode achter if __name__ == "__main__":, maak een Game aan en start het spel met run_world(game) uit game_engine.
  4. Print vóór het starten alle attributen om te bewijzen dat de staat goed is opgezet (game.player is een echt Player-object, game.enemies bevat meerdere vijanden, game.score is 0).

Acceptatiecriteria

  • Game bewaart player, enemies, bullets, score, width en height als attributen.
  • self.player is een echt Player-object (object-in-object).
  • De testcode staat achter if __name__ == "__main__":.
  • run_world(game) toont speler + vallende vijanden + de score; er zijn geen losse globals meer.