Cheatsheet

play package

Hoe upgrade of downgrade ik de versie van play?

Je kunt een specifieke versie van play installeren of de huidige versie bijwerken met de volgende commando's

Zie hier voor waar je het commando kan invoeren.

Upgraden naar de nieuwste versie:

pip install --upgrade coderius-play

Mocht je meldingen krijgen zoals Toegang geweigerd kan het helpen om --user toe te voegen:

pip install --upgrade --user coderius-play

Installeren van een specifieke versie:

pip install coderius-play==VERSIENUMMER

Vervang VERSIENUMMER door de gewenste versie, bijvoorbeeld 3.0.0.

Tip: Als je niet zeker weet welke versies er beschikbaar zijn, kun je deze bekijken op PyPI.

Nieuw of verbeterd in coderius-play versie 3.2

We hebben flink wat verbeteringen doorgevoegd in coderius-play versie 3.1.

Bij Fysica: alle vormen hebben nu altijd fysica, al merk je dit niet altijd. Weet wel: dit lost stiekem heel veel bugs op en maakt de code simpeler voor de ontwikkelaar en voor jou :).

Bij SNES-controller: Bug is gefixt waarbij when_button_pressed maar één keer gebeurde als je een knop inhield. Nu gaat de gebeurtenis elk frame af als je de knop inhoudt!

Bij Database (JSON): je kunt nu een zogenaamde "default" waarde meegeven, erg handig als je een high-score systeem gaat maken

Nieuw of verbeterd in coderius-play versie 3.1

We hebben flink wat verbeteringen doorgevoegd in coderius-play versie 3.1.

Bij een foutmelding sluit het spel nu meteen. Dat helpt bij het debuggen.

Bij Acties: als je twee of meer keer achter elkaar hide, show of remove aanroept, krijg je geen foutmelding meer

Bij Acties: the distance_to wordt nu uitgelegd in deze cheatsheet. Misschien leuk voor het programmeren van een tegenstander bij pong!

Bij Fysica: bij grote vormen raken de vormen weer netjes de muren zonder gekke onzichtbare rand

Bij Gebeurtenis bij een vorm: je kunt nu ook weten welke muur je hebt aangeraakt bij when_touching_wall en when_stopped_touching_wall

Bij Database (JSON): nu zelfs met aparte uitlegpagina

Editor

Hoe sla ik een bestand op in Thonny?

Je kunt een bestand opslaan in Thonny op verschillende manieren:

Methode 1: Via het menu

• Klik op File (Bestand) in de menubalk
• Klik op Save (Opslaan) of Save As... (Opslaan als...)

Methode 2: Met sneltoetsen

• Windows/Linux: druk op Ctrl + S
• Mac: druk op Cmd + S

Tip: Als je een nieuw bestand voor het eerst opslaat, moet je een naam en locatie kiezen. Zorg ervoor dat je bestand eindigt op .py (bijvoorbeeld mijn_spel.py).

Vormen

Cirkel (play.new_circle)

import play 

play.new_circle()

play.start_program()

Wat kan ik aanpassen aan een cirkel? Hierbij de lijst van attributen voor een cirkel:

• color: Kleur, staat standaard op 'black'. Op deze pagina zie je welke kleuropties er zijn. Je kunt ook direct een RGB-waarde opgeven zoals color=(100,100,100).
• x: x-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar links, groter dan 0 is naar rechts.
• y: y-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar beneden, groter dan 0 is naar boven.
• radius: straal, staat standaard op 100. Hoe groter de waarde, hoe groter de cirkel.
• border_color: kleur van de rand, staat standaard op 'light blue'. Let op, als de border_width 0 is, zie je de rand niet.
• border_width: de breedte van de rand. Staat standaard op 0 (geen rand zichtbaar)
• transparency: doorzichtigheid, 0 is onzichtbaar. 100 is volledig zichtbaar.

Voorbeeld van een kleine blauwe cirkel die een beetje naar rechts staat:

import play

cirkel = play.new_circle(color='blue', radius=20, x=100)

play.start_program()

Vierkant of rechthoek (play.new_box)

import play 

play.new_box()

play.start_program()

Net zoals bij play.new_circle heeft het programma voor ons nu ook al de kleur en grootte bepaald. Je kunt dit zelf natuurlijk aanpassen! Dit zijn de attributen voor play.new_box:

• color: Kleur, staat standaard op 'black'. Op deze pagina zie je welke kleuropties er zijn. Je kunt ook direct een RGB-waarde opgeven zoals color=(100,100,100).
• x: x-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar links, groter dan 0 is naar rechts.
• y: y-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar beneden, groter dan 0 is naar boven.
• width: de breedte van de rechthoek.
• height: de hoogte van de rechthoek.
• border_color: kleur van de rand, staat standaard op 'light blue'. Let op, als de border_width 0 is, zie je de rand niet.
• border_radius: de breedte van de rand. Staat standaard op 0 (geen rand zichtbaar)
• transparency: doorzichtigheid, 0 is onzichtbaar. 100 is volledig zichtbaar.

Voorbeeld van een rode rechthoek die een beetje boven het midden staat:

import play

box = play.new_box(color='red', y=100)

play.start_program()

Tekst (play.new_text)

import play 

play.new_text()

play.start_program()

Je kunt voor play.new_text kiezen uit:

• words: Woorden op het scherm, de woorden die op het scherm komen te staan
• x: x-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar links, groter dan 0 is naar rechts.
• y: y-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar beneden, groter dan 0 is naar boven.
• font: de font van de tekst. Kun je bijvoorbeeld aanpassen naar 'arial'.
• font_size: de grootte van de font.
• color: Kleur, staat standaard op 'black'. Op deze pagina zie je welke kleuropties er zijn. Je kunt ook direct een RGB-waarde opgeven zoals color=(100,100,100).

Voorbeeld van een blauwe tekst midden bovenaan het scherm met een net iets grote font size:

import play

tekst = play.new_text(words="Hello world", y=200, font_size=50)

play.start_program()

Afbeelding (play.new_image)

import play 

play.new_image('VERVANG_DIT_DOOR_NAAM_VAN_AFBEELDING')

play.start_program()

Je moet voor play.new_image kiezen uit:

• image: dit is de naam van het bestand op jouw computer, bijvoorbeeld cat.jpg (als je je afbeelding zo genoemd hebt)

Je kunt voor play.new_image kiezen uit:

• x: x-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar links, groter dan 0 is naar rechts.
• y: y-positie, staat standaard op 0 (het midden). Kleiner dan 0 is naar beneden, groter dan 0 is naar boven.
• size: de grootte van de afbeelding. De grootte staat standaard op 100. Een hoger getal dan 100 maakt de afbeelding groter en een lager getal maakt de afbeelding kleiner.
• transparency: doorzichtigheid, 0 is onzichtbaar. 100 is volledig zichtbaar.

Alleen gebruiken als je physics NIET gebruikt:

• angle: de hoek. Je kunt je afbeelding draaien door de angle te veranderen. Als je angle naar 180 verandert, staat de afbeelding op z'n kop.

Hoe weet ik precies de locatie van de rechterkant (right), linkerkant (left), bovenkant (top) en onderkant (bottom) van een vorm?

Dat gaat via:

• rechterkant (right)
• linkerkant (left)
• bovenkant (top)
• onderkant (bottom)

Als ik bijvoorbeeld wil weten wat de meest rechter pixel is van een cirkel, kan ik het volgende doen:

import play 

cirkel = play.new_circle()

print(cirkel.right)

play.start_program()

Als het goed is, zie je het volgende in je shell of console

pygame-ce 2.5.3 (SDL 2.30.12, Python 3.10.11)
100.0

Nu weet je dus dat de meest rechter pixel van de bal op x=100 staat.

Fysica

Hoe voeg ik fysica toe aan een vorm? (start_physics)

import play 

cirkel = play.new_circle()
cirkel.start_physics()

play.start_program()

Hoe verander ik de fysica-eigenschappen van een vorm? (start_physics)

import play 

cirkel = play.new_circle()
cirkel.start_physics(obeys_gravity=False)

play.start_program()

OF (nuttig als je iets wil veranderen tijdens het spel)

import play 

cirkel = play.new_circle()
cirkel.start_physics()

cirkel.physics.obeys_gravity = False

play.start_program()

Wat kan ik allemaal aanpassen aan de fysica? (start_physics)

Attribuut	Uitleg
obeys_gravity	True --> zwaartekracht wordt nagedaan, False --> geen zwaartekracht
x_speed	hoe hard wil je dat de bal beweegt op de horizontale as?
y_speed	hoe hard wil je dat de bal beweegt op de verticale as?
can_move	True --> de vorm mag bewegen, False, de vorm staat altijd stil
stable	True --> als iets botst tegen vorm, zal deze niet bewegen, False, de vorm zal bewegen bij een botsing.
bounciness	1.0 vorm kaatst net zo hard terug als dat deze aankwam. 0 --> vorm kaatst niet terug bij botsing
mass	hoe 'zwaar' is je vorm? Dit kan snel ingewikkeld worden. Maar je kan je voorstellen dat een botsing anders is tussen twee vormen die even zwaar zijn in plaats van als vormen verschillend gewicht hebben.
friction	0 --> geen frictie (energie blijft behouden).

Hoe zet ik de fysica op pauze en weer aan? (.phyiscs.pause() & .physics.unpause())

Met .physics.pause zet je de fysica op pauze en met .physics.unpause zet je de fysica weer aan.

Een voorbeeld met pause:

import play 

cirkel = play.new_circle()
cirkel.start_physics()
cirkel.physics.pause()

play.start_program()

Een voorbeeld met ook unpause:

import play 

cirkel = play.new_circle()
cirkel.start_physics()
cirkel.physics.pause()
cirkel.physics.unpause()

play.start_program()

Hoe zet ik de fysica uit? (stop_physics())

Met stop_physics() zet je de physics uit.

import play 

cirkel = play.new_circle()
cirkel.start_physics()
cirkel.stop_physics()
play.start_program()

Acties

Hoe maak ik een vorm onzichtbaar (hide)?

Hiermee teken je een cirkel en maak je hem onmiddelijk onzichtbaar.

Let op: .hide() verandert het volgende:

• cirkel.is_hidden krijgt de waarde True
• cirkel.is_shown krijgt de waarde False
• Als je fysica gebruikt, gaat die op pauze :)

import play 

cirkel = play.new_circle()
cirkel.hide()

play.start_program()

Hoe maak een ik vorm weer zichtbaar (show)?

Hiermee teken je een cirkel en maak je hem onmiddelijk onzichtbaar en weer zichtbaar

Let op: .show() verandert het volgende:

• cirkel.is_hidden krijgt de waarde False
• cirkel.is_shown krijgt de waarde True
• Als je fysica gebruikte, gaat deze weer aan en weer werken

import play 

cirkel = play.new_circle()
cirkel.hide()
cirkel.show()

play.start_program()

Hoe verwijder ik een vorm? (remove)?

Allereerst een vraag: heb je dit echt nodig of is .hide() misschien ook al genoeg? Met .remove():

• verwijder je de vorm
• je kunt opvragen of de vorm 'leeft' via cirkel.alive(). Deze is False als de vorm verwijderd is.

import play

cirkel = play.new_circle()
cirkel.remove()

play.start_program()

Hoe bereken ik de afstand tussen twee vormen (distance_to)?

Met .distance_to() kun je de afstand tussen twee vormen berekenen.

Je berekent de afstand tussen het midden van de ene vorm en het midden van de andere vorm, dus niet vanaf de zijkanten.

import play

cirkel1 = play.new_circle(x=-100, radius=20)
cirkel2 = play.new_circle(x=100, radius=20)

afstand = cirkel1.distance_to(cirkel2)
play.new_text(words=f"Afstand: {afstand}", y=200)

play.start_program()

Gebeurtenissen

Bij de start van het programma (@play.when_program_starts)

import play

@play.when_program_starts
def setup_game():
    play.new_text(words="Welkom!")      

play.start_program()

Bij het indrukken van één specifieke toets (@play.when_key_pressed)

Je gebruikt @play.when_key_pressed om te checken of een toets ingedrukt wordt. Wat je tussen de haakjes zet (in dit geval 'space') is welke toets gedetecteerd wordt.

import play

box = play.new_box()

@play.when_key_pressed("space")
def spatie_ingedrukt():
  box.x = box.x + 10
    
play.start_program()

Bij het indrukken van twee of meerdere toetsen (@play.when_key_pressed)

Als je met meerdere toetsen te maken hebt, heb je in ieder geval twee opties.

• twee losse @play.when_key_pressed gebeurtenissen
• één play.when_key_pressed gebeurtenis

twee @play.when_key_pressed gebeurtenissen

import play

box = play.new_box()

@play.when_key_pressed("up")
def omhoog():
  box.y = box.y + 10

@play.when_key_pressed('down')
def omlaag():
  box.y = box.y - 10
    
play.start_program()

OF

één @play.when_key_pressed gebeurtenis Let op, nu heb je key nodig.

import play

box = play.new_box()

@play.when_key_pressed("down", "up")
def omhoog_of_omlaag(key):
  if key == 'up':
    box.y = box.y + 10
  if key == 'down':
    box.y = box.y - 10
    
play.start_program()

Bij het loslaten van één specifieke toets (@play.when_key_released)

Je gebruikt @play.when_key_released om te checken of een toets losgelaten wordt.

import play

box = play.new_box()

@play.when_key_released("up")
def omhoog():
  box.y = box.y + 10
    
play.start_program()

Bij het loslaten van twee of meerdere toetsen (@play.when_key_released)

Als je met meerdere toetsen te maken hebt, heb je in ieder geval twee opties.

• twee losse @play.when_key_released gebeurtenissen
• één play.when_key_released gebeurtenis

twee @play.when_key_released gebeurtenissen

import play

box = play.new_box()

@play.when_key_released("up")
def omhoog():
  box.y = box.y + 10

@play.when_key_released('down')
def omlaag():
  box.y = box.y - 10
    
play.start_program()

OF

één @play.when_key_released gebeurtenis Let op, nu heb je key nodig.

import play

box = play.new_box()

@play.when_key_released("down", "up")
def omhoog_of_omlaag(key):
  if key == 'up':
    box.y = box.y + 10
  if key == 'down':
    box.y = box.y - 10
    
play.start_program()

Bij het indrukken van een willekeurige toets (@play.when_any_key_pressed)

Met @play.when_any_key_pressed kun je een functie uitvoeren zodra een willekeurige toets op het toetsenbord wordt ingedrukt. Met de key parameter weet je welke toets is ingedrukt.

import play

instructie_tekst = play.new_text("Druk op een toets", y=50)
feedback_tekst = play.new_text(words="", y=0)

@play.when_any_key_pressed
def handel_toets_af(key):
  feedback_tekst.words = f"Je drukte op: {key}"
    
play.start_program()

Bij het loslaten van een willekeurige toets (@play.when_any_key_released)

Met @play.when_any_key_released kun je een functie uitvoeren zodra een willekeurige toets op het toetsenbord wordt losgelaten. Met de key parameter weet je welke toets is losgelaten.

import play

instructie_tekst = play.new_text("Laat een toets los", y=50)
feedback_tekst = play.new_text(words="", y=0)

@play.when_any_key_released
def toets_wordt_losgelaten(key):
  feedback_tekst.words = f"Je liet los: {key}"
    
play.start_program()

Welke toetsen kun je gebruiken bij @play.when_key_pressed?

Op deze site kun je een lijst vinden van alle toetsen. Scrol naar beneden tot je bij de lijst bent. Het gaat om de kolom "Description".

Bij het indrukken van de muis (@play.when_mouse_clicked)

when_mouse_clicked gebruik je om een muisklik te detecteren.

import play

# Maak een cirkel
circle = play.new_circle(color="blue")

# Deze functie wordt uitgevoerd als je op de muis klikt
@play.when_mouse_clicked
def muis_geklikt():
  if circle.color == "blue":
    circle.color = "red"
  else:
    circle.color = "blue"
  print("Muis geklikt! De cirkel is nu " + str(circle.color))

# Start het programma
play.start_program()

Bij het loslaten van de muis (@play.when_click_released)

Let op, deze gebeurtenis gebeurt pas als je de muis loslaat.

import play

# Maak een cirkel
circle = play.new_circle(color="blue")

# Deze functie wordt uitgevoerd als je op de muis klikt
@play.when_click_released
def muis_geklikt():
  if circle.color == "blue":
    circle.color = "red"
  else:
    circle.color = "blue"
  print("Muis geklikt! De cirkel is nu " + str(circle.color))

# Start het programma
play.start_program()

Bij elk frame (@play.repeat_forever)

import play

frames=0
play.new_text('Aantal frames sinds start:', y=100)
tekst = play.new_text(words=str(frames))

@play.repeat_forever
def altijd():
  global frames
  frames = frames + 1
  tekst.words = str(frames)

play.start_program()

Gebeurtenis bij een vorm

Zodra twee vormen elkaar raken (@VARIABLE.when_touching)

Je gebruikt @VARIABLE.when_touching als je wilt weten of twee vormen elkaar raken.

import play

bal = play.new_circle(radius=50)
bal.start_physics(obeys_gravity=False, x_speed=20)

batje = play.new_box(x=200)

tekst = play.new_text("batje nog niet aangeraakt", y=200)

@bal.when_touching(batje)
def batje_aangeraakt():
    tekst.words = 'batje wel aangeraakt'

play.start_program()

Je kunt overigens ook VARIABLE.is_touching(VARIABLE) gebruiken: Elke keer als je pijltje omhoog klikt, zie je of de bal het batje aanraakt:

import play

bal = play.new_circle(radius=50)
bal.start_physics(obeys_gravity=False, x_speed=50)

batje = play.new_box(x=200)

tekst = play.new_text("bal raakt batje niet", y=200)

@play.when_key_pressed('up')
def pijltje_omhoog():
    if bal.is_touching(batje):
        tekst.words = 'bal raakt batje'
    else:   
        tekst.words = 'bal raakt batje niet'

play.start_program()

Wanneer een vorm stopt met het aanraken van een andere vorm (@VARIABLE.when_stopped_touching)

import play

bal = play.new_circle(color="blue", radius=50)
bal.start_physics(obeys_gravity=False, x_speed=60)

batje = play.new_box(x=300)
batje.start_physics(can_move=False, obeys_gravity=False)

text = play.new_text(words="batje is niet aangeraakt", y=200)

@bal.when_stopped_touching(batje)
def aangeraakt():
    text.words = 'batje is aangeraakt'
    
play.start_program()

Wanneer een vorm de muur aanraakt (@VARIABLE.when_touching_wall)

import play

bal = play.new_circle(radius=50)
bal.start_physics(obeys_gravity=False, x_speed=50)

@bal.when_touching_wall
def teleport():
    bal.x=0

play.start_program()

Je kunt ook specifiek detecteren wanneer een vorm een bepaalde muur aanraakt door een WallSide parameter mee te geven:

import play

bal = play.new_circle(radius=50)
bal.start_physics(obeys_gravity=False, x_speed=300)

tekst = play.new_text("", y=200)

@bal.when_touching_wall(wall=play.WallSide.LEFT)
def linkermuur_aangeraakt():
    tekst.words = "Linkermuur geraakt!"
    bal.x = 0

play.start_program()

Mogelijke waardes voor WallSide zijn:

• play.WallSide.LEFT - linkermuur
• play.WallSide.RIGHT - rechtermuur
• play.WallSide.TOP - bovenmuur
• play.WallSide.BOTTOM - ondermuur

Wanneer een vorm stopt met het aanraken van de muur (@VARIABLE.when_stopped_touching_wall)

import play

bal = play.new_circle(color="blue", radius=50)
bal.start_physics(obeys_gravity=False, x_speed=60)

text = play.new_text(words="muur is niet aangeraakt", y=200)

@bal.when_stopped_touching_wall
def aangeraakt():
    text.words = 'muur is aangeraakt'

play.start_program()

Je kunt ook specifiek detecteren wanneer een vorm stopt met het aanraken van een bepaalde muur door een WallSide parameter mee te geven:

import play

bal = play.new_circle(color="blue", radius=50)
bal.start_physics(obeys_gravity=False, x_speed=300)

tekst = play.new_text("", y=200)

@bal.when_stopped_touching_wall(wall=play.WallSide.LEFT)
def linkermuur_verlaten():
    tekst.words = "Linkermuur verlaten!"

play.start_program()

Mogelijke waardes voor WallSide zijn:

• play.WallSide.LEFT - linkermuur
• play.WallSide.RIGHT - rechtermuur
• play.WallSide.TOP - bovenmuur
• play.WallSide.BOTTOM - ondermuur

Wanneer er op een vorm geklikt wordt (@VARIABLE.when_clicked)

import play

bal = play.new_circle(radius=50)
bal.start_physics(obeys_gravity=False, x_speed=50)

@bal.when_clicked
def geklikt():
    bal.x=0

play.start_program()

Tijd

Ik wil tijdelijk iets veranderen aan een vorm, bijvoorbeeld de snelheid (async await)

import play

bal = play.new_circle(color='black')
bal.start_physics(obeys_gravity=False, x_speed=10)

@play.when_mouse_clicked
async def tijdelijk_sneller():
    bal.physics.x_speed = 30
    await play.timer(seconds=1)
    bal.physics.x_speed = 10

play.start_program()

Hoe maak ik een timer?

import play
 
time = 10
text = play.new_text(str(time))
print(time)
 
@play.repeat_forever
async def timer():
    global time
    if time > 0:
        time -= 1
        await play.timer(seconds=1)
        text.words = str(time)
play.start_program()

Global

Hoe houd ik de score van mijn spel bij? (global)

import play

score = 0
score_tekst = play.new_text(str(score), y=100, font_size=40)

@play.when_key_released("space")
def spatie_ingedrukt():
   global score
   score = score + 1
   score_tekst.words = str(score)
   
play.start_program()

Screen

Hoe weet ik hoeveel pixels breed het scherm is? (play.screen.width)?

Met play.screen.width kun je weten hoeveel pixels breed het scherm is.

import play 

print(play.screen.width)

play.start_program()

Hoe weet ik hoeveel pixels hoog het scherm is? (play.screen.height)?

Met play.screen.height kun je weten hoeveel pixels hoog het scherm is.

import play 

print(play.screen.height)

play.start_program()

Hoe weet ik wat de x-positie is van de linkerkant van het scherm (play.screen.left)?

Met play.screen.left kun je weten wat de x-positie is van de linkerkant van het scherm. Standaard staat dit op -400. Het midden van het scherm heeft een x-positie van 0. Naar links wordt de x-positie dus negatief

import play 

print(play.screen.left)

play.start_program()

Hoe weet ik wat de x-positie is van de rechterkant van het scherm (play.screen.right)?

Met play.screen.right kun je weten wat de x-positie is van de rechterkant van het scherm. Standaard staat dit op 400. Het midden van het scherm heeft een x-positie van 0. Naar rechts wordt de x-positie dus hoger.

import play 

print(play.screen.right)

play.start_program()

Hoe weet ik wat de y-positie is van de bovenkant van het scherm (play.screen.top)?

Met play.screen.top kun je weten wat de y-positie is van de bovenkant van het scherm. Standaard staat dit op 300. Het midden van het scherm heeft een y-positie van 0. Naar boven wordt de y-positie dus hoger.

import play 

print(play.screen.top)

play.start_program()

Hoe weet ik wat de y-positie is van de onderkant van het scherm (play.screen.bottom)?

Met play.screen.bottom kun je weten wat de y-positie is van de onderkant van het scherm. Standaard staat dit op -300. Het midden van het scherm heeft een y-positie van 0. Naar onder wordt de y-positie dus lager.

import play 

print(play.screen.bottom)

play.start_program()

Database (JSON)

Hoe maak ik een database aan (new_database)?

Met play.new_database() maak je een nieuwe database aan. Deze database slaat gegevens op in een JSON-bestand, zodat je informatie kunt bewaren tussen verschillende keren dat je je programma draait.

import play

database = play.new_database()

play.start_program()

Als je een database aanmaakt, wordt automatisch een bestand aangemaakt waar je gegevens worden opgeslagen. Dit bestand heet database.json en staat in dezelfde map als je Python bestand.

Hoe sla ik gegevens op in de database (set_data)?

Met set_data() sla je gegevens op in de database. Je geeft twee dingen mee:

• Een sleutel (key): de naam waaronder je de gegevens opslaat
• Een waarde (value): de gegevens die je wilt opslaan

import play

database = play.new_database()

# Sla de score op onder de naam 'punten'
database.set_data('punten', 100)

# Je kunt ook tekst opslaan
database.set_data('speler_naam', 'Jan')

play.start_program()

De gegevens blijven bewaard, zelfs als je het programma afsluit en weer opnieuw start.

Hoe haal ik gegevens op uit de database (get_data)?

Met get_data() haal je eerder opgeslagen gegevens op uit de database. Je geeft de sleutel (naam) mee van de gegevens die je wilt ophalen.

import play

database = play.new_database()

# Haal de opgeslagen score op
opgeslagen_score = database.get_data('punten')

play.new_text(words=f"Je score is: {opgeslagen_score}")

play.start_program()

Als de sleutel niet bestaat, krijg je None terug. Je kunt ook een default waarde meegeven:

opgeslagen_score = database.get_data('punten', 0)

Als 'punten' niet bestaat, krijg je nu 0 terug in plaats van None.

SNES-controller

Wat is een SNES-controller?

Een SNES-controller is een controller, die zo populair was dat deze zelfs een eigen Wikipedia pagina heeft. Als je via een zoekmachine zoekt op SNES controller, dan zul je zien dat deze op verschillende webshops nog te koop is.

Hoe weet ik of mijn computer de SNES-controller herkent?

Je kunt onderstaande codefragment draaien om te kijken of je computer de controller herkent

import play 

for controller in play.controllers.get_all_controllers():
    print(controller.get_instance_id(), controller.get_name())

In de console zie je vervolgens voor elke controller een index en een naam, bijvoorbeeld als er één SNES-controller verbonden is:

pygame-ce 2.5.5 (SDL 2.32.6, Python 3.12.10)
0 usb gamepad

De 0 geeft de ax (axis) van de controller aan en usb gamepad geeft de naam van de controller aan.

Bij het indrukken van een knop op de controller (play.controllers.when_button_pressed)

Je gebruikt play.controllers.when_button_pressed om te checken of een knop op de controller ingedrukt wordt. Verder geef je twee argumenten mee:

• index dit is de index van de controller, vaak is dit 0 als je maar één controller gebruikt
• button_id het nummer dat bij een knop hoort

Bijvoorbeeld:

import play 

play.new_text('Welke kleur is knop 0?', y=200, font_size=40)
play.new_text('Probeer de knoppen uit', y=100, font_size=40)

@play.controllers.when_button_pressed(0, 0)
def controller_0_knop_0():
    play.new_text('Die knop dus')

play.start_program()

Wanneer je dit codefragment draait, zou je de tekst Die knop dus moeten zien als je de knop indrukt die hoort bij knop 0.

Bij het loslaten van een knop op de controller (play.controllers.when_button_released)

Je gebruikt play.controllers.when_button_released om te checken of een knop op de controller losgelaten wordt. Verder geef je twee argumenten mee:

• index dit is de index van de controller, vaak is dit 0 als je maar één controller gebruikt
• button_id het nummer dat bij een knop hoort

import play 

play.new_text('Welke kleur is knop 0?', y=200, font_size=40)
play.new_text('Probeer de knoppen uit', y=100, font_size=40)

@play.controllers.when_button_released(0, 0)
def controller_0_knop_0():
    play.new_text('Die knop dus')

play.start_program()

Wanneer je dit codefragment draait, zou je de tekst Die knop dus moeten zien als je de knop loslaat die hoort bij knop 0.

Bij het indrukken van een willekeurige knop op een controller (play.controllers.when_any_button_pressed)

Je gebruikt play.controllers.when_any_button_pressed wanneer je een actie uit wilt voeren bij welke knop dan ook. Dit is ook een fijne manier om te weten welk nummer bij welke knop hoort. Je geeft alleen maar op welke controller je gebruikt (de index).

Bijvoorbeeld:

import play 

play.new_text('Welk nummer hoort bij welke knop?', y=200, font_size=40)
play.new_text('Probeer de knoppen uit', y=100, font_size=40)

tekst = play.new_text("Nog geen knop ingedrukt")

@play.controllers.when_any_button_pressed(0)
def een_knop_ingedrukt(button_id):
    tekst.words = f'De ingedrukte knop is: {button_id}'

play.start_program()

Bij het loslaten van een willekeurige knop op een controller (play.controllers.when_any_button_released)

Je gebruikt play.controllers.when_any_button_released wanneer je een actie uit wilt voeren bij het loslaten van welke knop dan ook. Dit is ook een fijne manier om te weten welk nummer bij welke knop hoort. Je geeft alleen maar op welke controller je gebruikt (de index).

Bijvoorbeeld:

import play 

play.new_text('Welk nummer hoort bij welke knop?', y=200, font_size=40)
play.new_text('Probeer de knoppen uit', y=100, font_size=40)

tekst = play.new_text("Nog geen knop losgetalen")

@play.controllers.when_any_button_released(0)
def een_knop_ingedrukt(button_id):
    tekst.words = f'De losgelaten knop is: {button_id}'

play.start_program()

Bij het indrukken van een pijltje op een controller (play.controllers.when_axis_moved)

Je gebruikt play.controllers.when_axis_moved om te detecteren of een pijltje is ingedrukt.

Je geeft twee argumenten mee: index en richting

index is het nummer dat bij de controller hoort (waarschijnlijk 0 als je er één gebruikt)

richting:

• 0: voor horizontaal, -1 is links en 1 is rechts
• 1 voor verticaal, -1 is boven en 1 is beneden

Bijvoorbeeld

import play 

play.new_text('Druk een pijltje in?', y=200, font_size=40)

tekst = play.new_text("Nog geen pijltje ingedrukt")

@play.controllers.when_axis_moved(0, 0)
def links_rechts(index, value):
    if value == 1:
        tekst.words = "rechts ingedrukt"
    if value == -1:
        tekst.words = "links ingedrukt"

@play.controllers.when_axis_moved(0, 1)
def boven_beneden(index, value):
    if value == 1:
        tekst.words = "naar onder ingedrukt"
    if value == -1:
        tekst.words = "naar boven ingedrukt"

play.start_program()