Sprint 7 · Methodes & self  ·  US3: Methodes die het spel besturen

Als gamedeveloper, wil ik dat mijn speler, kogels en vijanden zichzelf besturen via methodes met parameters en returnwaarden, zodat de engine alleen nog de methodes hoeft aan te roepen.

Taak 1: Een parameter stuurt de methode aan

Een methode zonder parameter doet altijd hetzelfde. Met een parameter laat je de aanroeper kiezen. Je leert een methode schrijven die een waarde krijgt en daarmee iets doet met zijn eigen object.

Eén methode met een parameter in plaats van drie bijna-gelijke

Tot nu toe had een methode alleen self. Dan kan hij maar één ding doen. Wil je een ander getal optellen? Dan schrijf je een nieuwe methode:

class Counter:
    def __init__(self):
        self.total = 0

    def add_one(self):
        self.total += 1

    def add_two(self):
        self.total += 2

    def add_five(self):
        self.total += 5

Dat wordt snel een lange rij bijna-gelijke methodes. Er is een betere manier: je geeft de methode een parameter. De aanroeper bepaalt dan zelf hoeveel er bij komt.

class Counter:
    def __init__(self):
        self.total = 0

    def add(self, amount):        # amount is de parameter
        self.total += amount


counter = Counter()
counter.add(5)      # amount is nu 5
counter.add(2)      # amount is nu 2
print(counter.total)   # 7
Eén methode, veel gedrag. self vult Python zelf in. Alle andere parameters geef jij mee tussen de haakjes, na self.

Zie het gebeuren

Druk op Volgende stap. Let op: amount bestaat alleen tijdens de aanroep.

>>> Oefenomgeving: Python REPL Simulator

Probeer zelf hoe een parameter werkt.

  1. counter = Counter()
  2. counter.add(5) — tel 5 op.
  3. counter.total — wat is de waarde?
  4. counter.add() — zonder waarde. Wat gebeurt er?
  5. counter.total — en nu?
  6. counter.add(amount=10) — met de naam erbij.
  7. counter.total — klopt je som?
Python 3.11 REPL Simulator · typ een commando en druk op Enter. # class Counter: # def __init__(self): self.total = 0 # def add(self, amount=1): self.total += amount # def reset(self): self.total = 0
>>> 
🧩

Jouw opdracht: Player.move(direction)

Je geeft je speler één methode om te bewegen. Een parameter bepaalt de richting.

  1. Maak een class Player met in __init__ de attributen self.x = 240, self.y = 580 en self.speed = 5.
  2. Schrijf de methode move(self, direction). De waarde direction is -1 (links), 0 (stil) of 1 (rechts). De methode verandert self.x met direction maal self.speed.
  3. Maak player = Player(). Roep player.move(1) drie keer aan en print player.x.
  4. Roep daarna player.move(-1) twee keer aan en player.move(0) één keer. Print player.x opnieuw.
  5. Schrijf in commentaar op: waarom is één methode met een parameter beter dan drie losse methodes move_left(), move_right() en stay()?

Acceptatiecriteria

  • move is een methode van Player met de parameter direction.
  • Na drie keer move(1) is player.x == 255.
  • Na twee keer move(-1) en één keer move(0) is player.x == 245.
  • De snelheid komt uit self.speed; er staat geen vast getal 5 in move.
  • Er zijn geen aparte methodes voor links en rechts.