Tip: bij welke `if` wordt gekeken of de speler tegen de linkerkant van het scherm aan zit?
#### 💡 Extra uitdaging - Laat de speler sneller bewegen als je de toets langer inhoudt - Laat de speler automatisch naar links of rechts bewegen als je een extra toets indrukt (bijvoorbeeld `A` of `D`) ### 📤 Inleveren 1. Leg in eigen woorden uit hoe de `player_speed` de snelheid van het spel veranderd. 2. Leg uit waarom de speler aan de linkerkant van het scherm 'stuitert' en wat heb je aangepast om dit te voorkomen? ## 3 Steen laten vallen In deze les gaan we de steen automatisch laten vallen. Zodra de steen de onderkant van het scherm bereikt, verschijnt hij opnieuw bovenaan op een willekeurige plek. ### Wat gaan we doen? We voegen een `rock_speed` toe en laten de `y`-positie van de steen langzaam toenemen in `update()`. We controleren of de steen het scherm uit valt, en zetten hem dan opnieuw bovenaan met een willekeurige x-positie. ### 🔰 Code ```python import pgzrun import random WIDTH = 800 HEIGHT = 600 player_x = 400 player_y = 550 player_width = 80 player_height = 20 player_speed = 5 rock_x = random.randint(0, WIDTH - 40) rock_y = 0 rock_size = 40 rock_speed = 3 def draw(): screen.clear() screen.draw.filled_rect(Rect((player_x, player_y), (player_width, player_height)), "blue") screen.draw.filled_rect(Rect((rock_x, rock_y), (rock_size, rock_size)), "gray") def update(): global player_x, rock_y, rock_x, rock_size if keyboard.left: player_x -= player_speed if keyboard.right: player_x += player_speed if player_x < 0: player_x = 0 if player_x > WIDTH - player_width: player_x = WIDTH - player_width # Steen laten vallen rock_y += rock_speed # Als de steen onderaan is, zet hem weer bovenaan met random x if rock_y > HEIGHT: rock_y = 0 rock_x = random.randint(0, WIDTH - rock_size) pgzrun.go() ``` ### ℹ️ Uitleg - `rock_speed`: bepaalt hoe snel de steen valt - `rock_y += rock_speed`: laat de steen naar beneden bewegen - `random.randint(...)`: zorgt voor een willekeurige x-positie als de steen opnieuw verschijnt ### 🛠️ Opdracht - Verander de `rock_speed` – wat gebeurt er? - Maak de steen groter of kleiner door `rock_size` aan te passen. - Zorg er nu voor dat elke keer als de steen opnieuw valt de rock\_size wordt aangepast en een random grootte krijgt. - Met random.randint(1, 10) wordt er een getal tussen 1 en 10 gegenereerd. Bedenk zelf mooie waarden en pas de code aan zodat de grootte van de steen telkens anders wordt. #### 💡 Extra uitdaging - Laat meerdere stenen tegelijk vallen - Laat elke steen een willekeurige snelheid hebben ### 📤 Inleveren 1. Leg uit hoe je ervoor hebt gezorgdt dat de steen telkens een ander grootte kijgt. ## 4 Botsing & Game Over In deze les gaan we controleren of de speler de steen raakt. Als er een botsing is, stopt het spel en verschijnt er de tekst “Game Over”. ### Wat gaan we doen? We maken een `Rect` van de speler en van de steen, en gebruiken `colliderect()` om te zien of ze elkaar raken. We gebruiken een variabele `game_over` om te stoppen met het spel als er een botsing is. ### 🔰 Code ```python import pgzrun import random from pygame import Rect WIDTH = 800 HEIGHT = 600 player_x = 400 player_y = 550 player_width = 80 player_height = 20 player_speed = 5 rock_x = random.randint(0, WIDTH - 40) rock_y = 0 rock_size = 40 rock_speed = 3 game_over = False def draw(): screen.clear() if game_over: screen.draw.text("GAME OVER", center=(WIDTH // 2, HEIGHT // 2), fontsize=60, color="red") return screen.draw.filled_rect(Rect((player_x, player_y), (player_width, player_height)), "blue") screen.draw.filled_rect(Rect((rock_x, rock_y), (rock_size, rock_size)), "gray") def update(): global player_x, rock_y, rock_x, game_over if game_over: return if keyboard.left: player_x -= player_speed if keyboard.right: player_x += player_speed if player_x < 0: player_x = 0 if player_x > WIDTH - player_width: player_x = WIDTH - player_width rock_y += rock_speed if rock_y > HEIGHT: rock_y = 0 rock_x = random.randint(0, WIDTH - rock_size) # Botsing detecteren speler_rect = Rect(player_x, player_y, player_width, player_height) steen_rect = Rect(rock_x, rock_y, rock_size, rock_size) if speler_rect.colliderect(steen_rect): game_over = True pgzrun.go() ``` ### ℹ️ Uitleg - `Rect(x, y, w, h)` maakt een rechthoek op de juiste plek - `colliderect()` kijkt of twee rechthoeken elkaar raken - `game_over` bepaalt of het spel nog doorgaat ### 🛠️ Opdracht - Laat de speler de steen raken en kijk of het spel stopt - Verplaats de speler naar de andere kant van het scherm – bots je dan nog? - Verander de “GAME OVER” tekst (bijvoorbeeld kleur of grootte) #### 💡 Extra uitdaging - Laat het spel herstarten als je op de `R`-toets drukt - Speel een geluid af bij de botsing (bijv. `sounds.hit.play()`) ### 📤 Inleveren 1. Leg eersts stap-voor-stap in he eigen woorden uit hoe er een botsing van de steen met de speler wordt gedetecteerd. 2. Leg daarna stap-voor-stap, in eigen woorden uit wat er allemaal gebeurt als de steen tegen de speler aan komt. Verwijs daarbij naar de code. ## 5 Meerdere stenen & moeilijker maken In deze les gaan we meerdere stenen tegelijk laten vallen. Bovendien maakt het spel zichzelf moeilijker naarmate je langer speelt: de stenen vallen sneller. ### Wat gaan we doen? We maken een lijst van stenen, elk met hun eigen positie en snelheid. We laten deze stenen vallen en bij een botsing stoppen we het spel. We laten het spel steeds moeilijker worden door de snelheid te verhogen na een paar seconden. ### 🔰 Code ```python import pgzrun import random from pygame import Rect WIDTH = 800 HEIGHT = 600 player_x = 400 player_y = 550 player_width = 80 player_height = 20 player_speed = 5 rocks = [] game_over = False rock_timer = 0 rock_interval = 60 # frames difficulty = 1.0 # Start met een paar stenen for _ in range(3): x = random.randint(0, WIDTH - 40) speed = random.uniform(2, 4) rocks.append({"x": x, "y": 0, "size": 40, "speed": speed}) def draw(): screen.clear() if game_over: screen.draw.text("GAME OVER", center=(WIDTH // 2, HEIGHT // 2), fontsize=60, color="red") return screen.draw.filled_rect(Rect((player_x, player_y), (player_width, player_height)), "blue") for rock in rocks: screen.draw.filled_rect(Rect((rock["x"], rock["y"]), (rock["size"], rock["size"])), "gray") def update(): global player_x, game_over, rock_timer, difficulty if game_over: return if keyboard.left: player_x -= player_speed if keyboard.right: player_x += player_speed player_x = max(0, min(WIDTH - player_width, player_x)) speler_rect = Rect(player_x, player_y, player_width, player_height) for rock in rocks: rock["y"] += rock["speed"] * difficulty if rock["y"] > HEIGHT: rock["y"] = 0 rock["x"] = random.randint(0, WIDTH - rock["size"]) rock["speed"] = random.uniform(2, 5) rock_rect = Rect(rock["x"], rock["y"], rock["size"], rock["size"]) if speler_rect.colliderect(rock_rect): game_over = True # Verhoog de moeilijkheid langzaam rock_timer += 1 if rock_timer % 300 == 0: difficulty += 0.2 pgzrun.go() ``` ### ℹ️ Uitleg - Elke steen is een dict met `x`, `y`, `size` en `speed` - We gebruiken een `for`-loop om alle stenen te laten vallen - Met `difficulty` verhogen we langzaam de snelheid van de stenen ### 🛠️ Opdracht - Test het spel en kijk of het spel moeilijker wordt na ongeveer 15 seconden! - Nu gaan we de grootte van de stenen weer aanpassen naar een random waarde zoals we dat bij de vorige opdracht ook hebben gedaan. **Zorg er dus voor dat bij het aanmaken van de stenen iedere steen een andere (random) grootte krijgt.** Dat gaat iets anders omdat we nu meerdere 'rocks' hebben. In de` for rock in rocks:` loop worden één voor één alle blokken behandeld. De grootte van de rock staat in `rock["size"]`Tip: weet je nog dat je met `random.randint(1,4)` een getal tussen 1 en 4 kan genereren?
#### 💡 Extra uitdaging - Laat het aantal stenen toenemen naarmate het spel langer duurt - Laat een andere kleur steen verschijnen bij hogere moeilijkheid. - Laat elke steen een ander formaat hebben - Toon je “score” op het scherm: hoe lang heb je overleefd? ### 📤 Inleveren 1. Lever je code (.py bestand) in. \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ## 6 Score, Reflectie & Uitbreiding In deze les voeg je een score toe die laat zien hoelang je het hebt volgehouden. Daarnaast kijk je terug op je eigen werk én kies je een uitbreiding om het spel leuker of moeilijker te maken. ### Wat gaan we doen? - We voegen een `score` toe die telt hoeveel frames je overleeft - We tonen deze score linksboven op het scherm - Bij Game Over laten we je eindscore zien ### 🔰 Toevoegingen aan bestaande code ```python score = 0 # bij de andere variabelen def draw(): screen.clear() if game_over: screen.draw.text("GAME OVER", center=(WIDTH // 2, HEIGHT // 2), fontsize=60, color="red") screen.draw.text(f"Score: {score}", center=(WIDTH // 2, HEIGHT // 2 + 50), fontsize=40, color="black") return ... screen.draw.text(f"Score: {score}", (10, 10), fontsize=40, color="black") def update(): global score if game_over: return ... score += 1 ``` ### ℹ️ Uitleg - `score` wordt bij elke frame 1 hoger → hoe langer je speelt, hoe hoger je score - `screen.draw.text()` toont je score tijdens én na het spel ### 🧠 Reflectie Beantwoord de volgende vragen onderaan je code als commentaar of in een apart document: - Wat vond je het leukst om te maken in dit spel? - Wat vond je moeilijk, en hoe heb je dat opgelost? - Wat heb je geleerd over Python en programmeren? - Waar ben je trots op? ### 🎮 Uitbreiding (kies er één) - 💥 Laat een explosie zien of geluid horen bij Game Over - 🧱 Voeg bewegende obstakels toe - 🏆 Houd een highscore bij (hoogste score van de sessie) - 🚀 Geef de speler power-ups: tijdelijk onsterfelijk, versnellen, etc. - 🎨 Verander het uiterlijk van de speler of achtergrond na elke 30 seconden #### 💡 Eigen idee? Bedenk zelf een uitbreiding en probeer deze te maken. Schrijf kort op wat jouw idee is en hoe je het hebt aangepakt. ### 📤 Inleveren - Lever je eindversie van het spel in (inclusief score en uitbreiding) - Voeg een korte beschrijving toe van wat je hebt toegevoegd of aangepast - Lever ook je reflectie in (de 4 vragen) - Optioneel: voeg een screenshot of kort filmpje toe van je spel ## 🧠 Reflectieopdracht Deze reflectieopdracht helpt je om stil te staan bij wat je hebt geleerd tijdens het programmeren van je spel. Beantwoord de onderstaande vragen eerlijk en in je eigen woorden. Je mag je antwoorden inleveren via een apart document of onderaan je Python-bestand als commentaar zetten. ### 📋 Vragen - 🔹 Wat vond je het leukste om te maken of uit te proberen? - 🔹 Wat vond je lastig? Hoe heb je dat opgelost? - 🔹 Wat heb je geleerd over Python (of programmeren in het algemeen)? - 🔹 Waar ben je trots op in jouw eindresultaat? - 🔹 Wat zou je de volgende keer anders willen doen of verbeteren? ### 📤 Inleveren Lever je reflectie in bij je docent via de afgesproken manier (document, upload of als commentaar in je code). ## \### ## \# Docenten ## 🎓 Docentenhandleiding ### 📘 Overzicht - **Doelgroep:** Leerlingen met basiskennis Python (13-16 jaar) - **Duur:** 6 lessen van ±45-60 minuten - **Software:** Thonny + Pygame Zero - **Spelconcept:** De speler ontwijkt vallende objecten (stenen) en het spel wordt steeds moeilijker ### 🎯 Leerdoelen - Werken met coördinaten en schermlogica - Gebruik van `draw()` en `update()` - Toetsenbordbesturing met `keyboard.left` en `keyboard.right` - Beweging simuleren met variabelen - Objecten detecteren met `Rect` en `colliderect()` - Werken met lijsten voor meerdere objecten - Reflecteren op het leerproces en zelf uitbreidingen bedenken ### 📚 Lesoverzicht| Les | Onderwerp | Nieuwe concepten |
|---|---|---|
| 1 | Speler en steen tekenen | `draw()`, rechthoek tekenen, coördinaten |
| 2 | Speler beweegt | `update()`, keyboard input, begrenzen |
| 3 | Steen valt en komt terug | Beweging, `random`, logica |
| 4 | Botsing + Game Over | `Rect`, `colliderect()`, boolean vlag |
| 5 | Meerdere stenen + moeilijkheid | Lijsten, `for`-loops, moeilijkheidsschaal |
| 6 | Score, Reflectie & Uitbreiding | Scorevariabele, `draw.text()`, vrije opdracht |
| Criterium | Omschrijving | Score (1-5) |
|---|---|---|
| Werkt het spel | Geen fouten, spel werkt zoals bedoeld | 🟩 |
| Code is leesbaar | Logische structuur, goede naamgeving | 🟩 |
| Uitbreiding toegevoegd | Creatieve of technische aanvulling | 🟩 |
| Reflectie | Antwoorden zijn volledig en met inzicht | 🟩 |
Tip: Kopieer je vorige project en noem het anders.
##### *Voorbeeld*  ## 1 Teken de slangkop In deze les gaan we beginnen met het maken van een eigen versie van Snake in Python met Pygame Zero. We gaan eerst de kop van de slang tekenen op het scherm. Je ziet dan een vierkantje dat straks kan gaan bewegen. ### Wat gaan we doen? We maken een slangkop als vierkant met een bepaalde positie en grootte, en tekenen die in de `draw()`-functie. ### 📦 Benodigdheden - Een werkende Python-omgeving met Pygame Zero (zoals Thonny) - Geen plaatjes nodig – we tekenen de slang met blokken ### 🔰 Startercode ```python # importeer library import pgzrun # Spelgrootte WIDTH = 600 HEIGHT = 400 # Startpositie van de slangkop snake_x = 100 snake_y = 100 tile_size = 20 def draw(): screen.clear() screen.draw.filled_rect(Rect((snake_x, snake_y), (tile_size, tile_size)), "green") #start programma pgzrun.go() ``` ### ℹ️ Uitleg - `WIDTH` en `HEIGHT`: grootte van het spelvenster - `snake_x` en `snake_y`: positie van de slangkop - `tile_size`: grootte van het blokje - `screen.draw.filled_rect(...)`: tekent een gevuld vierkantje op het scherm ### 🛠️ Opdracht - Pas de waarde van `snake_x` en `snake_y` aan – wat gebeurt er? - Maak het vierkant groter of kleiner door `tile_size` te wijzigen - Verander de kleur van het vierkant in bijvoorbeeld `"blue"` of `"orange"` #### 💡 Extra uitdaging Teken een tweede blokje naast de slangkop alsof er al een stukje staart is. Gebruik nog een `screen.draw.filled_rect()`. ### 📤 Inleveren 1. Maak een screenshot van je 'slangkop' op het scherm (dus geen code) waarbij je de 'slangkop'duidelijke op een andere positie hebt gezet (bijvoorbeeld rechtsonder in het schrem, of in het midden). ## 2 Beweeg de slang In deze les gaan we de slangkop laten bewegen met de pijltjestoets die je indrukt. We gebruiken daarvoor de `update()`-functie van Pygame Zero en de toetsenbordinput. ### Wat gaan we doen? We maken een richting-variabele en passen de positie van de slang aan op basis van de pijltjes die je indrukt. ### 🔰 Code Dit is een **deel van de code**, je moet jouw bestaande code aanpassen aan de hand van deze nieuwe code. Je hoeft dus niet alles opnieuw te typen. Plaats de `update()` functie en pas eventueel `snake_x`, `snake_y`, `tile_size` en `step` aan in jouw bestaande code. ```python # Startpositie van de slangkop snake_x = 200 snake_y = 200 tile_size = 10 step = 1 def draw(): screen.clear() screen.draw.filled_rect(Rect((snake_x, snake_y), (tile_size, tile_size)), "green") def update(): global snake_x, snake_y if keyboard.left: snake_x -= step if keyboard.right: snake_x += step if keyboard.up: snake_y -= step if keyboard.down: snake_y += step ``` ### ℹ️ Uitleg - `update()` wordt automatisch meerdere keren per seconde uitgevoerd - `keyboard.left` controleert of de linkerpijl is ingedrukt - Telkens als je een toets indrukt, verandert de positie van de slang - `step` bepaalt hoe ver de slang per stap beweegt ### 🛠️ Opdracht - Beweeg de slang door het scherm met de pijltjes - Pas `step` aan naar een andere waarde – wat merk je? - Laat de slang sneller of langzamer bewegen door minder of meer pixels per keer te verplaatsen #### 💡 Extra uitdaging Laat de slang automatisch blijven bewegen in de laatst gekozen richting: - Gebruik een variabele `richting` die je bijwerkt met `on_key_down()` - Laat de slang dan elke update in die richting verder bewegen ### 📤 Inleveren 1. Leg uit wat de variable step doet. 2. Welke waarde heb je gekozen, waarom? (je kunt dit inleveren in het tekst veld of in een .txt. bestandje) ## 3 Automatische beweging In deze les gaan we de slang automatisch laten blijven bewegen in de richting van de laatste pijltjestoets die je hebt ingedrukt. ### 🔍 Wat gaan we doen? - We maken een nieuwe variabele `richting`. - Als je op een pijltjestoets drukt, verandert de waarde van `richting`. - In de `update()` functie verplaatst de slang zich elke keer opnieuw in de gekozen richting – ook als je de toets niet ingedrukt houdt! ### 🔰 Code Gebruik deze versie als nieuwe code (je mag dit toevoegen aan of combineren met je bestaande code): ```python import pgzrun WIDTH = 600 HEIGHT = 400 snake_x = 200 snake_y = 200 tile_size = 20 step = 10 richting = "right" def draw(): screen.clear() screen.draw.filled_rect(Rect((snake_x, snake_y), (tile_size, tile_size)), "green") def update(): global snake_x, snake_y, richting if richting == "left": snake_x -= step elif richting == "right": snake_x += step elif richting == "up": snake_y -= step elif richting == "down": snake_y += step def on_key_down(key): global richting if key == keys.LEFT: richting = "left" elif key == keys.RIGHT: richting = "right" elif key == keys.UP: richting = "up" elif key == keys.DOWN: richting = "down" pgzrun.go() ``` ### ℹ️ Uitleg - `richting`: deze variabele onthoudt de laatst gekozen richting - `on_key_down()`: dit is een functie die wordt uitgevoerd als je op een toets drukt - `update()`: deze functie verplaatst de slang elke keer in de gekozen richting, ook als je geen toets indrukt ### 🛠️ Opdracht - Test of je slang automatisch blijft bewegen nadat je een pijl indrukt - Wat gebeurt er als je twee keer snel op een andere richting drukt? - Probeer met `tile_size` en `step` te spelen voor een ander effect #### 💡 Extra uitdaging Voeg grenzen toe aan je spel: laat de slang stoppen of ergens anders naartoe gaan als hij de rand van het scherm raakt. ### 📤 Inleveren 1. Leg in je eigen woorden uit wat de functie `on_key_down()` doet (Lever dit in via het tekstvak of via een upload.) ## 4 Randbotsing en automatische richting In deze les zorgen we ervoor dat de slang niet zomaar het scherm verlaat. Zodra hij een rand raakt, verandert hij automatisch van richting. Zo beweegt hij steeds binnen het scherm! ### 🔍 Wat gaan we doen? - We controleren of de slang de rand van het scherm raakt. - Als dat zo is, passen we automatisch de richting aan. ### 🔰 Code (let op: onvolledig!) Hieronder zie je de code. De code is onvolledig en moet worden aangepast.Hint: kijk naar de ... (drie puntjes)
```python import pgzrun WIDTH = 600 HEIGHT = 400 snake_x = 200 snake_y = 200 tile_size = 20 step = 5 richting = "right" def draw(): screen.clear() screen.draw.filled_rect(Rect((snake_x, snake_y), (tile_size, tile_size)), "green") def update(): global snake_x, snake_y, richting if richting == "left": snake_x -= step elif richting == "right": snake_x += step elif richting == "...": snake_y -= step elif richting == "...": snake_y += step # 🧠 Hier controleren we of de slang de rand raakt if snake_x < 0: richting = "right" elif snake_x + tile_size > WIDTH: richting = "left" elif snake_y < 0: richting = "..." elif snake_y + tile_size > HEIGHT: richting = "..." def on_key_down(key): global richting if key == keys.LEFT: richting = "left" elif key == keys.RIGHT: richting = "right" elif key == keys.UP: richting = "up" elif key == keys.DOWN: richting = "down" pgzrun.go() ``` Als je de linker- of rechterkant raakt, dan 'stuitert' je terug. Dat gebeurt niet als je de boven- of onderkant aanraakt. Pas de code aan zodat je ook naar boven en beneden kan bewegen en zodat je ook terugstuiters als je de onder-of bovenkant aanraakt. ### ℹ️ Uitleg - `snake_x + tile_size > WIDTH`: betekent dat de slang voorbij de rechterrand gaat - Als de slang een rand raakt, verander je de variabele `richting` ### 🛠️ Opdracht - Pas de code aan zodat de slang alle richtingen uit kan bewegen en zodat hij als hij de rand raakt (link, recht en boven en beneden) terug 'stuiterd'. - Test of de slang de alle richtingen op gaat en hij aan alle kantne goed terug 'stuiterd'! #### 💡 Extra uitdaging Laat de slang bij elke randbotsing van kleur veranderen! (Tip: maak een variabele `kleur` en gebruik bijvoorbeeld `random.choice()`) ### 📤 Inleveren 1. Leg in **eigen woorden** uit **wat** je hebt aangepast op regel 35 en 36 en **hoe dat werkt.** Vind je dit lastig? Dan *kun* je de deze template gebruiken: ``` Ik heb op regel 35 .... aangepast en ik heb op regel 36 .... aangepast. Wat er dan gebeurt is dat als de Snake ......... en de toets ..... wordt ingedrukt dan verandert de .......... van .......... naar ............ ``` (Lever dit in via het tekstvak of via een upload.) ## 5 Geen omkeren toegestaan In deze les zorgen we ervoor dat de slang niet meteen omkeert. In een echte Snake-game kun je namelijk niet ineens van rechts naar links bewegen – dan zou de slang zichzelf opeten! ### 🔍 Wat gaan we doen? - We voorkomen dat de slang direct de tegenovergestelde richting kiest. - We vergelijken de huidige richting met de nieuwe richting voordat we die veranderen. ### 🔰 Code (let op: onvolledig!) De volgende code voorkomt omkeren, maar jij moet één voorwaarde nog zelf aanvullen. ```python import pgzrun WIDTH = 600 HEIGHT = 400 snake_x = 200 snake_y = 200 tile_size = 20 step = 1 richting = "right" def draw(): screen.clear() screen.draw.filled_rect(Rect((snake_x, snake_y), (tile_size, tile_size)), "green") def update(): global snake_x, snake_y, richting if richting == "left": snake_x -= step elif richting == "right": snake_x += step elif richting == "up": snake_y -= step elif richting == "down": snake_y += step def on_key_down(key): global richting if key == keys.LEFT and richting != "right": richting = "left" elif key == keys.RIGHT and richting != "left": richting = "right" elif key == keys.UP and richting != "down": richting = "up" elif key == keys.DOWN and richting != "...": richting = "down" pgzrun.go() ``` ### Stuiteren tegen randen werkt niet meer Het botsen tegen de randen wat in stap 4 is gedaan, zit niet in deze code. Dat is express gedaan. We proberen op deze manier een ding gelijktijdig uit te leggen en het voorkomt dat je op dit moment "*door de bomen het bos niet meer ziet*". ### ℹ️ Uitleg - We gebruiken een `if`-voorwaarde om te voorkomen dat je teruggaat in de tegenovergestelde richting. - De ontbrekende regel is die voor `keys.DOWN`: welke richting is dan niet toegestaan? ### 🛠️ Opdracht - Vul de ontbrekende voorwaarde aan zodat de slang niet van "up" naar "down" mag keren - Test alle richtingen: kun je nog steeds normaal draaien? Keren lukt niet meer, toch? #### 💡 Extra uitdaging Laat de slang een geluidje maken als je op een toets drukt, maar de richting wordt niet veranderd (bijv. als je wél op links drukt, maar dat mag niet). Met deze code kan je ene geluidje afspelen. ``` sounds.beep.play() ``` Om een sound af te kunnen spelen moet jouw project folder een mapje maken sounds en daarin moet een beep.wav komen. ``` mijn_project/ ├── main.py └── sounds/ └── beep.wav ``` ##### Geluidjes toevoegen Je kunt zelf geluidjes toevoegen, stel je hebt een geluidje **bel.wav** dan plaats je dat in de sounds directory en dan gebruik je het commando `souds.bel.play()` ### 📤 Inleveren 1. Leg uit **wat** je hebt veranderd en **hoe** het werkt (dit zijn dus twee vragen: **wat** en **hoe**). Vind je dit lastig? Dan *kun* je de deze template gebruiken: ``` Ik heb op regel ... ....... aangepast. Wat er dan gebeurt is dat als de Snake ......... en de toets ..... wordt ingedrukt dan ........ ``` (Lever dit in via het tekstvak of via een upload.) ## 6 Appel tekenen en raken In deze les voegen we een appel toe aan het spel. De appel verschijnt op een willekeurige plek op het scherm. Als de slang de appel raakt, verschijnt er een bericht in de console. ### 🔍 Wat gaan we doen? - We gebruiken de `random`-module om een appel op een willekeurige positie te tekenen. - We tekenen de 'appel' met een geel cirkeltje of vierkantje. - We detecteren of de slang de appel raakt. ### 📦 Benodigdheden - Je slangkop beweegt al automatisch over het scherm - Je hebt al gewerkt met `tile_size` en `snake_x`/`snake_y` ### 🔰 Code (let op: onvolledig!) Onderstaande code tekent een slangkop en een appel. De botsing werkt al, maar na een botsing blijft de appel op dezelfde plek staan. Vul zelf aan wat er moet gebeuren! ```python import pgzrun import random WIDTH = 600 HEIGHT = 400 tile_size = 20 snake_x = 100 snake_y = 100 richting = "right" step = 3 # Appelpositie (willekeurig op het grid) apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size def draw(): screen.clear() screen.draw.filled_rect(Rect((snake_x, snake_y), (tile_size, tile_size)), "green") screen.draw.filled_circle((apple_x + tile_size // 2, apple_y + tile_size // 2), tile_size // 2, "yellow") def on_key_down(key): global richting if key == keys.LEFT and richting != "right": richting = "left" elif key == keys.RIGHT and richting != "left": richting = "right" elif key == keys.UP and richting != "down": richting = "up" elif key == keys.DOWN and richting != "up": richting = "down" def update(): global snake_x, snake_y, apple_x, apple_y, richting if richting == "left": snake_x -= step elif richting == "right": snake_x += step elif richting == "up": snake_y -= step elif richting == "down": snake_y += step # Botst de slang met de appel? snake_rect = Rect((snake_x, snake_y), (tile_size, tile_size)) apple_rect = Rect((apple_x, apple_y), (tile_size, tile_size)) if snake_rect.colliderect(apple_rect): print("🍏 Appel geraakt!") # 👇 VUL HIER AAN: genereer een nieuwe positie voor de appel # apple_x = ... # apple_y = ... pgzrun.go() ``` ### ℹ️ Uitleg - `random.randint()`: geeft een willekeurig geheel getal terug - De appelpositie wordt op het grid berekend, zodat deze altijd netjes uitlijnt - `filled_circle()`: tekent een geel rondje (je kunt ook `filled_rect()` gebruiken) ### 🛠️ Opdracht - Test of de appel op het scherm verschijnt - Beweeg de slang naar de appel – zie je de console-uitvoer? - Vul de ontbrekende regels in zodat de appel na een botsing op een **nieuwe plek** verschijnt #### 💡 Extra uitdaging Laat de appel niet precies op dezelfde plek als de slang verschijnen wanneer hij opnieuw wordt gegenereerd! ### 📤 Inleveren 1. Lever de code in .py bestand. ## 7 De slang groeit In deze les maak je van je slang een échte slang: eentje die uit meerdere blokjes bestaat en langer wordt als hij een appel eet. ### 🔍 Wat gaan we doen? - We veranderen de slang van één blokje naar een lijst van blokjes - De slang groeit bij het eten van een appel - We houden de lengte gelijk als er geen appel wordt gegeten ### 📘 Strategie De code wordt nu iets ingewikkelder. Het is niet erg als je niet alles direct begrijpt. Probeer wel te volgen wat er gebeurt. We bespreken de strategie: 1. De slang bestaat uit meerdere delen. De code in de `draw()`-functie tekent elk stukje. 2. Bij elke update wordt er een nieuw blokje toegevoegd aan de kop van de slang. 3. Als de slang een appel raakt: dan blijft de slang langer. 4. Als er geen appel is geraakt: dan wordt het laatste stukje van de slang verwijderd. Dus in het kort: 1. Teken de slang 2. Voeg een stukje toe aan de kop 3. Geen appel? Verwijder de staart ### 🔰 Code ```python import pgzrun import random WIDTH = 600 HEIGHT = 400 tile_size = 20 snake = [(100, 100)] richting = "right" step = 3 apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size def draw(): screen.clear() for segment in snake: screen.draw.filled_rect(Rect(segment, (tile_size, tile_size)), "green") screen.draw.filled_circle((apple_x + tile_size // 2, apple_y + tile_size // 2), tile_size // 2, "yellow") def on_key_down(key): global richting if key == keys.LEFT and richting != "right": richting = "left" elif key == keys.RIGHT and richting != "left": richting = "right" elif key == keys.UP and richting != "down": richting = "up" elif key == keys.DOWN and richting != "up": richting = "down" def update(): global apple_x, apple_y, richting head_x, head_y = snake[0] if richting == "left": head_x -= step elif richting == "right": head_x += step elif richting == "up": head_y -= step elif richting == "down": head_y += step new_head = (head_x, head_y) snake.insert(0, new_head) head_rect = Rect(new_head, (tile_size, tile_size)) apple_rect = Rect((apple_x, apple_y), (tile_size, tile_size)) if head_rect.colliderect(apple_rect): print("🍏 Appel geraakt!") apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size else: snake.pop() # staart verwijderen if new_head in snake[1:]: # Deze code detecteerd of de slang zichzelf raakt. print("🚫 Game over! De slang raakte zichzelf.") exit() pgzrun.go() ``` ### ℹ️ Uitleg - `snake = [(x, y), ...]`: lijst van alle slangsegmenten - `insert(0, new_head)`: voegt een nieuw blokje toe aan de voorkant - `pop()`: verwijdert het laatste stukje (staart) - `if new_head in snake[1:]`: controle of slang zichzelf raakt ``` Voorbeeld bij beweging: Stap 1: slang = [(4,2), (3,2), (2,2)] Stap 2: kop wordt (5,2) → slang = [(5,2), (4,2), (3,2)] Stap 3: geen appel → staart eraf → slang = [(5,2), (4,2)] ``` #### 📚 Waarom werkt dit zo? Door altijd eerst een kop toe te voegen, beweegt de slang vooruit. Als er geen appel is geraakt, halen we de staart weg zodat de lengte gelijk blijft. Wordt er wél een appel geraakt, dan blijft de slang langer: we doen dan geen `pop()`. Dit is hoe de slang groeit! ### 🛠️ Opdracht - Controleer of de slang groeit als hij een appel eet - Controleer of hij even lang blijft als er geen appel wordt geraakt ### 📄 Inleveren 1. Beantwoord de vraag: **Wat gebeurt er als je `snake.pop()` vergeet?** (Lever dit in via het tekstvak of als bestand.) ## 8 De slang sneller maken met vertraging In deze les leer je hoe je de slang sneller kunt laten groeien door de `step` te vergroten, zonder dat het spel te snel en onspeelbaar wordt. ### 🔍 Wat is het probleem? Je denkt misschien: "Ik wil dat de slang sneller beweegt, dus ik maak `step` groter." Maar als je `step = 20` doet, wordt het spel ineens **veel te snel**. Dat komt omdat `update()` standaard 60 keer per seconde wordt uitgevoerd. Dus je slang maakt dan 60 sprongen van 20 pixels per seconde: dat is 1200 pixels! ### ❌ Fout idee ```python step = 20 # grotere stap # maar het spel gaat nu te snel! ``` ### ✅ Goede oplossing: beweging vertragen We laten de slang **niet elke update** bewegen, maar bijvoorbeeld 1x per 10 frames. Zo kun je `step` groter maken, zonder dat het spel onbestuurbaar wordt. ### 🔰 Code ```python import pgzrun import random WIDTH = 600 HEIGHT = 400 tile_size = 20 step = 20 vertraging = 10 # aantal frames wachten frames = 0 snake = [(100, 100)] richting = "right" apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size def draw(): screen.clear() for segment in snake: screen.draw.filled_rect(Rect(segment, (tile_size, tile_size)), "green") screen.draw.filled_circle((apple_x + tile_size // 2, apple_y + tile_size // 2), tile_size // 2, "yellow") def on_key_down(key): global richting if key == keys.LEFT and richting != "right": richting = "left" elif key == keys.RIGHT and richting != "left": richting = "right" elif key == keys.UP and richting != "down": richting = "up" elif key == keys.DOWN and richting != "up": richting = "down" def update(): global frames frames += 1 if frames < vertraging: return frames = 0 beweeg_slang() def beweeg_slang(): global apple_x, apple_y, richting head_x, head_y = snake[0] if richting == "left": head_x -= step elif richting == "right": head_x += step elif richting == "up": head_y -= step elif richting == "down": head_y += step new_head = (head_x, head_y) snake.insert(0, new_head) head_rect = Rect(new_head, (tile_size, tile_size)) apple_rect = Rect((apple_x, apple_y), (tile_size, tile_size)) if head_rect.colliderect(apple_rect): print("\U0001F34F Appel geraakt!") apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size else: snake.pop() if new_head in snake[1:]: print("\u274C Game over! De slang raakte zichzelf.") exit() pgzrun.go() ``` ### 🧠 Waarom werkt dit? - `frames += 1`: telt hoe vaak `update()` al is uitgevoerd - Pas als `frames >= vertraging`, beweegt de slang echt - `step` bepaalt nu de grootte van de stap, niet de snelheid van het spel ### 🚀 Opdracht - Stel `step = 20` in en test of de slang nu sneller groeit - Experimenteer met `vertraging = 5` of `vertraging = 15` - Wat is een fijne balans tussen stapgrootte en snelheid? - Test het spel; wat gebeurt er precies als de slang tegen zijn eigen staart botst? #### 🔎 Extra uitdaging Laat de slang naarmate hij langer wordt automatisch steeds iets sneller bewegen (tip: verlaag `vertraging` bij elke appel). ### 📄 Inleveren 1. Leg uitwat er gebeurt als de slang tegen zijn staart aankomt. 2. Probeer te vertellen wat je zou willen veranderen; wat moet er gebeuren als de slang tegen zijn slang aan botst? (Lever dit in via het tekstvak of als bestand.) ## 9 Score bijhouden en Game Over tonen In deze les voegen we een score toe aan het spel. Elke keer als je een appel eet, krijg je 1 punt. En als de slang zichzelf raakt, laten we **"Game Over"** op het scherm zien en stopt het spel. ### 🔍 Wat gaan we doen? - Een variabele `score` bijhouden - De score op het scherm tonen met `screen.draw.text()` - Bij een botsing met jezelf: `game_over = True` - Het spel stoppen en "Game Over" tonen ### 🔰 Startercode ```python import pgzrun import random WIDTH = 600 HEIGHT = 400 tile_size = 20 step = 20 vertraging = 10 frames = 0 snake = [(100, 100)] richting = "right" score = 0 apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size game_over = False def draw(): screen.clear() if game_over: screen.draw.text("GAME OVER", center=(WIDTH // 2, HEIGHT // 2), fontsize=60, color="red") screen.draw.text(f"Score: {score}", center=(WIDTH // 2, HEIGHT // 2 + 50), fontsize=40, color="white") else: for segment in snake: screen.draw.filled_rect(Rect(segment, (tile_size, tile_size)), "green") screen.draw.filled_circle((apple_x + tile_size // 2, apple_y + tile_size // 2), tile_size // 2, "yellow") screen.draw.text(f"Score: {score}", topleft=(10, 10), fontsize=30, color="white") def on_key_down(key): global richting if key == keys.LEFT and richting != "right": richting = "left" elif key == keys.RIGHT and richting != "left": richting = "right" elif key == keys.UP and richting != "down": richting = "up" elif key == keys.DOWN and richting != "up": richting = "down" def update(): global frames if game_over: return frames += 1 if frames < vertraging: return frames = 0 beweeg_slang() def beweeg_slang(): global apple_x, apple_y, score, game_over, richting head_x, head_y = snake[0] if richting == "left": head_x -= step elif richting == "right": head_x += step elif richting == "up": head_y -= step elif richting == "down": head_y += step new_head = (head_x, head_y) if new_head in snake[1:]: print("❌ Game over! De slang raakte zichzelf.") game_over = True return snake.insert(0, new_head) head_rect = Rect(new_head, (tile_size, tile_size)) apple_rect = Rect((apple_x, apple_y), (tile_size, tile_size)) if head_rect.colliderect(apple_rect): print("\U0001F34F Appel geraakt!") score += 1 apple_x = random.randint(0, (WIDTH - tile_size) // tile_size) * tile_size apple_y = random.randint(0, (HEIGHT - tile_size) // tile_size) * tile_size else: snake.pop() pgzrun.go() ``` ### 🧠 Waarom werkt dit? - We tekenen de score linksboven tijdens het spel - We zetten `game_over = True` bij een zelfbotsing - Als `game_over` waar is, stoppen we de beweging en tonen een ander scherm ### 🚀 Opdracht - Laat de slang een paar appels eten en kijk of de score klopt - Laat de slang zichzelf raken en controleer of "Game Over" verschijnt #### 🔎 Extra uitdaging - Laat de score ook in de console printen bij elke appel - Laat het spel automatisch herstarten na een paar seconden (of met een toets) ### 📄 Inleveren 1. Beantwoord: **Hoe weet de code dat het "Game Over" is en wat gebeurt er dan precies?** Leg stap-voor-stap uit wat er gebeurt. Kijk goed naar de code! (Lever dit in via het tekstvak of als bestand.) ## 10 Snake – Eindopdracht ### 🌯️ Houd de slang binnen het scherm Op dit moment kan de slang zomaar van het scherm verdwijnen als je te ver naar links, rechts, boven of onder beweegt. Bedenk zelf hoe je dat kunt oplossen! **Tip:** je kunt controleren of de kop van de slang buiten het scherm terechtkomt. Bijvoorbeeld: ```python if head_x < 0 or head_x >= WIDTH or head_y < 0 or head_y >= HEIGHT: game_over = True ``` Op deze manier ben je 'af' als je het scherm raakt. Je zou ook van richting kunnen veranderen, maar dit is wat lastiger om uit te voeren. ### 🛠️ Opdracht Zorg ervoor dat de slang niet buiten het beeld kan verdwijnen. Je kunt het natuurlijk zo maken dat als je de rand raakt, het spel klaar is ("Game over"). Een ander optie is om van richting te veranderen. Dat is lastiger, weet je waarom? Hoe zou je het op een goede manier kunnen uitvoeren? ### 📄 Inleveren 1. Leg uit waarom het lastig is om de slang van richting te laten veranderen als die de rand van het scherm raakt. Je hoeft het niet te coderen, maar leg uit hoe je de slang precies van richting zou kunnen laten veranderen als die de rand raakt. En werkt dit ook in de hoeken? *Probeer te omschrijven hoe het zou kunnen werken. maak als het ware een **AI prompt** (een AI opdracht) om de code op een bepaalde manier aan te passen. Beschrijf **precies** wat er moet gebeuren!* #### 🔎 Extra uitdaging Als je goed hebt beschreven wat er precies moet gebeuren en je hebt ook rekening gehouden met de hoeken dan kun je misschien AI vragen jouw te helpen om dit echt te bouwen? Probeer maar ! Als het lukt, wordt het spel leuker om te spelen! \-- # Introductie AI ## 1, wat is AI? [datasource](https://www.roc.ovh/books/software-development-2025/page/introductie-ai) ### 🔰Introductie In deze les leren we wat AI is en we gaan kijken naar het verschil van programmeren met en zonder AI. We kijken naar de kracht van AI maar ook naar de tekortkomingen. ### 🎯 Leerdoelen Aan het einde van deze les: - Kun je uitleggen wat Artificial Intelligence (AI) is. - Kun je voorbeelden geven van toepassingen van AI in het dagelijks leven en in softwareontwikkeling. - Kun je het verschil benoemen tussen klassieke ('gewone') code en code gemaalkt door AI. - Kun je minimaal drie voordelen van het gebruik van AI benoemen. - Kun je minimaal drie nadelen of risico’s van AI toelichten. - Kun je uitleggen hoe je AI slim en verantwoord kunt inzetten bij schoolopdrachten of programmeertaken. - Heb je een eerste indruk gekregen van wat prompt engineering is en waarom het belangrijk is bij het gebruiken van AI. #### Bekijk deze video: [https://www.youtube.com/watch?v=QJE\_ycgR8E8](https://www.youtube.com/watch?v=QJE_ycgR8E8) ### 🛠️Opdracht 1 Vat in één tot drie zinnen samen wat de kernboodschap van dit filmpje is. ### 📤Inleveren 1. Maak de samenvatting in van het filmpje in een text document en vul deze in. Lever een **TXT** document in. ## 2, AI toepassingen AI is veel meer dan alleen ChatGPT. In deze video wordt uitgelegd waarvoor AI kan worden gebruikt. Bekijk deze video: [https://www.youtube.com/watch?v=stw2upLHCuI](https://www.youtube.com/watch?v=stw2upLHCuI) ### 💡Theorie AI-toepassingen per taaktype Hieronder staan concrete voorbeelden van hoe kunstmatige intelligentie (AI) wordt toegepast in verschillende soorten taken| Eigenschap | Klassieke code | AI-code | Geen van beiden |
|---|---|---|---|
| Voert altijd precies dezelfde handeling uit | |||
| Kan leren van voorbeelden | |||
| Maakt soms fouten bij onbekende situaties | |||
| Is goed in rekenen en logica | |||
| Kan patronen herkennen | |||
| Is 100% voorspelbaar | |||
| Kan nieuwe dingen maken (zoals een tekening) | |||
| Kan adviseren of je in Bitcoin moet stappen of moet verkopen | |||
| Zal altijd goed advies geven voor de aankoop/verkoop van Bitcoin | |||
| Kan jouw foto veranderen en jou in een hele vreemde situatie zetten |
*AI weet niet wat jij denkt!*
De context is alles om een vraag heen. ##### Voorbeeld ``` Maak een quiz. ``` Deze opdracht is **veel te vaag**. De AI weet niet: - Over welk onderwerp je quiz moet gaan - Voor welke doelgroep (leeftijd, niveau) - Hoeveel vragen je wilt - Of het meerkeuzevragen of open vragen moeten zijn - Hoe gedetailleerd het antwoord moet zijn ### 🧠Voorbeeld met goede prompt engineering: ``` Maak een quiz van 5 meerkeuzevragen voor leerlingen van 14 jaar over het onderwerp ‘kunstmatige intelligentie’. Geef bij elke vraag vier antwoordmogelijkheden en vermeld welk antwoord correct is ``` Deze prompt is **beter** omdat hij: - context geeft (leerlingen van 14 jaar, onderwerp) - duidelijk beschrijft het formaat (5 meerkeuzevragen) - details bevat (vier antwoordkeuzes, juiste antwoord) We gaan hier in de module prompt engineering verder mee werken, maar we gaan nu vast een oefening doen. ### 🛠️Opdracht, maak een prompt (deze opdracht is vervallen ivm met de volgorde van onderwerpen in het 1ste jaar) Maak één prompt waarin je je AI vraagt een PHP programma dat zoveel mogelijk lijkt op:  Je hoeft geen database te maken, je hoeft alleen front-end code te maken. Maak dit met één prompt en wees zo compleet mogelijk. ### 🛠️Alternatieve opdracht, maak een prompt Maak de game breakout in Pyton: - Je start met drie levens - Plaatjes zoals balletje kan je ook door AI laten maken (via Python Script). Laat het spel er zoveel mogelijk als volgt uit zien.    ### 🧠 Prompting strategiën ##### One shot prompt Bij **one-shot prompting** probeer je in één keer een **zo volledig mogelijke prompt** te schrijven. Je beschrijft alle specificaties, wensen en details tegelijk. 🎯 **Doel:** met één opdracht het hele resultaat (bijvoorbeeld een spel of programma) laten maken. 💡 Daarna gebruik je alleen nog een paar kleine vervolgprompts om details aan te passen. ##### Iterative prompting Bij **iterative prompting** werk je **stapsgewijs**. Je bouwt het project op in **kleine, logische stappen**. 🎯 **Doel:** controle houden over het proces en beter begrijpen wat er gebeurt. 💡 Je moet zelf goed bedenken welke stappen je kunt onderscheiden en in welke volgorde je ze uitvoert — net als bij het bouwen van een huis begin je niet met het dak of de tuin. ##### Advies Omdat AI het concept van een *break-out game* al kent, is een **one-shot prompt** goed mogelijk. Je hoeft dus niet helemaal uit te leggen hoe het spel werkt — de AI vult zelf details aan of “verzint” onderdelen die jij niet benoemt. 👉 **Tip:** probeer je prompt een paar keer te herschrijven en kijk hoe kleine aanpassingen het resultaat veranderen. 👉 **Tip:** vraag AI of jouw prompt voldoende informatie bevat en of alles specifiek genoeg beschreven is. Vraag aan AI wat je nog kan doen om de prompt duidelijker te maken. ### Uitdaging Als je tijd over hebt, is het leuk om een **eigen versie** van het spel te maken. Bedenk zelf hoe je het spel spannender of leuker kunt maken! ### 📤Inleveren 1. De door jouw gemaakte prompt 2. Het resultaat in code \-- # Snake Challenge ## Snake Challenge! [datasource](https://www.roc.ovh/books/software-development-2025/page/snake-challenge) ### Maak je eigen snake versie! In deze laatste les ga je zelf aan de slag. Je krijgt een paar uitdagingen waar je zelf oplossingen voor moet bedenken. De code werkt al goed, maar nog niet perfect: je slang kan bijvoorbeeld zomaar uit beeld verdwijnen. En misschien wil je het spel ook leuker of spannender maken? ### ✨ Bedenk en bouw je eigen toevoeging Voeg nu zelf iets toe aan het spel. Kies uit een van de onderstaande ideeën, of verzin er zelf een! #### 🚀 Idee 1: Maak het spel sneller Verlaag de vertraging een beetje elke keer als je een appel eet. Dan wordt het spel steeds spannender! ```python vertraging = max(1, vertraging - 1) ``` #### 🎈 Idee 2: Verander de kleur van de slang bij elke appel Gebruik bijvoorbeeld `random.choice(["green", "blue", "purple"])` om de kleur van de slang steeds te wisselen. #### ⛅️ Idee 3: Maak obstakels op het scherm Voeg een vaste lijst toe met blokken waar de slang niet overheen mag. Als hij ze raakt: game over! ### 💡 Extra idee? Heb je zelf een ander idee? Ga ervoor! Laat je creativiteit zien. Denk aan een "pauze-knop", meerdere appels tegelijk, of een level-systeem. ### 📄 Inleveren 1. Maak een korte beschrijving van wat je hebt aangepast (txt bestand) 2. Lever je aangepaste en werkende spel in. # Kennis Check Blok 2 ## Kennis Check Blok 2 [datasource](https://www.roc.ovh/books/software-development-2025/page/kennis-check-blok-2) ### Vallende Stenen