# Guida di &kturtle; alla programmazione &logo;

## Comandi

Usando i comandi tu dici alla tartaruga o a &kturtle; di fare qualcosa. Alcuni comandi richiedono argomenti, alcuni restituiscono risultati. In questa sezione spieghiamo tutti i comandi che possono essere usati in &kturtle;.

### Muovere la tartaruga

Ci sono vari comandi per muovere la tartaruga sullo schermo.

avanti

-     avanti X

  `avanti` muove la tartaruga avanti di X pixel. Quando la penna è giù la tartaruga lascerà un tratto. `avanti` può essere abbreviato in `av`

indietro

-     indietro X

  `indietro` muove la tartaruga indietro di X pixel. Quando la penna è giù la tartaruga lascerà un tratto. `indietro` può essere abbreviato in `in`.

sinistra

-     sinistra X

  `sinistra` comanda alla tartaruga di girare X gradi a sinistra. `sinistra` può essere abbreviato in `sx`.

destra

-     destra X

  `destra` comanda alla tartaruga di girare X gradi a destra. `destra` può essere abbreviato in `dx`.

direzione

-     direzione X

  `direzione` imposta la direzione della tartaruga a X gradi partendo da zero, e così non è relativo alla precedente direzione della tartaruga. `direzione` può essere abbreviato in `dir`.

centro

-     centro

  `centro` muove la tartaruga al centro dell'area di disegno.

vai

-     vai X,Y

  `vai` comanda alla tartaruga di andare in un certo punto dell'area di disegno. Questo punto dista X pixel da sinistra e Y pixel dall'alto dell'area di disegno. Nota che usando il comando `vai` la tartaruga non disegnerà una linea.

vaix

-     vaix X

  `vaix` usando questo comando la tartaruga si muoverà a X pixel dalla sinistra dell'area di disegno mantenendo la sua altezza.

vaiy

-     vaiy Y

  `vaiy` usando questo comando la tartaruga si muoverà a Y pixel dall'alto dell'area di disegno mantenendosi alla stessa distanza dal bordo sinistro dell'area di disegno.

### La tartaruga ha una penna

La tartaruga ha una penna, che disegna una linea quando la tartaruga si muove. Ci sono alcuni comandi che controllano la penna. In questa sezione vengono spiegati questi comandi.

pennasu

-     pennasu

  `pennasu` alza la penna dall'area di disegno. Quando la penna è su nessuna linea sarà disegnata quando la tartaruga si muove. Vedi anche `pennagiu`. `pennasu` può essere abbreviato in `ps`.

pennagiu

-     pennagiu

  `pennagiu` abbassa la penna sull'area di disegno. Quando la penna è giù sull'area di disegno sarà disegnata una linea quando la tartaruga si muove. Vedi anche `pennasu`. `pennagiu` può essere abbreviato in `pg`.

spessorepenna

-     spessorepenna X

  `spessorepenna` imposta lo spessore della penna (lo spessore della linea) a X pixel. `spessorepenna` può essere abbreviato in `sp`.

colorepenna

-     colorepenna R,G,B

  `colorepenna` imposta il colore della penna. `colorepenna` richiede una combinazione RGB come argomento. `colorepenna` può essere abbreviato in `cp`.

### Comandi per controllare l'area di disegno

Ci sono vari comandi per controllare l'area di disegno.

dimensionesfondo

-     dimensionesfondo X,Y

  Con il comando `dimensionesfondo` puoi impostare la dimensione dell'area di disegno. Richiede X e Y come argomenti, dove X è la nuova larghezza dell'area di disegno in pixel, e Y è la nuova altezza dell'area di disegno in pixel. `dimensionesfondo` può essere abbreviato in `ds`.

coloresfondo

-     coloresfondo R,G,B

  `coloresfondo` imposta il colore dell'area di disegno. `coloresfondo` richiede una combinazione RGB come argomento. `coloresfondo` può essere abbreviato in `cs`.

attorno

-     attorno

  Con il comando `attorno` puoi attivare l'avvolgimento per l'area di disegno. Consulta il glossario se vuoi sapere cosa è l'avvolgimento.

muro

-     muro

  Con il comando `muro` puoi disattivare l'avvolgimento per l'area di disegno. Ciò significa che la tartaruga può muoversi al di fuori dell'area di disegno e perdersi. Consulta il glossario se vuoi sapere cosa è l'avvolgimento.

### Comandi per fare pulizia

Ci sono due comandi per pulire l'area di disegno dopo che hai fatto confusione.

pulisci

-     pulisci

  Con `pulisci` puoi pulire tutti i disegni dall'area di disegno. Tutte le altre cose rimangono: la posizione e l'angolo della tartaruga, il colore dell'area di disegno, la visibilità della tartaruga e la dimensione dell'area di disegno. `pulisci` può essere abbreviato in `cls`.

ricomincia

-     ricomincia

  `ricomincia` pulisce molto più accuratamente del comando `pulisci`. Dopo un comando `ricomincia` tutto ritorna come era quando hai avviato &kturtle;. La tartaruga è posizionata nel mezzo dello schermo, il colore dell'area di disegno è bianco e la tartaruga disegna linee nere sull'area di disegno.

### La tartaruga è un folletto

Molte persone non sanno cosa sono i folletti, così qui vi è una breve spiegazione: i filletti sono piccoli disegni che possono essere mossi in giro per lo schermo. (per maggiori informazioni vedi la voce di glossario sui folletti). Così la tartaruga è un folletto!

Di seguito troverai una descrizione completa di tutti i comandi che lavorano con i folletti.

[L'attuale versione di &kturtle; non supporta ancora l'uso di folletti diversi dalla tartaruga. Con le future versioni potrai cambiare la tartaruga in qualcos'altro creato da te!]

mostra

-     mostra

  `mostra` rende nuovamente visibile la tartaruga dopo che è stata nascosta. `mostra` può essere abbreviato in `ms`.

nascondi

-     nascondi

  `nascondi` nasconde la tartaruga. Ciò può essere usato se non conviene che la tartaruga appaia nel tuo disegno. `nascondi` può essere abbreviato in `ns`.

### Può la tartaruga scrivere del testo?

La risposta è: sì. La tartaruga può scrivere, e scrive tutto quello che tu le comandi di scrivere.

scrivi

-     scrivi X

  Il comando `scrivi` è usato per comandare alla tartaruga di scrivere qualcosa sull'area di disegno. `scrivi` accetta numeri e stringhe come parametri. Puoi scrivere vari numeri e stringhe usando il simbolo +. Guarda qui un piccolo esempio:

      anno = 2004
      autore = "Cies"
      scrivi "KTurtle è stato scritto nel " + anno + " da " + autore

dimensionecarattere

-     dimensionecarattere X

  `dimensionecarattere` imposta la dimensione del tipo di carattere usato dal comando `scrivi`. `dimensionecarattere` richiede un argomento che dovrebbe essere un numero. La dimensione è impostata in pixel.

### Un comando che lancia un dado per te

C'è un comando che lancia un dado per te

casuale

-     casuale X,Y

  `casuale` è un comando che richiede parametri e restituisce un valore. Come parametri richiede due numeri, il primo(X) imposta il valore minimo restituito, il secondo (Y) imposta il massimo. Il valore restituito è un numero scelto casualmente maggiore o uguale del minimo e minore o uguale del massimo. Qui vi è un piccolo esempio:

      ripeti 500 [
        x = casuale 1,20
        avanti x
        sinistra 10 - x
      ]

  Usando il comando `casuale` puoi aggiungere un po' di caos al tuo programma.

## Contenitori

I contenitori sono lettere o parole che possono essere usate dal programmatore per memorizzare un numero o del testo. I contenitori che contengono un numero sono chiamati variabili, quelli che possono contenere del testo sono chiamati stringhe.

I contenitori che non sono stati ancora usati contengono 0 in maniera predefinita. Un esempio:

    scrivi N

Questo scriverà uno 0.

### Variabili: contenitori numerici

Iniziamo con un esempio:

    x = 3
    scrivi x

Nella prima linea linea la lettera `x` è trasformata in una variabile (contenitore numerico). Come vedi il valore della variabile `x` è impostato a 3. Nella seconda linea viene stampato a video il valore.

Nota che se volevamo scrivere una x avremmo dovuto scrivere

    scrivi "x"

Quello era semplice, vediamo ora un esempio un po' più complesso:

    A = 2004
    B = 25
    AB = A + B

    # il comando seguente scrive "2029"
    scrivi AB
    indietro 30
    # il comando seguente scrive "2004 più 25"
    scrivi "" + A + " più " + B
    indietro 30
    # il comando seguente scrive "1979"
    scrivi A - B

nelle prime due righe le variabili `A` e `B` sono impostare a 2004 e 25. Nella terza riga la variabile `AB` è impostata ad `A + B`, che è 2029. Il resto dell'esempio è costituito da 3 comandi `scrivi` con `indietro 30` in mezzo. Il comando `indietro 30` ci assicura che ogni testo è scritto in una nuova riga. In questo esempio puoi anche vedere che le variabili possono essere usate nei calcoli matematici.

### Stringhe: contenitori di testo

Le stringhe sono molto simili alle variabili. La più grande differenza è che le stringhe non possono essere usate in calcoli matematici e domande. Un esempio sull'uso delle stringhe:

    x = "Ciao "
    nome = finestrainserimento "Inserisci il tuo nome..."
    scrivi x + nome + ", come va?

Nella prima riga la stringa `x` è impostata a Ciao . Nella seconda riga la stringa `nome` è impostata al risultato del comando `finestrainserimento`. Nella terza riga il programma scrive nell'area di disegno una stringa composta da tre stringhe.

Questo programma ti chiede di inserire il tuo nome. Quando inserisci, per esempio, il nome Paolo, il programma scrive Ciao Paolo, come va?. Nota che il segno più (+) è l'unico segno matematico che puoi usare con le stringhe.

## Può la tartaruga eseguire calcoli?

Sì, &kturtle; farà la matematica per te. Puoi aggiungere (+), sottrarre (-), moltiplicare (*) e dividere (/). Qui vi è un esempio nel quale usiamo tutte le operazioni:

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

Lo sai che valori hanno a, b, c e d?

Se vuoi sesguire un semplice calcolo puoi scrivere qualcosa di simile a questo:

    scrivi 2004-12

Ora un esempio con le parentesi:

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

Ciò che si trova dentro le parentesi sarà calcolato prima. In questo esempio, sarà calcolato 20-5, quindi moltplicato per 2, diviso per 30, e viene infine aggiunto 1 (avendo 2 come risultato).

## Chiedere domande, avere risposte...

`se` e `mentre` sono comandi di controllo dell'esecuzione di cui parleremo nella prossima sezione. In questa sezione usiamo il comando `se` per spiegare le domande.

Un semplice esempio di domanda:

    x = 6
    se x > 5 [
      scrivi "ciao"
    ]

In questo esempio la domanda è costituita da `x > 5`. Se la risposta a questa domanda è vero sarà eseguito il codice tra le parentesi quadre. Le domande sono una parte molto importante della programmazione e sono spesso usate insieme ai comandi di controllo dell'esecuzione, come `se`. Tutti i numeri e le variabili (contenitori numerici) possono essere confrontati l'un l'altro con le domande.

Qui vi sono tutte le possibili domande:

## Tipi di domande

`a == b` | uguale | la risposta è vero se `a` è uguale a `b`
`a != b` | non uguale | la risposta è vero se `a` non è uguale a `b`
`a > b` | maggiore | la risposta è vero se `a` è maggiore di `b`
`a < b` | minore | la risposta è vero se `a` è minore di `b`
`a >= b` | maggiore o uguale | la risposta è vero se `a` è maggiore o uguale a `b`
`a <= b` | minore o uguale | la risposta è vero se `a` è minore o uguale a `b`

Le domande posso essere unite l'un l'altra con i collanti delle domande, in questo modo poche domande possono diventare una grande domanda.

    a = 1
    b = 5
    se a < 5 e b == 5 [
      scrivi "ciao"
    ]

In questo esempio è usato il collante `e` per unire insieme due domande (`a < 5`, `b == 5`). Se un lato di `e` avrà come risposta falso l'intera domanda avrà come risposta falso, poiché con il collante `e` devono essere vero per poter rispondere vero.

`e` non è l'unico collante, ce ne sono altri due. Sono tutti nella tabella seguente:

## I collanti delle domande

`e` | entrambi i lati devono essere vero per poter rispondere vero
`o` | se uno dei lati è vero la risposta è vero
`non` | solo se entrambi i lati sono falso la risposta è falso

## Controllare l'esecuzione

I comandi di controllo dell'esecuzione ti permettono — come dicono il loro nomi — di controllare l'esecuzione

### Far aspettare la tartaruga

Se hai programmato in &kturtle; devi aver notato che la tartaruga può essere molto veloce a disegnare. Questo comando fa sì che la tartaruga ci metta un po' più di tempo.

attendi

-     attendi X

  `attendi` fa sì che la tartaruga attenda X secondi.

      ripeti 36 [
        avanti 5
        destra 10
        attendi 0.5
      ]

  Questo codice disegna un cerchio, ma la tartaruga attenderà mezzo secondo dopo ogni passo. Ciò da' l'impressione di un movimento più fluido della tartaruga.

### Eseguire "se"

se

-     se domanda [ ... ]

  Il codice che si trova tra le parentesi quadre sarà eseguito solo `se` la risposta alla domanda è vero. Per maggiori informazioni leggi sulle domande nella sezione sulle domande.

      x = 6
      se x > 5 [
        scrivi "x è più grande di cinque!"
      ]

  Nella prima linea `x` è impostato a 6. Nella seconda linea è chiesta la domanda `x > 5`. Dato che la risposta a uesta domanda è vero il comando di controllo dell'esecuzione `se` permetterà che venga eseguito il codice tra le parentesi quadre

### Eseguire "mentre"

mentre

-     mentre domanda [ ... ]

  Il comando di controllo dell'esecuzione `mentre` è molto simile a `se`. La differenza è che `mentre` ripete il codice tra le parentesi quadre fino a quando la risposta alla domanda è falso.

      x = 1
      mentre x < 5 [
        avanti 10
        attendi 1
        x = x + 1
      ]

  Nella prima linea `x` è impostato a 1. Nella seconda linea viene chiesta la domanda `x < 5`. Dato che la risposta a questa domanda è vero il comando di controllo dell'esecuzione `mentre` esegue il codice tra le parentesi quadre fino a quando la risposta alla domanda è falso. In questo caso il codice tra le parentesi quadre sarà eseguito 4 volte, dato che ogni volta che viene eseguita la quinta linea `x` è incrementato di 1..

### Se no, in altre parole: "altrimenti"

altrimenti

-     se domanda [ ... ] altrimenti [ ... ]

  `altrimenti` può essere usato in aggiunta al comando di controllo dell'esecuzione `se`. Il codice tra le parentesi quadre dopo `altrimenti` è eseguito solo se la risposta alla domanda chiesta è falso.

      x = 4
      se x > 5 [
        scrivi "x è più grande di cinque!"
      ] altrimenti [
        scrivi "x è più piccolo di cinque!"
      ]

  La domanda chiede se `x` è più grande di 5. Dato che `x` è stato impostato a 4 nella prima linea, la risposta alla domanda è falso. Ciò significa che viene eseguito il codice tra le parentesi dopo `altrimenti`.

### Il ciclo "per"

per

-     per punto di partenza finoa punto di arrivo [ ... ]

  Il ciclo `per` è un ciclo contato, &ie; conta per te.

      per x = 1 finoa 10 [
        scrivi x * 7
        avanti 15
      ]

  Ogni volta che viene eseguito il codice tra le parentesi quadre, `x` viene incrementato di 1, fino a quando `x` raggiunge il valore di 10. Il codice tra le parentesi quadre scrive il valore di `x` moltiplicato per 7. Alla fine dell'esecuzione di questo programma vedrai scritta sull'area di disegno la tabellina del 7.

## Crea i tuoi comandi!

`impara` è un comando molto particolare, dato che è usato per creare comandi personalizzati. Il comando che crei può richiedere parametri e restituire valori. Diamo un'occhiata a come creare un nuovo comando:

    impara cerchio (x) [
      ripeti 36 [
        avanti x
        sinistra 10
      ]
    ]

Il nuovo comando è chiamato `echio`. `cerchio` richiede un parametro, un numbero, per impostare la dimensione del cerchio. `cerchio` non restituisce valori. Il comando `cerchio` può essere ora usato come un normale comando. Guarda questo esempio:

    impara cerchio (x) [
      ripeti 36 [
        avanti x
        sinistra 10
      ]
    ]

    vai 30,30
    cerchio 20

    vai 40,40
    cerchio 50

Nell'esempio seguente viene creato un comando con un valore restituito.

    impara moltiplicatoPerSeStesso (n) [
      r = n * n
      restituisci r
    ]
    i = finestrainserimento "Inserisci un numero e premi OK"
    scrivi i + " moltiplicato per se stesso è: " + moltiplicatoPerSeStesso (i)

In questo esempio viene creato un nuovo comando chiamato `moltiplicatoPerSeStesso`. Il parametro di questo nuovo comando è moltiplicato per se stesso e quindi restituito, usando il comando `restituisci`. Il comando `restituisci` è il modo per restituire un valore da una funzione che hai creato.