El manual del KTurtle

# El manual del KTurtle

Breijs, Cies `<cies AT kde DOT nl>`

Mahfouf, Anne-Marie `<annma AT kde DOT org>`

Piacentini, Mauricio `<piacentini AT kde DOT org>`

Traductor: Daniel Fortuny Anguera
Traductor: Antoni Bella
revisió Aplicacions 20.12 (20 de gener de 2020)

Dret de reproducció © 2004, 2009 Cies Breijs

Dret de reproducció © 2004, 2007 Mahfouf, Anne-Marie

Dret de reproducció © 2007 Mauricio Piacentini

Avís legal

El KTurtle és un entorn educatiu de programació que pretén ensenyar a programar de la manera més senzilla possible. Per a aconseguir-ho, el KTurtle permet accedir a totes les eines de programació des de la interfície d'usuari. El llenguatge de programació és el TurtleScript, el qual permet traduir-ne les ordres.

Llistat de taules

4.1. Tipus de preguntes
5.1. Diferents tipus de codi i el seu color de ressaltat
5.2. Combinacions RGB més utilitzades

Capítol 1. Introducció
Introducció

# Capítol 1. Introducció

El KTurtle és un entorn de programació educatiu que fa servir TurtleScript, un llenguatge de programació basat i inspirant en el Logo. La meta del KTurtle és fer de la programació una activitat fàcil i accessible. Això fa que el KTurtle esdevingui una eina adequada per a ensenyar els fonaments de les matemàtiques, geometria i... programació. La característica de TurtleScript és que les ordres es poden traduir a l'idioma del programador.

El KTurtle s'ha anomenat així perquè «la tortuga» és la protagonista de l'entorn de programació. L'estudiant instruirà la tortuga, utilitzant les ordres de TurtleScript, perquè dibuixi en el llenç.

## Què és el TurtleScript?

El KTurtle és un entorn de programació educatiu que fa servir TurtleScript, un llenguatge de programació basat i inspirant en el Logo. La primera versió del llenguatge de programació Logo va ser creada en un laboratori d'intel·ligència artificial del MIT per en Seymour Papert l'any 1967, a partir del llenguatge de programació LISP. Des d'aleshores han aparegut moltes versions de Logo. Cap a l'any 1980 van tenir protagonisme les versions per a MSX, Commodore, Atari, Apple II i els PC d'IBM. Aquestes versions estaven vinculades a projectes educatius. El MIT encara manté un lloc web sobre Logo que conté una llista de diverses implementacions del llenguatge.

El TurtleScript comparteix una característica que es troba en moltes altres implementacions de Logo: La capacitat de traduir les ordres per a adaptar-se a l'idioma matern de l'estudiant. Aquesta característica fa que sigui més fàcil començar per als estudiants que tenen poc o cap coneixement d'anglès. A més d'aquesta característica, el KTurtle té moltes altres característiques destinades a facilitar als estudiants l'experiència inicial amb la programació.

Característiques del KTurtle
Característiques del KTurtle

## Característiques del KTurtle

El KTurtle té algunes característiques interessants que fan que començar a programar sigui molt fàcil. Observeu alguns dels aspectes més destacats del conjunt de característiques del KTurtle:

- Un entorn integrat i amb un intèrpret, un editor, un llenç i altres eines de TurtleScript en una sola aplicació (sense dependències addicionals).

- La capacitat de traduir les ordres de TurtleScript utilitzant l'estructura de traducció de KDE.

- El TurtleScript admet les funcions definides per l'usuari, la recursivitat i el canvi de tipus dinàmic.

- L'execució es pot alentir, posar en pausa o aturar en qualsevol moment.

- Un potent editor que permet fer un ressaltat intuïtiu de la sintaxi, numeració de les línies, marcadors d'error, execució visual i altres coses.

- El llenç, on la tortuga dibuixa, es pot imprimir o desar com a una imatge (PNG) o un dibuix (SVG).

- Ajuda contextual: Ajuda quan ho necessiteu. Només haureu de prémer F2 (o veure Ajuda → Ajuda sobre: ...) per a obtenir ajuda en la part de codi actualment sota el cursor.

- Un diàleg d'error que vincula els missatges d'error per als errors en el programa i els marca en vermell.

- Terminologia de programació simplificada.

- Programes d'exemple integrats per a fer més fàcil començar. Aquests exemples es tradueixen utilitzant l'estructura de traducció del KDE.

Capítol 2. Usar el KTurtle
Usar el KTurtle

# Capítol 2. Usar el KTurtle

La finestra principal del KTurtle té tres parts principals: L'editor (1) a l'esquerra és on escriviu les ordres de TurtleScript, el llenç (2) a la dreta on la tortuga farà el seu dibuix, i l'inspector (3) el qual us donarà informació quan executeu el programa. A més d'aquests es troba la barra de menús (5) des d'on es poden abastar totes les accions, la barra d'eines (4) la qual permet seleccionar amb rapidesa les accions més utilitzades, El quadre d'entrada Consola:, el qual podeu utilitzar per a introduir una ordre per a provar-la, i la barra d'estat (a la part inferior de la finestra) on trobareu la informació sobre l'estat del KTurtle.

## L'editor

En l'editor escriureu les ordres de TurtleScript. La majoria de les funcions de l'editor es poden trobar en els menús Fitxer i Edita. L'editor es pot acoblar sobre cada vora de la finestra principal o es pot desacoblar i posar a qualsevol lloc de l'escriptori.

Teniu diverses maneres d'obtenir algun codi en l'editor. La manera més senzilla és utilitzar un exemple: Seleccioneu el submenú Fitxer → Exemples i seleccioneu un exemple. El fitxer d'exemple que trieu s'obrirà a l'editor, a continuació, podeu utilitzar l'element de menú Executa → Executa (drecera: Alt+F2) o el botó Executa des de la barra d'eines per a executar el codi si així ho desitgeu.

Podeu obrir fitxers de TurtleScript escollint l'element de menú Fitxer → Obre....

La tercera manera és escriure directament el vostre propi codi en l'editor o fer copia/enganxa sobre algun codi.

El llenç
El llenç

## El llenç

El llenç és el domini de la tortuga, la tortuga hi dibuixa d'acord amb les ordres que rep. Després d'aconseguir una mica de codi en l'editor i executar-lo, poden passar dues coses: O bé el codi s'executa bé, i el més probable serà veure com canvia alguna cosa en el llenç; o heu comès un error en el codi, en aquest cas, apareixerà la pestanya d'error explicant l'error que s'ha comès.

Podeu apropar i allunyar el llenç amb la roda del ratolí.

L'inspector
L'inspector

## L'inspector

L'inspector informa sobre les variables, les funcions apreses i mostra l'arbre de codi mentre s'executa el programa.

L'inspector es pot acoblar sobre cada vora de la finestra principal, o es pot desacoblar i posar a qualsevol lloc de l'escriptori.

La barra d'eines
La barra d'eines

## La barra d'eines

Des d'aquí arribareu amb rapidesa a les accions més utilitzades. La barra d'eines també conté el quadre d'entrada Consola:, on podreu invocar les ordres amb rapidesa, això podria ser útil en cas que vulgueu provar una ordre sense modificar el contingut de l'editor.

Podeu configurar la barra d'eines utilitzant Arranjament → Configura les barres d'eines... per a ajustar-la millor a les vostres preferències.

La barra de menús
La barra de menús

## La barra de menús

A la barra de menús trobareu totes les accions del KTurtle. Es troben en els següents grups: Fitxer, Edita, Llenç, Executa, Eines, Arranjament i Ajuda. En aquesta secció es descriuen tots.

### El menú Fitxer

Fitxer → Nou (Ctrl+N)

  Crea un fitxer nou i buit de TurtleScript.

Fitxer → Obre... (Ctrl+O)

  Obre un fitxer de TurtleScript.

Fitxer → Obre'n un de recent

  Obre un fitxer de TurtleScript obert recentment.

Fitxer → Exemples

  Obre programes en TurtleScript d'exemple. Els exemples estan en el vostre idioma preferit que podeu triar el submenú Arranjament → Idioma de script.

Fitxer → Aconsegueix més exemples...

  Obre el diàleg Obtén les novetats candents per a descarregar fitxers en TurtleScript addicionals des d'Internet.

Fitxer → Desa (Ctrl+S)

  Desa el fitxer en TurtleScript actualment obert.

Fitxer → Desa com a... (Ctrl+Maj+S)

  Desa el fitxer en TurtleScript actualment obert en un lloc especificat.

Fitxer → Exporta com a HTML...

  Exporta el contingut actual de l'editor com un fitxer HTML que inclou els colors de ressaltat.

Fitxer → Imprimeix... (Ctrl+P)

  Imprimeix el codi actual en l'editor.

Fitxer → Surt (Ctrl+Q)

  Surt del KTurtle.

### El menú Edita

Edita → Desfés (Ctrl+Z)

  Desfà l'últim canvi al codi. El KTurtle desfà de manera il·limitada.

Edita → Refés (Ctrl+Maj+Z)

  Refà un canvi desfet en el codi.

Edita → Retalla (Ctrl+X)

  Retalla al porta-retalls el text seleccionat a l'editor.

Edita → Copia (Ctrl+C)

  Copia al porta-retalls el text seleccionat a l'editor.

Edita → Enganxa (Ctrl+V)

  Enganxa el text del porta-retalls a l'editor.

Edita → Selecciona-ho tot (Ctrl+A)

  Selecciona tot el text a l'editor.

Edita → Cerca... (Ctrl+F)

  Amb aquesta acció trobareu les frases en el codi.

Edita → Cerca la següent (F3)

  Utilitzeu aquesta opció per a cercar la següent ocurrència de la frase cercada.

Edita → Cerca l'anterior (Maj+F3)

  Feu-la servir per a trobar l'anterior ocurrència de la frase cercada.

Edita → Mode sobreescriptura (Insert)

  Commuta entre els modes «inserir» i «sobreescriure».

### El menú Llenç

Llenç → Exporta a imatge (PNG)...

  Exporta el contingut actual del llenç com una imatge del tipus PNG (Portable Network Graphics).

Llenç → Exporta a dibuix (SVG)...

  Exporta el contingut actual del llenç com un dibuix vectorial del tipus SVG (Scalable Vector Graphics).

Llenç → Imprimeix el llenç...

  Imprimeix el contingut actual del llenç.

### El menú Executa

Executa → Executa (F5)

  Comença l'execució de les ordres que es troben a l'editor.

Executa → Pausa (F6)

  Atura momentàniament l'execució. Aquesta acció només s'habilita quan les ordres s'estan executant.

Executa → Interromp (F7)

  Atura l'execució. Aquesta acció només s'habilita quan s'estan executant les ordres.

Executa → Velocitat d'execució

  Presenta una llista de les possibles velocitats d'execució, consisteix en: Velocitat màxima (sense ressaltat ni inspector), Velocitat màxima, Lenta, Més lenta, La més lenta i Instrucció a instrucció. Quan la velocitat d'execució s'estableix a Velocitat màxima (predeterminat) amb prou feines podreu mantenir-vos al dia amb què està succeint. De vegades, aquest comportament es vol, però de vegades volem fer un seguiment de l'execució. En aquest últim cas voldreu establir la velocitat d'execució a Lenta, Més lenta o La més lenta. Quan se selecciona un dels modes lents la posició actual de l'executor es mostrarà a l'editor. Instrucció a instrucció executarà una ordre a la vegada.

### El menú Eines

Eines → Selector de direcció...

  Aquesta acció obre el diàleg selector de direcció.

Eines → Selector de color...

  Aquesta acció obre el diàleg selector de color.

### El menú Arranjament

Arranjament → Idioma de script

  Tria el llenguatge per al codi.

Arranjament → Mostra l'editor (Ctrl+E)

  Mostra o oculta l'editor.

Arranjament → Mostra l'inspector (Ctrl+I)

  Mostra o oculta l'inspector.

Arranjament → Mostra els errors

  Mostra o oculta la pestanya Errors amb una llista dels errors resultants de l'execució del codi. Si aquesta opció està habilitada, feu clic al Llenç per a veure la tortuga una altra vegada.

Arranjament → Mostra els números de les línies (F11)

  Amb aquesta acció podeu mostrar els números de línia en l'editor. Això pot ser útil per a trobar els errors.

Arranjament → Mostra la barra d'eines

  Mostra o oculta la barra d'eines principal.

Arranjament → Mostra la barra d'estat

  Mostra o oculta la barra d'estat.

Arranjament → Configura les dreceres de teclat...

  El diàleg estàndard del KDE per a configurar les dreceres.

Arranjament → Configura les barres d'eines...

  El diàleg estàndard del KDE per a configurar les barres d'eines.

### El menú Ajuda

El KTurtle disposa del menú Ajuda predeterminat del KDE com es descriu en els Fonaments del KDE amb una entrada addicional:

Ajuda → Ajuda sobre: ... (F2)

  Aquesta és una funció molt útil: Ofereix ajuda sobre el codi a la posició del cursor a l'editor. Així, p. ex., heu utilitzat l'ordre `print` (`imprimeix`) en el vostre codi, i voleu llegir i saber el que diu el manual sobre aquesta ordre. Només cal moure el cursor sobre l'ordre i prémer la tecla F2. El manual mostrarà tota la informació sobre l'ordre `print` (`imprimeix`).

  Aquesta funció pot ser útil mentre s'aprèn TurtleScript.

La barra d'estat
La barra d'estat

## La barra d'estat

A la barra d'estat obtindreu informació sobre l'estat del KTurtle. Al costat esquerre es mostra informació sobre l'última acció. Al costat dret trobareu la ubicació actual del cursor (números de línia i columna). Enmig de la barra d'estat s'indica el llenguatge actualment utilitzat per a les ordres.

Capítol 3. Com començar
Com començar

# Capítol 3. Com començar

Quan inicieu el KTurtle veureu quelcom com això:

En aquesta guia sobre com començar assumirem que l'idioma de les ordres està en anglès. Podeu canviar aquest idioma a l'element de menú Arranjament → Idioma de script. Cal tenir en compte que l'idioma que heu establert aquí per al KTurtle, és el que utilitzareu per a escriure les ordres de TurtleScript, no l'idioma utilitzat pel KDE al vostre ordinador i ni l'utilitzat per a mostrar la interfície i els menús del KTurtle.

## Els primers passos amb TurtleScript: Trobar la Tortuga!

Podeu haver observat la tortuga al centre del llenç: Esteu a punt d'aprendre a controlar-la mitjançant les ordres a l'editor.

### Els moviments de la tortuga

Començarem per a aconseguir que la tortuga es mogui. La nostra tortuga pot fer tres tipus de moviments, (1) pot desplaçar-se cap endavant i cap enrere, (2) pot girar a l'esquerra i a la dreta i (3) pot anar (salt) directament a una posició a la pantalla. Proveu això, per exemple:

    forward 100
    turnleft 90

Escriviu-ho o copieu i enganxeu el codi a l'editor, i executeu-lo (emprant Executa → Executa) per a veure el resultat.

Quan escriviu i executeu les ordres com abans a l'editor observareu una o més de les següents coses:

1. Que -després d'executar les ordres- la tortuga es mou cap amunt, dibuixa una línia, i llavors gira un quart de volta cap a l'esquerra. Això és deu a què heu utilitzat les ordres `forward` i `turnleft`.

2. Que el color del codi canvia a mesura que l'escriviu: Aquesta característica s'anomena ressaltat intuïtiu -diferents tipus d'ordres són ressaltades de manera diferent-. Això fa que la lectura de grans blocs de codi sigui més fàcil.

3. La tortuga dibuixa una fina línia negra.

4. Potser heu rebut un missatge d'error. Això simplement pot significar dues coses: Que podríeu haver comès un error en copiar les ordres, o que encara s'ha de definir l'idioma correcte per a les ordres de TurtleScript (podeu fer-ho amb el submenú Arranjament → Idioma de script).

Vós interpreteu que en la instrucció `forward 100` la tortuga s'ha de moure a partir d'una línia, i que la instrucció `turnleft 90` serveix perquè la tortuga giri 90 graus a l'esquerra.

Fixeu-vos en els següents enllaços al manual de referència per a una explicació més completa de les ordres: `forward`, `backward`, `turnleft` i `turnright`.

### Més exemples

El primer exemple és molt senzill, el podeu fer sense cap dificultat!

    reset

    canvassize 200,200
    canvascolor 0,0,0
    pencolor 255,0,0
    penwidth 5

    go 20,20
    direction 135

    forward 200
    turnleft 135
    forward 100
    turnleft 135
    forward 141
    turnleft 135
    forward 100
    turnleft 45

    go 40,100

Altra vegada ho podeu escriure o copiar i enganxar a l'editor o obrir l'exemple `arrow` que trobareu en el submenú Exemples i executeu-lo (emprant Executa → Executa) per a veure el resultat. En els exemples següents s'espera que coneixereu l'exercici.

Podeu haver notat que aquest segon exemple utilitza molt més codi. També s'han fet servir un parell d'ordres noves. Aquí teniu una breu explicació de totes les ordres noves:

Després d'una ordre `reset` tot queda com estava quan vau iniciar el KTurtle.

`canvassize 200,200` estableix amplada i alçada del llenç a 200 x 200 píxels. L'amplada és igual que l'alçada, per tant, el llenç serà quadrat.

`canvascolor 0,0,0` fa que el llenç sigui negre. `0,0,0` és una combinació RGB on tots els valors estan establerts a `0`, el qual resultarà en el color negre.

`pencolor 255,0,0` estableix el color del dibuix a vermell. `255,0,0` és una combinació RGB on només el valor vermell està establert a `255` (completament) on tots els altres valors (verd i blau) estan establerts a `0` (no gens). Això resultarà en un to més brillant de color vermell.

Si no enteneu els valors de color, assegureu-vos de llegir el glossari sobre la combinació RGB .

`penwidth 5` canvia l'amplada (la mida) del traç a `5` píxels. A partir d'aquest moment, cada línia que dibuixi la tortuga ho farà amb `5` píxels d'amplada, fins que canvieu el valor de l'amplada de `penwidth` a una altra cosa.

`go 20,20` permet a la tortuga anar a un cert lloc sobre el llenç. Comptat a partir de la cantonada superior esquerra, aquest lloc és de 20 píxels cap a l'esquerra, i 20 píxels cap avall des de la part superior del llenç. Nota: Quan empreu l'ordre `go` no us dibuixarà una línia.

`direction 135` estableix la direcció de la tortuga. Les ordres `turnleft` i `turnright` canvien d'angle la tortuga a partir de la seva direcció actual. L'ordre `direction` canvia d'angle la tortuga des de zero, i per tant no és relativa a l'anterior direcció de la tortuga.

Després de l'ordre `direction` segueixen una gran quantitat d'ordres `forward` i `turnleft`. Aquestes ordres fan el dibuix.

Al final una altra ordre `go` s'utilitza per a moure la tortuga a un costat.

Assegureu-vos d'emprar els enllaços a la referència. La referència explica cadascuna de les ordres amb més detall.

Capítol 4. Referència de programació de TurtleScript
Referència de programació de TurtleScript

# Capítol 4. Referència de programació de TurtleScript

Aquesta és la referència per a TurtleScript del KTurtle. En la primera secció d'aquest capítol es fa un repàs a alguns aspectes de la gramàtica dels programes en TurtleScript. La segona secció es refereix exclusivament als operadors matemàtics, els operadors booleans (true/false -cert/fals-) i els operadors de comparació. La tercera secció bàsicament és una llista gegant explicant totes les ordres instrucció a instrucció. La quarta secció explica com assignar valors a les variables. Per a finalitzar, en la cinquena secció s'explica la forma d'organitzar l'execució d'ordres amb les sentències de control de l'execució i en la sisena secció com crear les vostres pròpies ordres amb `learn -aprèn-`.

## La gramàtica de TurtleScript

Igual que en qualsevol llenguatge, el TurtleScript té diferents tipus de paraules i símbols. En anglès es distingeixen els verbs (com «to walk» -caminar- o «to sing» -cantar-) i noms (com «sister» -germana- o «house» -casa-), que s'utilitzen per a diferents finalitats. El TurtleScript és un llenguatge de programació, el qual s'utilitza per a indicar el que ha de fer el KTurtle.

En aquesta secció s'expliquen amb brevetat alguns dels diferents tipus de paraules i símbols de TurtleScript. Expliquem els comentaris, les ordres i els tres tipus diferents de literals: nombres, cadenes i valors booleans («true/false» -cert/fals-).

### Comentaris

Un programa consisteix en les instruccions que s'executen en executar-lo i els anomenats comentaris. Els comentaris no s'executen, el KTurtle simplement els ignora en executar el vostre programa. Els comentaris hi són perquè altres programadors entenguin millor el vostre programa. Tot el que segueix a un símbol `#` és considerat un comentari de TurtleScript. Per exemple, aquest petit programa que no fa res:

    # Aquest petit programa no fa res. Només és un comentari!

És un xic inútil, però plasma molt bé l'assumpte.

Els comentaris són molt útils quan el programa es fa més complex. Poden ajudar a donar un consell als altres programadors. En el següent programa veureu que els comentaris s'utilitzen juntament amb l'ordre print.

    # Aquest programa ha estat realitzat per en Cies Breijs.
    print "Aquest text serà imprès en el llenç"
    # La línia anterior no és un comentari, però sí la línia següent:
    # print "Aquest text no s'imprimirà!"

La primera línia descriu el programa. La segona línia és executada pel KTurtle i imprimeix `Aquest text serà imprès en el llenç`. La tercera línia és un comentari. I la quarta línia és un comentari que conté un fragment de TurtleScript, si s'elimina el símbol `#` en la quarta línia, la declaració d'impressió serà executada pel KTurtle. Els programadors diuen: La sentència d'impressió en la quarta línia és un comentari (commented out).

Les línies comentades es ressalten en color gris clar en l'editor de codi.

### Ordres

L'ús d'ordres, li indiquen a la tortuga o al KTurtle que faci quelcom. Algunes ordres necessiten alguna entrada, alguna sortida.

    # «forward» és una ordre que necessita una entrada, en aquest cas el número 100:
    forward 100

La primera línia és un comentari. La segona línia conté l'ordre «`forward`» i el número 100. El nombre no forma part de l'ordre, es considera l'«entrada» d'aquesta.

Algunes ordres, com ara `go` (`vesa`) necessiten alguna cosa més que un valor d'entrada. Múltiples valors s'han de separar utilitzant el caràcter `,` (coma).

Per a una descripció detallada de totes les ordres que admet el KTurtle aneu aquí. Les ordres integrades es ressalten en color blau fosc.

### Nombres

El més probable és que ja sabeu quelcom sobre els nombres. La manera com s'utilitzen en el KTurtle no és gaire diferent del llenguatge parlat, o les matemàtiques.

Tenim els anomenats nombres naturals: `0`, `1`, `2`, `3`, `4`, `5`, etc. Els nombres negatius: `-1`, `-2`, `-3`, etc. I els nombres amb decimals, per exemple: `0.1`, `3.4`, `33.3333`, `-5.05`, `-1.0`. El caràcter `.` (punt) s'utilitza com a separador de decimals.

Els nombres es poden utilitzar en operacions matemàtiques i operadors de comparació. També es poden desar en les variables. Els nombres són ressaltats en color vermell fosc.

### Cadenes

Primer un exemple:

    print "Hola, soc una cadena."

En aquest exemple `print` és una ordre i on `"Hola, soc una cadena."` és una cadena. Les cadenes comencen i acaben amb la marca `"`, amb aquestes marques el KTurtle sabrà que és una cadena.

Les cadenes es poden posar en les variables, igual que els nombres. No obstant això, a diferència dels nombres, les cadenes no es poden utilitzar en els operadors matemàtics o els operadors de comparació. Les cadenes es ressalten en color vermell.

### Els valors booleans («true/false» -cert/fals-)

Només hi ha dos valors booleans: `true` (`cert`) i `false` (`fals`). De vegades també se'ls crida: «`on`» i «`off`», «`yes`» i «`no`», «`one`» i «`zero`». Però en el TurtleScript sempre se'ls crida, `true` i `false`. Doneu una ullada a aquest fragment de TurtleScript:

    $a = true

Si ens fixem en l'inspector, veurem que la variable `$a` s'estableix a `true` i té el tipus booleà.

Els valors booleans sovint són el resultat d'un operador de comparació, com en el següent fragment de TurtleScript:

    $answer = 10 > 3

La variable `$answer` està establerta a `true`, perquè `10` és més gran que `3`.

Els valors booleans, `true` i `false`, es ressalten en color vermell fosc.

Els operadors matemàtics, booleans i de comparació
Els operadors matemàtics, booleans i de comparació

## Els operadors matemàtics, booleans i de comparació

El títol d'aquesta secció pot reservar una certa dificultat, però, no és tan difícil com sona.

### Els operadors matemàtics

Aquests són els símbols matemàtics bàsics coneguts com: add «suma» (`+`), subtract «resta» (`-`), multiply «multiplicació» (`*`), divide «divisió» (`/`) i power «potència» (`^`).

Aquí teniu un petit exemple dels operadors matemàtics que podeu utilitzar en TurtleScript:

    $add      = 1 + 1
    $subtract = 20 - 5
    $multiply = 15 * 2
    $divide   = 30 / 30
    $power    = 2 ^ 2

Els valors resultants de les operacions matemàtiques són assignats a diverses variables. Utilitzant l'inspector podeu veure els valors.

Si el que voleu és fer un càlcul senzill, podeu fer quelcom com això:

    print 2010-12

Ara veurem un exemple amb parèntesis:

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

Les expressions entre parèntesis es calculen primer. En aquest exemple, es calcula 20 menys 5, després es multiplica per dos, es divideix per 30 i després se suma 1 (el qual ens dona 2). Els parèntesis també es poden utilitzar en altres casos.

El KTurtle també té funcions matemàtiques més avançades en forma d'ordres. Doneu una ullada a les següents ordres, però cal tenir present que es tracten d'operacions avançades: round, random, sqrt, pi, sin, cos, tan, arcsin, arccos, arctan.

### Els operadors booleans («true/false» -cert/fals-)

On els operadors matemàtics són principalment per als nombres, els operadors booleans són per als valors booleans (`true` i `false`). Només hi ha tres operadors booleans, anomenats: `and`, `or` i `not`. El següent fragment de TurtleScript ens mostra com emprar-los:

    $and_1_1 = true and true    # -> true
    $and_1_0 = true and false   # -> false
    $and_0_1 = false and true   # -> false
    $and_0_0 = false and false  # -> false

    $or_1_1 = true or true    # -> true
    $or_1_0 = true or false   # -> true
    $or_0_1 = false or true   # -> true
    $or_0_0 = false or false  # -> false

    $not_1 = not true   # -> false
    $not_0 = not false  # -> true

Utilitzant l'inspector podreu veure els valors, però també oferim aquests resultats com a petits comentaris al final de les línies. `and` avalua `true` només si ambdues parts són `true`. `or` avalua `true` si una part i l'altra són `true`. I `not` retorna un `true` a dintre de `false` i `false` a dintre de `true`.

Els operadors booleans es ressalten en color rosa.

#### Alguns exemples més avançats

Considerem el següent exemple amb `and`:

     $a = 1
    $b = 5
    if (($a < 10) and ($b == 5)) and ($a < $b) {
      print "hola"
    }

En aquest fragment de TurtleScript el resultat de tres operadors de comparació es fusionen utilitzant els operadors `and`. Això significa que els tres han d'avaluar «true» perquè s'imprimeixi «hola».

Un exemple amb `or`:

    $n = 1
    if ($n < 10) or ($n == 2) {
      print "hola"
    }

En aquest fragment de TurtleScript la part esquerra de `or` està avaluant a «true», el costat dret a «false». Atès que un dels dos costats de l'operador `or` és «true», l'operador `or` avaluarà com a «true». El qual vol dir que s'imprimirà «hola».

I, finalment, un exemple amb `not` que canvia de «true» a «false» i de «false» a «true». Doneu un cop d'ull:

    $n = 1
    if not ($n == 3) {
      print "hola"
    } else {
      print "sense hola ;-)"
    }

### Els operadors de comparació

Considereu en la possibilitat d'aquesta simple comparació:

    $answer = 10 > 3

Aquí `10` és comparat amb `3` amb l'operador «més gran que». El resultat d'aquesta comparació, el ​valor booleà `true` es desa a la variable `$answer`.

Tots els nombres i les variables (que contenen nombres) es poden comparar entre si amb els operadors de comparació.

Aquí hi ha tots els possibles operadors de comparació:

Taula 4.1. Tipus de preguntes

`$A == $B` | igual que | respon «true» si `$A` és igual que `$B`
`$A != $B` | no igual que | respon «true» si `$A` no és igual que `$B`
`$A > $B` | més gran que | respon «true» si `$A` és més gran que `$B`
`$A < $B` | més petit que | respon «true» si `$A` és més petit que `$B`
`$A >= $B` | més gran o igual que | respon «true» si `$A` és més gran o igual que `$B`
`$A <= $B` | més petit o igual que | respon «true» si `$A` és més petit o igual que `$B`

Cal tenir en compte que `$A` i `$B` han de ser nombres o variables que contenen nombres.

Ordres
Ordres

## Ordres

Utilitzant ordres li indicareu a la tortuga o al KTurtle que faci quelcom. Algunes ordres necessiten alguna entrada o sortida. En aquesta secció explicarem totes les ordres integrades del KTurtle. D'altra banda, utilitzant `learn (aprèn)`, podreu crear les vostres pròpies ordres. Les ordres integrades que es debaten aquí es ressalten amb color blau fosc.

### Moure la tortuga

Hi ha diverses ordres per a moure la tortuga sobre la pantalla.

forward -fw- (avança -av-)

      forward X

  `forward` mou la tortuga cap endavant la quantitat de X píxels. Quan el llapis està sota la tortuga aquesta deixa un rastre. `forward` pot abreujar-se com `fw`.

backward -bw- (recula -re-)

      backward X

  `backward` mou la tortuga cap enrere la quantitat de X píxels. Quan el llapis està avall la tortuga deixa un rastre. `backward` pot abreujar-se com `bw`.

turnleft -tl- (giraesquerra -ge-)

      turnleft X

  `turnleft` ordena a la tortuga tornar una quantitat de X graus cap a l'esquerra. `turnleft` pot abreujar-se com `tl`.

turnright -tr- (giradreta -gd-)

      turnright X

  `turnright` ordena a la tortuga tornar una quantitat de X graus cap a la dreta. `turnright` pot abreujar-se com `tr`.

direction -dir- (direcció -dir-)

      direction X

  `direction` estableix la direcció de la tortuga a una quantitat de X graus X comptant des de zero, i per tant no és relativa a la direcció anterior de la tortuga. `direction` pot abreujar-se com `dir`.

getdirection (obtinguesdireccio)

      getdirection (obtinguesdireccio)

  `getdirection` retorna la direcció de la tortuga a una quantitat de graus comptant des de zero, on zero és la direcció quan la tortuga està apuntant cap amunt.

center (centra)

      center

  `center` mourà la tortuga cap al centre sobre el llenç.

go (vesa)

      go X,Y

  `go` ordena a la tortuga anar cap a un lloc determinat en el llenç. Aquest lloc és X píxels des de l'esquerra del llenç, i Y píxels des de la part superior del llenç.

gox (vesax)

      gox X

  `gox` ordena a la tortuga que es desplaci X píxels des de l'esquerra del llenç mantenint la seva estada a la mateixa alçada. `gox` pot abreujar-se com `gx`.

goy (vesay)

      goy Y

  `goy` ordena a la tortuga que es desplaci Y píxels des de la part superior del llenç mantenint la seva estada a la mateixa distància de la vora esquerra del llenç. `goy` pot abreujar-se com `gy`.

### Nota

Utilitzant les ordres `go`, `gox`, `goy` i `center` la tortuga no dibuixarà una línia, tant se val si el llapis és cap amunt o cap avall.

### On està la tortuga?

Hi ha dues ordres que retornen la posició de la tortuga sobre la pantalla.

getx (obtinguesx)

  `getx` retorna el nombre de píxels des de l'esquerra del llenç cap a la posició actual de la tortuga.

gety (obtinguesy)

  `gety` retorna el nombre de píxels des de la part superior del llenç cap a la posició actual de la tortuga.

### La tortuga té un llapis

La tortuga té un llapis que traça una línia quan aquesta es mou. Hi ha unes quantes ordres per a controlar el llapis. S'expliquen en aquesta secció.

penup -pu- (aixecallapis -al-)

      penup

  `penup` aixeca el llapis del llenç. Quan el llapis està «amunt» no es dibuixarà cap línia quan es mogui la tortuga. Vegeu també `pendown`. `penup` pot abreujar-se com `pu`.

pendown -pd- (baixallapis -bl-)

      pendown

  `penup` pressiona el llapis sobre el llenç. Quan el llapis està «abaixat» es dibuixarà una línia quan es mogui la tortuga. Vegeu també `penup`. `pendown` pot abreujar-se com `pd`.

penwidth -pw- (gruixllapis -gl-)

      penwidth X

  `penwidth` estableix l'amplada del traç del llapis (l'amplada de la línia) per una quantitat de X píxels. `penwidth` pot abreujar-se com `pw`.

pencolor -pc- (colorllapis -cl-)

      pencolor R,G,B

  `pencolor` estableix el color del llapis. `pencolor` pren una combinació RGB com a entrada. `pencolor` pot abreujar-se com `pc`.

### Ordres per a controlar el llenç

Hi ha diverses ordres per a controlar el llenç.

canvassize -cs- (midapaper -mp-)

      canvassize X,Y

  Amb l'ordre `canvassize` podreu establir la mida del llenç. Agafa X i Y com a entrada, on X és l'amplada del llenç nou en píxels, i Y és l'alçada del llenç nou en píxels. `canvassize` pot abreujar-se com `cs`.

canvascolor -cc- (colorpaper -cp-)

      canvascolor R,G,B

  `canvascolor` estableix el color del llenç. `canvascolor` pren una combinació RGB com a entrada. `canvascolor` pot abreujar-se com `cc`.

### Ordres per a netejar

Hi ha dues ordres per a netejar el llenç després d'haver fet un embolic.

clear -ccl- (neteja -net-)

      clear

  Amb `clear` podreu netejar tots els dibuixos del llenç. Totes les altres coses hi romandran: La posició i l'angle de la tortuga, el color del llenç, la visibilitat de la tortuga i la mida del llenç.

reset (restableix)

      reset

  `reset` neteja molt més a fons que l'ordre `clear`. Després d'una ordre `reset` tot quedarà com en iniciar el KTurtle. La tortuga es col·loca al centre de la pantalla, el color del llenç és blanc, la tortuga dibuixa un traç negre sobre el llenç i la mida del llenç s'estableix a 400 x 400 píxels.

### La tortuga és un sprite

En primer lloc, una breu explicació del que són els sprites: Els sprites són imatges petites que es poden moure per la pantalla, com veiem sovint en els jocs d'ordinador. La nostra tortuga és un sprite. Per a més informació, vegeu el glossari quant a sprites.

A continuació trobareu una descripció completa de totes les ordres per a treballar amb sprites.

### Nota

La versió actual del KTurtle encara no admet l'ús de sprites que no sigui la tortuga. Amb les futures versions es podrà canviar la tortuga per alguna cosa del vostre propi disseny.

spriteshow -ss- (mostra -mo-)

      spriteshow

  `spriteshow` fa la tortuga visible de nou després d'haver-la ocultat. `spriteshow` pot abreujar-se com `ss`.

spritehide -sh- (oculta -oc-)

      spritehide

  `spritehide` oculta la tortuga. Es pot utilitzar si la tortuga no s'ajusta al vostre dibuix. `spritehide` pot abreujar-se com `sh`.

### Pot escriure la tortuga?

La resposta és: «Sí». La tortuga pot escriure: Escriu gairebé tot el que se li ordena.

print (imprimeix)

      print X

  L'ordre `print` s'utilitza per a ordenar a la tortuga que escrigui quelcom en el llenç. `print` pren els números i cadenes com a entrada. Podeu imprimir diversos nombres i cadenes mitjançant el símbol «+». Vegeu aquest petit exemple:

      $year = 2003
      $author = "Joan"
      print "En " + $author + " va començar el projecte KTurtle al " + $year + " i encara gaudeix treballant-hi!"

fontsize (midalletra)

      fontsize X

  `fontsize` estableix la mida de la lletra utilitzada per `print`. `fontsize` pren una entrada que ha de ser un nombre. La mida s'estableix en píxels.

### Ordres matemàtiques

Les següents ordres són les ordres matemàtiques més avançades del KTurtle.

round (arrod)

      round(x)

  `round` arrodoneix el nombre indicat a l'enter més proper.

      print round(10,8)
      forward 20
      print round(10,3)

  Amb aquest codi la tortuga imprimirà els nombres 11 i 10.

random -rnd- (aleatori -ale-)

      random X,Y

  `random` és una ordre que pren l'entrada i dona una sortida. Com entrada requereix dos nombres, el primer (X) estableix el mínim de la sortida, el segon (Y) estableix el màxim. La sortida és un nombre escollit a l'atzar que és igual o superior al mínim i igual o inferior que el màxim. Aquí hi ha un petit exemple:

      repeat 500 {
        $x = random 1,20
        forward $x
        turnleft 10 - $x
      }

  Utilitzant l'ordre `random` podeu afegir una mica de caos al vostre programa.

mod

      mod X,Y

  L'ordre `mod` retorna la resta de la divisió del primer número pel segon número.

sqrt (arrel)

      sqrt X

  L'ordre `sqrt` és un requisit per a trobar l'arrel quadrada d'un número, X.

pi

      pi

  Aquesta ordre retorna la constant Pi, `3,14159`.

sin, cos, tan

      sin X
      cos X
      tan X

  Aquestes tres ordres representen les famoses funcions trigonomètriques `sin`, `cos` i `tan`. L'argument d'entrada d'aquestes ordres, X, és un nombre.

arcsin, arccos, arctan

      arcsin X
      arccos X
      arctan X

  Aquestes ordres són les funcions inverses de sin, cos i tan. L'argument d'entrada d'aquestes ordres, X, és un nombre.

### Aportacions i comentaris a través dels diàlegs

Un diàleg és una petita finestra emergent que proporciona alguna informació o us demana alguna entrada. El KTurtle té dos ordres per als diàlegs, anomenades: `message` i `ask`

message (missatge)

      message X

  L'ordre `message` pren una cadena com a entrada. Mostra un diàleg emergent que conté el text de la cadena.

      message "En Joan va començar el projecte KTurtle el 2003 i encara gaudeix treballant-hi!"

ask (pregunta)

      ask X

  `ask` pren una cadena com a entrada. La mostra en un diàleg emergent (similar a message), juntament amb un camp d'entrada. Després que l'usuari ha introduït un nombre o una cadena, el resultat es pot desar en una variable o passar-lo com a argument a una ordre. Per exemple:

      $in = ask "Quina és la vostra data de naixement?"
      $out = 2003 - $in
      print "L'any 2003 vàreu tenir " + $out + " anys d'edat en algun moment."

  Si l'usuari cancel·la el diàleg d'entrada, o no introdueix res, la variable quedarà buida.

Assignar les variables
Assignar les variables

## Assignar les variables

En primer lloc, donarem una ullada a les variables, llavors ens centrarem en l'assignació de valors a aquestes variables.

Les variables són paraules que comencen amb un «$», en l'editor es ressalten amb color porpra.

Les variables poden contenir qualsevol nombre, cadena o valor booleà (true/false -cert/fals-). Utilitzant l'assignació, `=`, una variable pren el seu contingut. La qual mantindrà el contingut fins que el programa s'acabi d'executar o fins que la variable es torni a assignar a quelcom altre.

Podeu utilitzar variables, un cop assignades, simplement mantenen el seu contingut. Per exemple, en el següent fragment de TurtleScript:

    $x = 10
    $x = $x / 3
    print $x

Primer a la variable `$x` se li assigna `10`. Llavors a `$x` es torna a assignar a la seva divisió per `3` -això significa que `$x` es torna a assignar al producte de `10 / 3`. Finalment s'imprimeix `$x`. En la línia dos i tres veureu que `$x` s'utilitza com si fos el seu contingut.

Les variables s'han d'assignar per tal de ser utilitzades. Per exemple:

    print $n

Donarà com a resultat un missatge d'error.

Observem el següent fragment de TurtleScript:

    $a = 2004
    $b = 25

    # Les següents ordres imprimeixen «2029»
    print $a + $b
    backward 30
    # La següent ordre imprimeix «2004 més 25 és igual que 2029»
    print $a + " més " + $b + " és igual que " + ($a + $b)

En les dues primeres línies les variables `$a` i `$b` s'estableixen a 2004 i 25. Després s'executen dues ordres `print` amb una `backward 30` al mig. Els comentaris abans de l'ordre `print` expliquen el que faran. L'ordre `backward 30` hi és per a assegurar que cada sortida és una nova línia. Com podeu veure les variables es poden utilitzar com si fossin el que contenen, es poden utilitzar amb qualsevol mena d'operador o com a entrada en utilitzar altres ordres.

Un exemple més:

    $name = ask "Quin és el teu nom?"
    print "Hola " + $name + "! Bona sort mentre apreneu l'art de la programació..."

Força simple. Una vegada més podeu veure com la variable `$name`, és tractada com una cadena.

En utilitzar variables l'inspector resulta molt útil. Mostra el contingut de totes les variables que estan actualment en ús.

Controlar l'execució
Controlar l'execució

## Controlar l'execució

Els controladors de l'execució us permeten -tal com el seu nom indica- controlar l'execució.

Els controladors de l'execució es ressalten amb color verd fosc en una lletra en negreta. Els parèntesis s'utilitzen juntament amb els controladors de l'execució i es ressalten amb color negre.

### Fer que la tortuga esperi

Si heu fet alguna cosa de programació en el KTurtle, us haureu adonat que la tortuga pot ser molt ràpida dibuixant. Aquesta ordre farà que la tortuga esperi un període de temps determinat.

wait (espera)

      wait X

  `wait` fa que la tortuga esperi durant X segons.

      repeat 36 {
        forward 5
        turnright 10
        wait 0.5
      }

  Aquest codi dibuixa un cercle, però la tortuga esperarà mig segon després de cada pas. Això fa l'efecte d'una tortuga lenta.

### Executa «if -si-»

if (si)

      if booleà { ... }

  El codi que es col·loca entre els claudàtors només s'executarà si el valor booleà avalua «true».

      $x = 6
      if $x > 5 {
        print "$x és més gran que cinc!"
      }

  A la primera línia `$x` està establert a 6. En la segona línia s'utilitza un operador de comparació per a avaluar $x > 5. Atès que aquest avalua «true», 6 és més gran que 5, el controlador de l'execució `if` permet executar el codi entre els claudàtors.

### Si no, en altres paraules: «else -altrament-»

else (altrament)

      if booleà { ... } else { ... }

  `else` es pot utilitzar a més del controlador de l'execució `if`. El codi entre claudàtors després de `else` només s'executa si el booleà avalua «false».

      reset
      $x = 4
      if $x > 5 {
        print "$x és més gran que cinc!"
      } else {
        print "$x és més petit que sis!"
      }

  L'operador de comparació avalua l'expressió `$x > 5`. Donat que 4 no és més gran que 5, l'expressió s'avalua com «fals». Això significa que el codi entre claudàtors després de `else` serà executat.

### El bucle «while -mentre-»

while (mentre)

      while booleà { ... }

  El controlador de l'execució `while` s'assembla molt a `if`. La diferència és que `while` no deixa de repetir (en bucle) el codi entre claudàtors fins que el booleà avalua «false».

      $x = 1
      while $x < 5 {
        forward 10
        wait 1
        $x = $x + 1
      }

  En la primera línia `$x` s'estableix a 1. En la segona línia s'avalua `$x < 5`. Atès que la resposta a aquesta pregunta és «true» el controlador de l'execució while començarà a executar el codi entre claudàtors fins que `$x < 5` avaluï «false». En aquest cas el codi entre els claudàtors s'executarà quatre vegades, perquè cada vegada que s'executa la cinquena línia `$x` s'incrementa en 1.

### El bucle «repeat -repeteix-»

repeat (repeteix)

      repeat nombre { ... }

  El controlador de l'execució `repeat` és molt similar `while`. La diferència és que `repeat` no deixa de repetir (en bucle) el codi entre els claudàtors tantes vegades com indica el nombre.

### El bucle «for -per-», un bucle de comptatge

for (per)

      for variable = nombre to nombre { ... }

  El bucle `for` és un «bucle de comptatge», és a dir, que porta el compte per a vós. El primer nombre estableix la variable amb el valor en el primer bucle. Cada bucle incrementa aquest nombre fins que s'assoleix el segon nombre.

      for $x = 1 to 10 {
        print $x * 7
        forward 15
      }

  Cada vegada que s'executa el codi entre claudàtors `$x` s'incrementa en 1, fins que `$x` assoleix al valor de 10. El codi entre claudàtors imprimeix `$x` multiplicat per 7. Després que aquest programa acaba la seva execució veureu la taula de temps de 7 en el llenç.

  L'increment predeterminat d'un bucle és 1, podeu utilitzar un altre valor amb

      for variable = nombre to nombre step nombre { ... }

### Deixar un bucle

break (trenca)

      break

  Finalitza el bucle actual immediatament i transfereix el control a la sentència immediatament següent a aquest bucle.

### Aturar l'execució del vostre programa

exit (surt)

      exit

  Finalitza l'execució del vostre programa.

### Comprovar les declaracions en temps d'execució

assert (declara)

      assert booleà

  Es pot utilitzar per a raonar sobre la correcció del programa o de l'entrada.

      $in = ask "Quina és la vostra data de naixement?"
      # l'any ha de ser un nombre positiu
      assert $in
      > 0

Crear les vostres pròpies ordres amb «learn -aprèn-»
Crear les vostres pròpies ordres amb «learn -aprèn-»

## Crear les vostres pròpies ordres amb «learn -aprèn-»

`learn` és especial, ja que s'utilitza per a crear les vostres pròpies ordres. Les ordres que creeu poden agafar una entrada i retornar una sortida. Donem una ullada a com es crea una ordre nova:

    learn circle $x {
      repeat 36 {
        forward $x
        turnleft 10
      }
    }

La nova ordre s'anomena `circle`. `circle` té una entrada com argument, per a establir la mida del cercle. `circle` no torna cap sortida. Ara podeu utilitzar l'ordre `circle` com una ordre normal a la resta del codi. Vegeu aquest exemple:

    learn circle $X {
      repeat 36 {
        forward $X
        turnleft 10
      }
    }

    go 200,200
    circle 20

    go 300,200
    circle 40

En el següent exemple, es crea una ordre amb un valor de retorn.

    learn faculty $x {
      $r = 1
      for $i = 1 to $x {
        $r = $r * $i
      }
      return $r
    }

    print faculty 5

En aquest exemple es crea una ordre nova anomenada `faculty`. Si l'entrada d'aquesta ordre és `5`, la sortida serà `5*4*3*2*1`. Mitjançant l'ús de `return` s'especificarà el valor de la sortida i es retornarà la fi de l'execució.

Les ordres poden tenir més d'una entrada. En el següent exemple, es crea una ordre que dibuixa un rectangle:

    learn box $x, $y {
      forward $y
      turnright 90
      forward $x
      turnright 90
      forward $y
      turnright 90
      forward $x
      turnright 90
    }

Ara podeu executar `box 50, 100` i la tortuga dibuixarà un rectangle en el llenç.

Capítol 5. Glossari
Glossari

# Capítol 5. Glossari

En aquest capítol trobareu una explicació de la majoria dels mots «poc freqüents» que s'empren en aquest manual.

graus

  Els graus són unitats per a mesurar angles o girs. Un gir complet és de 360 graus, una mitja volta és de 180 graus i una quarta part de volta és de 90 graus. Us cal escriure les mesures en graus en les ordres `turnleft` (`giraesquerra`), `turnright` (`giradreta`) i `direction` (`direcció`).

Entrada i sortida de les ordres

  Algunes ordres agafen l'entrada, d'altres donen una sortida, d'altres agafen l'entrada i donen una sortida i d'altres ni agafen una entrada ni donen una sortida.

  Alguns exemples d'ordres que només agafen l'entrada són:

      forward 50
      pencolor 255,0,0
      print "Hola!"

  L'ordre `forward` (`avança`) pren `50` com a valor d'entrada. Us cal saber quants píxels necessiteu per a anar endavant. `pencolor` (`colorllapis`) agafa un color com entrada i `print` (`imprimeix`) agafa una cadena (un tros de text) com a entrada. Observeu que l'entrada també port ser un contenidor. El següent exemple ho il·lustra:

      $x = 50
      print $x
      forward 50
      $str = "hola!"
      print $str

  Ara alguns exemples d'ordres que donen la sortida:

      $x = ask "Si us plau, escriviu quelcom i premeu Bé... gràcies!"
      $r = random 1,100

  L'ordre `ask` (`pregunta`) agafa una cadena com a entrada i mostra com a eixida el nombre o cadena que s'introdueix. Com podeu veure, la sortida de `ask` es desa en el contenidor `x`. L'ordre `random` (`aleatori`) també dona la sortida. En aquest cas fa sortir un número entre 1 i 100. La sortida es desa en un contenidor anomenat `r`. Fixeu-vos que `x` i `r` no s'utilitzen en l'exemple de sobre.

  Hi ha ordres que necessiten una entrada, però no donen cap sortida. Mireu aquests exemples:

      clear
      penup

ressaltat intuïtiu

  Aquesta és una característica del KTurtle que facilita la creació de codi. El codi que escriviu obté un color indicant de quin tipus es tracta. En la llista següent trobareu els diversos tipus de codi i el color que s'obté en l'editor.

  Taula 5.1. Diferents tipus de codi i el seu color de ressaltat

  ordres normals | blau fosc | Les ordres normals es descriuen aquí.
  ordres que controlen l'execució | negre (en negreta) | Aquestes ordres especials que controlen l'execució, llegiu més sobre aquest tema aquí.
  comentaris | gris | Els comentaris de les línies s'inicien amb el caràcter (#). Aquestes línies no es tenen en compte en l'execució del codi. Aquests comentaris permeten al programador explicar el codi o bé impedir que una seqüència de codi s'executi.
  claus {, } | verd fosc (en negreta) | Les claus s'utilitzen per a agrupar porcions de codi. Sovint s'utilitzen juntament amb controladors d'execució.
  l'ordre learn (aprèn) | verd clar (en negreta) | L'ordre learn (aprèn) s'utilitza per a crear ordres noves.
  cadenes | vermell | No cal dir gaires coses sobre les cadenes (de text), tenint en compte que han de començar i finalitzar amb cometes dobles «"».
  nombres | vermell fosc | No hi ha gaire a dir sobre els nombres.
  valors booleans | vermell fosc | Hi ha exactament dos valors booleans, és a dir: «true (cert)» i «false (fals)».
  variables | púrpura | Comencen amb un «$» i poden contenir nombres, cadenes o valors booleans.
  operadors matemàtics | gris | Aquests són els operadors matemàtics: `+`, `-`, `*`, `/` i `^`.
  operadors de comparació | blau clar (en negreta) | Aquests són els operadors de comparació: `==`, `!=`, `<`, `>`, `<=` i `>=`.
  operadors booleans | rosa (en negreta) | Aquests són els operadors booleans: `and` (`i`), `or` (`o`) i `not` (`no`).
  text normal | negre |

píxels

  Un píxel és un punt en la pantalla. Si mireu de prop el monitor, veureu que la pantalla té uns quants punts que formen les imatges. Totes les imatges de la pantalla es construeixen per la combinació d'aquests píxels. Un píxel és l'element més petit dibuixat a la pantalla.

  Moltes de les ordres necessiten un nombre de píxels com a entrada. Aquestes ordres són: `forward` (`avança`), `backward` (`recula`), `go` (`vesa`), `gox` (`vesax`), `goy` (`vesay`), `canvassize` (`midapaper`) i `penwidth` (`gruixllapis`).

  En les primeres versions del KTurtle, el llenç era essencialment una imatge, però, per a les últimes versions del llenç és un dibuix vectorial. Això significa que al llenç es pot fer zoom apropant i allunyant, per tant, un píxel no necessàriament ha de traduir-se en un punt a la pantalla.

Combinacions RGB (codis de color)

  Les combinacions RGB són utilitzades per a descriure els colors. La «R» vol dir «vermell», la «G» vol dir «verd» i la «B» que vol dir «blau». Un exemple de la combinació RGB és `255,0,0`: El primer valor («vermell») és 255 i la resta 0, això vol dir que es tracta del vermell pur. Cada valor d'una combinació RGB ha d'estar en un interval entre el 0 i el 255. Aquí teniu una petita llista dels colors més utilitzats:

  Taula 5.2. Combinacions RGB més utilitzades

  `0,0,0` | negre
  `255,255,255` | blanc
  `255,0,0` | vermell
  `150,0,0` | vermell fosc
  `0,255,0` | verd
  `0,0,255` | blau
  `0,255,255` | blau clar
  `255,0,255` | rosa
  `255,255,0` | groc

  Hi ha dues ordres que necessiten una combinació RGB com a entrada: Aquestes són `canvascolor` (`colorpaper`) i `pencolor` (`colorllapis`).

sprite

  Un «sprite» és una petita imatge que es pot moure per tota la pantalla. La nostra tortuga, per exemple, és un sprite.

  ### Nota

  Amb aquesta versió del KTurtle l'«sprite» no es pot canviar. En futures versions del KTurtle es podrà fer.

Capítol 6. Guia de traducció del KTurtle
Guia de traducció del KTurtle

# Capítol 6. Guia de traducció del KTurtle

Com probablement ja sabeu, el TurtleScript és el llenguatge de programació del KTurtle, es permet traduir-lo. Això elimina una barrera per a algunes persones, especialment per als estudiants més joves, en el seu esforç per a entendre els conceptes bàsics de la programació.

Quan es tradueix el KTurtle a un nou idioma trobareu, a més de les cadenes de la interfície gràfica d'usuari, les ordres de programació, els exemples i els missatges d'error inclosos en els fitxers `.pot` estàndard utilitzats per a la traducció en el KDE. Tot és traduït utilitzant el mètode de traducció normal en el KDE, però, es recomana aprendre una mica sobre la forma de traducció (així com llegir els comentaris del traductor).

Si us plau, vegeu https://edu.kde.org/kturtle/translation.php per a obtenir més informació sobre el procés de traducció. Moltes gràcies per la vostra feina! El KTurtle depèn en gran manera de les vostres traduccions.

Capítol 7. Crèdits i Llicència
Crèdits i Llicència

# Capítol 7. Crèdits i Llicència

KTurtle

Copyright del programa 2003-2007 Cies Breijs `(cies AT kde DOT nl)`

Copyright de la documentació 2004, 2007 i 2009

- Cies Breijs `(cies AT kde DOT nl)`

- Mahfouf, Anne-Marie `(annma AT kde.org)`

- Canvis després de la correcció: Rodrigues, Philip `(phil AT kde.org)`

- Alguns canvis des de la darrera traducció: Andrew Coles `(andrew_coles AT yahoo DOT co DOT uk)`

Traductor de la documentació: Daniel Fortuny Anguera `(dfortuny AT pie.xtec.es)` i Antoni Bella `(antonibella5 AT yahoo.com)`

Aquesta documentació està llicenciada d'acord amb les clàusules de la Llicència de Documentació Lliure de GNU.

Aquest programa està llicenciat d'acord amb les clàusules de la Llicència Pública General de GNU.

Índex d'ordres
Índex d'ordres

# Índex d'ordres

### A

and, Els operadors booleans («true/false» -cert/fals-)
arccos, Ordres matemàtiques
arcsin, Ordres matemàtiques
arctan, Ordres matemàtiques
ask (pregunta), Aportacions i comentaris a través dels diàlegs
assert (declara), Comprovar les declaracions en temps d'execució

### B

backward -bw- (recula -re-), Moure la tortuga
break (trenca), Deixar un bucle

### C

canvascolor -cc- (colorpaper -cp-), Ordres per a controlar el llenç
canvassize -cs- (midapaper -mp-), Ordres per a controlar el llenç
center (centra), Moure la tortuga
clear -ccl- (neteja -net-), Ordres per a netejar
cos, Ordres matemàtiques

### D

direction -dir- (direcció -dir-), Moure la tortuga

### E

else (altrament), Si no, en altres paraules: «else -altrament-»
exit (surt), Aturar l'execució del vostre programa

### F

false, Els valors booleans («true/false» -cert/fals-)
fontsize (midalletra), Pot escriure la tortuga?
for (per), El bucle «for -per-», un bucle de comptatge
forward -fw- (avança -av-), Moure la tortuga

### G

getdirection (obtinguesdireccio), Moure la tortuga
getx (obtinguesx), On està la tortuga?
gety (obtinguesy), On està la tortuga?
go (vesa), Moure la tortuga
gox (gx), Moure la tortuga
goy (gy), Moure la tortuga

### I

if (si), Executa «if -si-»

### L

learn, Crear les vostres pròpies ordres amb «learn -aprèn-»

### M

message (missatge), Aportacions i comentaris a través dels diàlegs
mod, Ordres matemàtiques

### N

not, Els operadors booleans («true/false» -cert/fals-)

### O

or, Els operadors booleans («true/false» -cert/fals-)

### P

pencolor -pc- (colorllapis -cl-), La tortuga té un llapis
pendown -pd- (baixallapis -bl-), La tortuga té un llapis
penup -pu- (aixecallapis -al-), La tortuga té un llapis
penwidth -pw- (gruixllapis -gl-), La tortuga té un llapis
pi, Ordres matemàtiques
print (imprimeix), Pot escriure la tortuga?

### R

random -rnd- (aleatori -ale-), Ordres matemàtiques
repeat (repeteix), El bucle «repeat -repeteix-»
reset (restableix), Ordres per a netejar
return, Crear les vostres pròpies ordres amb «learn -aprèn-»
round (arrod), Ordres matemàtiques

### S

sin, Ordres matemàtiques
spritehide -sh- (oculta -oc-), La tortuga és un sprite
spriteshow -ss- (mostra -mo-), La tortuga és un sprite
sqrt (arrel), Ordres matemàtiques
step (pas), El bucle «for -per-», un bucle de comptatge

### T

tan, Ordres matemàtiques
to (finsa), El bucle «for -per-», un bucle de comptatge
true, Els valors booleans («true/false» -cert/fals-)
turnleft -tl- (giraesquerra -ge-), Moure la tortuga
turnright -tr- (giradreta -gd-), Moure la tortuga

### W

wait (espera), Fer que la tortuga esperi
while (mentre), El bucle «while -mentre-»