Workshop Programmeren in Scratch (deel 26)

Tijdens de HCC!kennisdag van 22 maart heb ik weer diverse mensen enthousiast kunnen maken, een aantal mensen verder kunnen helpen en zelf ook weer dingen geleerd. Oftewel, Scratch blijft gewoon heel leuk. Daarom nu deel 26.

René Suiker

Je hoort mensen wel eens zeggen, dat programmeren niet meer nodig is, want overal zijn al programma’s voor “en anders regelt AI het wel”. Dit is een misverstand. Op de wereld zijn er meer dan 28 miljoen mensen professioneel bezig met softwareontwikkeling. Als ik op mijn werk kijk, heb ik heel veel collega’s die hiermee bezig zijn. Het is dus nog steeds nuttig om te kunnen programmeren en er is nog steeds veel vraag naar mensen die dit kunnen. Anderzijds is het ook gewoon leuk om je computer dingen te laten doen die jij wilt: het creatieve en intellectuele aspect.

Er is overigens wel een verschil tussen sequentieel programmeren, bijvoorbeeld in Basic of Pascal, of objectgeoriënteerd programmeren, zoals in Scratch. Het vraagt namelijk een andere manier van denken. Met sequentieel programmeren bedoel ik dat alle opdrachten achter elkaar worden uitgevoerd. Nu kan de uitvoering wel eens een beetje springen, maar in principe moet je in één programma met alles rekening houden en stap voor stap alle acties coderen. Bij objectgeoriënteerd programmeren kijk je meer naar de objecten in je programma en bekijk je per object wat er moet gebeuren. Dit dus niet per se stap voor stap achter elkaar, maar per object parallel.

De manier waarop je een probleem in Scratch oplost, is wezenlijk anders dan hoe je dat in bijvoorbeeld Basic zou doen. Als voorbeeld gebruik ik het programma Bricks dat ik al in eerdere afleveringen beschreef.

Bricks

Mijn project in Scratch is te vinden op https://scratch.mit.edu/projects/1151020395. Net als in het arcadespel is het de bedoeling om blokjes uit de lucht te schieten door een balletje op een batje te laten stuiteren. Het batje bevindt zich onderin het scherm, de blokjes bovenin. Het balletje komt op basis van de zwaartekracht naar beneden, maar als hij dan op het batje wordt opgevangen, stuitert hij omhoog. Het balletje kan aan alle kanten tegen een blokje komen en stuitert dan weer. Dit gebeurt in principe op basis van “hoek van inval” is “hoek van uitval” maar met een beetje modificatie, zodat het spel niet altijd precies hetzelfde verloopt. Er zijn twee soorten blokjes, blauwe en oranje. Als het balletje een blauw blokje raakt, dan verdwijnt dat blokje. Als het balletje een oranje blokje raakt, dan wordt het blokje blauw. Zo’n blokje moet je dus twee keer raken om het te laten verdwijnen. Het batje wordt horizontaal bestuurd met de muis, verticaal staat die vast. Verder zijn er eenvoudige geluidseffecten en speelt er een muziekje tijdens het spelen.

Ik heb dit spel niet zelf verzonnen. Het is een bestaand arcadespel en de beschrijving in Scratch komt van de hand van Al Sweigart, al wijk ik hier en daar wel af van zijn aanpak. Om dit in bijvoorbeeld Basic te programmeren, heb je ettelijke pagina’s code nodig.

Afbeelding 1: In deze afbeelding zie je het speelveld tijdens het spelen

Laten we eens beginnen met het batje (4). In Basic moet je een routine schrijven die vastlegt hoe het batje beweegt, afhankelijk van de besturing. Je moet zorgen dat je in je programma op gezette tijden controleert of de muis beweegt, zodat je het batje erop kunt laten reageren. Maar je moet ook kijken of dat batje misschien tegen de bal aankomt.

Afbeelding 2: De code voor batje

In Scratch hoef je er minder rekening mee te houden dat het batje regelmatig onder de aandacht komt. Je hebt gewoon een stukje code voor het batje en dat wordt de hele tijd uitgevoerd, naast de processen voor de andere objecten. De code voor het batje is beperkt totdat wat je ziet in afbeelding 2.

In Scratch is het gebruikelijk om het programma te laten starten met behulp van de groene vlag. Maar als je alleen maar op de groene vlag drukt en nergens in je code kijk je naar deze vlag, dan doet je programma dus niets met de vlag. Vandaar dat je blok (1) in afbeelding 2 minstens één keer tegenkomt in elk programma. Meestal gebruik ik deze maar één keer in mijn programma’s, althans, dat is mijn nieuwste aanpak.

Het voordeel van objectgeoriënteerd werken is dat je je op de objecten kunt focussen. Het nadeel is dat je vaak net iets minder controle hebt. Daarom maak ik vaak gebruik van een initialisatieprocedure die reageert op de groene vlag en die vervolgens in de juiste volgorde alle andere objecten opstart. Maar voor dit programma is dat niet zo heel relevant, vandaar dat het batje zijn eigen startfunctie heeft.

In het begin, bij (2), worden wat variabelen geïnitieerd. Actief is een variabele die een status aangeeft, waarde 0 of 1. Tempo is een variabele die aangeeft hoe snel het batje beweegt. In de huidige versie van de code verandert deze niet, maar bij meerdere levels kun je ook verschillende snelheden hanteren zonder je hele code opnieuw te moeten schrijven, vandaar een variabele. Bij (3) zetten we het batje op zijn startpositie, horizontaal in het midden en verticaal bijna onderin. Bij (4) zeggen we dat het batje altijd plat moet blijven liggen, hoe hij ook beweegt. Bij (5) starten we de speellus voor het batje, die blijft lopen totdat Actief op 0 wordt gezet. Dat gebeurt nergens in dit codeblok, maar deze variabele kan in andere blokken ook worden bewerkt (en dat gebeurt dus ook).

Met (6) regelen we enige vertraging in de beweging van het batje ten opzichte van de muis, zodat het spel niet al te makkelijk wordt. Het batje blijft dus onderin, maar neemt de x-positie van de muiscursor over. Bij (7) bepalen we het raakpunt van de bal op het batje. Die waarde hebben we alleen maar nodig tijdens het stuiteren, dus om deze elke keer te berekenen is niet optimaal efficiënt, maar daar kun je misschien iets beters voor verzinnen. Het raakpunt gebruiken we straks bij het stuiteren om de hoek van uitval te modificeren. Hoe meer je de bal in het midden van het batje raakt, des te meer is de hoek van inval gelijk aan de hoek van uitval.

De blokjes programmeren

Kijken we in afbeelding 1 naar de blokjes (5), dan zie je dat het er 32 zijn. De meesten zijn blauw, slechts twee zijn oranje. In Basic moet je elk van die blokjes positioneren en telkens voor elk blokje controleren of ze door de bal geraakt zijn. En als ze geraakt zijn, dan moet je het effect op de bal bepalen, moet je kijken of het blokje moet verdwijnen of een andere kleur krijgt en moet je het speelscherm al naar gelang aanpassen. Reken maar weer op een aantal pagina’s code. En dat terwijl je code tegelijkertijd aandacht moet geven aan de bal (3) en het batje (4).

In Scratch heb je een stukje code voor een blokje en een stukje code voor de bal. We kijken even naar het blokje (afbeelding 3). Hier valt aardig wat te beschrijven en er is voor dit artikel niet zo heel veel ruimte meer, dus het balletje komt een andere keer aan de orde.  

Afbeelding 3: De code voor een blokje

Je ziet dat de code voor het blokje uit drie componenten bestaat. Bij (1) zie je de initialisatie, ook weer gestart met de groene vlag (4). Bij (2) zie je wat er moet gebeuren als het blokje “als een kloon” start. Tijdens de initialisatie maken we een aantal klonen van het blokje (7); hierover verderop meer. Elke kloon gaat door codeblok (2). Binnen codeblok (2) wordt een routine Verwerk hit aangeroepen en die routine is weer beschreven in blok (3). Dus in Scratch kun je ook met subroutines werken om de code compact en leesbaar te houden. Bij (4) zie je de startwaarden.
Bij (7) zie je twee lussen in elkaar. Het blokje zelf verplaatst zich over een aantal rijen en kolommen en zet dan telkens een kloon van zichzelf weg. Als hij daarmee klaar is verdwijnt het blokje uit beeld (8). Hij is er nog wel, maar niet meer zichtbaar en vervult verder ook geen rol meer in het programma. Zodra het blokje als kloon verschijnt, wordt bij (9) bepaald of het een blauw of een oranje blokje is. In ongeveer tien procent van de gevallen is het blokje oranje. Bij (10) wordt gekeken of de kloon (elke kloon bekijkt dit voor zichzelf!) de tennisbal raakt. Zo ja, dan wordt een geluidseffect afgespeeld en wordt routine (3) aangeroepen. Vervolgens wordt gekeken of de score gelijk is aan het totaal aantal blokjes. Zo ja, dan wordt het spel beëindigd. Bij het verwerken van een hit (3) wordt het signaal Stuiter (12) verstuurd (richting de bal hier, maar in principe kan elk object elk signaal ontvangen en gebruiken). Dan wordt gekeken of het blokje blauw of oranje is (13). Als het een oranje blokje was, dan wordt die nu blauw. Als het blokje (al) blauw was, dan wordt de score met één verhoogd en verdwijnt deze kloon (echt). Daar hoef je verder niets voor te doen.

Zoals je ziet, kun je met een klein beetje code al heel veel doen in Scratch. Wordt vervolgd.