# &kturtle;s naslagwerk voor programmeren met &logo;

## Commando's

Met behulp van commando's vertel je de schildpad of &kturtle; om iets te doen. Sommige commando's vragen om een invoer, anderen geven een uitvoer. In deze sectie zullen we alle commando's die in &kturtle; kunnen worden gebruikt aan je uitleggen.

### De schildpad voortbewegen

Er zijn verschillende commando's waarmee je de schildpad over het scherm kunt bewegen.

vooruit

-     vooruit X

  `vooruit` verplaatst de schildpad vooruit met het X pixels. Als de pen omlaag staat zal de schildpad een spoor achterlaten. `vooruit` kun je afkorten als `vt`.

achteruit

-     achteruit X

  `achteruit` verplaatst de schildpad achteruit met X pixels. Als de pen omlaag staat zal de schildpad een spoor achterlaten. `achteruit` kun je afkorten als `at`.

draailinks

-     draailinks X

  `draailinks` laat de schildpad X graden naar links draaien. `draailinks` kun je afkorten als `dl`.

draairechts

-     draairechts X

  `draairechts` laat de schildpad X graden naar rechts draaien. `draairechts` kun je afkorten als `dr`.

richting

-     richting X

  `richting` zet de richting van de schildpad op X graden, geteld vanaf 0. Dus niet vanuit de vorige positie van de schildpad. `richting` kun je afkorten als `rt`.

thuis

-     thuis

  `thuis` zet de schildpad in het midden van het canvas.

ganaar

-     ganaar X,Y

  `ganaar` laat de schildpad naar een bepaalde plek op het canvas gaan. De plek ligt X pixels vanaf de linkerkant en Y pixels vanaf de bovenkant van het canvas. Opmerking: het commando `ganaar` laat de schildpad geen lijn tekenen.

ganaarx

-     ganaarx X

  `ganaarx` laat de schildpad naar een positie gaan die X pixels vanaf de linkerkant van het canvas ligt. De hoogte blijft hetzelfde. `ganaarx` kun je afkorten als `gx`.

ganaary

-     ganaary Y

  `ganaary` laat de schildpad naar een positie gaan die Y pixels vanaf de bovenkant van het canvas ligt. De afstand vanaf de linkerkant van het canvas blijft hetzelfde. `ganaary` kun je afkorten als `gy`.

### De schildpad heeft een pen

De schildpad heeft een pen die een lijn tekent als de schildpad beweegt. Er zijn een aantal commando's die de pen bedienen. In deze sectie leggen we deze commando's uit.

penop

-     penop

  `penop` tilt de pen van het canvas. Als de pen omhoog is, dan wordt er geen lijn getekend als de schildpad loopt. Kijk ook bij `penneer`. `penop` kun je afkorten als `po`.

penneer

-     penneer

  `penneer` zet de pen op het canvas. Als de pen op het canvas drukt, dan wordt er een lijn getekend als de schildpad loopt. Zie ook `penop`. `penneer` kun je afkorten als `pn`.

pendikte

-     pendikte X

  `pendikte` zet de dikte van de pen (de breedte van de lijn) op X pixels. `pendikte` kun je afkorten als `pd`.

penkleur

-     penkleur R,G,B

  `penkleur` bepaalt de kleur van de pen. `penkleur` vraagt om een RGB-combinatie als invoer. `penkleur` kun je afkorten als `pk`.

### Commando's om het canvas te bedienen

Er zijn verschillende commando's waarmee je het canvas kunt veranderen.

canvasmaat

-     canvasmaat X,Y

  Met `canvasmaat` kun je de grootte van het canvas veranderen. Het commando vraagt om X en Y als invoer. X is de nieuwe breedte in pixels en Y is de nieuwe hoogte van het canvas in pixels. `canvasmaat` kun je afkorten als `cm`.

canvaskleur

-     canvaskleur R,G,B

  Met `canvaskleur` kun je de kleur van het canvas veranderen. `canvaskleur` vraagt om een RGB-combinatie als invoer. `canvaskleur` kun je afkorten als `ck`.

wikkelaan

-     wikkelaan

  Met het commando `wikkelaan` kun je het wikkelen van het canvas aanzetten. Kijk in het woordenboek van dit handboek wat wikkelen is.

wikkeluit

-     wikkeluit

  Met het commando `wikkeluit` kun je het wikkelen van het canvast uitzetten. Dit betekent dat de schildpad het canvas kan verlaten en kan verdwalen. Kijk in het woordenboek van dit handboek voor meer informatie over wikkelen.

### Commando's om schoon te maken

Er zijn twee commando's waarmee je het canvas kunt schoonmaken nadat je er een bende van hebt gemaakt.

schoon

-     schoon

  Met `schoon` kun je alle tekeningen op het canvas wissen. De rest blijft staan, de positie en hoek van de schildpad, de kleur van het canvas, de zichtbaarheid van de schildpad en de grootte van het canvas blijven zoals ze waren. `schoon` kun je afkorten als `cs`.

alsnieuw

-     alsnieuw

  `alsnieuw` maakt nog verder schoon dan het commando `schoon`. Na het commando `alsnieuw` is alles zoals het was toen je &kturtle; net had opgestart. De schildpad wordt in het midden van het scherm gezet, de canvaskleur is wit en de schildpad tekent een zwarte lijn op het canvas.

### De schildpad is een sprite

Vrijwel niemand weet wat sprites zijn, dus volgt hier een korte uitleg: sprites zijn kleine plaatjes die je kunt rondbewegen op het scherm (voor meer info, kijk in het woordenboek van dit handboek bij sprites). Dus de schildpad is een sprite!

Hierna volgt een volledig overzicht van alle commando's die je kunt gebruiken bij sprites.

(De huidige versie van &kturtle; heeft alleen een schildpad als sprite. Andere sprites kun je dus niet gebruiken. In toekomstige versies van het programma zul je de schildpad kunnen veranderen je eigen ontwerp!)

toon

-     toon

  `toon` maakt de schilpad weer zichtbaar nadat hij is verborgen. `toon` kun je afkorten als `ts`.

verberg

-     verberg

  `verberg` verstopt de schildpad. Dit is handig als je de schildpad niet in je tekening wilt zien. `verberg` kun je afkorten als `vs`.

### Kan de schildpad tekst schrijven?

Het antwoord is: ja. De schildpad kan schrijven. Hij schrijft zo'n beetje alles waartoe je hem opdraagt.

schrijf

-     schrijf X

  Het commando `schrijf` kun je gebruiken om de schildpad iets op het canvas te laten schrijven. `schrijf` vraagt om letters en/of cijfers als invoer. Je kunt automatisch verschillende getallen en tekst laten `invullen` in de tekst met behulp van het +-symbool. Hier is een klein voorbeeld:

      jaar = 2004
      maker = "Cies"
      schrijf "KTurtle is gemaakt in " + jaar + " door " + maker +

lettermaat

-     lettermaat X

  `lettermaat` bepaalt de grootte van de letters die wordt gebruikt door het commando `schrijf`. `lettermaat` vraagt om een getal als invoer. De grootte geef je op in pixels.

### Een commando dat een dobbelsteen voor je rolt

Er is een commando dat een dobbelsteen voor je laat rollen

gok

-     gok X,Y

  `gok` is een commando dat invoer vraagt en uitvoer geeft. Als invoer vraagt het commando twee cijfers, het eerste cijfer (X) zet de minimum uitvoer, en het tweede (Y) zet de maximum. De uitvoer is een willekeurig gekozen getal dat gelijk is aan of groter dan het minimum en gelijk aan of kleiner dan het maximum. Hier is een klein voorbeeld:

      herhaal 500 [
       x = gok 1,20
       vooruit x
       draailinks 10 - x
      ]

  . Met het commando `gok` kun je wat chaos aan je programma toevoegen.

## Containers

Containers zijn letters of woorden die door de programmeur kunnen worden gebruikt om een getal of tekst in op te slaan. Containers die een getal bevatten heten variabelen, containers die tekst bevatten heten tekenreeksen.

Containers die niet worden gebruikt staan standaard op 0. Een voorbeeld:

    schrijf N

Dit drukt een 0 af.

### Variabelen: getalcontainers

Laten we beginnen met een voorbeeld:

    x = 3
    schrijf x

Op de eerste regel wordt de letter `x` omgevormd tot een variabele (getalcontainer). Zoals je ziet is de waarde van de variabele `x` op 3 gezet. Op de tweede regel wordt de waarde afgedrukt.

Merk op dat als we een x wouden afdrukken, we het volgende hadden geschreven:

    schrijf "x"

Dat was gemakkelijk. Nu een wat moeilijker voorbeeld:

    A = 2004
    B = 25
    AB = A + B

    # het volgende commando schrijft "2029"
    schrijf AB
    achteruit 30
    # het volgende commando schrijft "2004 plus 25"
    schrijf "" +  A + " plus " + B
    achteruit 30
    # het volgende commando schrijft "1979"
    schrijf A - B

Op de eerste twee regels zijn de variabelen `A` en `B` gezet op 2004 en 25. Op de derde regel is de variabele `AB` gezet op `A + B`, wat 2029 is. De rest van het voorbeeld bestaat uit 3 `schrijf`-commando's met `achteruit 30` ertussen. De `achteruit` staat er om er voor te zorge dat elke uitvoer op een nieuwe regel staat. In dit voorbeeld zie je dat variabelen kunnen worden gebruikt in wiskundige berekeningen.

### Tekenreeksen: tekstcontainers

Tekenreeksen lijken veel op variabelen. Het grootste verschil is dat je tekenreeksen niet kunt gebruiken in wiskundige berekeningen e vragen. Een voorbeeld van het gebruiken tekenreeksen:

    x = " Hallo "
    naam = invoervenster "Voer je naam in..."
    schrijf x + naam +", hoe gaat het met je?

Op de eerste regel wordt `x` ingesteld op Hallo . Op de tweede regel wordt de term `naam` ingesteld op de uitvoer van het commando `invoervenster`. Op de derde regel schrijft het programma een samenstelling van drie tekenreeksen op het canvas.

Dit programma vraagt je om je naam in te voeren. Als je bijvoorbeeld de naam Paul invoert, dan schrijft het programma Hallo Paul, hoe gaat het met je?. Houd er rekening mee dat de plus (+) het enige rekenkundige teken is dat je kunt gebruiken met tekenreeksen.

## Kan de schildpad wiskunde?

Ja, &kturtle; kan jouw wiskunde voor je doen. Je kunt optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/). Dit is een voorbeeld die ze allemaal gebruikt:

    a = 20 - 5
    b = 15 * 2
    c = 30 / 30
    d = 1 + 1
    schrijf "a: "+a+", b: "+b+", c: "+c+", d: "+d

Weet je welke waarde a, b, c, en d hebben?

Als je een eenvoudige rekensom wilt uitvoeren, dan kun je zoiets als dit doen:

    schrijf 2004-12

Nu een voorbeeld met haakjes:

    schrijf ( ( 20 - 5 ) ) * 2 / 30 ) + 1

De rekensom tussen de haakjes zal als eerste worden uitgerekend. In dit voorbeeld wordt 20 gedeeld door 5,

## Stel vragen en krijg antwoorden...

`als` en `terwijl` zijn uitvoercontroles die we in de volgende sectie zullen bespreken. In deze sectie gaan we het commando `als` gebruiken om vragen uit te leggen.

Een voorbeeld van vragen:

    x = 6
    als x > 5 [
     schrijf "hallo"
    ]

In dit voorbeeld is de vraag het gedeelte `x > 5`. Als het antwoord op deze vraag waar is, dan wordt de code tussen de blokhaakjes uitgevoerd. vragen zijn een belangrijk onderdeel van programmeren en vaak gebruikt in combinatie met uitvoercontroles, zoals `als`. Alle cijfers en variabelen (getalcontainers) kunnen met elkaar worden vergeleken met vragen.

Hier zijn alle mogelijke vragen:

## Type vragen

`a == b` | gelijk aan | het antwoord is waar als `a` gelijk is aan `b`
`a != b` | niet gelijk aan | het antwoord is waar als `a` niet gelijk is aan `b`
`a > b` | groter dan | het antwoord is waar als `a` groter is dan `b`
`a < b` | kleiner dan | het antwoord is waar als `a` kleiner is dan `b`
`a >= b` | groter dan of gelijk aan | het antwoord is waar als `a` groter is dan `b`
`a <= b` | kleiner dan of gelijk aan | het antwoord is waar als `a` kleiner is dan of gelijk aan `b`

Vragen kunnen ook aan elkaar geplakt worden met vragenlijm. Zo kun je van een paar kleine vragen een grote vraag maken.

    a = 1
    b = 5
    als a < 5 en b == 5 [
     schrijf "hallo"
    ]

In dit voorbeeld is het lijmwoord `en` gebruikt om twee vragen (`a < 5`, `b == 5`) aan elkaar te plakken. Als een zijde van de `en` onwaar als antwoord heeft, dan zal de hele vraag onwaar zijn, omdat het lijmwoord `en` vereist dat beide zijden waar moeten zijn om het antwoord waar te geven.

`en` is niet het enige lijmwoord, er zijn nog twee. Ze staan alle drie in onderstaand tabel:

## Lijmwoorden voor vragen

`en` | beide zijden moeten waar zijn om het antwoord waar te kunnen geven
`of` | als een van beide zijden waar is, dan is het antwoord waar
`niet` | alleen als beide zijden onwaar zijn is het antwoord onwaar

## Uitvoering besturen

De uitvoercontroles maken het mogelijk, —zoals de naam al zegt— om controle uit te oefenen op de uitvoering van de commando's

### Laat de schildpad wachten

Als je wat hebt geprogrammeerd in &kturtle;, dan heb je vast gemerkt dat de schildpad erg snel is bij het tekenen. Dit commando maakt de schildpad een beetje rustiger.

wacht

-     wacht X

  `wacht` laat de schildpad X seconden wachten.

      herhaal 36[
       vooruit 5
       draairechts 10
       WACHT 0.5
      ]

  Deze code tekent een cirkel, maar de schildpad zal na elke stap een halve seconde wachten. Hier door lijkt het net of de schildpad kruipt.

### "als" uitvoeren

als

-     als vraag [ ... ]

  De code die tussen de blokhaakjes staat wordt alleen uitgevoerd wanneer `als` het antwoord op de vraag waar is. Lees voor meer informatie over vragen het vragengedeelte.

      x = 6
      als x > 5 [
       schrijf "x is groter dan vijf!"
      ]

  Op de eerste regel is `x` gezet op 6. Op de tweede regel wordt de vraag `x > 5` gesteld. Omdat het antwoord op deze vraag waar is zal de uitvoercontrole `als` de code tussen de haakjes laten uitvoeren.

### "terwijl" uitvoeren

terwijl

-     terwijl vraag [ ... ]

  De uitvoercontrole `terwijl` lijkt veel op als``. Het verschil is dat `terwijl` de code tussen de blokhaakjes blijft herhelen totdat de het antwoord op de vraag onwaar is.

      x = 1
      terwijl x < 5 [
       vooruit 10
       wacht 1
       x = x + 1
      ]

  Op de eerste regel is `x` gezet op 1. Op de tweede regel wordt de vraag `x < 5` gesteld. Omdat het antwoord op deze vraag waar is start de uitvoercontrole `terwijl` het uitvoeren van de code tussen de blokhaakjes totdat het antwoord op de vraag onwaar is. In dit voorbeeld wordt de code tussen de blokhaakjes 4 keer uitgevoerd, omdat telkens als de vijfde regel wordt uitgevoerd de waarde `x` met 1 wordt vermeerderd.

### Als niet, of in andere woorden: "anders"

anders

-     als vraag [ ... ] anders [ ... ]

  `anders` kan worden gebruikt als aanvulling op de uitvoercontrole `als`. De code tussen de haakjes na `anders` wordt alleen uitgevoerd als het antwoord op de gestelde vraag onwaar is.

      x = 4
      als x > 5 [
       schrijf "x is groter dan vijf!"
      ] anders [
       schrijf "x is kleiner dan zes!"
      ]

  De vraag vraagt of `x` groter is dan 5. Omdat `x` op 4 is gezet op de eerste regel ishet antwoord op de vraag onwaar. Dit betekent dat de code tussen de blokhaakjes achter `anders` zal worden uitgevoerd.

### De lus "voor"

voor

-     voor startpunt tot eindpunt [ ... ]

  De lus `voor` is een tellende lus, dus het houdt de telling voor je bij.

      voor x = 1 tot 10 [
       schrijf x * 7
       vooruit 15
      ]

  Telkens als de code tussen de blokhaakjes wordt uitgevoerd wordt de waarde `x` met 1 vermeerderd, totdat `x` de 10 heeft bereikt. De code tussen de blokhaakjes schrijft de `x` vermenigvuldigd met 7. Nadat deze commando's zijn uitgevoerd zie je de tafel van 7 op het canvas staan.

## Maak je eigen commando's!

`leer` is een speciaal commando, omdat het kan worden gebruikt om je eigen commando's te maken. Het commando dat je maakt kan invoer vragen en uitvoer geven. Laten we eens kijken hoe je een nieuw commando kunt maken:

    leer cirkel (x) [
     herhaal 36 [
       vooruit x
       draailinks 10
     ]
    ]

Het nieuwe commando heet `cirkel`. `circel` vraagt om een invoer, een getal, om de grootte van de cirkel te bepalen. `cirkel` geeft geen uitvoer. Het commando `cirkel` kan nu worden gebruikt als een normaal commando. Hier een voorbeeld:

    leer cirkel (x) [
      herhaal 36 [
        vooruit x
        draailinks 10
      ]
    ]

    ganaar 30,30
    cirkel 20

    ganaar 40,40
    cirkel 50

In het volgende voorbeeld maken we een commando met een uitvoerwaarde.

    leer vermenigvuldigMetZichzelf (n)[
     r = n * n
     geefdoor r
    ]
    i = invoervenster "Voer een getal in en klik op OK"
    schrijf i + " vermenigvuldigd met zichzelf is " + vermenigvuldigMetZichzelf (i)

In dit voorbeeld wordt een nieuw commando met de naam `VermenigvuldigMetZichzelf` gemaakt. De invoer van dit commando wordt vermenigdvuldigd met zichzelf en daarna doorgegeven met behulp van het commando `geefdoor`. Het commando `geefdoor` is een manier om de waarde van een functie die u hebt gemaakt als resultaat te geven.