Introductie Small Basic

Microsoft Small Basic

Een introductie in het Programmeren

Hoofdstuk 1

Een Introductie

Small Basic en Programmeren Het programmeren van een Computer wordt vaak omschreven als het proces van het schrijven van

computer software door gebruik te maken van een programmeer taal of talen. Net zoals we de taal

Nederlands Engels, Spaans of Frans verstaan en spreken, begrijpen computers programma’s geschreven

in bepaalde talen. Deze worden programmeer talen genoemd. In het begin had men maar een paar

programmeer talen die gemakkelijk te leren en te begrijpen waren. Met de evolutie van

computersystemen en software evolueerden echter ook de programmeertalen, en namen steeds toe in

complexere concepten gedurende deze ontwikkelingen. Met als resultaat dat een moderne

programmeer taal en de achterliggende concepten een behoorlijke uitdaging bieden vormen voor een

beginnend programmeur.

Dit feit was aanleiding dat steeds meer mensen ontmoedigde om een computer te programmeren.

Small Basic is een speciaal ontworpen programmeer taal om programmeren extreem eenvoudig ,

toegankelijk en plezierig voor beginners te maken. De intentie van Small Basic is om de

moeilijkheidsgraad te verlagen en graag als opstap wil dienen voor de wondere wereld van het

programmeren van computersystemen.

De Small Basic Omgeving Laten we beginnen met een snelle introductie van de Small Basic omgeving. Wanneer je Small Basic.exe

voor de eerste keer opstart, zie je een scherm wat op het onderstaande figuur lijkt

Figuur 1 - De Small Basic omgeving

Dit is de Small Basic omgeving, waar we onze Small Basic programma’s zullen schrijven en uitvoeren.

Deze omgeving heeft verschillende specifieke elementen die aangegeven zijn met een nummer.

De Editor, aangegeven met een [1] is waar we onze Small Basic programma’s zullen schrijven . Wanneer

je een voorbeeld programma opent of een opgeslagen programma , zal het hier worden getoond in de

editor. Je kunt het aanpassen en of opslaan voor later gebruik.

Je kunt ook tegelijkertijd meerdere programma’s openen en bewerken . Elke programma waar je in

werkt zal in een separate editor worden getoond. De editor die het programma bevat waar je nu direct

aan werkt noemen we de actieve editor.

De Gereedschapsbalk, aangegeven met een [2] wordt gebruikt om commando’s te geven aan de actieve

editor of de omgeving. We zullen meer leren over de verschillende commando’s in de gereedschapsbalk

als we ermee aan de slag gaan.

Het Oppervlak, aangegeven met een [3] is die plek waar alle editor schermen zich zullen bevinden.

Ons eerste programma Nu we wat bekend zijn met de Small Basic omgeving, kunnen we van start gaan en beginnen met

programmeren Small Basic. Zoals we hierboven hebben gelezen, is de editor de aangewezen plaats

waar we de onze programma’s gaan schrijven. Dus laten we starten en hier de onderstaande regel in

typen.

1

2

3

TextWindow.WriteLine("Hallo Wereld")

Zoals je ziet is de brontaal geschreven in het Engels, dat komt omdat een taal ook nog eerst vertaald dient te worden naar een taal die de

computer beter begrijpt, dat doet een compiler voor ons. Deze compiler begrijpt alleen de Engelse taal vandaar dat we Small Basic

programmeren in het Engels.

Dit is ons eerste Small Basic programma. En als je het juist hebt overgetypt, zie je de uitkomst als

hieronder afgebeeld in figuur 2.

Figuur 2 - Eerste Programma

Nu we ons nieuwe programma hebben ingetypt, laten we het eens uitvoeren en kijken wat er gebeurt.

We kunnen ons programma uitvoeren door op de Uitvoeren knop (F5) in de gereedschapsbalk te klikken

of om een kortere weg te kiezen namelijk de sneltoets combinatie F5 op het toetsenbord te kiezen. Als

alles in orde zal ons programma worden uitgevoerd en is zien we het resultaat als in figuur 3.

Figuur 3 - Eerste programma uitvoer

Gefeliciteerd! Je hebt zojuist jouw eerste Small

Basic Programma geschreven en uitgevoerd.

Een klein en eenvoudig programma, maar

desalniettemin een behoorlijke stap voorwaarts

om een echter computer programmeur te worden!

Welnu, er is nog een belangrijk detail te

behandelen voordat we verder gaan en grotere

programma’s gaan schrijven. We moeten

begrijpen wat er zojuist is gebeurd – wat vertelden

we nu precies tegen de computer en hoe vertelden

we de computer wat hij moest doen? In het

volgende hoofdstuk, analyseren we het

programma wat we zojuist hebben geschreven, en zo leren we begrijpen hoe dat in zijn werk gaat.

Figuur 4 - Intellisense

Bewaren van ons programma Wanneer je Small Basic wilt afsluiten en later wilt terugkeren om in Small Basic verder te werken aan het

programma dat je aan het maken bent of zojuist hebt ingetypt, kun je het programma ook bewaren

door het op te slaan. Het is een goede gewoonte om programma’s te bewaren en regelmatig op te

slaan, zo verlies je geen informatie in het geval van het per ongeluk afsluiten van de PC of in het geval

van een stroomstoring. Je kunt het huidige programma opslaan en bewaren door op het “opslaan”

icoon op de gereedschapsbalk te klikken of door de toetscombinatie “Ctrl+S” (druk op de “S” toets

terwijl je de “Ctrl-toets” ingedrukt houdt).

Terwijl je jouw eerste programma hebt

getypt,is het je misschien opgevallen dat er een

popup scherm verscheen met een lijst van

onderdelen (Fout! Verwijzingsbron niet

gevonden.). Dit wordt “intellisense” genoemd

en helpt je bij het sneller typen van

programma’s. Je kunt door deze lijst heen

lopen met behulp van de Up/Down pijltjes

toetsen, en as je iets vindt wat je nodig hebt,

gebruik je de Enter toets om het geselecteerde

onderdeel in te voegen in jouw programma.

Hoofdstuk 2

Begrijpen van ons eerste programma

Wat is nu eigenlijk een computer programma? Een programma is een set instructies (opdrachten) aan de computer. Deze instructies vertellen de

computer precies wat er moet gebeuren, en de computer volgt deze instructies altijd nauwkeurig op.

Net als mensen, kunnen computers alleen instructies opvolgen als deze is aangegeven in een taal die

men begrijpt. Dit worden programmeer talen genoemd. Er zijn vele talen die de computer kan

begrijpen en Small Basic is er een van.

Stel je een gesprek voor tussen jou een je vriendje. Jij en jouw vriendjes gebruiken woorden, die

samengesteld en georganiseerd als zinnen ervoor zorgen dat je informatie heen en weer kunt sturen.

Programmeer talen bevatten verzamelingen van woorden die kunnen worden georganiseerd in zinnen

die informatie naar de computer sturen. En programma’s is in de basis een set zinnen (soms enkel een

paar woorden , en soms enkele duizenden) die

samen begrijpelijk zijn voor zowel de computer

als voor de programmeur.

Small Basic Programma’s Een typisch Small Basic programma bevat een

heleboel uitdrukkingen (statements).

Elke lijn van het programma vertegenwoordigd een uitdrukking en elk statement (instructie) is een

instructie voor de computer. Wanneer we de computer vragen het Small Basic programma uit te

voeren, gebruikt het dit programma en leest het eerste instructie (statement ). Het begrijpt wat we

willen zeggen en voert dan onze instructies uit. Terwijl hij klaar is met het uitvoeren van de eerste

instructie (statement), keert het terug naar programma en leest de tweede regel en voert deze uit.

Er zijn vele talen die een computer kan

begrijpen. Java, C++, Python, VB, etc. zijn

allemaal krachtige en moderne computer talen

die worden gebruikt om simpele als complexe

software programma’s te ontwikkelen.

Dit blijft het programma doen net zolang totdat het einde van het programma is bereikt. Dat is wanneer

het programma stopt.

Terug naar ons eerste programma Hier is eerste programma wat we geschreven hebben:


Dit is een erg simpel programma dat bestaat uit een statement (uitdrukking). Dit statement verteld de

computer om een regel tekst te schrijven die de woorden Hallo Wereld bevat, in het Text Window

Letterlijk wordt het in de computer vertaald als: “Write” is het Engelse woord voor schrijven.

Schrijf de tekst Hallo Wereld

Misschien is het je opgevallen dat het statement op zijn manier in drie kleinere onderdelen net zoals

zinnen in woorden kan worden gedeeld. In het eerste statement zien we 3 distinctieve segmenten:

a) TextWindow

b) WriteLine

c) “Hallo Wereld”

De punt tussen TextWindow en Writeline, en tussen haakjes geplaatste tekst of tekens als

aanhalingstekens zijn allemaal leestekens die op exacte posities geplaatst moeten worden in het

statement (instructie), zodat de computer onze bedoelingen begrijpt.

Je kunt je misschien het zwarte venster herinneren wat tevoorschijn kwam toen we ons eerste

programma uitvoerden. Dit zwarte venster word

het TextWindow (tekst scherm) genoemd of ook

wel de Console (spreek uit als Consool). Hier

komt de uitkomst van ons programma.

TextWindow, in ons programma, wordt een

object genoemd. Er zijn een aantal van dit soort

objecten beschikbaar voor ons om te gebruiken in

onze programma’s. We kunnen verschillende

bewerkingen (operations) van deze objecten vragen. We hebben al gebruik gemaakt van de WriteLine

bewerking in ons programma. Wellicht is het je opgevallen dat de WriteLine bewerking gevolgd wordt

door de tekst Hallo Wereld binnen aanhalingstekens. Deze tekst wordt doorgegeven als invoer aan de

WriteLine bewerking, waardoor het als uitvoer word geprint op het scherm aan de gebruiker. Dit wordt

ook wel een input genoemd voor de bewerking. Sommige bewerkingen vinden plaats op meer dan een

plek in het programma op meerdere invoer terwijl andere juist geen invoer toestaan.

Leestekens zoals aanhalingstekens, spaties en

haakjes zijn zeer belangrijke voor een computer

programma. Gebaseerd op hun positie en

aantal, kunnen zij de betekenis van wat wordt

bedoeld met de uitvoer bepalen.

Ons tweede programma Nu we ons eerste programma hebben begrepen, laten we verder gaan en het wat mooier maken door

wat kleuren toe te voegen. “Yellow” is het Engelse woord voor de kleur geel.

TextWindow.ForegroundColor = "Yellow"


Figuur 5 - Kleur toevoegen

Wanneer je het bovenstaande programma uitvoert, zal het opvallen dat dezelfde tekst “Hallo Wereld”

als print in het TextWindow, deze keer in de kleur geel afgedrukt is in plaats van het grijs van zojuist.

Figuur 6 - Kleur toevoegen uitvoer

Noteer de nieuwe instructie (statement ) die we hebben toegevoegd aan het originele programma.

Het gebruikt een nieuw woord, ForegroundColor waar we de waarde “Yellow” aan hebben toegekend.

Dit betekend dat we de waarde “Yellow” hebben toegekend aan ForegroundColor. Welnu, het verschil

tussen ForegroundColor en de bewerking WriteLine is dat ForegroundColor geen enkele invoer nodig

had of aanhalingstekens. In plaats daarvan werd het gevolgd door een gelijk aan teken en een woord.

We beschrijven ForegroundColor als een eigenschap (Property) van TextWindow. Hier is een lijst van

waarden die toegestaan zijn voor de ForegroundColor eigenschap (property). Probeer eens “Yellow” te

vervangen door een van de andere en bekijk het resultaat eens – vergeet de aanhalingstekens niet, dit

zijn namelijk verplichtte lees tekens.

Black

Blue

Cyan

Gray

Green

Magenta

Red

White

Yellow

DarkBlue

DarkCyan

DarkGray

DarkGreen

DarkMagenta

DarkRed

DarkYellow

Hoofdstuk 3

Introductie van variabelen

Gebruik maken van variabelen in ons programma Zou het niet mooi zijn als ons programma “Hallo” met een gebruikersnaam zegt in plaats van “Hallo

Wereld” . Om dat voor elkaar te krijgen moeten we de gebruiker vragen zijn of haar naam in te voeren,

deze dan ergens op te slaan en daarna op het scherm “Hallo” met daarachter de gebruikersnaam te

printen. Laten we eens kijken hoe dat in zijn werk gaat:

TextWindow.Write("Voer hier jouw naam in: ")

naam = TextWindow.Read()

TextWindow.WriteLine("Hallo " + naam)

Wanneer je het programma uitvoert, dan zie je soortgelijke uitvoer als hieronder:

Figuur 7 - Vraag de gebruiker om zijn naam

En wanneer je jouw naam opgeeft en op de knop Enter drukt, dan zie je de volgende uitvoer:

Figuur 8 - Een warm welkom

Welnu, als we het programma weer opnieuw uitvoeren, zal de vraag opnieuw dezelfde vraag gesteld

worden. Kun je een andere naam opgeven en de computer zal dan “Hallo” met de andere opgegeven

naam laten zien.

Analyse van het programma In het zojuist uitgevoerde programma, zal de zin waar jouw aandacht op gevallen zijn deze:


Read() lijkt veel op WriteLine(), maar dan zonder invoer. Het is een bewerking en verteld de computer

om te wachten totdat de gebruiker iets intypt en de ENTER toets indrukt. Terwijl de gebruiker de ENTER

toets indrukt, neemt de computer over wat de

gebruiker heeft ingetypt en geeft het terug aan

het programma. Het interessante punt is dat wat

de gebruiker ook getypt heeft nu is opgeslagen in

iets wat we variabele de naam hebben genoemd.

Een variabele word vastgesteld als een plaats

waar we tijdelijk iets in kunnen opslaan om dit

later te kunnen gebruiken. In de lijn hierboven

wordt naam gebruikt om de naam van de

gebruiker in op te slaan.

De volgende lijn is ook interessant:


dit is de plaats die we gebruiken om de waarde in op te slaan in onze variabele, naam. We nemen de

waarde in naam en voegen het toe aan “Hallo” en schrijven het op TextWindow.

Write, net als WriteLine is een andere operatie

op het Console Scherm. Write maakt het

mogelijk om iets te schrijven (write) naar het

Console Scherm, maar staat opvolgende tekst

toe om op dezelfde lijn als de huidige tekst te

worden geplaatst.

Wanneer een variabele eenmaal is gezet, kun je het zo vaak je wilt hergebruiken. Bijvoorbeeld, kun je

het volgende doen:

TextWindow.Write("Voer hier jouw naam in: ")

name = TextWindow.Read()

TextWindow.Write("Hello " + naam + ". ")

TextWindow.WriteLine("hoe gaat het met je " + naam + "?")

En de volgende uitvoer zal worden getoond:

Figuur 9 - Hergebruik van een variabele

Regels voor namen van variabelen Variabelen hebben namen die hiermee geassocieerd zijn en zo identificeer je ze. Er zijn enkele

eenvoudige regels en bruikbare handleidingen voor het geven van namen van deze variabelen.

Dit zijn:

1. De naam moet beginnen met een letter en niet lijken op de woorden als if, for, then, etc.

2. Een variabele naam kan elke combinatie letters, cijfers en underscores ( _ teken) bevatten.

3. Het is gebruikelijk om zinvolle namen te gebruiken- omdat variabelen zo lang kunnen zijn als je

wenst, gebruik je het beste namen die de bedoeling ervan weergeven.

Spelen met getallen We hebben zojuist gezien dat we variabelen gebruiken om de naam van de gebruiker in op te slaan. In

de volgende programma’s zullen we zien hoe we getallen kunnen opslaan en bewerken in variabelen.

Laten we beginnen met een echt eenvoudig programma:

nummer1 = 10

nummer2 = 20

nummer3 = nummer1 + nummer2

TextWindow.WriteLine(nummer3)

Wanneer je het programma uitvoert dan krijg je de volgende uitvoer:

Figuur 10 - Twee getallen optellen

In de eerste regel van programma, ken je de waarde toe aan variabele nummer1 met een waarde van

10. En in de tweede regel, ken je de waarde toe aan variabele nummer2 met de waarde van 20. In de

derde regel, tel de waarde van nummer1 en nummer2 op en dan ken je de uitkomst van de optelsom

toe aan variabele nummer3. Dus in dit geval, krijgt nummer3 een waarde van 30. En dat is wat we

printen naar het TextWindow.

Welnu , laten we een zien als we het programma iets aanpassen en het resultaat gaan bekijken:

nummer1 = 10

nummer2 = 20

nummer3 = nummer1 * nummer2

TextWindow.WriteLine(nummer3)

Het bovenstaande programma vermenigvuldigd nummer1 met nummer2 en slaat het resultaat op in

nummer3. En je kunt de uitkomst van dat programma hier bekijken:

Figuur 11 - Vermenigvuldigen van twee getallen

Op gelijke wijze, kun je getallen van elkaar aftrekken of delen. Hier is een aftreksom:

nummer3 = nummer1 - nummer2

En het symbool voor aftrekken is ‘/’. Het programma zal er dan zo uitzien:

nummer3 = nummer1 / nummer2

en het resultaat van de deelsom is dan: Noteer date er om de getallen geen

aanhalingstekens staan. Voor getallen zijn

geen aanhalingstekens nodig. Je hebt alleen

aanhalingstekens nodig voor tekst.

Figuur 12 - Twee getallen delen

Een simpele Celcius naar Fahrenheit temperatuur omreken methode

Voor het volgende programma , gebruiken we de volgende formule ℉ = ℃ ∗5

9+ 32 om Celcius

temperaturen naar Fahrenheit temperaturen om te rekenen.

Als eerste, krijgen we de temperatuur in Celcius van de gebruiker en slaan dit op in een variabele. Er is

een speciale operatie die in staat stelt om nummers van de gebruiker te lezen en dat is

TextWindow.ReadNumber.

TextWindow.Write("Geef de temperatuur in Celcius: ")

celcius = TextWindow.ReadNumber()

als we eenmaal de temperatuur van Celcius hebben opgeslagen in een variabele, kunnen we deze

converteren naar Fahrenheit als volgt:

fahr = (celcius * 9/5) + 32

De haakje vertellen de computer om eerst celcius * 9/5 uit te rekenen en dan de rest uit te rekenen. Nu

is alles wat we nog moeten doen het resultaat als print aan de gebruikte te tonen. Dit allemaal

samenvattend, krijgen we dit programma:

TextWindow.Write("Geef de temperatuur in Celcius: ")

celcius = TextWindow.ReadNumber()

fahr = (celcius * 9/5) + 32

TextWindow.WriteLine("Temperature in Fahrenheit is " + fahr)

En het resultaat van het programma is:

Figuur 13 - Temperartuur conversie

Hoofdstuk 4

Condities en vertakkingen (Branching)

Terugkomend op ons eerste programma, zou het niet geweldig zijn dat in plaats van “Hallo Wereld”, we

goedemorgen of goedenavond kunnen zeggen, afhankelijk van de tijd van de dag? Voor ons volgende

programma, laten we de computer Goedemorgen Wereld printen als de tijd ligt voor 12:00 uur ’s

middags. En Goedemiddag wereld als het later is dan 12: 00 ‘s middags en Goedenavond Wereld als het

later is dan 18:00 uur ’s avonds.

If (Clock.Hour < 12) Then

TextWindow.WriteLine("Goedemorgen Wereld")

EndIf

If (Clock.Hour > 12) Then

TextWindow.WriteLine("Goedemiddag Wereld")

EndIf

If (Clock.Hour > 18 ) Then

Textwindow.Clear()

TextWindow.WriteLine("Goedeavond Wereld")

EndIf

Afhankelijk van wanneer je het programma uitvoert krijg je een van de volgende uitvoer:

Figuur 14 - Goedemorgen Wereld

Figuur 15 - Goedemiddag Wereld

Figuur 16 - Goedenavond Wereld

Laat ons de eerste drie regels van het programma

analyseren. Je hebt waarschijnlijk al door dat deze

regel de computer vertelt dat als de Clock.Hour

minder is als 12, hij “Goedemorgen Wereld ” print.

De woorden If, Then en EndIf zijn speciale

woorden die worden begrepen door de computer

wanneer het programma wordt uitgevoerd. Het

woord If wordt altijd gevolgd door een uitkomst

(conditie) waarna voldaan moet worden, welke in dit geval (Clock.Hour < 12). Onthoud dat de

aanhalingstekens niet nodig zijn voor getallen om jouw bedoelingen te begrijpen. De conditie wordt

gevolgd door then en de actuele operatie die wordt uitgevoerd. En na dat de operatie EndIf bereikt.

Verteld het de computer dat de conditionele uitvoer is beëindigd. Een slimmerik heeft wel door dat er

een trucje is gebruikt om maar een lijn tekst te krijgen als het later is dan 12 uur ‘s middags en ook later

is dan 6 uur. Heb jij door welk trucje dat is?

Tussen then en de EndIf, kunnen er meer dan een operatie worden uitgevoerd en de computer zal ze

allemaal uitvoeren als aan de conditie kan worden voldaan. Bijvoorbeeld, kun je iets schrijven als dit:


TextWindow.Write("Goedemorgen. ")

TextWindow.WriteLine("Hoe was het ontbijt?")

EndIf

In Small Basic, kun je het Clock object

gebruiken voor de huidige datum en tijd. Het

voorziet ook ineen boel eigenschappen

waarmee je de huidige Dag, Maand, Jaar, uur,

Minuten, Seconden onafhankelijk van elkaar

kunt krijgen.

Else In het programma aan het begin van dit hoofdstuk, zie het je misschien opgevallen dat de tweede

conditie een beetje overtollig (redundant) is. De Clock.Hour waarde kan zowel meer als minder zijn dan

12. Dus eigenlijk hoeven we dit niet voor de tweede keer te controleren. Als we dit tegenkomen ,

korten we de twee if..then..endif uitdrukkingen (statements ) door een nieuw woord , else te gebruiken.

Als we het programma opnieuw zouden schrijven met gebruik van het woord else,dan komt het er zo uit

te zien:


TextWindow.WriteLine("Goedemorgen Wereld ")

Else

TextWindow.WriteLine("Goedemiddag Wereld")

EndIf

En dit programma zal exact hetzelfde uitvoeren als het andere, wat ons een belangrijke les leert in het

programmeren:

In programmeren, zijn er vaak meerder wegen die tot hetzelfde resultaat leiden. Soms is een

manier meer voor de hand liggend om te gebruiken dan de andere. De keuze is aan jou , de

programmeur. Als je meer programma’s schrijft en meer ervaring opdoet, zullen je de

verschillen deze technieken gaan opvallen en hun voor en nadelen.

Inspringen In alle voorbeelden kun je zien hoe de statements tussen If, Else en EndIf ingesprogen zijn. Dit

inspringen is niet echt nodig. De computer zal het programma ook uitstekend begrijpen zonder dit

inspringen. Echter, helpen deze ons om het verschil en de structuur van het programma gemakkelijker

te herkennen. Vandaar, dat het een goed gebruik is om inspringen te gebruiken tussen zulke blokken.

Even of Oneven Nu we de If..Then..Else..EndIf statements in ons trukendoosje hebben zitten, laten we eens proberen

een programma te schrijven dat, gegeven een getal, ons verteld of het even of oneven getal is.

“

TextWindow.Write("Vul een nummer in: ")

getal = TextWindow.ReadNumber()

rest = Math.Remainder(getal, 2)

If (rest = 0) Then

TextWindow.WriteLine("Het getal is even")

Else

TextWindow.WriteLine("Het getal is oneven")

EndIf

En als je het programma uitvoert zie je een uitvoer als hieronder:

Figuur 1 - Even of Oneven

In dit programma , hebben we een andere bruikbare bewerking geïntroduceerd, Math.Remainder. en

zoals je wellicht al hebt uitgevonden, deelt Math.Remainder het eerste getal door het tweede getal en

geeft het rest getal weer.

Vertakking (Branching) Onthoud, in het tweede hoofdstuk leerde je dat de computer een programma statement per keer

uitvoert, in de volgorde van boven naar beneden. Echter, er is een speciaal statement waarmee je een

sprong kan maken naar een ander statement buiten de volgorde. Laten we eens kijken naar het

volgende programma.

i = 1

start:

TextWindow.WriteLine(i)

i = i + 1

If (i < 25) Then

Goto start

EndIf

Figuur 2 – Gebruik maken van Goto

In het hierboven afgebeelde programma, hebben we de waarde 1 toegekend aan de variabele i. En toen

hebben we een nieuw statement toegevoegd wat eindigt op een dubbele punt (:)

start:

Dit wordt een label genoemd . Labels zijn als bladwijzers die de computer begrijpt. Je kunt de

bladwijzer elke naam geven en je kunt zo veel bladwijzers gebruiken in jouw programma als je wenst, zo

lang ze maar een unieke naam hebben.

Een ander interessant statement hier is:

i = i + 1

Dit verteld de computer om de waarde 1 op te tellen bij de variabele i en deze waarde weer terug te

geven aan i. dus als de waarde van i voorheen 1 was voor het statement werd uitgevoerd, wordt het nu

2 nadat het statement wordt uitgevoerd.

En uiteindelijk,

If (i < 25) Then

Goto start

EndIf

Dit is het deel dat de computer verteld dat wanneer de waarde van i kleiner is dan 25, begin met het

uitvoeren (start) van statements vanaf de bladwijzer start.

Eindeloze uitvoer Door gebruik te maken van het Goto statement kun je de computer willekeurig iets vaker laten

herhalen. Bijvoorbeeld, kun je het Even of Oneven programma gebruiken en het zo als hieronder

aanpassen, en het programma zal eindeloos doorlopen. Je kunt het programma stoppen door op het

kruisje (X) te klikken rechtsboven in het uitvoerscherm.

begin:

TextWindow.Write("Voer een getal in: ")

getal = TextWindow.ReadNumber()

remainder = Math.Remainder(getal, 2)

If (remainder = 0) Then

TextWindow.WriteLine("Het getal is even")

Else

TextWindow.WriteLine("Het getal is oneven")

EndIf

Goto begin

Figuur 3 - Even of Oneven eindeloze uitvoer

Hoofdstuk 5

Loops

For Loop Laten we een programma pakken wat we in het vorige hoofdstuk hebben geschreven.

i = 1

start:


i = i + 1

If (i < 25) Then

Goto start

EndIf

Dit programma print de getallen van 1 tot 24 opvolgend af op het scherm. Dit proces van het laten

toenemen van een variabele is heel gebruikelijk in het programmeren waardoor programmeer talen

meestal een eenvoudige wijze hebben om dit voor elkaar te krijgen. Het programma hierboven is

gelijkwaardig aan het programma hieronder:

For i = 1 To 24


EndFor

En de output is:

Figuur 4 – Gebruik maken van de For Loop

Valt het je op dat we het programma in plaats van 8 lijnen naar 4 lijnen hebben vereenvoudigd, en het

nog steeds hetzelfde doet? Dit is een goed voorbeeld.

For..EndFor wordt, in programmeer termen, een loop genoemd. Het stelt je in staat om een variabele te

nemen, het een initiële (begin) waarde en een eindwaarde te geven, en laat de computer de toename in

waarde voor je uitvoeren. Elke keer dat de computer de waarde van de variabele laat toenemen, voert

het de statements uit tussen For en EndFor.

Maar wat als je zou willen dat de variabele toeneemt met de waarde 2 in plaats van 1 – als je bij wijze

van spreken alle oneven getallen tussen 1 en 24 op het scherm wilt printen, kun je de loop functie

gebruiken om dat uit te voeren.

For i = 1 To 24 Step 2


EndFor

Figuur 5 – alleen de oneven nummers

Het Step 2 (stap) deel van het For statement vertelt de computer om de waarde van i met 2 te laten

toenemen in plaats van met de gebruikelijke waarde 1. Door gebruik te maken van Step kun je elke

toename desgewenst opgeven. Je kunt zelfs een negatieve waarde voor de step opgeven en de

computer achterwaarts laten rekenen als je wilt, zoals in het voorbeeld hier beneden:

For i = 10 To 1 Step -1


EndFor

Figuur 6 – achterwaarts rekenen

While Loop De While loop is nog een andere manier van looping, die special bruikbaar is wanneer de step waarde

niet van te voren bekend is. Daar waar de For loop een vooraf gedefinieerde keer wordt uitgevoerd,

wordt de While loop uitgevoerd zolang de waarde geldig is. In het voorbeeld hier beneden, halveren we

een nummer totdat het resultaat groter dan 1 is.

getal = 100

While (getal > 1)

TextWindow.WriteLine(getal)

getal = getal / 2

EndWhile

Figuur 7 – Halveer loop

In het programma hierboven, kennen we de waarde 100 toe en voeren de loop uit net zolang de waarde

groter dan 1 is. Binnen de loop, printen we het getal en delen het door twee, halveren het feitelijk. And

zoals verwacht zijn de uitvoer van het programma die getallen die progressief gehalveerd worden achter

elkaar.

Het zal zeer lastig zijn om dit programma te schrijven door gebruik temaken van For loop, omdat we niet

weten hoeveel keer de loop zal worden uitgevoerd. Met een while loop is het gemakkelijk om te

conditie (uitkomst) te controleren en de computer te vragen om door te gaan of te stoppen met de

loop.

Het is interessant om te weten dat elke while loop

onderverdeeld kan worden een If Then

statement. Bijvoorbeeld , kan het programma

hierboven als volgt geschreven worden , zonder

het resultaat te beïnvloeden.

getal = 100

startLabel:

TextWindow.WriteLine(getal)

getal= getal / 2

If (getal > 1) Then

Goto startLabel

EndIf

In feite, schrijft de computer intern elke While

loop opnieuw in statements die gebruik maken

van If..Then met een of meer Goto

statements.

Hoofdstuk 6

Beginnen met afbeeldingen

Tot dusver in onze voorbeelden, hebben we gebruik gemaakt van TextWindow om de basisbegrippen

van de Small Basic programmeer taal uit te leggen. Echter, wordt Small Basic geleverd met een krachtige

set afbeelding capaciteiten die we nu in dit hoofdstuk zullen onderzoeken.

Introductie van GraphicsWindow Net zoals we TextWindow hebben waar we met letters en getallen kunnen werken, voorziet Small Basic

in een GraphicsWindow waarmee we tekeningen kunnen maken. Laat ons beginnen door het

GraphicsWindow te laten zien.

GraphicsWindow.Show()

Wanneer je dit programma uitvoert, zal het je opvallen dat in plaats van het gebruikelijkezwarte tekst

venster, je nu een wit Windows venster krijgt zoals hierobnder afgebeeld. Er is nog niet veel mee te

beginnen op dit dit scherm. Maar dit zal het basis venster zijn waarmee we zullen werken in dit

hoofdstuk. Je kunt het Windows venster sluiten door op de ‘X’ knop te klikken aan de rechterbovenkant

van het venster.

Figuur 8 – Een leeg afbeeldingen Windows venster

De opzet van het afbeeldingen venster Het afbeeldingen venster maakt het mogelijk om dit naar eigen smaak aan te passen. Je kunt de Titel ,

achtergrond en de grootte veranderen. Laten we verder gaan en het een beetje aanpassen, om met het

afbeeldingen venster vertrouwd te raken.

GraphicsWindow.BackgroundColor = "SteelBlue"

GraphicsWindow.Title = "Mijn afbeeldingen Windows venster"

GraphicsWindow.Width = 320

GraphicsWindow.Height = 200

GraphicsWindow.Show()

Zo ziet het aangepaste afbeeldingen Windows venster eruit. Je kunt de achtergrond aanpassen door

een van de waarden in de lijst van Appendix B. Speel maar met deze eigenschappen om te zien hoe je

kunt aanpassen hoe het venster er volgens jou uit moet zien.

Figuur 9 – Een aangepast afbeedlingen Windows venster

Het tekenen van lijnen Nu we het GraphicsWindow uitgevoerd hebben, zijn we in staat om vormen, tekst en zelfs plaatjes op

dit venster te tekenen. Laat ons starten met het tekenen van enkele eenvoudige vormen. Hier is een

programma waarmee een paar lijnen op het Graphics Window worden getekend.



GraphicsWindow.DrawLine(10, 10, 100, 100)


Figuur 10 – Kris kras

In plaats van het gebruik van de namen van de

kleur kun je ook de web kleur notatie gebruiken

(#RRGGBB). Bijvoorbeeld, #FF0000

vertegenwoordigt rood (Red) , #FFFF00

Geel(Yellow), en zo voorts. We zullen meer

leren over kleuren in Colors Appendix.

De eerste twee zinnen van te programma stellen het afbeeldingen venster in en de volgende twee

zinnen tekenen de kris kras lijnen. De eerste twee getallen achter DrawLine geven het startpunt van het

x en y coördinaat in en de en de andere twee geven de eindpunten aan van het x en y coördinaat.

Het interessante met afbeeldingen is dat de coördinaten (0,0) beginnen in de linker bovenhoek van het

venster. Als gevolg , wordt de coördinaten ruimte in het venster het 2de kwadrant genoemd.

Figuur 11 - De coördinaten map

Als we terugkeren naar ons programma, is het interessant om te weten dat Small basic het mogelijk

maakt waarmee je de waarde van de lijn zoals kleur en dikte aan kunt aanpassen. Laten we eerst de

kleur aanpassen van de lijnen zoal in het programma hier beneden.



GraphicsWindow.PenColor = "Green"


GraphicsWindow.PenColor = "Gold"


Figuur 12 – Veranderen van de lijnkleur

Laat ons nu, de afmeting ook veranderen. In het programma hier beneden , veranderen we de lijn

dikte in 10, in plaats van de standaard waarde die altijd 1 is.



GraphicsWindow.PenWidth = 10

GraphicsWindow.PenColor = "Green"


GraphicsWindow.PenColor = "Gold"


Figuur 13 – Dikke kleurvolle lijnen

PenWidth en PenColor passen de pen aan waarmee deze lijnen worden getekend. Niet alleen zijn ze van

invloed op de lijnen maar op elke vorm die getekend worden als de eigenschappen zijn gewijzigd.

Door gebruik te maken van looping statements hebben we geleerd in de voorgaande hoofdstukken, dat

we eenvoudig een programma kunnen schrijven waarmee meerder lijnen met een toenemende

pendikte kan tekenen.

GraphicsWindow.BackgroundColor = "Black"



GraphicsWindow.PenColor = "Blue"

For i = 1 To 10

GraphicsWindow.PenWidth = i

GraphicsWindow.DrawLine(20, i * 15, 180, i * 15)

endfor

Figuur 14 – Meerdere Pen diktes

Het interessante onderdeel van dit programma is de lus, waar wij, telkens wanneer de lus wordt

uitgevoerd we de waarde van de pendikte met een verhogen en een nieuw lijn tekenen onder de vorige.

Tekenen en het vullen van vormen Als het aankomt op het tekenen en vullen van vormen, zijn er Draw operations en Fill operations.

draw operations tekenen de kantlijn van de vorm door gebruik van de pen, en Fill operations schilderen

de vorm door een kwast. Bijvoorbeeld in het programma hieronder , zijn er twee rechthoeken , een

getekend met een rode pen en een geschilderd met een groene kwast.



GraphicsWindow.PenColor = "Red"

GraphicsWindow.DrawRectangle(20, 20, 300, 60)

GraphicsWindow.BrushColor = "Green"

GraphicsWindow.FillRectangle(60, 100, 300, 60)

Figuur 15 Tekenen en schilderen

Om een rechthoek te tekenen of te schilderen, heb je vier getallen nodig. De eerste twee getallen

vertegenwoordigen de X en Y coördinaten voor de linkerbovenhoek van de rechthoek. Het derde getal

geeft de breedte van de rechthoek aan en het vierde getal geeft de hoogte aan. In feite, gaat het zelfde

op voor het tekenen en schilderen van ellips vormen , zoals hier benden afgebeeld.




GraphicsWindow.DrawEllipse(20, 20, 300, 60)


GraphicsWindow.FillEllipse(60, 100, 300, 60)

Figuur 16 – Tekenen en schilderen van ellipsvormen

Ellipsvormen zijn eigenlijk een algemeen geval van cirkels. Wanneer je cirkels wilt tekenen, moet je de

zelfde breedte en hoogte opgeven.




GraphicsWindow.DrawEllipse(20, 20, 100, 100)


GraphicsWindow.FillEllipse(100, 100, 100, 100)

Figuur 17 – Cirkels

Hoofdstuk 7

Plezier met vormen

We zullen wat plezier gaan maken in dit hoofdstuk met alles wat we tot dusver hebben geleerd. Dit

hoofdstuk bevat voorbeelden die op interessante wijze aangeven hoe je al die kennis gecombineerd

kunt toepassen om er “Cool” uitziende programma’s mee te schrijven.

Rechthoeken feest Hier tekenen we meerdere rechthoeken in een loop, met een toename in afmeting.


GraphicsWindow.PenColor = "LightBlue"




GraphicsWindow.DrawRectangle(100 - i, 100 - i, i * 2, i * 2)

EndFor

Figuur 18 – Rechthoeken feest

Circel avontuur Een variant van het voorgaande programma, tekent cirkels in plaats van rechthoeken.


GraphicsWindow.PenColor = "LightGreen"




GraphicsWindow.DrawEllipse(100 - i, 100 - i, i * 2, i * 2)

EndFor

Figuur 19 – Cirkel avontuur

Willekeurig (Randomize) Dit programma gebruikt de operation GraphicsWindow.GetRandomColor om willekeurige kleuren in te

stellen voor de kwast en gebruikt daarna Math.GetRandomNumber om de x en y-coördinaten voor de

cirkels in te stellen. Deze twee operations kunnen op interessante wijze worden gecombineerd om

interessante programma’s te schrijven die elke keer als ze worden uitgevoerd verschillende uitvoer laten

zien.


For i = 1 To 1000

GraphicsWindow.BrushColor = GraphicsWindow.GetRandomColor()

x = Math.GetRandomNumber(640)

y = Math.GetRandomNumber(480)

GraphicsWindow.FillEllipse(x, y, 10, 10)

EndFor

Figuur 20 – Willekeurig (Randomize)

Fractaal1 Het volgende programma tekent een eenvoudige driehoekige fractaal door gebruikte maken van

willekeurige getallen. Een Fractaal is een geometrische vorm die kan worden onderverdeeld in

verschillende delen, die elk exact gelijk zijn aan de moedervorm. In dit geval , tekent het programma

honderden driehoekige vormen die allemaal exact gelijk zijn aan de driehoekige moedervorm. En

vanwege het feit dat het programma in enkele seconden wordt uitgevoerd, zie je de meerkleurige

vormen langzaam ontstaan. De logica erachter is niet eenvoudig te beschrijven en vraagt om wat

oefening voor jou om dat te ontdekken.

1 Een fractal, soms ook fractaal genoemd, is een meetkundige figuur die zelfgelijkend is, d.w.z.

opgebouwd is uit delen die min of meer gelijkvormig zijn met de figuur zelf.


x = 100

y = 100

For i = 1 To 100000

r = Math.GetRandomNumber(3)

ux = 150

uy = 30

If (r = 1) then

ux = 30

uy = 1000

EndIf

If (r = 2) Then

ux = 1000

uy = 1000

EndIf

x = (x + ux) / 2

y = (y + uy) / 2

GraphicsWindow.SetPixel(x, y, "LightGreen")

EndFor

Figuur 21 – Driehoekige Fractaal

Als je wilt kunnen waarnemen hoe de kleurige punten worden gevormd , kun je een vertraging in de

loop introduceren door het Proram. Delay operation te gebruiken. Deze operatie neemt een getal aan

uitgedrukt in milliseconden, hoe lang de vertraging moet gaan duren. Hieronder het aangepaste

programma met de aangepaste zin in het Vet gedrukt.


x = 100

y = 100

For i = 1 To 100000

r = Math.GetRandomNumber(3)

ux = 150

uy = 30

If (r = 1) then

ux = 30

uy = 1000

EndIf

If (r = 2) Then

ux = 1000

uy = 1000

EndIf

x = (x + ux) / 2

y = (y + uy) / 2


Program.Delay(2)

EndFor

Maak je de waarde van de vertraging groter dan zal de vertraging langer duren. Experimenteer maar

met de getallen om te zien wat het beste in de smaak valt.

Een andere modificatie die je aan het programma kunt maken is door de volgende zin te vervangen:


Met deze zin

color = GraphicsWindow.GetRandomColor()

GraphicsWindow.SetPixel(x, y, color)

Deze wijziging zorgt ervoor dat het programma de pixels van de driehoekige vormen in willekeurige

kleuren afdrukt.

Hoofdstuk 8

Turtle afbeeldingen

Logo Rond 1970s, was er een eenvoudige en toch krachtige programmeertaal , Logo genaamd die door enkele

onderzoekers werd gebruikt. Dit werd gebruikt totdat iemand iets aan de programmeertaal Logo heeft

toevoegd wat we nu “Turtle afbeeldingen” noemen. Een Turtle (Engelse woord voor schildpad)

verschijnt op het scherm en voert de respectievelijke commando’s Move Forward, Turn Right, Turn Left,

etc. uit. Door gebruik te maken van de Turtle , waren mensen in staat om interessante afbeeldingen op

het scherm te tekenen. Dit zorgde ervoor dat het programma direct in de belangstelling van mensen van

alle leeftijden kwam te staan , en was mede bepalende voor zijn bekendheid rond 1980.

Small Basic bevat ook een Turtle object met veel commando’s die kunnen worden aangeroepen binnen

Small Basic programma’s. In dit hoofdstuk gaan we de Turtle gebruiken om afbeeldingen op het scherm

te tekenen.

De Turtle (schildpad) Om te beginnen, moeten we de Turtle zichtbaar maken op het scherm. Dit kan worden bereikt een

eenvoudige zin aan het programma toe te voegen.

Turtle.Show()

Wanneer je dit programma uitvoert zul je een wit scherm net zoals in het vorige hoofdstuk zien, met als

uitzondering dat in dit scherm we een Turtle in het midden van het scherm aanwezig is. Deze Turtle zal

onze instructies gaan volgen en datgene tekenen wat het opdragen.

Figuur 22 - Turtle is zichtbaar

Verplaatsen en tekenen Een van de instructies die de Turtke begrijpt is Move (engels voor verplaatsen). Deze operatie gebruikt

een getal als input. Dit getal vertelt de Turtle hoe ver hij zich moet verplaatsen. Laten we zeggen, in het

voorbeeld hieronder, vragen we de Turtle om zichzelf 100 pixels te verplaatsen.

Turtle.Move(100)

Wanneer je dit programma uitvoert , zul je de

Turtle zichzelf langzaam 100 pixels omhoog zien

verplaatsen. Terijwl het zich verplaats zal het je

opvallen dat hij een lijn tekent achter zich aan

tekent. Wanneer de Turtle klaar is met zich

verplaatsen , zal het resultaat er uitzien als de

figuur hieronder afgebeeld.

Als we de operations gebruiken op de Turtle, is

het niet echt noodzakelijk om Show() aan te

roepen. De Turtle zal automatisch worden

neergezet en zichtbaar worden gemaakt als ere

en Turtle operation word uitgevoerd.

Figuur 23 – Verplaats honderd pixels

Een rechthoek tekenen Een rechthoek heeft vier zijden, twee verticale en twee horizontale. Om een rechthoek te tekenen

moeten in de gelegenheid zijn om de Turtle een lijn te laten tekenen, rechtsaf te laten slaan en een

andere lijn te tekenen en voort te gaan tot alle vier zijden van de rechthoek getekend zijn.

Als we dit in een programma schrijven, ziet het er zo uit.

Turtle.Move(100)

Turtle.TurnRight()

Turtle.Move(100)

Turtle.TurnRight()

Turtle.Move(100)

Turtle.TurnRight()

Turtle.Move(100)

Turtle.TurnRight()

Wanneer je dit programma uitvoert, zie je de Turtle een rechthoek tekenen, een lijn per keer, en het

resultaat lijkt op het figuur hier beneden.

Figuur 24 - Turtle tekent een rechthoek

Het zal interessant zijn om te weten dat we elke keer weer de zelfde twee instructies gebruiken – vier

keer om precies te zijn. En we hebben geleerd dat repeterende commando’s uitgevoerd kunnen worden

in een loop. Dus als we het programma van hierboven nemen en het aanpassen om gebruik te maken

van de For..EndFor loop, krijgen we uiteindelijk een eenvoudiger programma

For i = 1 To 4

Turtle.Move(100)

Turtle.TurnRight()

EndFor

Veranderen van kleur De Turtle tekent op exact hetzelfde GraphicsWindow wat we gezien hebben in het voorgaan de

hoofdstuk. Dit betekend dat alle operations die we in het voorgaande hoofdstuk hebben geleerd nog

steeds geldig zijn. Bijvoorbeeld, het volgende programma tekent een rechthoek met elke zijde in een

verschillende kleur.

For i = 1 To 4

GraphicsWindow.PenColor = GraphicsWindow.GetRandomColor()

Turtle.Move(100)

Turtle.TurnRight()

EndFor

Figuur 25 – Veranderende kleuren

Complexe vormen tekenen De Turtle, heeft buiten de TurnRight en TurnLeft operations, nog een Turn operation. Deze operation

gebruikt een input die aangeeft hoe groot de hoek moet zijn waarop de Turtle op zijn as draait. Door

gebruik te maken van deze operation, is het mogelijk elke veelhoek te tekenen. Het volgende

programma tekent een zeshoek (hexagon )een zesvoudige veelhoek.

For i = 1 To 6

Turtle.Move(100)

Turtle.Turn(60)

EndFor

Probeer dit programma om te zien of er daadwerkelijk een veelhoek wordt getekend. Observeer dat

omdat tussen de zijden de draaihoek 60 graden is, we Turn(60) gebruiken. Om zo een zeshoek te

tekenen, waarvan alle zijden gelijk zijn, kan de hoek tussen de zijden eenvoudig worden gevonden door

360 te delen door het aantal zijden. Gewapend met deze informatie en door gebruik te maken van

variabelen, kunnen we een prima generiek programma schrijven waarmee elke veelhoek kan worden

getekend.

sides = 12

length = 400 / sides

angle = 360 / sides

For i = 1 To sides

Turtle.Move(length)

Turtle.Turn(angle)

EndFor

Door gebruik te maken van dit programma, kunt u elke veelhoek tekenen door eenvoudig de sides

(zijde) variabele te wijzigen . Door hier 4 in te vullen krijgen we een vierkant waar we mee zijn gestart.

Vullen we hier een aanzienlijk groter getal in, laten we zeggen 50 is het resultaat bijna niet meer te

onderscheiden van een cirkel.

Figuur 26 – Tekenen van een 12-zijdige veelhoek

Door gebruik te maken van deze techniek die we zojuist hebben geleerd, kunnen we de Turtle meerdere

cirkels laten tekenen met een kleine verschuiving

die resulteert in een interessante uitkomst.

In programma hierboven , lieten we de Turtle

sneller gaan door de snelheid op 9 in te stellen.

Je kunt deze waarde op elke waarde tussen 1

en 10 instellen om de Turtle zo snel te laten

gaan als je zelf wilt..

sides = 50

length = 400 / sides

angle = 360 / sides

Turtle.Speed = 9

For j = 1 To 20

For i = 1 To sides

Turtle.Move(length)

Turtle.Turn(angle)

EndFor

Turtle.Turn(18)

EndFor

Het programma hierboven heeft twee For..EndFor loops, een binnen de ander. De binnenste loop (i = 1

to sides) lijkt op het veelhoek programma en is verantwoordelijk voor het tekenen van de cirkel. De

buitenste loop (j = 1 to 20) is verantwoordelijk voor een kleine draai van de Turtle voor elke cirkel die

wordt getekend. De buitenste loop vertelt de Turtle om 20 cirkels tekenen, en als deze zijn

samengesteld, laat het programma een interessant patroon zien zoals hier beneden afgebeeld.

Figuur 27 – In rondjes lopen

Bewegen Je kunt de Turtle vertellen om niet te tekenen door PenUp operatie te gebruiken. Dit laat je de Turtle

naar elke plek op het scherm verplaatsen zonder het tekenen van een lijn. Het gebruiken van PenDown

laat de Turtle weer tekenen. Dit kan worden gebruikt om interessante effecten te krijgen , laten we

zeggen een stippellijn. Hier is een programma die dit gebruikt om een gestippelde veelhoek te tekenen.

zijden = 6

length = 400 / zijden

angle = 360 / zijden

For i = 1 To zijden

For j = 1 To 6

Turtle.Move(length / 12)

Turtle.PenUp()

Turtle.Move(length / 12)

Turtle.PenDown()

EndFor

Turtle.Turn(angle)

EndFor

Ook nu weer heeft het programma twee loops. De binnenste (inner ) loop tekent een enkele

gestippelde lijn, terwijl de buitenste (outer) loop aangeeft hoe veel keer de lijnen moeten woerden

getekend. In ons voorbeeld, hebben we 6 gebruikt voor de zijden variabele en we kregen een

gestippelde zeshoek .

Figuur 28 – Gebruik maken van PenUp en PenDown

Hoofdstuk 9

Subroutines

Vaak komen we in programma’s de noodzaak tegen om keer op keer dezelfde stappenvolgorde uit te

voeren. In deze gevallen , is het vast niet raadzaam om dezelfde statements elke keer opnieuw in te

typen. Hier komen Subroutines erg van pas.

Een subroutine is een deel van de code binnen een groter programma wat normaliter iets heel

specifieks uitvoert. Subroutines worden aangeduid met een naam die achter het Sub sleutelwoord volgt

en wordt afgesloten met het EndSub sleutelwoord. Bijvoorbeeld, het volgende zinsnede

vertegenwoordigt een subroutine waarvan de naam PrintTijd is , en waarmee de huidige tijd wordt

afgedrukt op het TextWindow.

Sub PrintTijD

TextWindow.WriteLine(Clock.Time)

EndSub

Hieronder is een programma dat een subroutine bevat die vanuit verschillende plekken in het

programma worden aangeroepen.

PrintTijd()

TextWindow.Write("Geef hier jouw naam op: ")


TextWindow.Write(name + ", de tijd is nu: ")

PrintTijd()

Sub PrintTijd

TextWindow.WriteLine(Clock.Time)

EndSub

Figuur 29 – Het aanroepen van een eenvoudige Subroutine

Je voert een subroutine uit door het aanroepen van de SubroutineNaam(). Gebruikelijk, is de

punctuatie “()” nodig om de computer te vertellen dat je een subroutine wenst uit te voeren.

Voordelen van het gebruik van Subroutines Zoals we zojuist hierboven hebben kunnen zien , helpen subroutines de hoeveelheid code te

verminderen die je moet intypen. Wanneer je eenmaal de PrintTijd subroutine hebt geschreven , kun je

het aanroepen van elke plek in jouw programma en de huidige tijd laten afdrukken op het scherm.

Als toevoeging, kunnen subroutines helpen moeilijke problemen onder te verdelen in kleinere minder

moeilijke delen. Laten we zeggen dat je een moeilijke vergelijking moet oplossen, nu kun je

verschillende subroutines schrijven waarmee kleine deelproblemen van de moeilijke vergelijking worden

berekend. Daarna kun je de resultaten samenvoegen om de oplossing van de moeilijke vergelijking weer

te geven.

Subroutines kunnen ook behulpzaam zijn in het bevorderen van de leesbaarheid van een programma.

Met andere woorden, als je goed benoemde subroutines voor algemeen uitgevoerde berekeningen

delen van jouw programma gebruikt, wordt jouw programma beter leesbaar en te begrijpen. Dit is heel

belangrijk als je een programma wilt lezen en begrijpen van een ander of wanneer jouw programma

moet worden begrepen door anderen die het lezen. Soms is het zelfs behulpzaam als je jouw eigen

programma terugleest, laten we zeggen een week nadat je het hebt geschreven.

Het gebruik van variabelen Je kunt elke variabele waarde gebruiken in een programma vanuit een subroutine. Als voorbeeld,

accepteert het volgende programma twee getallen en print het hoogste getal van de twee. Noteer dat

de variabele max binnen en buiten de subroutine wordt gebruikt

TextWindow.Write("Voer het eerste getal in: ")

Getal1 = TextWindow.ReadNumber()

TextWindow.Write("voer het tweede getal in: ")

Getal2 = TextWindow.ReadNumber()

FindMax()

TextWindow.WriteLine("Het maximale getal is: " + max)

Sub FindMax

If (getal1 > getal2) Then

max = getal1

Else

max = getal2

EndIf

EndSub

En de uitvoer van het programma ziet er als volgt uit.

Figuur 30 – Maximale getal uit twee getallen via een Subroutine

Laat ons eens kijken naar een ander voorbeeld waarmee we het gebruik van subroutines willen

aangeven. Deze keer gebruiken we een grafisch programma dat verschillende punten uitrekent die het

stopt in de variabelen x en y. Daarna roept het een subroutine aan DrawCircleUsingCenter wat

verantwoordelijk is voor het tekenen van een cirkel die gebruik maakt van x en y als middelpunt.


GraphicsWindow.PenColor = "LightBlue"


For i = 0 To 6.4 Step 0.17

x = Math.Sin(i) * 100 + 200

y = Math.Cos(i) * 100 + 200

DrawCircleUsingCenter()

EndFor

Sub DrawCircleUsingCenter

startX = x - 40

startY = y - 40

GraphicsWindow.DrawEllipse(startX, startY, 120, 120)

EndSub

Figuur 31 – Grafisch voorbeeld in het gebruik van Subroutines

Aanroepen van subroutines binnen Loops Soms worden subroutines aangeroepen vanuit het binnenste van een Loop. Waarin zij dezelfde set

statements uitvoeren echter nu met de verschillende waarden in een of meer van de gebruikte

variabelen. Bijvoorbeeld , laten we zeggen dat een subroutine gebruikt die je PriemGetalTest hebt

genoemd en deze subroutine stelt vast of een getal een priemgetal is Ja of nee. Je kunt nu een

programma schrijven waarmee de gebruiker een getal mag intypen en jij kunt zeggen of het een

priemgetal is Ja of Nee, door gebruik te maken van de subroutine. Het programma hier benden

illustreert dat.

TextWindow.Write("Voer een getal in: ")

i = TextWindow.ReadNumber()

isPriemgetal = "True"

PriemGetalTest()

If (isPriemgetal = "True") Then

TextWindow.WriteLine(i + " is een priemgetal")

Else

TextWindow.WriteLine(i + " is geen priemgetal")

EndIf

Sub PriemGetalTest

For j = 2 To Math.SquareRoot(i)

If (Math.Remainder(i, j) = 0) Then

isPriemgetal = "False"

Goto EndLoop

EndIf

Endfor

EndLoop:

EndSub

De PriemGetalTest subroutine neemt de waarde van i en probeert het te delen door kleinere getallen.

Wanneer een getal i deelt en er geen rest over blijft, dan is i geen priemgetal. Op dit moment wordt de

waarde isPriemgetal op “False” gezet en sluit af. Als het getal niet meer deelbaar was door kleinere

getallen dan blijft de waarde van isPriemgetal als “True” over.

Figuur 32 – Priemgetal testen

Nu je een subroutine hebt gemaakt waarmee je de priemgetal test voor ons kunt uitvoeren, wil je

misschien een lijst maken van alle priemgetallen zeg onder de 100. Het is zeer eenvoudig om het

programma hiervoor aan te passen en de aanroep van PriemGetalTest binnen een loop te maken. Dit

zorgt ervoor dat de subroutine elke keer een andere waarde krijgt om te berekenen zodra de loop wordt

uitgevoerd. Laten we eens zien hoe dit gebeurt aan de hand van het voorbeeld hier beneden.

For i = 3 To 100

isPriemgetal = "True"

PriemGetalTest()

If (isPriemgetal = "True") Then


EndIf

EndFor

Sub PriemGetalTest

For j = 2 To Math.SquareRoot(i)

If (Math.Remainder(i, j) = 0) Then

isPriemgetal = "False"

Goto EndLoop

EndIf

Endfor

EndLoop:

EndSub

In het programma hierboven , wordt de waarde van i elke keer opgewaardeerd telkens wanneer de

loop word uitgevoerd. Binnen de loop, word een aanroep naar de subroutine PriemGetalTest gedaan.

De subroutine PriemGetalTest neemt daarna de waarde van i en berekent of i een priemgetal is. Dit

resultaat wordt opgeslagen in de variabele isPriemgetal waarna het wordt gebruikt door de loop buiten

de subroutine. De waarde van i wordt dan afgedrukt op het scherm omdat het een priemgetal betreft.

En omdat de loop vanaf het getal 3 begint en doorloopt tot 100, krijgen we een lijst met alle

priemgetallen tussen 3 en 100. Hieronder is het resultaat van het programma.

Figuur 33 – Priemgetallen

Hoofdstuk 10

Matrix (Arrays)

Nu zul je goed uitgerust zijn met kennis rond het gebruik van variabelen – je bent hier aangekomen en je

hebt er nog steeds plezier in, is het niet?

Laten we op dit moment het eerste progamma nogmaals bekijken wat we met variabelen hebben

geschreven:

TextWindow.Write("Geef jouw naam: ")



In dit programma, ontvangen en slaan we de naam op van de gebruiker in een variabele gebruiker

genaamd. Laat ons aannemen dat er meer dan een gebruiker is – zeg dat er 5 gebruikers zijn.

Maar hoe sla je nu al hun namen op? Een van de manieren is als volgt:

TextWindow.Write("Gebruiker1, voer jouw naam in: ")

name1 = TextWindow.Read()


naam2 = TextWindow.Read()







TextWindow.Write("Hallo ")

TextWindow.Write(naam1 + ", ")




TextWindow.WriteLine(naam5)

Wanneer je dit programma uitvoert krijg je het volgende resultaat:

Figuur 34 – Geen gebruik maken van een matrix

Het zou voor de hand liggen dat er een betere manier moet zijn om een dergelijk eenvoudig programma

te schrijven, is het niet? Zeker als we weten dat de computer erg krachtig is wanneer er wederkerende

taken moeten worden uitgevoerd. Waarom zouden we de moeite nemen om dezelfde code voor elke

nieuwe gebruiker opnieuw te schrijven? De truc is om meer dan een gebruikers naam op te slaan en op

te vragen gebruikmakend van dezelfde variabele. Als dat kan dan kunnen we gebruik maken van een For

loop waarover we geleerd hebben in voorgaande hoofdstukken. Hier is het gebruik van een matrix

behulpzaam.

Wat is een matrix? Een matrix is een speciale vorm van een variabele waarin meer dan een waarde per keer in kan worden

opgeslagen. Dit houd in dat we in plaats van het aanleggen van de variabelen naam1, naam2, naam3,

naam4 en naam5 om vijf gebruikersnamen in op te slaan, gebruiken we alleen naam om er alle vijf

gebruikersnamen in op te nemen. De manier waarop we meerdere variabelen kunnen opslaan is door

gebruik te maken van een zogenaamde “index”. Bijvoorbeeld , naam[1], naam[2], naam[3], naam[4] en

naam[5] kunnen elk een eigen waarde bevatten. De waarden 1,2,3,4,5 worden indices genoemd van de

matrix.

Zelfs als naam[1], naam[2], naam[3], naam[4] en naam[5] eruit zien als verschillende variabelen, zijn zij

eigenlijk één variabele. Wat is hier het voordeel van , vraag je jezelf af? Het mooie van opslaan van

variabelen in een matrix is dat je de index kunt aangeven door middel van een andere variabele –

waarmee we gemakkelijk toegang krijgen tot waarden in een matrix in een Loop.

Welnu, laat we eens kijken hoe we deze nieuwe kennis kunnen gebruiken door het voorgaand

programma te herschrijven met een matrix.

For i = 1 To 5

TextWindow.Write("Gebruiker" + i + ", geef uw naam op: ")

naam[i] = TextWindow.Read()

EndFor


For i = 1 To 5

TextWindow.Write(naam[i] + ", ")

EndFor

TextWindow.WriteLine("")

Veel gemakkelijker om te lezen, niet? Let op de twee vetgedrukte zinnen. De eerste slaat de waarde in

de matrix op en de tweede haalt de waarde op uit de matrix. De waarde in naam[1] wordt niet

beïnvloed door de waarde door wat je opslaat als waarde in naam[2]. Vandaar dat je voor algemeen

gebruik je naam[1] en naam[2] als twee verschillende variabelen kunt beschouwen met dezelfde

identiteit.

Figuur 35 – Een matrix gebruiken

Het hierboven afgebeelde programma geeft bijna dezelfde uitkomst als hetgeen zonder matrix, met als

uitzondering de komma op het eind van Mantis. We kunnen dit oplossen door de printloop als volgt te

herschrijven:


For i = 1 To 5

TextWindow.Write(naam[i])

If i < 5 Then

TextWindow.Write(", ")

EndIf

EndFor

TextWindow.WriteLine("")

Indexering van een matrix In ons vorige programma zag u dat we getallen gebruikten als indices om de waarden in op te slaan en

op te vragen uit de matrix. Blijkbaar zijn indices niet beperkt tot getallen en in de praktijk is het erg

handig om ook tekstuele indices te gebruiken. Bijvoorbeeld, in het volgende programma , vragen we om

verschillende gegevens van een gebruiker en printen dan de informatie waar hij/zij om vraagt.

TextWindow.Write("Geef uw naam op: ")

Gebruiker["naam"] = TextWindow.Read()

TextWindow.Write("Enter age: ")

Gebruiker["leeftijd"] = TextWindow.Read()

TextWindow.Write("Geef uw woonplaats op: ")

Gebruiker["stad"] = TextWindow.Read()

TextWindow.Write("Enter zip: ")

Gebruiker["postcode"] = TextWindow.Read()

TextWindow.Write("Welke informatie heeft u nodig? ")

index = TextWindow.Read()

TextWindow.WriteLine(index + " = " + Gebruiker[index])

Figuur 36 – Gebruik maken van niet-numerieke indices

Meer dan een dimensie Laten we zeggen dat je de naam en het telefoonnummer van al jouw vrienden wilt opslaan en daarna

wilt kunnen opzoeken wanneer je dat wenst – net als een telefoonboek. Hoe zouden we zo’n

programma schrijven? In dit geval, zijn er twee sets indices (ookwel bekend als de matrix dimensie) bij

betrokken. Nemen we aan dat we onze vrienden identificeren aan een de hand van een koosnaam. Dit

wordt de eerste index in onze matrix. Wanneer we de eerste index gebruiken om de vriend variabele te

achterhalen, de tweede set van indices , naam en telefoon helpen ons om de actuele naam en

telefoonnummer van deze vriend of vriendin te achterhalen.

De manier waarop we deze gegevens opslaan is als volgt:

vrienden["Rob"]["Naam"] = "Robert"

vrienden["Rob"]["Telefoon"] = "012-3456789"

vrienden["VJ"]["Naam"] = "Vijaye"

vrienden["VJ"]["Telefoon"] = "012-9456783"

vrienden["Ash"]["Naam"] = "Ashley"

vrienden["Ash"]["Telefoon"] = "014-3256789"

Omdat we een twee indices hebben op dezelfde matrix , vrienden, wordt deze matrix een

tweedimensionale matrix genoemd.

Nadat we dit programma hebben geladen , kunnen we de koosnaam als invoer voor een vriend nemen

en die informatie op het scherm printen die we van hen hebben opgeslagen. Hieronder het programma

wat dat uitvoert:

vrienden["Rob"]["Naam"] = "Robert"

vrienden["Rob"]["Telefoon"] = "012-3456789"

vrienden["VJ"]["Naam"] = "Vijaye"

vrienden["VJ"]["Telefoon"] = "012-9456783"

vrienden["Ash"]["Naam"] = "Ashley"

vrienden["Ash"]["Telefoon"] = "014-3256789"

TextWindow.Write("Geef de koosnaam op: ")

koosnaam = TextWindow.Read()

TextWindow.WriteLine("Naam: " + vrienden[koosnaam]["Naam"])

TextWindow.WriteLine("Telefoon: " + vrienden[koosnaam]["Telefoon"])

Figuur 37 – een eenvoudig telefoonboek

Gebruik maken van matrices om roosters voor te stellen Een veelvoudig gebruik van Multi dimensionale matrices dient als voorstelling van roosters/tabellen.

Roosters hebben rijen en kolommen, die mooi passen in een twee dimensionale matrix. Een eenvoudig

programma dat vierkantjes in een rooster plaatst vindt je hier beneden:

rows = 8

columns = 8

size = 40

For r = 1 To rows

For c = 1 To columns


boxes[r][c] = Shapes.AddRectangle(size, size)

Shapes.Move(boxes[r][c], c * size, r * size)

EndFor

EndFor

Dit programma voegt rechthoeken toe en positioneert hen in een 8x8 rooster. Bovendien slaat het

boven op de plaatsing van de rechthoeken deze ook op in een matrix. Hierdoor wordt het vinden van de

rechthoeken en hergebruik gemakkelijker.

Figuur 38 – Lay-out van rechthoeken in een rooster

Bijvoorbeeld, door het toevoegen van de volgende code aan het eind van het programma , verplaatsen

alle rechthoeken in het rooster zich naar de linkerbovenhoek.

For r = 1 To rows

For c = 1 To columns

Shapes.Animate(boxes[r][c], 0, 0, 1000)

Program.Delay(300)

EndFor

EndFor

Figuur 39 – Bijhouden van rechthoeken in een rooster

Hoofdstuk 11

Gebeurtenissen en Interactiviteit

In de eerste twee hoofdstukken, hebben we objecten geïntroduceerd die beschikken over

eigenschappen en bewerkingen. Als toevoeging op eigenschappen en bewerkingen hebben sommige

objecten ook wat we Gebeurtenis (Event) noemen. Gebeurtenissen( Events) lijken op signalen die

opgeworpen worden, bijvoorbeeld, als antwoord op acties van gebruikers, zoals het verplaatsen van de

muis of een muisklik. Je zou kunnen zeggen dat een gebeurtenis tegenovergesteld is aan een

bewerking. Jij als programmeur benoemt de bewerking om de computer iets uit te voeren, terwijl in het

geval van een gebeurtenis de computer jou laat weten dat er iets interessants heeft plaatsgevonden.

Hoe gebruiken we gebeurtenis? Gebeurtenissen (Events) zijn belangrijk bij het introduceren van interactiviteit in een programma. Als je

de gebruiker wilt toestaan om interactief om te gaan starten met jouw programma, zul je een

gebeurtenis gebruiken. Laten we zeggen , je maakt een boter, kaas en eierenspel. Dan wil je dat de

gebruiker zijn/haar spel kan beginnen, toch? Hier is waar gebeurtenissen zich aandienen- je ontvangt

gebruikersinvoer vanuit jouw programma door gebruik te maken van gebeurtenissen.(Events)

Het lijkt misschien moeilijk te bevatten, maar maak je geen zorgen, we nemen een kijkje in een

eenvoudig voorbeeld waarmee je geholpen wordt om te begrijpen wat gebeurtenissen zijn en hoe zij

gebruikt kunnen worden.

Hieronder staat een eenvoudig programma wat uit een statement en een subroutine bestaat. De

subroutine gebruikt de ShowMessage bewerking op het GraphicsWindow object om een boodschap

blokje aan de gebruiker te laten zien.

GraphicsWindow.MouseDown = OnMouseDown

Sub OnMouseDown

GraphicsWindow.ShowMessage("Je hebt op de muis geklikt.", "Hallo")

EndSub

Het interessante deel in het programma om te begrijpen is de zin waar we de subroutine naam

toekennen aan de MouseDown gebeurtenis van het GraphicsWindow object. Het zal je opvallen dat

MouseDown veel lijkt op een eigenschap – met als uitzondering dat in plaats van een waarde

toekennen, kennen we de subroutine OnMouseDown eraan toe. Dat maakt gebeurtenissen zo speciaal

– wanneer er gebeurtenissen plaatsvinden, wordt de subroutine automatisch aangeroepen. In dit geval ,

wordt de subroutine OnMouseDown elke keer aangeroepen wanneer de gebruiker op de muisknop

klikt, binnen het GraphicsWindow. Ga je gang, en voer het programma uit en probeer het eens. Elke

keer je op de muisknop klikt in het GraphicsWindow venster , zie je een boodschappen blokje

verschijnen net als op het plaatje hier beneden.

Figuur 40 – Respons op een gebeurtenis

Deze vorm van gebeurtenis afhandeling is zeer krachtig en geeft de mogelijkheden voor zer creatieve en

interessante programma’s. Programma’s die op deze manier geschreven zijn noemen we gebeurtenis

gedreven programmatuur (Event-Driven)

Je kunt de subroutine OnMouseDown andere dingen laten doen als het laten zien van een

boodschappen tekstblok. Bijvoorbeeld, net als in het programma hieronder, kun je blauwe punten

tekenen waar de gebruiker de muis aanklikt.

GraphicsWindow.BrushColor = "Blue"


Sub OnMouseDown

x = GraphicsWindow.MouseX - 10

y = GraphicsWindow.MouseY - 10


EndSub

Figuur 41 – Afhandeling Mouse Down Gebeurtenissen

Noteer dat in het programma hierboven , we MouseX en MouseY gebruiken om de muis coördinaten te

krijgen. Daarna gebruiken we deze om een cirkel te tekenen met de muis coördinaten als middelpunt.

Afhandeling van meerdere gebeurtenissen Er zijn geen beperkingen aan hoeveel gebeurtenissen je wenst af te handelen. Je kunt zelfs een

subroutine hebben waarin je meerdere gebeurtenissen afhandelt. Echter, je kunt gebeurtenis maar één

keer afhandelen, als je probeert twee subroutines aan dezelfde gebeurtenis toe te kennen , dan wint de

tweede.

Om dit duidelijk te maken , nemen we het vorige voorbeeld en voegen een subroutine toe , waarmee

we toetsindrukken afhandelen. Laten we ook deze nieuwe subroutine de kleur van de kwast wijzigen ,

waardoor je een verschillende gekleurde punt krijgt.

GraphicsWindow.BrushColor = "Blue"


GraphicsWindow.KeyDown = OnKeyDown

Sub OnKeyDown


EndSub

Sub OnMouseDown

x = GraphicsWindow.MouseX - 10

y = GraphicsWindow.MouseY - 10


EndSub

Figuur 42 – afhandelen van meerdere gebeurtenissen

Als je het programma hebt uitgevoerd en op het scherm hebt geklikt, krijg je een blauwe punt. Wanneer

je nu op een toets drukt en nogmaals klikt, krijg je een andere kleur. Wat er gebeurt is dat wanneer je

een toets indrukt de subroutine OnKeydown wordt uitgevoerd waardoor de kleur willekeurig wordt

gewijzigd. Hierna wordt er wanneer je de muisknop klit een cirkel getekend, gebruik makend van de ze

nieuwe kleur. Zo worden er willekeurige kleuren gevormd.

Een teken programma Uitgerust met gebeurtenissen en subroutines, kunnen we nu een programma schrijven waarmee

gebruikers op het scherm kunnen tekenen. Het is verassend eenvoudig om zo een programma te

schrijven, vooropgesteld dat er het probleem onderverdelen in kleinere delen. Als eerste stap , schrijven

wen een programma waarmee de gebruiker instaat is om de muis overal op het GraphicsWindows

scherm te plaatsen, een spoor achterlatend wanneer ze de muis bewegen.

GraphicsWindow.MouseMove = OnMouseMove

Sub OnMouseMove

x = GraphicsWindow.MouseX

y = GraphicsWindow.MouseY

GraphicsWindow.DrawLine(prevX, prevY, x, y)

prevX = x

prevY = y

EndSub

Echter als je dit programma uitvoert, start de eerste lijn altijd van de linker bovenhoek van het venster

(0,0). Dit kunnen we oplossen door het afhandelen van de MouseDown gebeurtenis en het opvangen

deze waarden in prevX en prevY wanneer de gebeurtenis plaatsvindt.

Ook hebben we alleen het spoor nodig als de gebruiker de muisknop ingedrukt heeft. Anders zouden we

de lijn niet tekenen. Om dit gedrag te krijgen, gebruiken we de IsLeftButtonDown eigenschap van het

Mouse muisobject. Deze eigenschap verteld wanneer de linkermuisknop is ingedrukt of niet. Wanneer

deze waarde waar is , tekenen we de lijn, anders slaan we deze lijn over.



Sub OnMouseDown

prevX = GraphicsWindow.MouseX

prevY = GraphicsWindow.MouseY

EndSub

Sub OnMouseMove

x = GraphicsWindow.MouseX

y = GraphicsWindow.MouseY

If (Mouse.IsLeftButtonDown) Then

GraphicsWindow.DrawLine(prevX, prevY, x, y)

EndIf

prevX = x

prevY = y

EndSub

Appendix A

Fun voorbeelden

Turtle Fractal

Figuur 43 - Turtle tekent een boom fractal

angle = 30

delta = 10

distance = 60

Turtle.Speed = 9


GraphicsWindow.PenColor = "LightGreen"

TekenBoom()

Sub TekenBoom

If (distance > 0) Then

Turtle.Move(distance)

Turtle.Turn(angle)

Stack.PushValue("distance", distance)

distance = distance - delta

TekenBoom()

Turtle.Turn(-angle * 2)

TekenBoom()

Turtle.Turn(angle)

distance = Stack.PopValue("distance")

Turtle.Move(-distance)

EndIf

EndSub

Foto’s van Flickr

Figuur 44 – Ophalen van afbeeldingen van Flickr



Sub OnMouseDown

pic = Flickr.GetRandomPicture("mountains, river")

GraphicsWindow.DrawResizedImage(pic, 0, 0, 640, 480)

EndSub

Dynamische bureaublad achtergrond

For i = 1 To 10

pic = Flickr.GetRandomPicture("mountains")

Desktop.SetWallPaper(pic)

Program.Delay(10000)

EndFor

Paddle Spel

Figuur 45 - Paddle Spel

GraphicsWindow.BackgroundColor = "DarkBlue"

paddle = Shapes.AddRectangle(120, 12)

ball = Shapes.AddEllipse(16, 16)


x = 0

y = 0

deltaX = 1

deltaY = 1

RunLoop:

x = x + deltaX

y = y + deltaY

gw = GraphicsWindow.Width

gh = GraphicsWindow.Height

If (x >= gw - 16 or x <= 0) Then

deltaX = -deltaX

EndIf

If (y <= 0) Then

deltaY = -deltaY

EndIf

padX = Shapes.GetLeft (paddle)

If (y = gh - 28 and x >= padX and x <= padX + 120) Then

deltaY = -deltaY

EndIf

Shapes.Move(ball, x, y)

Program.Delay(5)

If (y < gh) Then

Goto RunLoop

EndIf

GraphicsWindow.ShowMessage("Je hebt Verloren", "Paddle")

Sub OnMouseMove

paddleX = GraphicsWindow.MouseX

Shapes.Move(paddle, paddleX - 60, GraphicsWindow.Height - 12)

EndSub

Appendix B

Kleuren

Hier is een lijst met benoemde kleuren die in Small Basic worden ondersteund, gecategoriseerd door

middel van hun basis tint.

Rode kleuren

IndianRed #CD5C5C

LightCoral #F08080

Salmon #FA8072

DarkSalmon #E9967A

LightSalmon #FFA07A

Crimson #DC143C

Red #FF0000

FireBrick #B22222

DarkRed #8B0000

Roze Kleuren

Pink #FFC0CB

LightPink #FFB6C1

HotPink #FF69B4

DeepPink #FF1493

MediumVioletRed #C71585

PaleVioletRed #DB7093

Oranje Kleuren

LightSalmon #FFA07A

Coral #FF7F50

Tomato #FF6347

OrangeRed #FF4500

DarkOrange #FF8C00

Orange #FFA500

Gele kleuren

Gold #FFD700

Yellow #FFFF00

LightYellow #FFFFE0

LemonChiffon #FFFACD

LightGoldenrodYellow #FAFAD2

PapayaWhip #FFEFD5

Moccasin #FFE4B5

PeachPuff #FFDAB9

PaleGoldenrod #EEE8AA

Khaki #F0E68C

DarkKhaki #BDB76B

Purper kleuren

Lavender #E6E6FA

Thistle #D8BFD8

Plum #DDA0DD

Violet #EE82EE

Orchid #DA70D6

Fuchsia #FF00FF

Magenta #FF00FF

MediumOrchid #BA55D3

MediumPurple #9370DB

BlueViolet #8A2BE2

DarkViolet #9400D3

DarkOrchid #9932CC

DarkMagenta #8B008B

Purple #800080

Indigo #4B0082

SlateBlue #6A5ACD

DarkSlateBlue #483D8B

MediumSlateBlue #7B68EE

Groene kleuren

GreenYellow #ADFF2F

Chartreuse #7FFF00

LawnGreen #7CFC00

Lime #00FF00

LimeGreen #32CD32

PaleGreen #98FB98

LightGreen #90EE90

MediumSpringGreen #00FA9A

SpringGreen #00FF7F

MediumSeaGreen #3CB371

SeaGreen #2E8B57

ForestGreen #228B22

Green #008000

DarkGreen #006400

YellowGreen #9ACD32

OliveDrab #6B8E23

Olive #808000

DarkOliveGreen #556B2F

MediumAquamarine #66CDAA

DarkSeaGreen #8FBC8F

LightSeaGreen #20B2AA

DarkCyan #008B8B

Teal #008080

Blauwe kleuren

Aqua #00FFFF

Cyan #00FFFF

LightCyan #E0FFFF

PaleTurquoise #AFEEEE

Aquamarine #7FFFD4

Turquoise #40E0D0

MediumTurquoise #48D1CC

DarkTurquoise #00CED1

CadetBlue #5F9EA0

SteelBlue #4682B4

LightSteelBlue #B0C4DE

PowderBlue #B0E0E6

LightBlue #ADD8E6

SkyBlue #87CEEB

LightSkyBlue #87CEFA

DeepSkyBlue #00BFFF

DodgerBlue #1E90FF

CornflowerBlue #6495ED

MediumSlateBlue #7B68EE

RoyalBlue #4169E1

Blue #0000FF

MediumBlue #0000CD

DarkBlue #00008B

Navy #000080

MidnightBlue #191970

Bruine kleuren

Cornsilk #FFF8DC

BlanchedAlmond #FFEBCD

Bisque #FFE4C4

NavajoWhite #FFDEAD

Wheat #F5DEB3

BurlyWood #DEB887

Tan #D2B48C

RosyBrown #BC8F8F

SandyBrown #F4A460

Goldenrod #DAA520

DarkGoldenrod #B8860B

Peru #CD853F

Chocolate #D2691E

SaddleBrown #8B4513

Sienna #A0522D

Brown #A52A2A

Maroon #800000

Witte kleuren

White #FFFFFF

Snow #FFFAFA

Honeydew #F0FFF0

MintCream #F5FFFA

Azure #F0FFFF

AliceBlue #F0F8FF

GhostWhite #F8F8FF

WhiteSmoke #F5F5F5

Seashell #FFF5EE

Beige #F5F5DC

OldLace #FDF5E6

FloralWhite #FFFAF0

Ivory #FFFFF0

AntiqueWhite #FAEBD7

Linen #FAF0E6

LavenderBlush #FFF0F5

MistyRose #FFE4E1

Grijze kleuren

Gainsboro #DCDCDC

LightGray #D3D3D3

Silver #C0C0C0

DarkGray #A9A9A9

Gray #808080

DimGray #696969

LightSlateGray #778899

SlateGray #708090

DarkSlateGray #2F4F4F

Black #000000

Introductie Small Basic

Documents

Transcript of Introductie Small Basic