# 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 ou voltas. Uma volta completa corresponde a 360 graus, uma meia-volta corresponde a 180 graus e um quarto-de-volta a 90 graus. Os comandos `turnleft`, `turnright` e `direction` 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:

      forward 50
      pencolor 255,0,0
      print "olá!"

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

      x = 50
      print x
      texto = "olá!"
      print texto

  Agora alguns exemplos de comandos que devolvam resultados:

      x = inputwindow "por favor digite algo e pressione OK... obrigado!"
      r = random 1,100

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

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

      clear
      penup
      wrapon
      hide

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.

  ## Os diferentes tipos de código e a sua cor de realce

  comandos normais | verde escuro | Os comandos normais estão descritos aqui.
  controladores de execução | preto (negrito) | Os comandos especiais que controlam a execução; você poderá ler mais sobre eles aqui.
  comentários | amarelo escuro | 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.
  colchetes [, ] | verde claro (negrito) | Os colchetes são usados para agrupar pedaços de código. Os colchetes são usados normalmente com os controladores de execução.
  o comando learn | verde claro (negrito) | O comando learn é usado para criar comandos novos.
  números | azul | Números, bem não temos muita coisa para falar sobre eles.
  texto | vermelho escuro | 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 (").
  caracteres matemáticos | cinza | Estes são os caracteres matemáticos: +, -, *, /, (, e ). Leia mais sobre eles aqui.
  caracteres das perguntas | azul (negrito) | Leia mais sobre as perguntas aqui.
  palavras de colagem das perguntas | cor de rosa | Leia mais sobre as palavras de colagem de perguntas ('and', 'or' e 'not') aqui.
  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 uma quantidade de pontos como parâmetro, e são: o `forward`, `backward`, `go`, `gox`, `goy`, `canvassize` e o `penwidth`.

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:

  ## 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

  Para descobrir facilmente as combinações RGB de uma cor, você deverá experimentar o extrator de cores! Você poderá encontrá-lo aqui: Ferramentas Extrator de Cor.

  Dois comandos necessitam de uma combinação RGB como parâmetro, e são eles: o `canvascolor` e o `pencolor`.

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.

envolvência

  A envolvência é o que acontece quando a tartaruga desenha algo que é muito grande para caber na área de desenho e a envolvência está ativa Isto é o que acontece quando a envolvência está ligada Um exemplo de envolvência Quando a tartaruga passa para fora de um extremo da área de desenho ele vai passar para o extremo imediatamente oposto para que possa continuar o seu movimento. Deste modo, a tartaruga irá estar sempre na tela, enquanto se move.

  A envolvência poderá ser ativada e desativada com os comandos `wrapon` e `wrapoff`. Quando o &kturtle; inicia, a envolvência está ativa por padrão.