Variabelen, invoer en scores in spellen

Een spel kan je score tussen het vangen door onthouden. Het bewaart die score in een variabele, een plek met een naam die een waarde opslaat.

Probeer een papieren variabele

Teken een doos en schrijf “score” op het etiket. Leg er een kaartje in waarop 5 staat. Het etiket is de naam van de variabele. Het getal op het kaartje is de waarde.

Vervang nu het kaartje door een kaartje met 8. Je variabele bevat 8. Die bevat steeds één waarde, dus 5 is vervangen. Op het etiket staat nog steeds “score”.

Een programma doet ongeveer hetzelfde. Het gebruikt de naam om de waarde te vinden die het nodig heeft. Als het die waarde verandert, blijft de naam van de variabele gelijk. Een scorebord bij basketbal werkt zo: “Thuis” blijft staan terwijl de score van 10 naar 12 en naar 15 gaat.

Onthoud verschillende dingen apart

Een spel heeft misschien je score, levens, resterende tijd en niveau nodig. Elk betekent iets anders, dus elk heeft een eigen variabele nodig. De waarde van “levens” vertelt hoeveel kansen er nog zijn. De waarde van “resterendeTijd” vertelt hoeveel seconden er nog zijn.

Ook je huidige score en je beste score hebben aparte opslagplaatsen nodig. Een variabele met de naam “score” bevat de punten van dit spel. Een andere met de naam “hoogsteScore” onthoudt de beste score. Als je de huidige score vervangt, hoeft het record niet te verdwijnen. Om een oude waarde te bewaren, kopieer je die naar een andere variabele voordat je die vervangt.

Herken wat kan veranderen

Kijk naar het blok move 10 steps. Het getal 10 is in het blok getypt. Het blijft 10 telkens als dat blok wordt uitgevoerd, tenzij je het aanpast. Een variabele is anders: het programma kan de opgeslagen waarde veranderen terwijl het draait.

Je herkent hetzelfde idee buiten spellen. Een stappenteller onthoudt de stappen die je tot dan toe hebt gezet. Een weerscherm bewaart de nieuwste temperatuur. Een quiz onthoudt hoeveel antwoorden je goed had. In elk van deze gevallen vertelt de naam wat de veranderende waarde betekent.

Duidelijke namen helpen je een programma te lezen. Ze helpen je ook een blok te herkennen dat de verkeerde waarde verandert.

Maak en toon een variabele

Open in Scratch Variabelen en kies “Maak een variabele”. Typ een naam zoals “score”. Kies “Voor alle sprites” als meerdere sprites de variabele delen.

Je hebt nu blokken om de variabele in te stellen, te veranderen, te tonen en te verbergen. Het ronde blok meldt de huidige waarde. Je kunt dat ronde blok in een ander blok zetten dat een waarde nodig heeft.

Vink het vakje naast de variabele aan om de weergave op het speelveld te tonen. Scratch noemt dit ook een monitor. Een weergave zoals “score 3” toont zowel de naam als de huidige waarde. Die verandert mee als de waarde verandert. De blokken show variable en hide variable bepalen of je de weergave ziet; als je die verbergt, blijft de opgeslagen waarde bewaard.

Kies namen die hun taak uitleggen

Gebruik namen zoals “levens”, “resterendeTijd” en “spelerNaam”. Bij een naam als “ding” moet je raden wat ermee wordt bedoeld. Gebruik één variabele voor elke taak. Namen die bijna hetzelfde zijn, zoals “score” en “score2”, haal je makkelijk door elkaar. Controleer het variabelenmenu in elk maak- of veranderblok.

Met “Voor alle sprites” kunnen meerdere sprites één gedeelde waarde veranderen. Een appel en een ster kunnen allebei punten bij dezelfde score optellen. “Voor deze sprite alleen” maakt een aparte variabele die alleen de scripts van die sprite kunnen instellen of veranderen. Twee sprites kunnen elk hun eigen variabele “levens” hebben. Dat zijn aparte opslagplaatsen, ook al zijn de namen gelijk.

Lees de variabelen van een programma

Stel dat het startscript set score to 0 en set lives to 3 bevat. Later verandert de score met 1 als de sprite Appel wordt aangeraakt. Levens verandert met -1 als de sprite Vleermuis wordt aangeraakt. Je kunt beide variabelen beschrijven:

Zoek naar maakblokken, veranderblokken, ronde blokken en weergaven op het speelveld. Sommige ronde blokken, waaronder x position, timer en answer, zijn ingebouwd. Je kunt hun waarden aflezen zonder ze zelf te maken.

Probeer gebruiken, aanpassen, maken. Speel eerst een spel en zoek de variabelen. Verander daarna de beginwaarde van levens van 3 naar 5 en voorspel het resultaat. Maak ten slotte een klein programma met je eigen variabele met een duidelijke naam.

Een nieuw spel moet beginnen met de waarden die je hebt bedacht. Gebruik een maakblok om elke beginwaarde in te stellen.

Geef het spel een nieuwe start

Het blok set score to 0 vervangt de vorige score door 0. Een variabele de eerste waarde geven heet initialiseren. Je kunt dit ook de beginwaarde instellen noemen.

Zet de beginblokken direct onder when green flag clicked. Ze horen vóór de blokken te staan die deze variabelen veranderen of controleren:

when green flag clicked
set score to 0
set lives to 3
set timeLeft to 30
set level to 1

Elke beginwaarde heeft een taak. Nul betekent dat er nog geen punten zijn verdiend. Drie geeft de speler drie kansen. Dertig zorgt voor een aftelling van 30 seconden en niveau 1 is het eerste niveau. Met meer levens aan het begin wordt het spel makkelijker.

Scratchvariabelen bewaren hun waarde als een programma stopt. Hun waarden worden ook met het project opgeslagen. Als je laatste score 14 was, wist een klik op de vlag die score niet vanzelf. Het maakblok aan het begin geeft het volgende spel de bedoelde score van 0.

Zet beginblokken vóór herhalende blokken

Zet set score to 0 vóór de oneindige lus van het spel. Binnen de lus zou het blok de score bij elke doorgang terugzetten. Bij het vangen komt er misschien een punt bij, maar de volgende doorgang zou dat weer wissen.

Je kunt maakblokken later nog steeds gebruiken voor een nieuwe waarde. Bij het bereiken van een nieuw niveau kunnen set level to 2 en set timeLeft to 30 worden uitgevoerd. Daarmee begint niveau 2 opnieuw met 30 seconden.

Bewaar het record tussen spellen

Sommige waarden moeten langer dan één spel bewaard blijven. Zet “hoogsteScore” één keer op 0 als je het spel maakt. Bewaar die waarde tussen spellen, zodat de beste score wordt onthouden. Zet “score” bij elk nieuw spel terug, maar laat “hoogsteScore” staan totdat je een beter resultaat hebt om op te slaan.

Als je een munt vangt, moeten er punten bij komen boven op de punten die je al hebt. Een veranderblok gebruikt de oude waarde om de nieuwe te berekenen.

Vergelijk maak en verander

Stel dat “score” 7 bevat. Deze blokken doen iets anders:

De regel voor een veranderblok is:

Als “score” 4 is, maakt change score by 1 er 5 van. Als je voor elke vangst set score to 1 gebruikt, blijft de score op 1 staan. Maak blijft de score vervangen door hetzelfde getal.

Verlaag waarden

Een negatieve verandering haalt iets weg. change lives by -1 maakt van 3 levens 2 levens. Het minteken hoort in het getalvak; in Scratch is er geen apart verlaagblok.

Veranderingen kunnen groter zijn dan 1. Een gouden munt kan 10 punten opleveren. Een zilveren munt kan er 5 opleveren. Een fout antwoord in een quiz kan de score met -2 veranderen.

Niets in een veranderblok houdt een waarde tegen bij nul. Als je één leven van 0 afhaalt, krijg je -1. Voeg een controle toe die het spel beëindigt op de plek waar levens kunnen veranderen.

Gebruik een andere waarde bij een verandering

De veranderingswaarde kan uit een andere variabele komen. Stel dat “score” 40 is en “timeLeft” 12. Het blok change score by (timeLeft) telt de 12 seconden als bonuspunten erbij op:

De score wordt 52. “timeLeft” blijft 12, omdat dit blok alleen “score” verandert.

Je kunt ook plus of min binnen een maakblok gebruiken. set score to (score + 10) leest eerst de oude score, telt er 10 bij op en bewaart het resultaat. Het doet hetzelfde als change score by 10. Op dezelfde manier komt set lives to (lives - 1) overeen met change lives by -1.

Tel elke keer dat een blok wordt uitgevoerd

Binnen repeat 5 wordt een blok dat de score met 2 verandert vijf keer uitgevoerd. Het telt in totaal 10 op. Een lus herhaalt de verandering, niet alleen de woorden eromheen.

Positiewaarden werken ook zo. change x by 10 verplaatst een sprite naar rechts. change x by -10 verplaatst die naar links. Gaat de beweging de verkeerde kant op, controleer dan het teken.

Je kunt het resultaat van een programma uitzoeken voordat je het uitvoert. Stap voor stap doorlopen betekent dat je de blokken in volgorde volgt en veranderende waarden opschrijft.

Schrijf voor elke verandering een rij

Lees deze reeks van boven naar beneden: set score to 0, change score by 10, change score by 10, change score by -5.

De laatste rij toont de eindscore: 15. De eerdere rijen zijn momentopnamen, geen extra punten. Als je de kolom optelt, tel je die momentopnamen bij elkaar op.

Werk een lus uit op papier

Laat “coins” beginnen bij 5. Herhaal daarna change coins by 3 vier keer. Schrijf eerst 5 op. De vier veranderingen geven 8, 11, 14 en 17. Je hebt voor elke doorgang een rij nodig. Als je maar één verandering telt, krijg je 8 en mis je drie doorgangen.

Een voorwaarde bepaalt of een verandering wordt uitgevoerd. Laat de score in een quiz beginnen bij 0. Vraag “Wat is 6 × 7?” en tel 1 op bij het antwoord 42. Vraag daarna “Wat is 9 + 8?” en tel 1 op bij het antwoord 17. De antwoorden 42 en 16 geven de scores 0, 1 en 1. Het foute tweede antwoord levert niets op.

Zet variabelen in aparte kolommen

Begin met score 0 en levens 3. Een ster levert 5 punten op. Een vleermuis kost één leven. Na ster, vleermuis, ster ziet je tabel er zo uit:

Neem een waarde over als die bij een gebeurtenis niet verandert. De vleermuis verandert levens, dus blijft de score in die rij 5.

Je kunt een afteller op dezelfde manier stap voor stap doorlopen. Laat “resterendeTijd” beginnen bij 3. Herhaal een wachttijd van één seconde en een verandering van -1 totdat de waarde gelijk is aan 0. De waarden zijn 3, 2, 1, 0: drie doorgangen en ongeveer drie seconden.

Vergelijk je voorspelling met een uitvoering

Toon de variabeleweergaven en voer het programma uit. Voeg tijdens het testen korte wachttijden toe als de veranderingen te snel gaan. Verschillen het scherm en de tabel? Zoek dan hun eerste verschil. Bekijk het blok op die plek en controleer de voorwaarde of lus eromheen.

Een programma heeft informatie van buitenaf nodig. Die informatie heet invoer. Je geeft invoer als je een toets indrukt, op een sprite klikt, een muis beweegt of een antwoord typt. Ook een microfoon of een knop op een klein computerbordje kan invoer geven.

Verbind invoer met acties

Een gebeurtenis kan een script starten. Bijvoorbeeld:

when right arrow key pressed
change x by 10

Elke druk op de toets start de beweging. Om te blijven bewegen zolang een toets wordt ingedrukt, controleer je die binnen een lus:

forever
  if key left arrow pressed? then
    change x by -10

De lus controleert de toets bij elke doorgang opnieuw. Als de toets ingedrukt is, wordt de verandering opnieuw uitgevoerd.

Stel een vraag en wacht

Het blok ask [What is your name?] and wait toont een vraag en een antwoordvak. Het script wacht daar totdat de speler op Enter drukt of op het vinkje klikt. Blokken onder dat vraagblok wachten op het antwoord.

Het ingebouwde blok answer bevat wat de speler heeft getypt. Het bewaart het nieuwste antwoord. Een volgende vraag vervangt het.

Bewaar een antwoord direct na de vraag als je het later nodig hebt:

ask [What is your name?] and wait
set playerName to (answer)
ask [What is your favorite color?] and wait

Na het tweede antwoord bevat answer de kleur. “playerName” bevat nog steeds de naam, omdat je die hebt gekopieerd voordat je opnieuw een vraag stelde. Als je beide vragen stelt voordat je de naam bewaart, gaat dat antwoord uit answer verloren.

Laat invoer het spel beïnvloeden

Je kunt vragen: “Hoeveel levens wil je: 3 of 5?” Daarna bewaart set lives to (answer) de keuze. Test ook onverwachte antwoorden. Een speler kan 0 typen, het vak leeg laten of een woord invoeren. Een duidelijke vraag helpt, maar dwingt de speler niet om een van de voorgestelde getallen te typen.

In een quiz wordt het antwoord gebruikt voor een vergelijking. Het programma controleert of answer overeenkomt met het juiste antwoord. Het telt er een punt bij op als de controle waar is.

Je programma moet zijn resultaten laten zien. Uitvoer is informatie uit een programma die mensen zien of horen. Daaronder vallen beweging, tekstballonnen, geluiden, uiterlijken, achtergronden, variabeleweergaven en lampjes op apparaten.

Volg invoer, verwerking en uitvoer

Als je op het pijltje naar rechts drukt, is de toetsdruk invoer. Het programma voert change x by 10 uit: dat is verwerking, het werk dat het doet. Dat je de kat naar rechts ziet bewegen, is uitvoer.

Een quiz volgt dezelfde weg. Je typt 42 als invoer. Het programma controleert het antwoord en telt 1 op bij “score”. Dat is verwerking. Een scoreweergave met 1 en een tekstballon met “Goed!” zijn uitvoer.

Toon een getal of een bericht

Een variabeleweergave is handig voor scores, levens en aftellers. Zodra die zichtbaar is, verandert die mee telkens als de variabele verandert.

Een tekstballon kan ook een waarde tonen. Sleep het ronde blok score in een zegblok:

say (score) for 2 seconds

Dit toont het opgeslagen getal. Als je het woord “score” in het zegblok typt, toont het in plaats daarvan dat woord. Het ronde blok vertelt het programma dat het de waarde moet opzoeken.

Het voeg-samenblok zet woorden en een waarde bij elkaar:

say (join [Your score is ] (score))

Bij een score van 15 luidt het bericht “Your score is 15”. Laat een spatie na “is” staan binnen het eerste vak. Zonder die spatie is het resultaat “Your score is15”.

Opgeslagen invoer kan ook in een bericht verschijnen. Als “spelerNaam” “Mia” bevat, geeft het samenvoegen van “Veel succes, ” met die variabele “Veel succes, Mia”.

Toon de waarde na de verandering

De volgorde van blokken beïnvloedt een tekstballon. Als de score 4 is en je eerst de score laat zeggen en die daarna met 1 verandert, toont de tekstballon 4. Om de nieuwe score van 5 te tonen, zet je eerst het veranderblok en daarna het zegblok. Een zichtbare variabeleweergave verandert vanzelf mee, maar een zegblok leest de waarde wanneer het wordt uitgevoerd.

Uitvoer kan een resultaat vieren. Een scorecontrole kan een juichgeluid of een achtergrond met “Je wint!” starten als het doel is bereikt.

Een spel moet beslissen wanneer je wint of wanneer je levens op zijn. Een vergelijking controleert twee waarden. Het resultaat is waar of onwaar.

Lees de drie vergelijkingsblokken

De symbolen >, < en = betekenen groter dan, kleiner dan en gelijk aan. Vergelijkingsblokken passen in een als-blok of een herhaal-tot-lus.

Als de score 10 is:

Groter dan sluit gelijkheid uit. Als een speler bij een gehele score van 10 of meer moet winnen, gebruik je score > 9. Een controle met score > 10 mist precies 10. De waarde waarbij een beslissing verandert, heet een grenswaarde.

Een als-dan-andersblok kiest tussen twee acties. Tel bij een quizantwoord van 42 een punt op en zeg “Goed!”. Zeg anders “Het antwoord is 42”. Alleen de gekozen tak wordt uitgevoerd.

Blijf controleren terwijl het spel verandert

Een enkele controle aan het begin ziet alleen de beginwaarde van levens. Zet de controle in een spellus die draait, zodat die blijft controleren terwijl levens veranderen:

forever
  if lives = 0 then
    say [Game over]
    stop all

Een herhaal-tot-lus controleert de voorwaarde vóór elke doorgang. Als de controle onwaar is, worden de blokken binnen de lus één keer uitgevoerd. Als de controle bij de volgende keer waar is, gaat het script onder de lus verder. Een doorgang binnen de lus stopt niet halverwege.

Let op een overgeslagen waarde

Stel dat “resterendeTijd” bij 25 begint en bij elke doorgang met 2 daalt. De waarde bereikt 3, dan 1 en dan -1. Die is nooit gelijk aan 0. Een lus die op timeLeft = 0 wacht, blijft doorgaan. Een controle met timeLeft < 1 vangt nul en lagere waarden op.

Je kunt ook twee variabelen vergelijken. Gebruik aan het einde van een spel if score > highScore then set highScore to (score). Als het record 12 is en je 15 scoort, wordt het record 15. Bij een latere score van 9 blijft het 15.

Bepaal wat elke gebeurtenis in het spel moet doen. Het vangen van een appel kan 1 punt opleveren. Het aanraken van een vleermuis kan 1 leven kosten. Zet elke verandering binnen de bijbehorende voorwaarde.

Bouw de vallende appel

Maak “score” en “lives” voor alle sprites. Zet in het startscript van de kat de score op 0 en lives op 3. De appel heeft een herhalend script nodig:

when green flag clicked
go to x: (pick random -200 to 200) y: 170
forever
  change y by -5
  if touching Cat? then
    change score by 1
    go to x: (pick random -200 to 200) y: 170
  if y position < -170 then
    go to x: (pick random -200 to 200) y: 170

De negatieve y-verandering verplaatst de appel omlaag. Als je hem vangt, komt er een punt bij en gaat hij terug naar boven. De laatste controle stuurt ook een gemiste appel terug. De onderrand van het speelveld ligt op y = -180, dus deze controle stuurt de appel vlak bij de onderkant terug. Zonder die controle kan een gemiste appel daar vast komen te zitten.

Voorkom dat één vangst vaak telt

Een oneindige lus kan vaak worden uitgevoerd terwijl twee sprites elkaar aanraken. Als de lus alleen een punt toevoegt, kan één appel veel punten opleveren. Door de appel direct na het scoren weg te bewegen, beëindig je de aanraking. Je kunt ook wachten totdat de sprites elkaar niet meer aanraken voordat je nog een punt toestaat.

Als je het gevangen object verbergt, worden er zolang het verborgen is ook geen punten voor aanraking geteld. Toon het weer als je het terugzet voor de volgende vangst.

Gebruik hetzelfde idee voor levens. Voer na een treffer door een vleermuis change lives by -1 uit en beweeg de vleermuis weg. Controleer daarna of de levens op zijn en beëindig het spel. Anders kan het herhaalde contact in een ogenblik alle levens kosten.

Kies de regels voor punten en snelheid

Een fout antwoord in een quiz kan 2 punten kosten. Als je regels zeggen dat scores niet onder 0 mogen komen, laat je op de puntenaftrek if score < 0 then set score to 0 volgen.

Variabelen kunnen ook de beweging in het spel veranderen. Gebruik change y by (fallStep) en laat “fallStep” beginnen bij -5. Als je die in niveau 2 op -8 zet, valt de appel bij elke doorgang 8 stappen.

Voor een quiz met vijf vragen kan een eindbericht “Je had ”, de score en “ van de 5 goed” samenvoegen. Bij een score van 4 krijg je dan “Je had 4 van de 5 goed”. Als meerdere sprites punten geven, moeten ze dezelfde gedeelde score veranderen.

In sommige spellen moet je klaar zijn voordat de tijd om is. Bij wedstrijden gaat het erom hoelang je erover deed.

Meet de tijd die oploopt

Scratch heeft een ingebouwde timer. Die telt in seconden omhoog en kan decimalen tonen, zoals 12,4. Gebruik reset timer aan het begin om vanaf het begin van je spel te meten.

Om een spel na 60 seconden te beëindigen, gebruik je wait until timer > 60 en daarna stop all. Laat bij een wedstrijd de klokwaarde zeggen als de speler finisht. round (timer) rondt 12,4 af op het dichtstbijzijnde hele getal, 12. De klok blijft lopen, dus sla de waarde bij de finish op als je die wilt bewaren.

Bouw een klok die aftelt

Maak je eigen variabele “timeLeft” en toon die. Zet deze afteller in een apart script:

when green flag clicked
set timeLeft to 30
repeat until timeLeft < 1
  wait 1 seconds
  change timeLeft by -1
say [Time's up!]
stop all

Elke doorgang wacht en haalt dan één seconde weg. De waarden gaan van 30 naar 29, 28 en verder tot 0. Er zijn 30 doorgangen, die ongeveer 30 seconden duren. Door de wachttijd blijft elke getoonde waarde even op het scherm staan.

Houd zowel de wachttijd als de verandering binnen de lus. Zonder de wachttijd telt de klok bijna meteen af. Staat de verandering na de lus, dan verandert de klok nooit terwijl de lus wacht tot de tijd om is.

Laat de klok en de speler tegelijk lopen

Een script maakt zijn lus af voordat het bij de blokken eronder komt. Een bewegingslus onder de afteller zou te laat beginnen. Geef de beweging een eigen script met de groene vlag. Dan kan de speler bewegen terwijl de afteller loopt.

Een spel kan eindigen als de levens op zijn of als de tijd om is. Blijf beide controleren, zodat elk van die gebeurtenissen het spel kan stoppen. In een spel dat beloont als je vroeg klaar bent, tel je de overgebleven tijd als bonus op bij de score.

Bewaar de snelste wedstrijdtijd

Een kortere wedstrijdtijd is beter. Zet “besteTijd” na de eerste voltooide wedstrijd op die finishtijd. Vervang die bij latere wedstrijden alleen als de nieuwe finishtijd korter is. Het record bij 0 laten beginnen zou niet werken: een echte wedstrijd kan niet sneller dan nul seconden zijn. Bewaar “besteTijd” tussen wedstrijden.

Gebruik tijdens het testen van een langer spel een afteller van vijf seconden. Zet de bedoelde tijdslimiet terug zodra het werkt.

Leg je spel in een paar zinnen uit voordat je blokken kiest. Vertel wat de speler doet, wanneer die wint en waardoor het spel kan eindigen.

Begin met een klein idee

Bij “Appels vangen” beweeg je een kat met de pijltjestoetsen. Vang appels voor punten en ontwijk vleermuizen die levens afpakken. Probeer binnen 30 seconden 10 punten te halen. De besturing is invoer. De bewegende sprites, zichtbare waarden, geluiden en eindberichten zijn uitvoer.

Zet alleen de variabelen op een rij die je spel nodig heeft. Een kleine eerste versie kan één vallende appel en een score gebruiken. Voeg levens, een klok of niveaus toe nadat het eerste deel werkt.

Maak een variabelenplan

Schrijf voor elke variabele de naam, betekenis, beginwaarde en veranderingen op. Vermeld ook de grootte van elke verandering.

Dit plan helpt je in elk blok de juiste variabele te kiezen. Het laat ook zien welke waarden aan het begin een maakblok nodig hebben.

Schets de stappen voordat je bouwt

Een algoritme is een reeks stappen om een taak uit te voeren. Schrijf de stappen in gewone woorden of teken een stroomschema. Laat gebeurtenissen, lussen, keuzes en veranderingen van variabelen zien.

Voor de appel kan je plan zeggen: begin bovenaan; blijf vallen; tel na een vangst een punt op en ga terug naar boven; ga na een misser terug naar boven. Laat voor de klok zien dat een wachttijd en een verlaging worden herhaald. Neem controles voor winnen en verliezen op.

Bepaal hoe je weet of het werkt

Schrijf succescriteria die je kunt testen door te spelen. “Het spel is goed” is moeilijk te controleren. Deze geven je duidelijke tests:

• “Elk nieuw spel begint met score 0.”
• “Eén gevangen appel levert precies 1 punt op.”
• “Het spel eindigt als levens 0 bereikt.”

Denk ook aan de speler. Toon een korte instructie zoals “Gebruik de pijltjestoetsen om appels te vangen”. Houd score, levens en tijd zichtbaar. Als je met meer levens of meer tijd begint, wordt het spel makkelijker.

Voeg een paar blokken toe, voer ze uit en controleer het resultaat. Als je in kleine stappen bouwt, vind je een nieuwe programmeerfout makkelijker bij de blokken die je net hebt toegevoegd.

Vergelijk verwachte en werkelijke resultaten

Testen betekent dat je controleert of wat er gebeurt overeenkomt met wat je verwachtte. Schrijf de actie, het verwachte resultaat en het werkelijke resultaat op.

Een mislukte test geeft je een aanwijzing. De tweede rij wijst op herhaald scoren tijdens één aanraking.

Test de grenzen en speel ook op de gewone manier. Probeer precies de score waarmee je wint, het laatste leven en het moment waarop de tijd om is. Speel een tweede spel om de beginwaarden te controleren. Probeer bij getypte antwoorden een goed antwoord, een fout antwoord, een leeg antwoord en woorden zoals “tweeënveertig”.

Zoek de eerste verkeerde verandering

Toon de variabeleweergaven. Vertraag veranderingen met korte wachttijden en doorloop de blokken met de hand. Controleer de eerste plek waar de werkelijke waarde afwijkt van je voorspelling.

Deze controles helpen bij veelvoorkomende programmeerfouten met variabelen:

• Verkeerde beginwaarde: voeg het maakblok aan het begin toe of verbeter het.
• Score blijft op 1 staan: controleer of maak verander moet zijn.
• Levens stijgen na een treffer: controleer het teken van de verandering.
• Punten stijgen zonder vangst: controleer of de verandering binnen het als-blok staat.
• Eindcontrole gebeurt nooit: zorg dat die wordt uitgevoerd terwijl het spel doorgaat.
• Afteller gaat voorbij nul: controleer de vergelijking.
• Een andere sprite kan de score niet veranderen: controleer hoe de variabele wordt gedeeld.

Verhelp de fout en test opnieuw

Stel dat één aanraking met een vleermuis levens van 3 naar -40 laat gaan. De lus blijft aftrekken zolang de sprites elkaar aanraken. Ook ontbreekt een werkende eindcontrole. Beweeg de vleermuis na een treffer weg en controleer lives < 1 om “Spel afgelopen” te zeggen en alles te stoppen.

Verander één ding tegelijk en herhaal de mislukte test. Controleer daarna wat er bij vergelijkbaar gedrag gebeurt, zoals bij nog een aparte treffer. Zo zie je welke verandering elk probleem heeft opgelost.

Vraag een vriend om te spelen zodra het spel werkt. Zoek uit wat leuk of verwarrend was. Gebruik die feedback om één verbetering te kiezen, zoals duidelijkere instructies, een niveau, een geluid of een hoogste score. Test het aangepaste deel opnieuw.