Manual de KTurtle

# Manual de KTurtle

Cies Breijs `<cies EN kde PUNTO nl>`

Anne-Marie Mahfouf `<annma EN kde PUNTO org>`

Mauricio Piacentini `<piacentini EN kde PUNTO org>`

Tradutor do proxecto Trasno: Marce Villarino
Tradutor do proxecto Trasno: Xosé Calvo
Revisión 0.8.1 beta (Aplicacións 16.04) (2016-05-07)

Copyright © 2004, 2009 Cies Breijs

Copyright © 2004, 2007 Anne-Marie Mahfouf

Copyright © 2007 Mauricio Piacentini

Aviso Legal

KTurtle é un ambiente educativo de programación que pretende facer que aprender a programar sexa tan sinxelo como se poida. Para conseguilo KTurtle fai que todas as ferramentas de programación estean dispoñíbeis na interface do usuario. A linguaxe de programación que se emprega é TurtleScript, que permite traducir as ordes ao seu idioma.

Lista de Táboas

4.1. Tipos de preguntas
5.1. Os distintos tipos de código e a cor coa que se realzan
5.2. Combinacións RGB empregadas a miudo

Capítulo 1. Introdución
Introdución

# Capítulo 1. Introdución

KTurtle é un ambiente de programación para a educación que utiliza TurtleScript, unha linguaxe de programación inspirada en Logo e baseada nesta. O propósito de KTurtle é simplificar a programación e facela tan accesíbel como for posíbel. Isto fai que KTurtle sexa axeitado para ensinarlles aos cativos os fundamentos das matemáticas, a xeometría e a programación. Unha das principais características de TurtleScript é que as ordes da linguaxe poden traducirse ao idioma do programador.

O nome de KTurtle procede « do sapoconcho » que ten un papel central no ambiente de programación. O estudante normalmente ordenaralle ao sapoconcho, mediante as ordes de TurtleScript, que debuxe unha imaxe no lenzo.

## Que é TurtleScript?

TurtleScript, a linguaxe de programación empregada en KTurtle, está inspirada na familia de linguaxes de programación Logo. A primeira versión de Logo creouna Seymour Papert do Laboratorio de Intelixencia Artificial do MIT en 1967 como fillo da linguaxe LISP. Desde entón publicáronse varias versións de Logo. En 1980 Logo gañou popularidade: había versións para MSX, Commodore, Atari, Apple II e IBM PC. Estas versións foron principalmente destinadas a usos educativos. O MIT aínda mantén ten un sitio web sobre Logo que contén unha lista de varias realizacións populares desta linguaxe.

TurtleScript comparte unha funcionalidade que se atopa en moitas outras realizacións de Logo: a posibilidade de traducir as ordes ao idioma nativo do estudante. Isto fai máis sinxelo comezar para os estudantes que non coñecen ou que coñecen moi pouco inglés. Ademais desta característica KTurtle ten moitas outras que intentan simplificar as primeiras experiencias dos estudantes coa programación.

Funcionalidades de KTurtle
Funcionalidades de KTurtle

## Funcionalidades de KTurtle

KTurtle ten algunhas características que facilitan moito o comezar a programar. Estas son algunhas das funcionalidades máis realzábeis de KTurtle:

- Un ambiente integrado cun intérprete de TurtleScript, editor, lenzo e outras utilidades todas xuntas nun aplicativo (sen dependencias adicionais).

- A posibilidade de traducir as ordes de TurtleScript empregando a infraestrutura de tradución de KDE.

- TurtleScript permítelle o usuario definir funcións, recursión e cambio dinámico de tipos.

- A execución pode ralentizarse, pausarse ou deterse en calquera momento.

- Un potente editor con realzado intuitivo da sintaxe, numeración de liñas, marcas de erros, execución visual e máis cousas.

- O lenzo, onde debuxa o sapoconcho, pode imprimirse ou gardarse como unha imaxe (PNG) ou debuxo (SVG).

- Axuda contextual: onde a precise. Prema F2 (ou consulte Axuda → Sobre: …) para obter axuda sobre a peza de código que teña baixo o cursor.

- Un diálogo de erro que liga as mensaxes de erro cos erros no programa e que as sinala en vermello.

- Terminoloxía de programación moi simplificada.

- Programas de exemplo para facilitar aínda máis os inicios. Estes exemplo tradúcense empregando a infraestrutura de tradución de KDE.

Capítulo 2. Utilización de KTurtle
Utilización de KTurtle

# Capítulo 2. Utilización de KTurtle

A xanela principal de KTurtle ten tres partes principais: o editor de código (1) á esquerda onde pode escribir as ordes de TurtleScript, o lenzo (2), á dereita, onde a tartaruga fai o deseño e o inspector (3) que dá información cando se executa o programa. Alén destes, atópanse a barra de menú (5), desde a que se pode acceder a todas as accións, a barra de ferramentas (4) que permite acceder rapidamente ás accións máis empregadas, a Consola, que permite escribir unha liña de ordes para probala, e a barra de estado (na parte inferior da pantalla), na que se atopa información referente ao estado de KTurtle.

## O editor

No editor é onde se escriben as ordes de TurtleScript. A maioría das súas funcións atópanse nos menús Ficheiro e Editar. O editor pode acoplarse en calquera bordo da xanela principal ou pode desprenderse e porse en calquera parte do escritorio.

Hai varias maneiras de ter código no editor. A máis fácil é empregar un exemplo xa feito: escolla Ficheiro → Exemplos no menú Ficheiro e escolla un exemplo. O que escolla será aberto no editor, e entón poderá empregar Executar → Executar na barra de menú ou o botón Executar da barra de menú para executar o código se o desexa.

Pode abrir ficheiros escritos en TurtleScript mediante Ficheiro → Abrir….

A terceira maneira é escribir directamente o código no editor ou copiar e pegar código desta guía do usuario.

O lenzo
O lenzo

## O lenzo

O lenzo é a área na que se visualiza o efecto das ordes, na que a tartaruga debuxa segundo a orde que reciba. Tras escribir algún código no editor, e executalo poden ocorrer dúas cousas: ou que se execute correctamente o código, e o máis probábel é que vexa algún cambio no lenzo; ou que cometese algún erro no código e aparecerá a lapela de erros cunha mensaxe que explica o erro que cometeu.

Pode achegar e afastar o lenzo mediante a roda do rato.

O inspector
O inspector

## O inspector

O inspector informa acercas das variábeis, as funcións definidas e mostra a árbore de código durante a execución do programa.

Pode acoplar o inspector a calquera bordo da xanela principal ou pode mesmo desprendelo e poñelo en calquera parte do escritorio.

A barra de ferramentas
A barra de ferramentas

## A barra de ferramentas

Aquí se poden buscar rapidamente as accións máis utilizadas. A barra de ferramentas contén tamén a Consola, desde a que se poden invocar ordes rapidamente; isto pode ser útil se se quere probar unha orde sen modificar o contido do Editor.

Pode configurar a barra de ferramentas mediante Configuración → Configurar as barras de ferramentas… para que se axuste mellor ás súas preferencias.

A barra de menú
A barra de menú

## A barra de menú

Na barra de menú atópanse todas as accións de KTurtle. Agrúpanse nos grupos seguintes: Ficheiro, Editar, Lenzo, Executar, Ferramentas, Configuracióne Axuda. Esta sección descríbeos todos.

### O menú Ficheiro

Ficheiro → Novo (Ctrl+N)

  Crea un ficheiro de TurtleScript novo baleiro.

Ficheiro → Abrir… (Ctrl+A)

  Abre un ficheiro de TurtleScript.

Ficheiro → Abrir un recente

  Abre un ficheiro de TurtleScript que se abrise recentemente.

Ficheiro → Exemplos

  Abre programas de exemplo de TurtleScript. Os exemplos están na súa linguaxe segundo a escollese en Configuración → Linguaxe do script.

Ficheiro → Obter máis exemplos…

  Abrir o diálogo Obter novidades para descargar ficheiros de TurtleScript adicionais de internet.

Ficheiro → Gardar (Ctrl+G)

  Garda o ficheiro de TurtleScript que estea aberto.

Ficheiro → Gardar como... (Ctrl+Maiúsc+c)

  Garda nun lugar indicado o ficheiro aberto de TurtleScript.

Ficheiro → Exportar a HTML…

  Exporta o contido do editor a un ficheiro en HTML que inclúe as cores de realzado.

Ficheiro → Imprimir… (Ctrl+P)

  Imprime o código que haxa no editor.

Ficheiro → Saír (Ctrl+Q)

  Sae de KTurtle.

### O menú Editar

Editar → Desfacer (Ctrl+Z)

  Desfai o último cambio feito no código. KTurtle non ten límite ao desfacer.

Editar → Refacer (Ctrl+Maiúsc+Z)

  Refai un cambio desfeito no código.

Editar → Cortar (Ctrl+X)

  Corta o texto escollido no editor para o portapapeis.

Editar → Copiar (Ctrl+C)

  Copia o texto escollido no editor ao portapapeis.

Editar → Pegar (Ctrl+V)

  Pega o texto do portapapeis no editor.

Editar → Escoller todo (Ctrl+A)

  Escolle todo o texto do editor.

Editar → Atopar… (Ctrl+F)

  Con esta acción pode atopar frases no código.

Editar → Atopar o seguinte (F3)

  Empregue isto para atopar a seguinte aparición da frase que busca.

Editar → Atopar a anterior (Maiúsc+F3)

  Empregue isto para atopar a aparición anterior da frase que busca.

Editar → Modo de substitución (Ins)

  Troca entre os modos «inserir» e «substituír».

### O menú Lenzo

Lenzo → Exportar como imaxe (PNG)…

  Exporta o contido do Lenzo como imaxe de bits tipo PNG (Gráficos de rede portábeis).

Lenzo → Exportar como debuxo (SVG)…

  Exporta o contido do Lenzo como debuxo vectorial do tipo SVG.

Lenzo → Imprimir o lenzo…

  Imprime o contido do Lenzo.

### O menú Executar

Executar → Executar (F5)

  Comeza a execución das ordes do editor.

Executar → Pausar (F6)

  Detén temporalmente a execución. Esta acción só está activada cando se están a executar ordes.

Executar → Cancelar (F7)

  Detén a execución. Esta acción só está activada cando se están a executar ordes.

Executar → Velocidade de execución

  Presenta unha lista coas velocidades de execución, que son: Velocidade máxima (sen realzado nin inspector), Velocidade máxima, Amodo, Máis amodo, Aínda máis amodo e Paso por paso. Se a velocidade de execución é Velocidade máxima (a predeterminada) será moi difícil seguir o que está a ocorrer. Ás veces búscase este comportamento, pero outras veces quererá saber que está a pasar. Neste caso escollerá as velocidades Amodo, Máis amodo ou Aínda máis amodo. Se escolle un dos modos de vagar mostrarase a posición actual en execución no editor. Paso por paso executará unha orde de cada vez.

### O menú de Ferramentas

Ferramentas → Selector de dirección…

  Esta acción abre o diálogo de selección de dirección.

Ferramentas → Selector de cor…

  Esta acción abre o diálogo de selección de cor.

### O menú Configuración

Configuración → Linguaxe do script

  Escoller o idioma no que estará o código.

Configuración → Mostrar o editor (Ctrl+E)

  Mostrar ou agochar o Editor.

Configuración → Mostrar o inspector (Ctrl+I)

  Mostrar o agochar o inspector.

Configuración → Mostrar os erros

  Mostrar ou agochar a lapela Erros cunha lista dos erros que xorden ao executar o código. Se activa esta opción, prema o Lenzo para ver de novo o sapoconcho.

Configuración → Mostrar os números de liña (F11)

  Con esta acción pode mostrar os números de liña no editor. Isto pode axudalo a atopar os erros.

Configuración → Mostrar a barra de ferramentas

  Conmutar a barra de ferramentas principal

Configuración → Mostrar a barra de estado

  Conmutar a barra de estado

Configuración → Configurar os atallos de teclado…

  O diálogo estándar de KDE para configurar os atallos.

Configuración → Configurar as barras de ferramentas…

  O diálogo estándar de KDE para configurar as barras de ferramentas.

### O menú de Axuda

KTurtle ten un menú de Axuda de KDE predeterminado, como se describe nos Fundamentos de KDE, cunha entrada adicional:

Axuda → Axuda sobre: … (F2)

  Esta é unha función moi útil: fornece axuda sobre o código no punto no que está o cursor no editor. Así, isto é utilizaches a orde `imprimir` no código e queres ler e saber o que di o manual sobre esta orde.Simplemente moves o cursor para que estea na orde `imprimir` e premes F2. O manual mostra toda a información sobre a orde `imprimir`.

  Esta función pode resultar moi útil para aprender TurtleScript.

A barra de estado
A barra de estado

## A barra de estado

A barra de estado mostra información sobre o estado de KTurtle. Á esquerda mostra información da última acción. Á dereita atópase o lugar onde está o cursor (número de liña e columna). Na parte central indícase a linguaxe empregada para as ordes.

Capítulo 3. Comezando
Comezando

# Capítulo 3. Comezando

Cando inicie KTurtle verá algo como isto:

Nesta guía de iniciación asumirase que o idioma das ordes de TurtleScript é o galego. Pode cambiar o idioma en Configuración → Idioma do script. Lembre que o idioma que lle indique aquí a KTurtle é o que utilizará para escribir as ordes de TurtleScript, non o idioma empregado por KDE no computador e utilizado na interface e menús de KTurtle.

## Os primeiros pasos con TurtleScript: coñeza o sapoconcho!

Xa se debeu decatar de que hai un sapoconcho no centro do lenzo: agora aprenderá a controlalo mediante ordes no editor.

### Os movementos do sapoconcho

Comecemos facendo que se mova o sapoconcho. O noso animal pode facer tres tipos de movemento, (1) pode moverse adiante e atrás, (2) pode xirar á esquerda e á dereita e (3) pode ir (saltar) directamente a unha posición na pantalla. Probe isto:

    avanza 100
    xiraesquerda 90

Escriba ou corte e pegue o código no editor e execúteo (empregando Executar → Executar) para ver o resultado.

Cando escribiu e executou as ordes como as de arriba no editor pode que se decatase dunha ou máis das seguintes cousas:

1. Que — tras executar as ordes — o sapoconcho rube, debuxa unha liña, e logo xira un cuarto de volta á esquerda. Isto é debido a que empregou as ordes `avanza` e `xiraesquerda`.

2. Que se cambiou a cor do código mentres a estaba a escribir: esta funcionalidade é chamara realzado intuitivo — distintos tipos de ordes son realzados de xeito distinto. Isto facilita a lectura de grandes bloques de código.

3. Que o animal debuxa unha liña branca fina.

4. Quizais obteña unha mensaxe de erro. Isto simplemente significará dúas cousas: ou que cometeu un erro ao copiar as ordes, ou que aínda non indicou a linguaxe correcta para as ordes de TurtleScript (pode facelo mediante Configuración → Linguaxe do script).

Posibelmente xa se decatase de que `avanza 100` ordenoulle ao sapoconcho que se mova cara diante deixando un rastro, e que `xiraesquerda 90` é para que o animal xire 90 graus á esquerda.

Consulte as seguintes ligazón ao manual de referencia para ter unha explicación completa das seguintes ordes: `avanza`, `retrocede`, `xiraesquerda` e `xiradereita`.

### Máis exemplos

O primeiro exemplo era moi simples, continuemos!

    reinicia

    tamañolenzo 200,200
    corlenzo 0,0,0
    corlapis 255,0,0
    ancholapis 5

    vai 20,20
    direccion 135

    avanza 200
    xiraesquerda 135
    avanza 100
    xiraesquerda 135
    avanza 141
    xiraesquerda 135
    avanza 100
    xiraesquerda 45

    vai 40,100

Novamente, pode escribir ou copiar e pegar o código no editor ou abrir o exemplo `frecha` no menú Exemplos e executalo (mediante Executar → Executar) para ver o resultado. Nos seguintes exemplos suponse que coñece o sistema.

Posibelmente xa se decatou de que este segundo exemplo utiliza moito máis código. Tamén hai un par de ordes novas. Velaí vai unha explicación breve das novas ordes:

Tras unha orde `reinicia` todo volve ser como se acabase de arrincar KTurtle.

`tamañolenzo 200,200` fai que a anchura e altura do lenzo sexa de 200 píxeles. A anchura e a altura son iguais, polo que o lenzo será un cadrado.

`corlenzo 0,0,0` fai que o lenzo sexa negro. `0,0,0` é unha combinación RGB onde todos os valores son `0`, o que dá a cor negra.

`corlapis 255,0,0` fai que a cor do lapis sexa vermella. `255,0,0` é unha combinación RGB onde só a cor vermella é `255` (total) mentres que as outras (verde e azul) son `0` (nulas). Isto resulta na cor vermella.

Se non comprende os valores das cores, lea a entrada no glosario sobre as combinacións RGB.

`ancholapis 5` fai que a anchura (o tamaño) do trazo sexa de `5` píxeles. De agora en diante cada liña que debuxe o sapoconcho terá un gordo de `5`, ata que cambie o `ancholapis`.

`vai 20,20` fai que o animal vaia a un certo lugar do lenzo. Contando desde a esquina superior esquerda, este lugar está a 20 píxeles da esquerda, e 20 píxeles para baixo do cume do lenzo. Lembre que cando se utiliza a orde `vai` o sapoconcho non debuxa liña ningunha.

`direccion 135` estabelece a dirección a onde mira o sapoconcho. As ordes `xiraesquerda` e `xiradereita` cambian o ángulo do animal desde a posición actual. A orde `direccion` cámbiao desde o cero, e polo tanto non é relativo á dirección anterior do sapoconcho.

Despois da orde `direccion` van unha morea de ordes `avanza` e `xiraesquerda`. Estes son os que fan o debuxo en si.

Finalmente outra orde `vai` move o sapoconcho para un lado.

Siga as ligazóns á referencia. Aló explícase cada orde con máis detalle.

Capítulo 4. Referencia do programador de TurtleScript
Referencia do programador de TurtleScript

# Capítulo 4. Referencia do programador de TurtleScript

Este é o manual do TurtleScript de KTurtle. Na primeira sección vense algúns aspectos da gramática dos programas de TurtleScript. A segunda sección trata das operacións matemáticas, operacións lóxicas (certo/falso) e operacións de comparación. A terceira sección é unha lista de todas as ordes explicándoas unha por unha. A cuarta sección explica como asignar valores a variábeis. Na quinta sección explícase como ordear a execución das ordes con sentenzas de control da execución e finalmente na sexta como crear as tuas proprias ordes con define.

## A gramática de TurtleScript

Como calquera linguaxe, TurtleScript ten diferentes tipos de palabras e símbolos. En galego distinguimos verbos (como «camiñar» ou «falar») e nomes (como «tartaruga» ou «bicicleta»), e úsanse para cousas diferentes. TurtleScript é unha linguaxe de programación que se usa para dicirlle á KTurtle o que ten que facer.

Nesta sección explícase brevemente que son algúns tipos de palabras de TurtleScript. Explicaremos os comentarios, ordes e os tres tipos diferentes de literais: números, textos e valores lóxicos (certo/falso).

### Comentarios

Un programa consiste en instrucións que se executan cando se executa o programa e en comentarios. Os comentarios non se executan, KTurtle ignóraos; somente están aí para que outros programadores entendan mellor o que fai o programa. En TurtleScript considérase comentario todo o que segue a un símbolo `#`. Por exemplo este programa que non fai ren:

    #este programa non fai ren, só é un comentario!

É pouco útil pero explica moi ben o asunto.

Os comentarios son moi útiles cando o programa empeza a ser algo complexo. Poden axudar a outros programadores. No seguinte programa podes ver comentarios usados xunto coa orde escribe.

    # este programa fíxoo Cies Breijs.
    escribe "este texto hase escribir no lenzo"
    # a liña anterior non é un comentario, a seguinte si:
    # escribe "este texto non se ha escribir!"

A primeira liña describe o programa. KTurtle executa a segunda e imprime `este texto hase escribir no lenzo` no lenzo. A terceira liña é un comentario, e a cuarta liña é un comentario que contén unha peza de TurtleScript, se eliminásemos o símbolo `#` desta liña KTurtle había executar a orde. Os programadores din: a orde escribe na cuarta liña está «comentada».

As liñas comentadas son realzadas en gris claro no editor do código.

### Ordes

Mediante as ordes díslle á tartaruga de KTurtle que faga algo. Algunhas ordes precisan datos, outras producen algunha saída.

    # avanza é unha orde que precisa de datos, neste caso o número 100:
    avanza 100

A primeira liña é un comentario. A segunda liña contén a orde `avanza` e o número `100`. O número non é parte da orde, senón que se considera «entrada» del.

Algunhas ordes como isto é `vai` precisan de máis dun dato de entrada. Cando son varios valores hai que separalos mediente `,` (comas).

Para coñecer máis detalles sobre todas as ordes permitidas por KTurtle vaia aquí. As ordes de serie reálzanse en azul escuro

### Números

Posibelmente xa saiba bastante sobre os números. A maneira de utilizar os números en KTurtle non é moi distinta da oral, nin da matemática.

Temos os números naturais: `0`, `1`, `2`, `3`, `4`, `5` etc, os números negativos: `-1`, `-2`, `-3` etc. E tamén temos números con parte decimal, por exemplo: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`. Úsase o `.` (punto) como separador decimal.

Os números poden ser utilizados en operacións matemáticas e comparacións. Tamén poden gardarse en variábeis. Os números reálzanse en roxo.

### Textos

Primeiro un exemplo:

    escribe "Olá, son un texto."

Neste exemplo `escribe` é unha orde na que `"Olá, son un texto."` é un texto. Os textos comezan e rematan con aspas, `"`, mediante as cais KTurtle sabe que é un texto.

Os textos poden porse en variábeis, igual que os números, pero a diferenza destes non poden usarse en operacións matemáticas nin en comparacións. Os textos reálzanse en vermello.

### Valores lóxicos (certo/falso)

Só hai dous valores lóxicos: `certo` e `falso`. Algunhas veces tamén se lles chama: verdadeiro e falso, si e non, un e cero. Pero en TurtleScript sempre se lles chama `certo` e `falso`. Bótalle unha olla da e este retallo de TurtleScript:

    $a = certo

. Se miran no inspector verás que a variábel `$a` ten o valor `certo` e é de tipo lóxico.

A miúdo os valores lóxicos son o resultado dunha operación de comparación, como no seguinte retallo de TurtleScript:

    $resposta = 10 > 3

A variábel `$resposta` ten o valor `certo` porque `10` é maior que `3`.

Os valores lóxicos, `certo` e `falso`, son realzados en roxo escuro.

Operacións matemáticas, lóxicas e de comparación
Operacións matemáticas, lóxicas e de comparación

## Operacións matemáticas, lóxicas e de comparación

O título desta sección pode parecer difícil, pero non o é tanto como parece.

### Operacións matemáticas

Estes son os símbolos matemáticos básicos: suma (`+`), resta (`-`), multiplicación (`*`), división (`/`) e potencia(`^` ).

Este é un exemplo das operacións matemáticas que podes usar no TurtleScript:

    $suma      = 1 + 1
    $resta      = 20 - 5
    $multiplica= 15*2
    $divide    = 30 / 30
    $repite    = 2 ^ 2

Os resultados das operacións matemáticas asígnanse a variábeis. Mediante o inspector pode consultalas.

Se só ques facer un cálculo simples podes facer algo como isto:

    escribe 2010-12

Agora un exemplo con parénteses:

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

As expresións entre parénteses serán calculadas primeiro. Neste exemplo, calcularase 20-5, logo multiplicarase por 2, dividirase entre 30, e finalmente engádeselle 1, co que dá o resultado 2. Os parénteses tamén se poden usar noutros casos.

KTurtle tamén ten funcionalidades matemáticas máis avanzadas entre as súas ordes. Bótalle un ollo ás seguintes ordes, pero ten en conta que son operacións avnzadas: redondea, aleatorio, raiz, pi, seno, coseno, tanxente, arcoseno, arcocoseno, arcotanxente.

### Operacións lóxicas (certo/falso)

Mentres que as operacións matemáticas son principalmente para números, as lóxicas sono para valores lóxicos (`certo` e `falso`). Só hai tres operacións lóxicas: `e`, `ou`, e `non`. Este retallo de TurtleScript mostra como usalos:

     $e_1_1 = certo e certo    # -> certo
    $e_1_0 = certo e falso              # -> falso
    $e_0_1 = falso e falso                        # -> falso
    $e_0_0 = falso e falso                        # -> falso

    $ou_1_1 = certo ou certo # -> certo
    $ou_1_0 = certo ou falso           # -> certo
    $ou_0_1 = falso ou certo           # -> certo
    $ou_0_0 = falso ou falso                     # -> falso
    n$non_1 = non certo   # -> falso
    $non_0 = non falso             # -> certo

Usando o inspector pode consultar os valores, aínda que poñemos os resultados nos comentarios ao final das liñas. `e` dá `certo` só se ambos os dous lados son `certo`. `ou` dá `certo` se algún dos lados é `certo`. E `non` converte un `certo` nun `falso` e un `falso` nun `certo`.

A operacións lóxicas reálzanse en rosa.

#### Algúns exemplos máis avanzados

Considera o seguinte exemplo con `e`:

    $a = 1
    $b = 5
    se ( ($a < 10) e ($b == 5) ) e ($a < $b) {
      escribe "Olá"
    }

Neste retallo de TurtleScript o resultado de tres operacións de comparación xúntase mediante operacións `e`. Isto significa que os tres deben dar «certo» para que se escriba «Olá».

Un exemplo con `ou`:

    %n = 1
    se ($n < 10) ou ($n == 2) {
      escribe "Olá"
    }

Neste retallo de TurtleScript o lado da esquerda do `ou` avalíase como «certo» e o da dereira a «falso». Xa que un dos lados do operador `ou` é «certo», o operador `ou` avalíase como «certo», en consecuencia escríbese «Olá».

E finalmente un exemplo con `non`, que troca para «certo» por «falso» e «falso» por «certo». Mira:

    $n = 1
    se non ($n == 3) {
      escribe "Olá"
    } senon {
      escribe "non olá ;-)"
    }

### Operacións de comparación

Considera esa sinxela comparación:

    $resposta = 10 > 3

Aquí compárase`10` con `3` mediante o operador «maior que». O resultado desta comparación, o valor lóxico `certo` gárdase na variábel `$resposta`.

Os números e as variábeis (que conteñen números) poden compararse entre si mediante operacións de comparación.

Este son todas as operacións de comparación:

TáboaTáboa 4.1. Tipos de preguntas

`$A == $B` | é igual a | a resposta é « certo » se `$A` conté o mesmo valor que `$B`
`$A != $B` | é diferente de | a resposta é « certo » se `$A` non é igual que `$B`
`$A > $B` | maior que | a resposta é « certo » se `$A` é maior que `$B`
`$A < $B` | menor que | a resposta é « certo » se `$A` é menor que `$B`
`$A >= $B` | maior ou igual que | a resposta é « certo » se `$A` é maior que ou igual a `$B`
`$A <= $B` | menor ou igual que | a resposta é « certo » se `$A` é menor que ou igual a `$B`

Lembra que $A e $B teñen que ser números ou variábeis que conteñan númeors.

Ordes
Ordes

## Ordes

Mediante as ordes pode dicirlle ao sapoconcho de KTurtle que faga algo. Algunhas ordes precisan de parámetros, outras xeran un resultado. Nesta sección explicamos todas as ordes que veñen de serie no KTurtle. Ademáis, mediante a orde define pode crear as súas propias ordes. As ordes de serie que se explican aquí reálzanse en azul escuro.

### Mover o sapoconcho

Hai varias ordes que moven o sapoconcho pola pantalla.

avanza (av)

      avanza X

  `avanza` move o sapoconcho cara diante X píxeles. Cando o lapis está pousado deixará un rastro. `avanza` pode abreviarse como `av`

retrocede (re)

      retrocede X

  `retrocede` move o sapoconcho cara atrás X píxeles. Se o lapis está pousado deixará un rastro. `retrocede` pode abreviarse como `re`.

xiraesquerda (xe)

      xiraesquerda X

  `xiraesquerda` ordénalle ao sapoconcho que xire X graus á esquerda. `xiraesquerda` pode abreviarse como `xe`.

xiradereita (xd)

      xiradereita X

  `xiradereita` ordénalle ao sapoconcho que xire X graus á dereita. `xiradereita` pode abreviarse como `xd`.

direccion (dir)

      direccion X

  `direccion` fai que o sapoconcho tome unha ruta a X graus do cero, polo que non é relativa á anterior ruta que seguise o sapoconcho. `direccion` pode abreviarse como `dir`.

obtendireccion

      obtendireccion

  `obtendireccion` devolve a dirección na que mira a tartaruga como unha cantidade de graus contados desde arriba.

vaiamedio

      vaimedio

  `vaiamedio` leva o sapoconcho ao centro do lenzo.

vai

      vai X,Y

  `vai` fai que o sapoconcho vaia a un lugar concreto do lenzo. Este lugar está a X píxeles da beira esquerda do lenzo e a Y píxeles da parte de riba do lenzo.

vaix

      vaix X

  `vaix` fai que o sapoconcho vaia a unha posición situada a X píxeles do borde esquerdo do lenzo sen desprazarse en altura. `vaix` pode abreviarse com `vx`.

vaiy

      vaiy Y

  `vaiy` fai que o sapoconcho vaia a unha posición situada a Y píxeles do cume do lenzo sen desprazarse en horizontal. `vaiy` pode abreviarse como `vy`.

### Nota

Cando se utilizan as ordes `vai`, `vaix`, `vaiy` e `vaimedio` o sapoconcho non debuxa a liña, con independencia de que o lapis estea erguido ou pousado.

### Onde está o sapoconcho?

Hai dúas ordes que din a posición do sapoconcho na pantalla.

coordenadaX

  `coordenadax` devolve a cantidade de píxeles que hai desde a esquerda do lenzo ata a posición do sapoconcho.

coordenaday

  `coordenaday` devolve a cantidade de píxeles que hai do cume do lenzo ata a posición do sapoconcho.

### O sapoconcho ten un lapis

O sapoconcho ten un lapis que debuxa unha liña a medida que se move o animal. Hai unhas poucas ordes que controlan este lapis. Nesta sección explicarémolas.

subelapis (sl)

      subelapis

  `subelapis` separa o lapis do lenzo. Cando o lapis está « subido » non se debuxan liñas ao moverse o sapoconcho. Consulta tamén `baixalapis`. `subelapis` pode abreviarse como `sl`.

baixalapis (bl)

      baixalapis

  `baixalapis` pousa o lapis no lenzo. Cando o lapis está « baixado » debúxanse liñas cando se move o sapoconcho. Consulta tamén `subelapis`. `baixalapis` pode abreviarse como `bl`.

ancholapis (al)

      ancholapis X

  `ancholapis` estabelece o grosor do trazo co valor de X píxeles. `ancholapis` pode abreviarse como `al`.

corlapis (cl)

      corlapis R,G,B

  `corlapis` estabelece a cor do trazo. `corlapis` toma como parámetro unha combinación RGB. `corlapis` code abreviarse como `cl`.

### Ordes para controlar o lenzo

Hai varias ordes que controlan o lenzo.

tamañolenzo (tlz)

      tamañolenzo X,Y

  Mediante a orde `tamañolenzo` pode axustar o tamaño da área. Toma X e Y como entradas, onde X é a nova anchura do lenzo en píxeles e Y é a nova altura en píxeles. `tamañolenzo` pode abreviarse como `tlz`.

corlenzo (clz)

      corlenzo R,G,B

  `corlenzo` estabelece a cor do lenzo. `corlenzo` toma unha combinación RGB como entrada. `corlenzo` pode abreviarse como `clz`.

### Ordes para limpar

Hai dúas ordes para limpar o lenzo cando o emborrona.

borra (br)

      borra

  Con `borra` pode limpar todos os debuxos do lenzo. As demais cousas quedan: a posición, dirección e visibilidade do sapoconcho, e a cor e o tamaño do lenzo.

reinicia

      reinicia

  `reinicia` limpa máis a fondo do que o fai a orde `borra`. Despois de executar unha orde `reinicia` todo volve ser como cando iniciou KTurtle. O sapoconcho estará posto no centro da pantalla, a cor do lenzo será branco, debuxarase cun trazo negro e o tamaño do lenzo será de 400 x 400 píxeles.

### O sapoconcho é un sprite

Os sprites son pequenas imaxes que se poden mover pola pantalla, como se ve nos xogos de computador. O noso animaliño tamén é un sprite. Para saber máis sobre isto, consulte a entrada sprites no glosario.

A continuación atopará un resumo completo de todas as ordes que traballan sobre sprites.

[A versión actual de KTurtle aínda non permite utilizar outros sprites que non sexan o sapoconcho. En versións futuras poderá cambialo por un deseño seu]

mostrasprite (ms)

      mostrasprite

  `mostrasprite` fai visíbel o sapoconcho se antes se agochou. `mostrasprite` pode abreviarse como `ms`.

agochasprite (as)

      agochasprite

  `agochasprite` agocha o sapoconcho. Isto pode empregarse se o animal non couber no debuxo. `agochasprite` pode abreviarse como `as`.

### Pode escribir o sapoconcho?

A resposta é: « pode ». A tartaruga pode escribir, e escribirá case calquera cousa que lle ordene.

escribe

      escribe X

  A orde `escribe` ordéalle ao sapoconcho que escriba algo no lenzo. `escribe` pode tomar textos e números como parámetros. Pode `escribe`r varios números e cadeas mediante o símbolo « + ». Aquí vai un exemplo:

      $ano = 2021
      $autor = "Aroa"
      escribe $autor + " debuxou unha nora en KTurtle no ano" + $ano + " e gustoulle moito!"

tamañoletra

      tamañoletra X

  `tamañoletra` modifica o tamaño de letra utilizado ao `escribe`r. `tamañoletra` toma un argumento numérico. O tamaño indícase en píxeles.

### Ordes matemáticas

As seguintes ordes son as máis avanzadas de KTurtle para matemáticas.

redondea

      redondea X

  `redondea` o número indicado ao enteiro máis próximo.

      escribe redondea 10.8
      avanza 20
      escribe redondea 10.3
      avanza 20

  Con este código o sapoconcho escribirá os números 11 e 10.

aleatorio (alea)

      aleatorio X,Y

  `aleatorio` é unha orde que toma unha entrada e saca un resultado. Como entrada precisa de dous números, o primeiro (X) é o resultado mínimo, o segundo (Y) o máximo. A saída é un número escollido ao chou que é como mínimo o menor e como máximo o maior. Aquí vai un exemplo:

      repite 500 {
        $x = aleatorio 1,20
        avanza $x
        xiraesquerda 10 - $x
      }

  Mediante a orde `aleatorio` pode introducir algo de caos no programa.

mod

      mod X,Y

  `mod` devolve o resto da división do primeiro número entre o segundo.

raiz

      raiz X

  A orde `raiz` devolve a raíz cuadrada do argumento.

pi

      pi

  Esta orde devolve a constante Pi, `3.14159`.

seno, coseno, tanxente

      seno X
      coseno X
      tanxente X

  Estas tres ordes representan as famosas funcións trigonométricas `seno`, `coseno` e `tanxente`. O argumento destas tres ordes, X, é un número.

arcoseno, arcocoseno, arcotanxente

      aroceion X
      arcocoseno X
      arcotanxente X

  Estas ordes son as funcións inversar deseno, coseno e tanxente. O argumento, X, é un número.

### Introdución de datos e obtención de resultados mediante diálogos

Un diálogo é unha pequena xanela emerxente que lle fornece algo de información ou que lle pide algún dato. KTurtle ten dúas ordes para diálogos, que son: `mostra` e `pregunta`

mostra

      mostra X

  A orde `mostra` toma un texto como entrada, e mostra un diálogo que contén o texto.

      mostra "Brandán debuxou unha nora en KTurtle no ano 2021 e gustoulle moito!"

pregunta

      pregunta X

  `pregunta` toma un texto como entrada. Mostra un diálogo que contén o texto, como fai mostra, pero ademais tamén pon un campo de texto no diálogo. Mediante este campo o usuario pode introducir un número ou un texto, que pode gardar nunha variábel ou pasar como argumento a unha orde. Por exemplo

      $idade = pregunta "Cantos anos tes?"
      $resultado = 2003 - $idade
      escribe "En 2003 tiñas " + $resultado + " anos."

  Cando un usuario cancela o diálogo de pergunta, ou non insere nada, a variábel estará baleira.

Asignación de variábeis
Asignación de variábeis

## Asignación de variábeis

Primeiro vexamos o que son as variábeis, logo como asignarlles valores.

As variábeis son palabras que comezan cun « $ ». No editor reálzanse en morado.

As variábeis poden contar calquera número, texto ou valor lóxico (certo/falso. Dáselles contido mediante a asignación, `=`. Terá ese valor até que o programa remate a execución ou até que se lle asigne outro valor.

Unha vez asignadas, pode usar as variábeis no canto do seu valor. Por exemplo no seguinte retallo de TurtleScript

    $x = 10
    $x = $x / 3
    escribe $x

Primeiro a variábel `$x` convértese no `10`. Logo `$x` convértese no valore resultante de dividirse entre `3` — o que significa que se reasigna a `$x` o resultado de `10/3`. Finalmente, escríbese `$x`. Nas liñas segunda e terceira podes ver que `$x` é usada como se ela fose o que contén.

Para poder usar unha variábel ten que asignarse. Exemplo:

    escribe $n

Non escribirá nada e pola contra mostrará unha mensaxe de erro.

Vexamos o seguinte retallo de TurtleScript:

    $a = 2004
    $b = 25

    # a seguinte orde escribe "2029"
    escribe $a + $b
    retrocede 30
    # a seguinte orde escribe "2004 máis 25 é igual a 2029"
    escribe $a + " máis " + $b " é igual a " ($a + $b)

Nas primeiras dúas liñas dáselles os valores 2004 e 25 ás variábeis `$a` e `$b`. Despois execútanse dúas ordes `escribe` cunha `retrocede 30` no medio. Os comentarios antes de cada orde `escribe` explícan o que fan. A orde `retrocede` foi posta aí para garantir que cada cousa se escriba nunha liña nova. Neste exemplo tamén vemos como as variábeis poden empregarse como se fosen o que conteñen, pode usalas con calquera operación ou usalas como parámetros das ordes.

Outro exemplo máis:

    $nome = pregunta "Como te chamas?"
    escribe "Olá " + $nome + "! Verás que sinxelo é aprender a programar..."

Abondo claro. e novo vese o uso da variábel `$nome` tratada como un texto.

O inspector é de moita axuda cando se usan variábeis. Móstra o contido de todas as variábeis que se están a usar.

Control da execución
Control da execución

## Control da execución

Os controladores da execución permítenlle, como indica o nome, controlar o fluxo de execución.

As ordes de control da execución son realzadas en letra verde grosa. As chaves utilízanse caseque sempre xunto cos controladores de execución e son realzadas en letra negra grosa.

### Facer que o sapoconcho agarde

Se programou algo en KTurtle xa se decataría de que o sapoconcho pode ser moi moi moi rápido cando debuxa. Esta orde fai que agarde durante un tempo.

agarda

      agarda X

  `agarda` fai que o sapoconcho estea quedo durante X segundos.

      repite 36 {
        avanza 5
        xiradereita 10
        agarda 0.5
      }

  Este código debuxa un círculo, pero o animal agardará medio segundo tras cada paso. Isto dá a impresión dun sapoconcho lento.

### Executar «se»

se

      se valor lóxico { … }

  O código que vai entre as chaves só será executado `se` o predicado é « certo ».

      $x = 6
      se $x > 5 {
        escribe "x é maior que cinco!"
      }

  Na primeira liña `$x` vale 6. Na segunda liña úsase unha operación de comparación para avaliar `x > 5`. Xa que a resposta é « certo » o controlador de execución `se` permitirá que se execute o código entre as chaves.

### Se non, ou en caso contrario: "senon"

senon

      se boolean { ... } senon { ... }

  `senon` pode empregarse xunto ccontrolador de execución `se`. O código entre as chaves que seguen a `senon` só se executará se o predicado é « falso ».

      reinicia
      $x = 4
      se $x > 5 {
       escribe "x é maior que cinco!"
      }
      senon
      {
        escribe "x é menor que seis!"
      }

  A comparación avalia a expresión `$x > 5`. Xa que 4 no o é a resposta é « falso ». Isto implica que se executará o código entre as chaves que seguen a `senon`.

### O ciclo «mentres»

mentres

      mentres valor lóxico { … }

  O controlador de execución `mentres` seméllase moito a `se`. A diferenza é que `mentres` repite o código entre as chaves ate que o valor lóxico sexa « falso ».

      $x = 1
      mentres $x < 5 {
        avanza 10
        agarda 1
        $x = $x + 1
      }

  Na primeira liña `$x` toma o valor 1. Na segunda liña avalíase `$x < 5`. Dado que a resposta é « certo » o controlador de execución `mentres` comeza a executar o código entre as chaves ata que `$x < 5` sexa « falso ». Neste caso executarase 4 veces, porque cada vez que se executa a quinta liña `$x` increméntase.

### O ciclo «repite»

repite

      repite número { … }

  O controlador de execucion `repite` seméllase moito a `mentres`. A diferenza é que `repite` executa o código entre as chaves o número dado de veces.

### O ciclo «desde», un ciclo cun contador

desde

      desde variábel = número ate número { ... }

  O bucle `desde` é un « bucle con contador », isto é, mantén por si o reconto. O primeiro número é o valor da variábel na primeira volta. En cada ciclo a variábel increméntase até que se acade o segundo número.

      desde $x = 1 ate 10 {
        escribe $x * 7
        avanza 15
      }

  Cada vez que se executa o código entre as chaves o `$x` aumenta en 1, ate que `$x` acada o valor de 10. O código nas chaves escribe o valor do `$x` multiplicado por 7. Cando este programa remate a execución verá a táboa de multiplicar do 7 no lenzo.

  O paso predeterminado no bucle é 1, pero pode utilizar outro valor mediante

      desde variábel = número ate número pasando número { ... }

### Saír dun bucle

sair

      sair

  Termina de inmediato esta volta ao bucle e transfere o control á instrucción que vai despois del.

### Detén a execución do programa

fin

      fin

  Remata a execución do programa.

### Comprobar asercións durante a execución

aserto

      aserto predicado

  Pode usarse para razonar acerca do programa ou comprobar que as entradas sexan correctas.

      $en = pregunta "En que ano naciches?"
      # o ano debe ser positivo
      aserto $en
      > 0

Cree as súas propios ordes con « define »
Cree as súas propios ordes con « define »

## Cree as súas propios ordes con « define »

`define` é unha orde moi especial, porque se utiliza para crear novas ordes. A orde que cree pode tomar entradas e devolver resultados. Vexamos como se crea unha orde nova:

    define faiCirculo $x {
      repite 36 {
        avanza $x
        xiraesquerda 10
      }
    }

O nova orde chámase `faiCirculo`. `faiCirculo` toma unha entrada, un número que indica o tamaño do círculo. `faiCirculo` non devolve nengún resultado. A orde `faiCirculo` pode ser utilizado como unha orde normal no resto do código. Vexa este exemplo:

    define faiCirculo $X {
      repite 36 {
        avanza $X
        xiraesquerda 10
      }
    }
    vai 200,200
    faiCirculo 20

    vai 300,300
    faiCirculo 40

No seguinte exemplo, créase unha orde que un valor.

    define factorial $x {
      $r = 1
      deste $i = 1 ate $x  {
        $r = $r * $i
      }
      devolve $r
    }

    escribe factorial 5

Neste exemplo críase unha orde nova chamada `factorial`. Se entrada desta orde é`5` a saída será `5*4*3*2*1`. Ao usar `devolve` especifícase o valor devolto e a execución continúase.

As ordes poden ter máis dun parámetro. No seguinte exemplo, créase unha orde que debuxa un rectángulo.

    define debuxaRectangulo $X, $Y {
      avanza $Y
      xiradereita 90
      avanza $X
      xiradereita 90
      avanza $Y
      xiradereita 90
      avanza $X
      xiradereita 90
    }

Agora pode ordenar `debuxaRectangulo 50,100` e o sapoconcho debuxará no lenzo un rectángulo.

Capítulo 5. Glosario
Glosario

# Capítulo 5. Glosario

Neste capítulo atopará unha explicación da maioría das palabras « especializadas » que se empregan no manual.

graus

  Os graos son unidades para medir ángulos ou xiros. Unha circunferencia completa ten 360 graus, media circunferencia 180 graus e un cuarto de circunferencia 90 graus. As ordes `xiraEsquerda`, `xiraDereita` e `direccion` precisan que dun parámetro expresado en graus.

entrada e saída das ordes

  Algunhas ordes requiren de entradas (parámetros), outros xeran saídas (resultados), outros toman entradas e dan saídas e outros nin requiren de parámetros nin xeran resultados.

  Exemplos de ordes que só toman parámetros:

      avanza 50
      corLapis 255,0,0
      escribe "Olá"

  A orde `avanza` toma o parámetro `50`. `avanza` precisa deste parámetro para saber cantos píxeles deve avanzar. `corLapis` toma unha cor como parámetro e `escribe` un texto. Lembre que os parámetros tamén poden ser variábeis. O seguinte exemplo ilustra isto:

      $x = 50
      escribe $x
      avanza 50
      $str = "hello!"
      escribe $str

  Exemplos de ordes que xeran saídas:

      $x = pregunta "Escriba algo e prema Aceptar… grazas!"
      $r = aleatorio 1,100

  A orde `pregunta` toma unha cadea como entrada, e devolve o número ou cadea que se insire. Como pode ver, o resultado de `pregunta` é gardado na variábel `x`. A orde `aleatorio` tamén xera saídas. Neste caso devolve un número entre 1 e 100. A saída de aleatorio é gardada tamén neste caso nunha variábel chamada `r`. Lembre que as variábeis `x` e `r` non son empregados no exemplo de riba.

  Tamén hai ordes que nin precisan de parámetros nin devolven resultados. Estes son algúns exemplos:

      borra
      subeLapis

realzado intuitivo

  Esta é unha funcionalidade de KTurtle que simplifica aínda máis o escribir os programas. Co realzado intuitivo o código que escribe é colorido cunha cor que indica o tipo de código que é. Na seguinte lista atopará os distintos tipos de código xunto coa cor que teñen no editor.

  TáboaTáboa 5.1. Os distintos tipos de código e a cor coa que se realzan

  ordes normais | azul escuro | As ordes normais descríbense aquí.
  ordes que controlan a execución | negro (grosa) | As ordes de control do fluxo da execución, lea máis sobre eles aquí.
  comentarios | gris | As liñas comentadas comezan polo paracter #. Estas liñas son ignoradas cando se executa o código. Os comentarios permítenlle ao programados dar explicacións acerda do código e tamén serven para evitar temporalmente que se execute un cacho de código.
  chaves {, } | verde escuro (grosa) | As chaves son empregadas para agrupar porcións de código. As chaves son empregadas a miudo xunto cos controladores de execución.
  a orde define | verde claro (grosa) | A orde define utilízase para crear ordes novas.
  textos | vermello | Tampouco hai moito que dicir sobre as cadeas (de texto), só que sempre deben ir entre comiñas (").
  números | roxo | Non hai moito que explicar sobre os números.
  valores lóxicos | roxo | Hai exactamente dous valores lóxicos, que son: certo e falso.
  variábeis | morado | Comezan cun «$» e poden conter números, textos ou valores lóxicos.
  operacións matemáticas | gris | Estas son as operacións matemáticas: `+`, `─`, `*`, `/` e `^`.
  operacións de comparación | azul claro (grosa) | Estas son as operacións de comparación: `==`, `!=`, `<`, `>`, `<=` e `>=`.
  operacións loxicas | rosa (grosa) | Estas son os operadores booleanos: `e`, `ou` e `non`.
  texto normal | negro |

píxeles

  Un píxel é un punto na pantalla. Se mira moi de preto á pantalla do monitor verá que emprega píxeles. Todas as imaxes na pantalla están feitas con píxeles. Un píxel é a cousa máis pequena que pode debuxarse na pantalla.

  Moitas ordes precisan que se lles pase como parámetro un número de píxeles. Estas ordes son: `avanza`, `retrocede`, `vai`, `vaix`, `vaiy`, `tamañolenzo` e `ancholapis`.

  Nas primeiras versións de KTurtle o lenzo era esencialmente unha imaxe raster, pero nas máis recentes é un debuxo vectorial. Isto significa que pode achegalo e afastalo, polo que un pixel non se corresponde necesariamente cun punto da pantalla.

Combinacións RGB (códigos de cor)

  As combinacións RGB empréganse para describir cores. O « R » provén de « vermello », o « G » de « verde » e o « B » de « azul ». Un exemplo de combinación RGB é `255,0,0`: o primeiro valor (« vermello ») é de 255 e os outros son 0, polo que isto represente un vermello. Os valores das combinacións RGB deben estar no intervalo de 0 a 255. A continuación móstrase unha lista con algunhas cores empregadas a miudo:

  TáboaTáboa 5.2. Combinacións RGB empregadas a miudo

  `0,0,0` | negro
  `255,255,255` | branco
  `255,0,0` | vermello
  `150,0,0` | roxo
  `0,255,0` | verde
  `0,0,255` | azul
  `0,255,255` | azul claro
  `255,0,255` | rosa
  `255,255,0` | amarelo

  Hai dúas ordes que precisan dunha combinación RGB: son `corlenzo` e `corlapis`.

sprite

  Un sprite é unha imaxe pequena que pode desprazarse pola pantalla. O noso sapoconcho, sen ir máis lonxe, é un sprite.

  Nota: nesta versión de KTurtle non se pode cambiar o sapoconcho por outra cousa. En versións futuras de KTurtle poderase facer.

Capítulo 6. Guía do tradutor de KTurtle
Guía do tradutor de KTurtle

# Capítulo 6. Guía do tradutor de KTurtle

Como xa saberá a linguaxe de programación de KTurtle, TurtleScript, permite traducirse. Isto elimina unha barreira para algunha xente, en especial estudantes novos, no seu esforzo por comprender os fundamentos da programación.

Cando traduza KTurtle a un novo idioma atopará, ademais dos textos da GUI nos ficheiros .pot estándar, as ordes de programación, os exemplos e as mensaxes de erro, para a súa tradución como o resto de KDE. Tradúcese todo co sistema estándar empregado no resto de KDE, aínda que se recomenda aprender un chisco sobre como traducir esta cousas (como se lle indica nos comentarios para os tradutores).

Consulte http://edu.kde.org/kturtle/translator.php para obter máis información sobre o proceso de tradución. Grazas polo seu traballo! KTurtle depende moito das traducións.

Capítulo 7. Recoñecementos e licenza
Recoñecementos e licenza

# Capítulo 7. Recoñecementos e licenza

KTurtle

Copyright do software 2003-2007 Cies Breijs `(cies EN kde PUNTO nl)`

Copyright da documentación 2004, 2007, 2009

- Cies Breijs `(cies EN kde PUNTO nl)`

- Anne-Marie Mahfouf `(annma EN kde PUNTO org)`

- Philip Rodrigues `(phil AT kde.org)` fixo algúns cambios tras unha revisión

- Actualizar o como de tradución e algúns cambios tras unha revisión son obra de Andrew Coles `(andrew_coles EN yahoo PUNTO co PUNTO uk)`

mvillarino`(mvillarino AT users.sourceforge.net)`

Xosé`(xosecalvo AT gmail.com)`

Esta documentación está licenciada sob os termos da GNU Free Documentation License.

Este programa está licenciado sob os termos da Licenza Pública Xeral de GNU.

Índice das ordes
Índice das ordes

# Índice das ordes

### A

agarda, Facer que o sapoconcho agarde
agochasprite (as), O sapoconcho é un sprite
aleatorio (alea), Ordes matemáticas
ancholapis (al), O sapoconcho ten un lapis
arccoseno, Ordes matemáticas
arcoseno, Ordes matemáticas
arcotanxente, Ordes matemáticas
aserto, Comprobar asercións durante a execución
ate, O ciclo «desde», un ciclo cun contador
avanza (av), Mover o sapoconcho

### B

baixalapis (bl), O sapoconcho ten un lapis
borra (br), Ordes para limpar

### C

certo, Valores lóxicos (certo/falso)
coordenadax, Onde está o sapoconcho?
coordenaday, Onde está o sapoconcho?
corlapis (cl), O sapoconcho ten un lapis
corlenzo (clz), Ordes para controlar o lenzo
coseno, Ordes matemáticas

### D

define, Cree as súas propios ordes con « define »
desde, O ciclo «desde», un ciclo cun contador
devolve, Cree as súas propios ordes con « define »
direccion (dir), Mover o sapoconcho

### E

e, Operacións lóxicas (certo/falso)
escribe, Pode escribir o sapoconcho?

### F

falso, Valores lóxicos (certo/falso)
fin, Detén a execución do programa

### M

mentres, O ciclo «mentres»
mod, Ordes matemáticas
mostra, Introdución de datos e obtención de resultados mediante diálogos

### N

non, Operacións lóxicas (certo/falso)

### O

obtendireccion, Mover o sapoconcho
ou, Operacións lóxicas (certo/falso)

### P

pasando, O ciclo «desde», un ciclo cun contador
pi, Ordes matemáticas
pregunta, Introdución de datos e obtención de resultados mediante diálogos

### R

raiz, Ordes matemáticas
redondea, Ordes matemáticas
reinicia, Ordes para limpar
repite, O ciclo «repite»
retrocede (re), Mover o sapoconcho

### S

sair, Saír dun bucle
se, Executar «se»
seno, Ordes matemáticas
senon, Se non, ou en caso contrario: "senon"
subelapis (sl), O sapoconcho ten un lapis

### T

tamañolenzo (tlz), Ordes para controlar o lenzo
tamañoletra, Pode escribir o sapoconcho?
tanxente, Ordes matemáticas

### V

vai, Mover o sapoconcho
vaimedio, Mover o sapoconcho
vaix (vx), Mover o sapoconcho
vaiy (vy), Mover o sapoconcho

### X

xiradereita (xd), Mover o sapoconcho
xiraesquerda (xe), Mover o sapoconcho