Manual do KTurtle

# Manual do KTurtle

Cies Breijs `<cies AT kde DOT nl>`

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

Mauricio Piacentini `<piacentini AT kde DOT org>`

Tradução: Marcus Gama
Tradução: André Marcelo Alvarenga
revisão Applications 20.12 (20/01/2021)

Copyright © 2004, 2009 Cies Breijs

Copyright © 2004, 2007 Anne-Marie Mahfouf

Copyright © 2007 Mauricio Piacentini

Nota Legal

O KTurtle é um ambiente de programação educativo que permite aprender como programar de maneira simples. Para conseguir isto, o KTurtle disponibiliza todas as ferramentas de programação a partir da interface do usuário. A linguagem de programação usada é o TurtleScript, que permite a tradução dos seus comandos.

Lista de Tabelas

4.1. Tipos de perguntas
5.1. Os diferentes tipos de código e a sua cor de realce
5.2. Combinações RGB mais usadas

Capítulo 1. Introdução
Introdução

# Capítulo 1. Introdução

O KTurtle é um ambiente educativo de programação que usa o TurtleScript, uma linguagem de programação vagamente baseada e inspirada pelo Logo. O objetivo do KTurtle é fazer a programação tão fácil e acessível quanto possível. Isto torna o KTurtle adequado para ensinar às crianças as bases da Matemática, Geometria e... programação. Uma das características principais do TurtleScript é a habilidade de traduzir os comandos no idioma do programador.

O KTurtle tem o nome com base na “tartaruga” que desempenha um papel central no ambiente de programação. O usuário programa a tartaruga, usando os comandos do TurtleScript, para desenhar uma imagem na área de desenho.

## O que é o TurtleScript?

A TurtleScript, a linguagem de programação usada no KTurtle, é inspirada por alguns dos conceitos fundamentais da família de linguagens de programação Logo. A primeira versão da linguagem de programação Logo foi criada por Seymour Papert do Laboratório de Inteligência Artificial do MIT em 1967 como uma alternativa à linguagem de programação LISP. Desde então, foram lançadas várias versões do Logo. Em 1980, o Logo foi ganhando adeptos, com versões para o MSX, Commodore, Atari e sistemas IBM PC. Estas versões eram principalmente para fins educativos. O MIT ainda mantém um site sobre Logo; que poder ser acessado em página do Logo contendo uma lista de diversas implementações populares da linguagem.

O TurtleScript compartilha uma funcionalidade que é encontrada em muitas outras implementações do Logo: a capacidade de traduzir os comandos, de modo a adequar-se à língua nativa do aluno. Esta funcionalidade permite simplificar aos alunos que tenham pouco ou nenhum conhecimento de Inglês para começarem a aprender. Além desta funcionalidade, o KTurtle tem muitas outras funcionalidades que permitem facilitar aos alunos a experiência inicial com a programação.

Recursos do KTurtle
Recursos do KTurtle

## Recursos do KTurtle

O KTurtle possui alguns recursos legais que tornam a introdução à programação muito simples. Veja aqui alguns dos detalhes dos recursos do KTurtle:

- Um ambiente integrado com o interpretador de TurtleScript, um editor, uma área de desenho e outras ferramentas, tudo num único aplicativo (sem dependências extra).

- A capacidade de traduzir os comandos do TurtleScript com a plataforma de traduções do KDE.

- O TurtleScript suporta funções definidas pelo usuário, a recursividade e a mudança dinâmica de tipos.

- A execução pode ser tornada mais lenta, pausada ou interrompida a qualquer momento.

- Um editor poderoso com um realce de sintaxe intuitivo, numeração de linhas, entre outras coisas.

- A área de desenho, onde a tartaruga circula, pode ser impressa ou salva como uma imagem (PNG) ou desenho (SVG).

- Ajuda de contexto: ajuda onde você precisa dela. Basta pressionar F2 (ou ver a opção Ajuda → Ajuda sobre: ...) para obter ajuda sobre o pedaço de código que está atualmente sob o seu cursor.

- Uma janela de erros que associa as mensagens de erro aos erros propriamente ditos no programa, marcando-os em vermelho.

- Uma terminologia de programação simplificada.

- Programas de exemplo integrados que simplificam a sua introdução. Estes exemplos estão traduzidos com a plataforma de traduções do KDE.

Capítulo 2. Usando o KTurtle
Usando o KTurtle

# Capítulo 2. Usando o KTurtle

A janela principal do KTurtle possui três componentes principais: o editor (1) à esquerda, onde você digita os comandos de TurtleScript; a área de desenho (2) à direita, onde a tartaruga faz o seu desenho; e o inspetor (3) que lhe dá informações sobre as variáveis durante a execução do programa. Além dos componentes você pode encontrar a barra de menus (5) onde todas as ações podem ser acessadas; a barra de ferramentas (4) que permite-lhe selecionar rapidamente as ações mais utilizadas; o Console:, que você poderá usar para inserir um comando numa única linha para teste; e a barra de status (na parte inferior da janela) onde você encontrará alguma informação sobre o estado do KTurtle.

## O editor

No editor, você poderá digitar os comandos de TurtleScript. A maioria das suas funcionalidades são encontradas no menu Editar e Arquivo. O editor pode ser acoplado a qualquer um dos lados da janela principal ou poderá ser destacado e colocado em qualquer local da sua tela.

Você tem várias formas de obter algum código no editor. A forma mais fácil é usar um exemplo já feito. Selecione um exemplo no submenu Arquivo → Exemplos. O arquivo de exemplo que escolher será aberto no editor, e você poderá ir então usar o menu Executar → Executar (atalho: Alt+F2) ou o botão Executar da barra de ferramentas para executar o código se desejar.

Você poderá abrir os arquivos de TurtleScript selecionando o menu Arquivo → Abrir....

A terceira forma é digitar diretamente o seu código no editor ou copiar/colar algum código.

A área de desenho
A área de desenho

## A área de desenho

A área de desenho é a área onde os comandos são visualizados, ou seja, onde eles “desenham” uma imagem. Em outras palavras, é o espaço de recreio da tartaruga. Depois de inserir algum código no editor e de executá-lo, duas coisas poderão acontecer: ou o código é executado perfeitamente e você poderá ver algo mudando na área de desenho, ou você tem um erro no seu código e existirá uma mensagem que lhe dirá qual o erro que você cometeu.

Você poderá ampliar ou diminuir a área de desenho com a roda do seu mouse.

O inspetor
O inspetor

## O inspetor

O inspetor informa-o das variáveis, as funções aprendidas e a árvore de código enquanto o programa está em execução.

O inspetor pode ser embutido em qualquer canto da janela principal ou pode ser desanexado e colocado em qualquer lugar de sua área de trabalho.

A barra de ferramentas
A barra de ferramentas

## A barra de ferramentas

Aqui você poderá acessar rapidamente às ações mais utilizadas. A barra de ferramentas também contém a caixa de entrada Console:, onde poderá invocar rapidamente os comandos; isto poderá ser útil no caso de querer testar um comando sem modificar o conteúdo do Editor.

Você poderá configurar a barra de ferramentas se usar o menu Configurações → Configurar as Barras de Ferramentas..., para se ajustar às suas preferências.

A barra de menus
A barra de menus

## A barra de menus

No menu, você irá encontrar todas as ações do KTurtle. Elas estão nos seguintes grupos: Arquivo, Editar, Área de Desenho, Executar, Ferramentas, Configurações e Ajuda. Esta seção descreve todas elas.

### Menu Arquivo

Arquivo → Novo (Ctrl+N)

  Cria um arquivo de TurtleScript novo e vazio.

Arquivo → Abrir... (Ctrl+O)

  Abre um arquivo do TurtleScript.

Arquivo → Abrir recente

  Abre um arquivo de TurtleScript que foi aberto recentemente.

Arquivo → Exemplos

  Um exemplo dos programas do TurtleScript. Os exemplos estão em seu idioma favorito, que poderá ser selecionado no submenu Configurações → Linguagem dos scripts.

Arquivo → Obter mais exemplos...

  Abra o diálogo Obter novidades para baixar arquivos do TurtleScript adicionais da Internet.

Arquivo → Salvar (Ctrl+S)

  Salva o arquivo de TurtleScript atualmente aberto.

Arquivo → Salvar como... (Ctrl+Shift+S)

  Salva o arquivo do TurtleScript aberto atualmente num local especificado.

Arquivo → Exportar para HTML...

  Exporta o conteúdo atual do Editor como um arquivo em HTML que inclui as cores do realce.

Arquivo → Imprimir... (Ctrl+P)

  Imprime o código atual no editor.

Arquivo → Sair (Ctrl+Q)

  Sai do KTurtle.

### Menu Editar

Editar → Desfazer (Ctrl+Z)

  Desfaz a última alteração no código. O KTurtle pode fazer desfazer de forma ilimitada.

Editar → Refazer (Ctrl+Shift+Z)

  Refaz uma alteração desfeita no código.

Editar → Recortar (Ctrl+X)

  Corta o texto selecionado do editor para a área de transferência.

Editar → Copiar (Ctrl+C)

  Copia o texto selecionado do editor para a área de transferência.

Editar → Colar (Ctrl+V)

  Cola o texto na área de transferência no editor.

Editar → Selecionar tudo (Ctrl+A)

  Seleciona todo o texto do editor.

Editar → Procurar... (Ctrl+F)

  Com esta ação, você poderá procurar frases no código.

Editar → Procurar próximo (F3)

  Use isto para procurar a próxima ocorrência da frase que estava pesquisando.

Editar → Localizar anterior (Shift+F3)

  Use isto para procurar a ocorrência anterior da frase que estava pesquisando.

Editar → Modo de edição (Ins)

  Alterne entre o modo de 'inserir' e 'sobrescrever'.

### Menu Tela

Área de Desenho → Exportar para Imagem (PNG)...

  Exporta o conteúdo atual da Área de Desenho como uma imagem rasterizada no formato PNG (Portable Network Graphics).

Área de Desenho → Exportar para Desenho (SVG)...

  Exporta o conteúdo atual da Área de Desenho como um desenho vetorial no formato SVG (Scalable Vector Graphics).

Área de Desenho → Imprimir a Área de Desenho...

  Imprime o conteúdo atual da Área de Desenho.

### Menu Executar

Arquivo → Executar (F5)

  Inicia a execução dos comandos no editor.

Executar → Pausa (F6)

  Coloca a execução em pausa. Esta ação só fica ativa quando os comandos estiverem de fato sendo executados.

Executar → Interromper (F7)

  Interrompe a execução; esta ação só fica ativa quando os comandos estiverem de fato sendo executados.

Executar → Velocidade da Execução

  Apresenta uma lista com as velocidades de execução possíveis, consistindo em: velocidade máxima (sem realce e inspetor), velocidade máxima, velocidade baixa, velocidade mais baixa, velocidade mínima e passo-a-passo. Quando a velocidade de execução é igual velocidade máxima (padrão), você poderá não conseguir ver o que está acontecendo. Em alguns dos casos este comportamento poderá ser o desejado, mas em outros casos você poderá querer ter uma ideia da execução. No último caso, você poderá desejar configurar a velocidade da execução como velocidade baixa, velocidade mais baixa ou velocidade mínima. Quando um dos modos lentos for selecionado, a posição atual de execução será exibida no editor. O passo-a-passo irá executar um comando por vez.

### Menu Ferramentas

Ferramentas → Seletor de direção...

  Esta ação abre o diálogo do seletor de direção.

Ferramentas → Seletor de cores...

  Esta ação abre o diálogo do seletor de cores.

### Menu Configurações

Configurações → Linguagem de Programação

  Escolhe a linguagem para o código.

Configurações → Mostrar o Editor (Ctrl+E)

  Mostra ou oculta o Editor.

Configurações → Mostrar o Inspetor (Ctrl+I)

  Mostra ou oculta o Inspetor.

Configurações → Mostrar os Erros

  Exiba ou esconda a aba Erros com a lista de erros resultantes do código em execução. Se esta opção estiver habilitada, clique na área de desenho para ver a tartaruga novamente.

Configurações → Mostrar números de linha (F11)

  Com esta ação, você poderá mostrar os números de linha no editor. Isto poderá ser útil para procurar um erro.

Configurações → Mostrar barra de ferramentas

  Ativa ou desativa a barra de ferramentas principal.

Configurações → Mostrar barra de estado

  Alterna a barra de status.

Configurações → Configurar atalhos...

  O diálogo padrão do KDE para configurar os atalhos.

Configurações → Configurar barras de ferramentas...

  A janela padrão do KDE para configurar as barras de ferramentas.

### Menu Ajuda

O KTurtle tem o menu Ajuda padrão do KDE, tal como se encontra descrito nos Fundamentos do KDE, com um item adicional:

Ajuda → Ajuda sobre: ... (F2)

  Esta é uma função muito útil: ela oferece ajuda sobre o código sob o cursor na janela do editor. Por isso, por exemplo, você poderá ter usado o comando `mostre` no seu código e deseja ler e aprender o que o manual diz sobre este comando. Basta mover o seu cursor para cima do `mostre` e pressionar então F2. O manual irá então mostrar toda a informação sobre o comando `mostre`.

  Esta função poderá ser útil enquanto aprende o TurtleScript.

A barra de status
A barra de status

## A barra de status

Na barra de status você poderá saber o estado do KTurtle. Do lado esquerdo, ela fornece o resultado da última ação. Do lado direito, você encontra a localização atual do cursor (os números da linha e da coluna). No meio da barra de status é indicado o idioma atual usado para os comandos.

Capítulo 3. Primeiros passos
Primeiros passos

# Capítulo 3. Primeiros passos

Ao iniciar o KTurtle, você verá algo como isto:

Neste guia introdutório, iremos assumir que o idioma dos comandos do TurtleScript é o português do Brasil. Você poderá alterar o idioma em Configurações → Linguagem dos scripts. Observe que o idioma que você definir para o KTurtle precisa ser o mesmo idioma que você usa para digitar os comandos do TurtleScript, não o idioma usado pelo KDE no seu computador e usado para exibir a interface e os menus do KTurtle.

## Primeiros passos no TurtleScript: apresentamos a tartaruga!

Você já deve ter reparado que a tartaruga está no meio da área de desenho: você está agora prestes a aprender como controlá-la, usando os comandos no editor.

### A tartaruga se move

Vamos começar colocando a tartaruga para andar. A nossa tartaruga pode fazer 3 tipos de movimentos: (1) pode mover-se para a frente e para trás, (2) pode virar à esquerda ou à direita e (3) poderá ir diretamente (saltar) para uma posição da tela. Tente isto, por exemplo:

    parafrente 100
    paraesquerda 90

Digita ou copie e cole o código no editor e execute-o (usando o Executar → Executar) para ver o resultado.

Quando tiver digitado e executado os comandos acima no editor, você irá reparar em uma ou mais das seguintes coisas:

1. Que — depois de executar os comandos — a tartaruga vai mover-se, desenhar uma linha e depois dar um quarto de volta para a esquerda. Isto acontece porque você usou os comandos `parafrente` e `paraesquerda`.

2. Que a cor do código mudou à medida que o foi digitando; este recurso chama-se realce intuitivo — os diferentes tipos de comandos são realçados de forma diferente. Isto torna a leitura de grandes blocos de código mais fácil.

3. Que a tartaruga desenha uma linha preta fina.

4. Talvez você tenha obtido uma mensagem de erro. Isto poderá simplesmente significar duas coisas: você poderá ter cometido um erro ao copiar os comandos ou você precisa definir o idioma correto para os comandos de TurtleScript (você pode fazer isto usando o submenu Configurações → Linguagem dos scripts).

Você irá da mesma forma perceber que o `parafrente 100` instruiu a tartaruga andar em frente, deixando uma linha, e que o `paraesquerda 90` instruiu a tartaruga para virar 90 graus à esquerda.

Por favor, veja as seguintes referências para o manual para uma explicação completa dos novos comandos: `parafrente`, `paratrás`, `paraesquerda` e `paradireita`.

### Mais exemplos

O primeiro exemplo foi muito simples, por isso vamos continuar!

    apague

    tamanhodatela 200,200
    cordofundo 0,0,0
    cordolápis 255,0,0
    larguradolápis 5

    vápara 20,20
    direção 135

    parafrente 200
    paraesquerda 135
    parafrente 100
    paraesquerda 135
    parafrente 141
    paraesquerda 135
    parafrente 100
    paraesquerda 45

    vápara 40,100

Mais uma vez, você deverá digitar ou copiar e colar o código para o editor ou abrir o exemplo `flecha` no submenu Exemplos e execute-o (usando a opção Executar → Executar) para ver o resultado. Nos próximos exemplos, iremos considerar que você já entendeu o funcionamento básico desse código.

Você já deve ter notado que este segundo exemplo usa muito mais código. Você deve ter visto também um conjunto de comandos novos. Aqui está uma breve explicação de todos os comandos novos:

Após um comando `apague` tudo volta para como estava quando você iniciou o KTurtle.

O `tamanhodatela 200,200` configura a largura e a altura da área de desenho para 200 pontos. A largura e a altura são iguais em tamanho, o que significa que a área de desenho deverá ser agora um quadrado.

A `cordofundo 0,0,0` deixa a área de desenho em preto. O `0,0,0` é uma combinação RGB onde todos os valores ficam iguais a `0`, o que corresponde a preto.

A `cordolápis 255,0,0` deixa a cor do traço em vermelho. O `255,0,0` é uma combinação RGB em que só o valor do 'vermelho' fica igual a `255` enquanto que os outros (verde e azul) ficam em `0`, o que resulta num tom claro de vermelho.

Se não compreender os valores das cores, leia no glossário sobre as combinações RGB.

A `larguradolápis 5` configura a largura (ou tamanho) do traço a `5` pontos. A partir de agora, todas as linhas que a tartaruga desenhar irão ter uma largura de `5` pontos, até que se mude a `larguradolápis` para outra coisa qualquer.

O `vápara 20,20` manda a tartaruga ir para um determinado lugar da área de desenho. A contar do canto superior esquerdo, este lugar fica a 20 pontos a contar da esquerda e a 20 pontos da parte superior. Lembre-se que, ao usar o comando `vápara`, a tartaruga não irá desenhar uma linha.

A `direção 135` define a direção da tartaruga. O `paraesquerda` e o `paradireita` mudam o ângulo da tartaruga a partir da direção atual dela. A `direção` muda o ângulo da tartaruga a partir do zero e, como tal, não é relativo à posição anterior da tartaruga.

Depois do comando `direção`, segue-se um conjunto de comandos `parafrente` e `paraesquerda`. Estes comandos fazem, de fato, o desenho.

Por fim, é usado outro comando `vápara` para mover a tartaruga para o lado.

Certifique-se de seguir as referências. Elas explicam cada comando em mais detalhes.

Capítulo 4. Referência de programação do TurtleScript
Referência de programação do TurtleScript

# Capítulo 4. Referência de programação do TurtleScript

Esta é a referência para o TurtleScript do KTurtle. Na primeira seção deste capítulo dê uma olhada em alguns aspectos da gramática dos programas em TurtleScript. A segunda seção lida exclusivamente com os operadores matemáticos, os operadores booleanos (verdadeiro/falso) e os operadores de comparação. A terceira seção é uma lista enorme com todos os comandos, explicando-os um-a-um. A quarta seção explica como atribuir valores às variáveis. Finalmente, é explicado como organizar a execução dos comandos com as instruções de controle da execução na quinta seção e como criar os seus próprios comandos com o `aprender` , na última seção.

## A Gramática do TurtleScript

Como em qualquer linguagem, o TurtleScript possui diferentes tipos de palavras e símbolos. No Português, é feita a distinção entre os verbos (como 'andar' ou 'cantar') e os substantivos (como 'irmã' ou 'casa'), sendo usados para diferentes fins. O TurtleScript é uma linguagem de programação, sendo usada para indicar ao KTurtle o que fazer.

Nesta seção, alguns dos diferentes tipos de palavras e símbolos do TurtleScript são explicados de forma breve. Serão explicados os comentários, os comandos e os três diferentes tipos de literais: números, cadeias de caracteres e os valores booleanos (verdadeiro/falso).

### Comentários

Um programa contém instruções que são executadas quando o programa é executado e outros itens, chamados de comentários. Os comentários não são executados; o KTurtle simplesmente ignora-os ao executar o seu programa. Os comentários estão lá para que os outros programadores possam compreender melhor o seu programa. Tudo o que estiver após um símbolo `#` é considerado um comentário no TurtleScript. Por exemplo, este pequeno programa não faz nada:

    # este pequeno programa não faz nada, é apenas um comentário!

É um pouco inútil, mas explica bem o conceito.

Os comentários tornam-se bastante úteis quando o programa se torna um pouco mais complexo. Ele poderá ajudar a fornecer alguns conselhos aos outros programadores. No programa a seguir, irá ver os comentários a serem usados juntamente com o comando imprimir.

    # este programa foi feito pelo Cies Breijs.
    mostre "este texto será impresso na área de desenho"
    # a linha anterior não é um comentário, mas a seguinte é:
    # mostre "este texto não será impresso!"

A primeira linha descreve o programa. A segunda é executada pelo KTurtle e imprime a mensagem `este texto será impresso na área de desenho` na área de desenho propriamente dita. A terceira linha é um comentário. A quarta linha é um comentário que contém um pedaço de TurtleScript, se for retirado o símbolo `#` da quarta linha, a instrução 'imprimir' será executada pelo KTurtle. Os programadores dizem: a instrução da quarta linha está 'comentada'.

As linhas comentadas ficam realçadas em cinza claro no editor.

### Comandos

Ao usar os comandos, você diz à tartaruga ou ao KTurtle para fazerem algo. Alguns comandos precisam de dados de entrada, enquanto outros geram resultados.

    # o 'parafrente' é um comando que necessita de dados de entrada, neste caso do número 100:
    parafrente 100

A primeira linha é um comentário. A segunda linha contém o comando `avancar` e o número `100`. O número não faz parte do comando, mas é considerada uma 'entrada' para o comando.

Alguns comandos como por exemplo `vápara` precisam de mais de um valor de entrada. Valores múltiplos devem ser separados usando o caracter `,` (vírgula).

Para uma ideia geral de todos os comandos que o KTurtle suporta, veja aqui. Os comandos incorporados são realçados em azul-escuro.

### Números

Muito provavelmente você já conhece alguma coisa sobre os números. A forma como eles são usados no KTurtle não é muito diferente do idioma falado ou da matemática.

Temos então os números conhecidos por naturais: `0`, `1`, `2`, `3`, `4`, `5`, etc. Os números negativos: `-1`, `-2`, `-3`, etc. Finalmente, os números decimais ou fracionários, como por exemplo: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`. O caractere `.` (ponto) é usado como separador decimal.

Os números poderão ser usados nos operadores matemáticos e nos operadores de comparação. Também poderão ser guardados em variáveis. Os números são realçados em vermelho escuro.

### Cadeias de caracteres

Primeiro um exemplo:

    mostre "Olá, sou uma cadeia de caracteres."

Neste exemplo, o `mostre` é um comando, enquanto o `"Olá, sou uma cadeia de caracteres."` é, de fato, uma cadeia de caracteres. Elas começam e terminam com o símbolo `"`; através destes símbolos, o KTurtle sabe que é uma cadeia de caracteres.

As cadeias de caracteres poderão ser colocadas em variáveis, como acontece com os números. Contudo, ao contrário dos números, as cadeias de caracteres não podem ser usadas nos operadores matemáticos ou nos operadores de comparação. As cadeias de caracteres são realçadas em vermelho.

### Valores booleanos (verdadeiro/falso)

Existem apenas dois valores booleanos: `verdadeiro` e `falso`. Às vezes também são chamados de: “`ligado`” e “`desligado`”, “`sim`” e “`não`”, “`um`” e “`zero`”. Contudo, no TurtleScript são sempre chamados de `verdadeiro` e `falso`. Dê uma olhada neste trecho de TurtleScript:

    $a = verdadeiro

Se olhar para o inspetor, poderá ver que a variável `$a` está igual a `verdadeiro`, tendo um tipo booleano.

Normalmente, os valores booleanos são o resultado de um operador de comparação, como acontece no seguinte trecho de TurtleScript:

    $resposta = 10 > 3

A variável `$resposta` é configurada como `verdadeiro`, uma vez que `10` é maior que `3`.

Os valores booleanos, `true` (verdadeiro) e `false` (falso), estão realçados a vermelho escuro.

Operadores matemáticos, booleanos e de comparação
Operadores matemáticos, booleanos e de comparação

## Operadores matemáticos, booleanos e de comparação

O título deste seção poderá soar muito complicado, mas não é tão difícil de compreender como parece.

### Operadores matemáticos

Estes são os símbolos matemáticos básicos conhecidos: a adição (`+`), a subtração (`-`), a multiplicação (`*`), a divisão (`/`) e a potenciação (`^`).

Aqui está um pequeno exemplo dos operadores matemáticos que poderá usar no TurtleScript:

    $somar      = 1 + 1
    $subtrair = 20 - 5
    $multiplicar = 15 * 2
    $dividir   = 30 / 30
    $elevar    = 2 ^ 2

Os valores que resultam das operações matemáticas serão atribuídos às diversas variáveis. Se utilizar o inspetor, poderá ver os valores.

Se você somente queria fazer um cálculo simples, você poderá fazer algo semelhante a isto:

    mostre 2010-12

Agora, um exemplo com parênteses:

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

O que estiver entre parênteses será calculado em primeiro lugar. Neste exemplo, o 20-5 será calculado, depois será multiplicado por 2, dividido por 30 e depois é adicionado 1 (o que dá 2). Parênteses podem ser usados em outros casos.

O KTurtle também possui mais funcionalidades sob a forma de comandos. Dê uma olhada nos seguintes comandos, mas tenha em mente o que diz respeito a operações avançadas: arredonda, aleatório, raizquadrada, pi, seno, cosseno, tangente, arcoseno, arcocosseno, arcotangente.

### Operadores booleanos (verdadeiro/falso)

Enquanto os operadores matemáticos são usados principalmente para os números, os operadores booleanos são para os valores booleanos (`verdadeiro` e `falso`). Existem apenas três operadores booleanos e são chamados de: `e`, `ou`, e `não`. O seguinte exemplo de TurtleScript mostra como usá-los:

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

    $ou_1_1 = verdadeiro ou verdadeiro    # -> verdadeiro
    $ou_1_0 = verdadeiro ou falso   # -> verdadeiro
    $ou_0_1 = falso ou verdadeiro   # -> verdadeiro
    $ou_0_0 = falso ou falso  # -> falso

    $not_1 = nao verdadeiro   # -> falso
    $not_0 = nao falso  # -> verdadeiro

Se usar o inspetor, poderá ver os valores; contudo, fornecemos estes resultados como pequenos comentários no fim das linhas. O `e` é avaliado como `verdadeiro` apenas se ambos os lados forem `verdadeiro`. O `ou` é avaliado como `verdadeiro` se qualquer um dos lados for `verdadeiro`. Finalmente, o `nao` transforma um `verdadeiro` num `falso` e um `falso` num `verdadeiro`.

Os operadores booleanos são realçados em rosa.

#### Alguns exemplos mais avançados

Veja o exemplo a seguir com o `e`:

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

Neste trecho de TurtleScript, o resultado dos três operadores de comparação é reunido com os operadores `e`. Isto significa que todos os três têm de ser avaliados como “verdadeiro” para imprimir o “olá”.

Um exemplo com o `ou`:

    $n = 1
    se ($n < 10) ou ($n == 2) {
      mostre "olá"
    }

Neste trecho de TurtleScript, o lado esquerdo do `ou` é avaliado como “verdadeiro”, enquanto o direito é avaliado como “falso”. Uma vez que um dos dois lados do operador `ou` é “verdadeiro”, o operador `ou` é avaliado como “verdadeiro”. Isto significa que o “olá” é impresso.

Finalmente, um exemplo com o `não`, que muda o “verdadeiro” para “falso” e o “falso” para “verdadeiro”. Dê uma olhada:

    $n = 1
    se nao ($n == 3) {
      mostre "olá"
    } senao {
      mostre "não olá ;-)"
    }

### Operadores de comparação

Considere esta simples comparação:

    $resposta = 10 > 3

Aqui o `10` é comparado com o `3`, através do operador “maior que”. O resultado desta comparação, o valor booleano `verdadeiro` é guardado na variável `$resposta`.

Todos os números e variáveis (que contenham números) poderão ser comparados entre si, com os operadores de comparação.

Aqui estão todos os possíveis operadores de comparação:

Tabela 4.1. Tipos de perguntas

`$A == $B` | é igual | a resposta é “verdadeira” se o `$A` for igual a `$B`
`$A != $B` | é diferente | a resposta é “verdadeira” se o `$A` não for igual ao `$B`
`$A > $B` | maior que | a resposta é “verdadeira” se o `$A` for maior que o `$B`
`$A < $B` | menor que | a resposta é “verdadeira” se `$A` for menor que `$B`
`$A >= $B` | maior ou igual a | a resposta é “verdadeira” se `$A` for maior ou igual ao `$B`
`$A <= $B` | menor ou igual a | a resposta é “verdadeira” se `$A` for menor ou igual a `$B`

Lembre-se que o `$A` e o `$B` têm de ser números ou variáveis que contenham números.

Comandos
Comandos

## Comandos

Ao usar os comandos, você diz à tartaruga ou ao KTurtle para fazer algo. Alguns comandos precisam de dados introduzidos, enquanto outros trazem resultados. Nesta seção iremos explicar todos os comandos incorporados que podem ser usados no KTurtle. Em alternativa, usando o `aprenda`, poderá criar os seus próprios comandos. Os comandos incorporados ficam realçados em azul escuro.

### Movendo a tartaruga

Existem vários comandos para mover a tartaruga pela tela.

parafrente (pf)

      parafrente X

  O `parafrente` move a tartaruga para a frente X pontos. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O `parafrente` pode ser abreviado para `pf`.

paratrás (pt)

      paratrás X

  O `paratrás` move a tartaruga para trás X pontos. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O `paratrás` pode ser abreviado para `pt`.

paraesquerda (pe)

      paraesquerda X

  O `paraesquerda` diz à tartaruga para se virar X graus para a esquerda. O `paraesquerda` pode ser abreviado para `pe`.

paradireita (pd)

      paradireita X

  O `paradireita` diz à tartaruga para se virar X graus para a direita. O `paradireita` pode ser abreviado para `pd`.

direção (dir)

      direção X

  A `direção` configura a direção da tartaruga para um ângulo de X graus a contar do zero, e isto não é relativo à direção anterior da tartaruga. A `direção` pode ser abreviado para `dir`.

lerdireção

      lerdireção

  O `lerdireção` retorna a direção da tartaruga para um ângulo de X graus a contar do zero, onde zero é a direção quando a tartaruga está apontando para frente.

centralize

      centralize

  O `centralize` move a tartaruga para o centro da área de desenho.

vápara

      vápara X,Y

  O `vápara` manda a tartaruga ir para um determinado local da área de desenho. Este local está a X pontos do lado esquerdo da área de desenho e a Y pontos do topo da área de desenho.

váparax

      váparax X

  Ao usar o comando `váparax`, a tartaruga irá mover-se X pontos a partir da esquerda da área de desenho, mantendo-se na mesma altura. O `váparax` pode ser abreviado como `vx`.

váparay

      váparay Y

  Ao usar o comando `váparay`, a tartaruga irá mover-se Y pontos a partir do topo da área de desenho, mantendo-se na mesma distância do lado esquerdo da área de desenho. O `váparay` pode ser abreviado como `vy`.

### Nota

Ao usar os comandos `vápara`, `váparax`, `váparay` e `centralize` a tartaruga não irá desenhar uma linha, não importa se usado com `usenada` ou `uselápis`.

### Onde está a tartaruga?

Existem dois comandos que devolvem a posição da tartaruga na tela.

pegax

  `pegax` devolve o número em pontos a partir da esquerda da área de desenho até a posição atual da tartaruga.

pegay

  `pegay` devolve o número em pontos a partir do topo da área de desenho até a posição atual da tartaruga.

### A tartaruga tem um traço

A tartaruga tem um traço e vai desenhando uma linha à medida que a tartaruga se move. Existem alguns comandos para controlar o traço. Nesta seção iremos explicar estes comandos.

usenada (un)

      usenada

  O `usenada` levanta o traço da área de desenho. Quando o traço está “em cima”, não é desenhada nenhuma linha à medida que a tartaruga se move. Veja também o `uselápis`. O `usenada` pode ser abreviado para `un`.

uselápis (ul)

      uselápis

  O `uselápis` pressiona o traço para baixo na área de desenho. Quando o traço está “em baixo”, é desenhada uma linha à medida que a tartaruga se move. Veja também o `usenada`. O `uselápis` pode ser abreviado para `ul`.

larguradolápis (ll)

      larguradolápis X

  A `larguradolápis` configura a espessura do traço para X pontos. A `larguradolápis` pode ser abreviado para `ll`.

cordolápis (cl)

      cordolápis R,G,B

  A `cordolápis` configura a cor do traço. A `cordolápis` recebe uma combinação de RGB como parâmetro. A `cordolápis` pode ser abreviado para `cl`.

### Comandos para controlar a área de desenho

Existem vários comandos para controlar a área de desenho.

tamanhodatela (tt)

      tamanhodatela X,Y

  Com o comando `tamanhodatela` você poderá alterar o tamanho da área de desenho. Ele recebe dois parâmetros (X e Y) de entrada, em que o X é a nova largura da área de desenho em pontos, e o Y é a nova altura da mesma área em pontos. O `tamanhodatela` pode ser abreviado para `tt`.

cordofundor (cf)

      cordofundo R,G,B

  A `cordofundo` define a cor da área de desenho. A `cordofundor` recebe uma combinação RGB como parâmetro. A `cordofundo` pode ser abreviado para `cf`.

### Comandos para limpar

Existem dois comandos para limpar a área de desenho, depois de você ter deixado tudo bagunçado.

limpetela (lt)

      limpetela

  Com o `limpetela`, você poderá limpar todos os desenhos da área de desenho. Todo o resto permanece igual: a posição e o ângulo da tartaruga, a cor da área de trabalho, a visibilidade da tartaruga e o tamanho da área de desenho.

apague

      apague

  O `apague` limpa tudo de forma mais abrangente que o comando `limpetela`. Depois de um comando `apague`, tudo fica como estava quando você iniciou o KTurtle. A tartaruga é posicionada no meio do tela, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho e o tamanho da tela é definido para 400 x 400 pontos.

### A tartaruga é uma imagem móvel

Muitas pessoas não sabem o que são as imagens móveis ('sprites' em inglês), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer a tela (para mais informações, veja o glossário sobre as imagens móveis).

A seguir você irá encontrar uma apresentação completa de todos os comandos que lidam com imagens móveis.

### Nota

A versão atual do KTurtle não suporta ainda o uso de imagens móveis além da tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa que desejar.

apareça (ap)

      apareça

  O `apareça` torna a tartaruga visível de novo depois de ter ficado escondida. O `apareça` pode ser abreviado para `ap`.

desapareça (da)

      desapareça

  O `desapareça` esconde a tartaruga. Isto pode ser usado se a tartaruga não couber no seu desenho. O `desapareça` pode ser abreviado para `da`.

### A tartaruga sabe escrever?

A resposta é: “sim”. A tartaruga sabe escrever e pode escrever tudo o que lhe disser para escrever.

mostre

      mostre X

  O comando `mostre` é usado para dizer à tartaruga para escrever algo na área de desenho. O `mostre` recebe números e texto como parâmetros. Você poderá executar o `mostre` para vários parâmetros com o sinal “+”. Veja aqui um pequeno exemplo:

      $ano = 2003
      $autor = "Cies Breijs"
      mostre $autor + " iniciou o projeto do KTurtle em " + $ano + " e ainda continua gostando de trabalhar nele!"

tamanhodafonte

      tamanhodafonte X

  O `tamanhodafonte` configura o tamanho da letra que é usado pelo `mostre`. O `tamanhodafonte` recebe um parâmetro que deverá ser um número. O tamanho é definido em pontos.

### Comandos matemáticos

Os seguintes comandos são as instruções matemáticas mais avançadas do KTurtle.

arredonda

      arredonda(x)

  O `arredonda` arredonda o número indicado ao inteiro mais próximo.

      mostre arredonda 10.8
      parafrente 20
      mostre arredonda 10.3
      parafrente 20

  Com este código, a tartaruga iria apresentar os números 11 e 10.

aleatório (al)

      aleatório X,Y

  O `aleatório` é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, onde o primeiro define o resultado mínimo (X) e o segundo o máximo (Y). O resultado é um número escolhido aleatoriamente que é maior ou igual ao mínimo e menor ou igual ao máximo. Aqui está um pequeno exemplo:

      repita 500 {
        $x = aleatório 1,20
        parafrente $x
        paraesquerda 10 - $x
      }

  Com o comando `aleatório`, você poderá adicionar um pouco de confusão ao seu programa.

resto

      resto X,Y

  O comando `resto` retorna o resto da divisão do primeiro número pelo segundo.

raizquadrada

      raizquadrada X

  O comando `raizquadrada` é usado para descobrir a raiz quadrada de um número X.

pi

      pi

  Este comando devolve a constante Pi, `3,14159...`.

seno, cosseno, tangente

      seno X
      cosseno X
      tangente X

  Estes três comandos representam as conhecidas funções trigonométricas `seno`, `cosseno` e `tangente`. O argumento de entrada destes comandos, X, deve ser a medida de um ângulo em graus.

arcsin, arccos, arctan

      arcoseno X
      arcocosseno X
      arcotangente X

  Estes comandos são as funções inversas do seno, cosseno e tangente. O argumento de entrada destes comandos, X, é um número.

### Entrada de dados e reação através de janelas

Um diálogo é uma pequena janela que fornece algum retorno ou pergunta por alguma entrada. O KTurtle tem dois comandos para diálogos, chamados`mensagem` e o `perguntar`

mensagem

      mensagem X

  O comando `mensagem` recebe uma cadeia de caracteres como entrada. Exibe então uma janela que contém o texto da cadeia de caracteres.

      mensagem "Cies iniciou o projeto do KTurtle em 2003 e ainda continua gostando de trabalhar nele!"

perguntar

      perguntar X

  O `perguntar` recebe uma cadeia de caracteres como entrada. Ele mostra o texto da cadeia de caracteres em uma janela (de maneira similar ao mensagem), mostrando também um campo de entrada de texto. Após o usuário inserir um número ou uma cadeia de caracteres nesta caixa, o resultado poderá ser guardado numa variável ou passado como argumento a um comando. Por exemplo

      $entrada = perguntar "Qual o ano do seu nascimento?"
      $saida = 2003 - $entrada
      mostre "Em 2003, você tinha " + $saida + " anos em determinado momento."

  Quando um usuário cancelar a janela ou não inserir nada, a variável fica vazia.

Atribuição de variáveis
Atribuição de variáveis

## Atribuição de variáveis

Vejamos primeiro as variáveis, e depois iremos ver como atribuir valores a essas variáveis.

As variáveis são palavras que começam por um “$”; no editor, são realçadas em púrpura.

As variáveis poderão conter qualquer número, texto ou valor booleano (verdadeiro/falso). Ao usar a atribuição `=`, uma variável ficará com conteúdo associado. Irá manter esse conteúdo até que o programa termine a execução ou até a variável ser atribuída de novo a outra coisa qualquer.

Você poderá usar as variáveis, uma vez atribuídas, como se fossem o seu próprio conteúdo. Por exemplo, no seguinte trecho de TurtleScript:

    $x = 10
    $x = $x / 3
    mostre $x

Primeiro, é atribuído à variável `$x` o valor `10`. Depois, o `$x` terá como novo valor o seu próprio valor dividido por `3` — isto significa na prática que o `$x` terá atribuído o valor do produto `10 / 3`. Finalmente, é impresso o valor do `$x`. Nas linhas 2 e 3, irá ver que o `$x` é usado como se fosse o seu próprio conteúdo.

As variáveis têm que estar atribuídas para poderem ser usadas. Por exemplo, um:

    mostre $n

Irá resultar numa mensagem de erro.

Considere o pequeno trecho de código em TurtleScript:

    $a = 2004
    $b = 25

    # o próximo comando imprime "2029"
    mostre $a + $b
    paratrás 30
    # o próximo comando imprime "2004 mais 25 é igual a 2029"
    mostre $a + " mais " + $b + " é igual a " + ($a + $b)
    paratrás 30

Nas duas primeiras linhas, as variáveis `$a` e `$b` são configuradas como sendo iguais a 2004 e 25. Depois nos dois comandos `mostre` existe um comando `paratrás 30` no meio são executados. Os comentários antes dos comando `mostre` explicam o que ele está fazendo. O comando `paratrás 30` está ai para garantir que cada saída está numa nova linha. Como poderá ver, as variáveis poderão ser usadas como se fossem o valor que contêm, podendo usá-las com qualquer tipo de operadores ou fornecendo-os como entradas na invocação dos comandos.

Mais um exemplo:

    $nome = perguntar "Como se chama?"
    mostre "Olá " + $nome + "! Boa sorte ao aprender a arte da programação..."

É bastante simples. Mais uma vez, poderá ver que a variável `$nome`, é tratada apenas como texto.

Ao usar as variáveis, o inspetor torna-se bastante útil. Ele mostra o conteúdo de todas as variáveis que estão sendo usadas atualmente.

Controlando a execução
Controlando a execução

## Controlando a execução

Os controladores de execução permitem-lhe — como o nome deles indica — controlar a execução.

Os comandos de controle de execução são realçados em verde escuro e negrito. As chaves são frequentemente usadas juntamente com os controladores de execução e eles são realçados em preto.

### Fazendo a tartaruga esperar

Se você já tentou programar um pouco no KTurtle, você já poderá ter reparado que a tartaruga pode ser bastante rápida desenhando. Este comando faz a tartaruga andar um pouco mais devagar.

aguarde

      aguarde X

  O `aguarde` faz a tartaruga esperar X segundos.

      repita 36 {
        parafrente 5
        paradireita 10
        aguarde 0.5
      }

  Este código irá desenhar uma circunferência, mas a tartaruga irá esperar meio segundo a cada passo. Isto dá a noção de uma tartaruga vagarosa.

### Executar “se”

se

      se booleano { ... }

  O código que é colocado entre os parênteses só será executado `se` o valor booleano for “verdadeiro”.

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

  Na primeira linha, o `$x` é inicializado a 6. Na segunda linha, a operador de comparação é usado para avaliar `x > 5`. Uma vez que a resposta a esta pergunta é “verdadeira”, o controlador de execução `se` irá permitir que o código entre chaves seja executado.

### Se não, em outras palavras: “senão”

senão

      se booleano { ... } senao { ... }

  O `senao` pode ser usado além do controlador de execução `se`. O código entre chaves a seguir ao `senao` só é executado se o valor booleano for “falso”.

      apague
      $x = 4
      se $x > 5 {
        mostre "O x é maior que cinco!"
      } senao {
        mostre "O x é menor que seis!"
      }

  O operador de comparação testa a expressão `x > 5`. Uma vez que o `x` fica igual a 4 na primeira linha, a resposta à pergunta é “falso”. Isto significa que o código entre chaves a seguir ao `senao` é executado.

### O ciclo “enquanto”

enquanto

      enquanto booleano { ... }

  O controlador de execução `enquanto` é um pouco como o `se`. A diferença é que o `enquanto` continua a repetir o código entre parênteses até que a resposta à valor booleano seja “falso”.

      $x = 1
      enquanto $x < 5 {
        parafrente 10
        aguarde 1
        $x = $x + 1
      }

  Na primeira linha, o `$x` fica igual a 1. Na segunda, a expressão `x < 5` é avaliada. Uma vez que a resposta a esta pergunta é “verdadeiro”, o controlador de execução `enquanto` começa a execução do código entre chaves até que a condição `$x < 5` seja “falso”. Neste caso, o código entre parênteses será executado 4 vezes, uma vez que, cada vez que a quinta linha é executada, o `$x` fica um número acima.

### O ciclo “repita”

repita

      repita número { ... }

  O controlador de execução `repita` funciona um pouco como o `enquanto`. A diferença é que o `repita` repete o código entre parênteses um número fixo de vezes, igual ao número dado.

### O ciclo “para”, um ciclo de contagem

para

      para variável = número até número { ... }

  O ciclo `para` é um “ciclo de contagem”, isto é, faz uma contagem para você. O primeiro membro configura a variável com o valor do primeiro ciclo. Em cada iteração, o número é aumentado até atingir o segundo número.

      para $x = 1 ate 10 {
        mostre $x * 7
        avancar 15
      }

  Cada vez que o código entre chaves é executado, o `$x` é incrementado de uma unidade, até que o valor do `$x` chegue a 10. O código entre chaves imprime o valor de `$x` multiplicado por 7. Depois deste programa terminar a sua execução, você irá ver a tabuada dos 7 na área de desenho.

  O passo padrão para um ciclo é 1, você pode usar um outro valor com

      para variável = número até number passo número { ... }

### Deixar um ciclo

quebre

      quebre

  Termina imediatamente o ciclo atual e transfere o controle para a instrução imediatamente após esse ciclo.

### Interrompe a execução do seu programa

sair

      sair

  Termina a execução do seu programa.

### Verificar os testes durante a execução

declara

      declara booleano

  Pode ser usado para confirmar a correção do programa ou seus parâmetros.

      $entrada = perguntar "Qual é a sua data de nascimento?"
      # o ano deve ser positivo
      declara $entrada
      > 0

Crie os seus próprios comandos com o “aprenda”
Crie os seus próprios comandos com o “aprenda”

## Crie os seus próprios comandos com o “aprenda”

O `aprenda` é um comando muito especial, porque é usado para criar os seus próprios comandos. O comando que criar poderá receber parâmetros e devolver resultados. Vamos ver como é criado um novo comando.

    aprenda circunferência $x {
      repita 36 {
        parafrente $x
        paraesquerda 10
      }
    }

O novo comando chama-se `circunferencia`. O `circunferencia` recebe um parâmetro, um número, para definir o tamanho da circunferência. O `circunferencia` não devolve nenhum resultado. O comando `circunferencia` pode agora ser usado como um comando normal. Veja este exemplo:

    aprenda círculo $X {
      repita 36 {
        parafrente $X
        paraesquerda 10
      }
    }

    vápara 200,200
    círculo 20

    vápara 300,200
    círculo 40

No próximo exemplo, vai ser criado um comando com um valor de resultado devolvido.

    aprender faculdade $x {
      $r = 1
      para $i = 1 ate $x {
        $r = $n * $i
      }
      devolver $r
    }

    imprimir faculdade 5

Neste exemplo, existe agora um comando novo chamado `faculdade`. Se o parâmetro deste comando for `5`, então o resultado é igual a `5*4*3*2*1`. Ao usar o `devolver`, o valor do resultado é indicado e a execução é devolvida.

Os comandos poderão ter mais de uma entrada. No seguinte exemplo, é criado um comando que desenha um retângulo.

    aprenda caixa $X, $Y {
      parafrente $Y
      paradireita 90
      parafrente $X
      paradireita 90
      parafrente $Y
      paradireita 90
      parafrente $X
      paradireita 90
    }

Agora, você poderá usar o `caixa 50, 100` para que a tartaruga desenhe um retângulo na área de desenho.

Capítulo 5. Glossário
Glossário

# Capítulo 5. Glossário

Neste capítulo, você irá obter uma explicação para a maioria das palavras “pouco comuns” que são usadas no manual.

graus

  Os graus são uma unidade para medir ângulos. Uma volta completa corresponde a 360 graus, uma meia-volta corresponde a 180 graus e um quarto de volta a 90 graus. Os comandos `paraesquerda`, `paradireita` e `direção` necessitam de um parâmetro em graus.

parâmetros e resultado dos comandos

  Alguns comandos recebem parâmetros, outros devolvem resultados, outros fazem ambas as coisas e finalmente existem outros que não fazem nenhuma delas.

  Alguns exemplos de comandos que só recebem parâmetros são:

      parafrente 50
      cordolápis 255,0,0
      mostre "Olá!"

  O comando `parafrente` recebe o `50` como parâmetro, porque o `parafrente` precisa deste parâmetro para saber quantos pontos deverá andar em frente. O `cordolápis` recebe um parâmetro e o `mostre` recebe uma cadeia de caracteres como parâmetro. Lembre-se que o parâmetro também poderá ser um recipiente. O próximo exemplo ilustra isto:

      $x = 50
      mostre $x
      parafrente 50
      $txt = "Olá!"
      mostre $txt

  Agora alguns exemplos de comandos que devolvem resultados:

      $x = perguntar "Por favor, digite algo e pressione OK... obrigado!"
      $r = aleatório 1,100

  O comando `perguntar` recebe um texto como parâmetro e devolve o número ou o texto que é introduzido. Como poderá ver, o resultado do `perguntar` é guardado no recipiente `x`. O comando `aleatório` também devolve um resultado. Neste caso, devolve um número entre 1 e 100. O resultado do `aleatório` é de novo guardado num recipiente, chamado `r`. Lembre-se que os recipientes `x` e `r` não são usados no código do exemplo acima.

  Também existem alguns comandos que não precisam de parâmetros nem devolvem nada. Alguns exemplos:

      limpetela
      usenada

realce intuitivo

  Este é um recurso do KTurtle que torna a codificação ainda mais simples. Com o realce intuitivo, o código que você escrever ganha uma cor que indica qual tipo de código é. Na próxima lista, você irá encontrar os diferentes tipos de código e a cor que obtém no editor de código.

  Tabela 5.1. Os diferentes tipos de código e a sua cor de realce

  comandos normais | azul escuro | Os comandos normais estão descritos aqui.
  comandos de controle da execução | preto (negrito) | Estes comandos especiais controlam a execução; você poderá ler mais sobre eles aqui.
  comentários | cinza | As linhas que estão comentadas começam por caracteres de comentário (#); estas linhas são ignoradas quando o código é executado. Os comentários permitem ao programador explicar um pouco do seu código ou podem ser usadas para evitar temporariamente que um pedaço de código seja executado.
  chaves {, } | verde escuro (negrito) | As chaves são usadas para agrupar pedaços de código. As chaves são usadas geralmente com os controladores de execução.
  o comando aprenda | verde claro (negrito) | O comando aprenda é usado para criar comandos novos.
  texto | vermelho | Também não há muito a dizer sobre o texto nas cadeias de caracteres, a não ser que começam e terminam com aspas (").
  números | vermelho escuro | Números, bem não temos muita coisa para falar sobre eles.
  valores booleanos | vermelho escuro | Existem exatamente dois valores booleanos: verdadeiro e falso.
  variáveis | púrpura | Começa com um '$' e poderá conter números, textos ou valores booleanos.
  operadores matemáticos | cinza | Estes são os operadores matemáticos: `+`, `-`, `*`, `/` e `^`.
  operadores de comparação | azul claro (negrito) | Estes são os operadores de comparação: `==`, `!=`, `<`, `>`, `<=` e `>=`.
  operadores booleanos | rosa (negrito) | Estes são os operadores booleanos: `e`, `ou` e `não`.
  texto normal | preto |

pontos

  Um ponto é um ponto na tela. Se você olhar muito de perto para o que vê na tela do seu monitor, irá constatar que ela usa pontos. Todas as imagens da tela são criadas com estes pontos. Um ponto é a menor coisa que poderá ser desenhada na tela.

  Existem vários comandos que precisam de números como parâmetros, e são: o `parafrente`, `paratrás`, `vápara`, `váparax`, `váparay`, `tamanhodatela` e o `larguradolápis`.

  Nas versões anteriores do KTurtle, a área de desenho era uma imagem rasterizada; agora, nas versões mais recentes, é um desenho vetorial. Isto significa que a área de desenho poderá ser ampliada ou reduzida, porém, um ponto na área de desenho pode não corresponder a um ponto na tela.

Combinações de RGB (códigos de cores)

  As combinações de RGB são usadas para descrever cores. O “R” vem de “red” (vermelho), o “G” de “green” (verde) e o “B” de “blue” (azul). Um exemplo de uma combinação RGB é o `255,0,0`, onde o valor da componente vermelha é 255 e as outras são 0, o que resulta num tom claro de vermelho. Cada valor de uma combinação RGB terá que estar no intervalo entre 0 e 255. Aqui está uma lista com as cores mais usadas:

  Tabela 5.2. Combinações RGB mais usadas

  `0,0,0` | preto
  `255,255,255` | branco
  `255,0,0` | vermelho
  `150,0,0` | vermelho escuro
  `0,255,0` | verde
  `0,0,255` | azul
  `0,255,255` | azul claro
  `255,0,255` | cor de rosa
  `255,255,0` | amarelo

  Dois comandos necessitam de uma combinação RGB como parâmetro, e são eles: o `cordofundo` e o `cordolápis`.

imagem móvel

  Uma imagem móvel é uma pequena imagem que pode ser movida pela tela. A nossa tartaruga é uma imagem móvel, por exemplo.

  ### Nota

  Com esta versão do KTurtle, a imagem móvel não consegue ser alterada de uma tartaruga para outra coisa. As versões futuras do KTurtle serão capazes de fazer isso.

Capítulo 6. Guia do tradutor do KTurtle
Guia do tradutor do KTurtle

# Capítulo 6. Guia do tradutor do KTurtle

Como você já deve saber, a linguagem de programação do KTurtle - o TurtleScript -, permite a sua própria tradução. Isto retira uma barreira para alguns alunos, especialmente os mais novos, no seu esforço para compreender as bases da programação.

Ao traduzir o KTurtle para uma nova língua, você irá encontrar incluídos, além dos textos da GUI, os comandos de programação, os exemplos e as mensagens de erro nos arquivos `.pot` normais que são usados nas traduções do KDE. Tudo é traduzido com o método normal de traduções que está implementado no KDE, se bem que é altamente aconselhável aprender um pouco sobre como traduzi-los (conforme você também irá ler nos comentários do tradutor).

Por favor, veja https://edu.kde.org/kturtle/translation.php para mais informação sobre o processo de tradução. Muito obrigado pelo seu trabalho! O KTurtle depende muito destas traduções.

Capítulo 7. Créditos e licença
Créditos e licença

# Capítulo 7. Créditos e licença

KTurtle

Programa com 'copyright' 2003-2007 de Cies Breijs `(cies AT kde DOT nl)`

Direitos autorais da documentação 2004, 2007, 2009

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

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

- Algumas alterações de revisão de texto por Philip Rodrigues `(phil AT kde.org)`

- Ajuda de tradução atualizada e algumas mudanças de revisão de Andrew Coles `(andrew_coles AT yahoo DOT co DOT uk)`

Tradução de Marcus Gama `(marcus.gama AT gmail.com)` e André Marcelo Alvarenga `(alvarenga AT kde.org)`

Esta documentação é licenciada sob os termos da Licença de Documentação Livre GNU.

Este programa é licenciado sob os termos da Licença Pública Geral GNU.

Índice de comandos
Índice de comandos

# Índice de comandos

### A

aguarde, Fazendo a tartaruga esperar
aleatório (al), Comandos matemáticos
apague, Comandos para limpar
apareça (ap), A tartaruga é uma imagem móvel
aprenda, Crie os seus próprios comandos com o “aprenda”
arccos, Comandos matemáticos
arcotangente, Comandos matemáticos
arcsin, Comandos matemáticos
arredonda, Comandos matemáticos
até, O ciclo “para”, um ciclo de contagem

### C

centralize, Movendo a tartaruga
cordofundor (cf), Comandos para controlar a área de desenho
cordolápis (cl), A tartaruga tem um traço
cosseno, Comandos matemáticos

### D

declara, Verificar os testes durante a execução
desapareça (da), A tartaruga é uma imagem móvel
direção (dir), Movendo a tartaruga

### E

e, Operadores booleanos (verdadeiro/falso)
enquanto, O ciclo “enquanto”

### F

falso, Valores booleanos (verdadeiro/falso)

### L

larguradolápis (ll), A tartaruga tem um traço
lerdireção, Movendo a tartaruga
limpetela (lt), Comandos para limpar

### M

mensagem, Entrada de dados e reação através de janelas
mostre, A tartaruga sabe escrever?

### N

não, Operadores booleanos (verdadeiro/falso)

### O

ou, Operadores booleanos (verdadeiro/falso)

### P

para, O ciclo “para”, um ciclo de contagem
paradireita (pd), Movendo a tartaruga
paraesquerda (pe), Movendo a tartaruga
parafrente (pf), Movendo a tartaruga
paratrás (pt), Movendo a tartaruga
passo, O ciclo “para”, um ciclo de contagem
pegax, Onde está a tartaruga?
pegay, Onde está a tartaruga?
perguntar, Entrada de dados e reação através de janelas
pi, Comandos matemáticos

### Q

quebre, Deixar um ciclo

### R

raizquadrada, Comandos matemáticos
repita, O ciclo “repita”
resto, Comandos matemáticos
resultado, Crie os seus próprios comandos com o “aprenda”

### S

sair, Interrompe a execução do seu programa
se, Executar “se”
senão, Se não, em outras palavras: “senão”
seno, Comandos matemáticos

### T

tamanhodafonte, A tartaruga sabe escrever?
tamanhodatela (tt), Comandos para controlar a área de desenho
tangente, Comandos matemáticos

### U

uselápis (ul), A tartaruga tem um traço
usenada (un), A tartaruga tem um traço

### V

vápara, Movendo a tartaruga
váparax (vx), Movendo a tartaruga
váparay (vy), Movendo a tartaruga
verdadeiro, Valores booleanos (verdadeiro/falso)