# Referência de Programação em &logo; do &kturtle;

## 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 secção iremos explicar todos os comandos que podem ser usados no &kturtle;.

### Mover a tartaruga

Existem vários comandos para mover a tartaruga pelo ecrã.

forward

-     forward X

  O `forward` move a tartaruga para a frente X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O `forward` pode ser abreviado para `fw`

backward

-     backward X

  O `backward` move a tartaruga para trás X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O `backward` pode ser abreviado para `bw`.

turnleft

-     turnleft X

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

turnright

-     turnright X

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

direction

-     direction X

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

center

-     center

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

go

-     go X,Y

  O `go` manda a tartaruga ir para um dado local da área de desenho. Este local está a X pixels do lado esquerdo da área de desenho e a Y pixels do topo da área. Lembre-se que, ao usar o comando `go`, a tartaruga não irá desenhar nenhuma linha.

gox

-     gox X

  Ao usar o comando `gox`, a tartaruga irá mover-se X pixels a partir da esquerda da área de desenho, mantendo à mesma a sua altura.

goy

-     goy Y

  Ao usar o comando `goy`, a tartaruga irá mover-se Y pixels a partir do topo da área de desenho, mantendo à mesma a sua distância ao lado esquerdo da área de desenho.

### 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 secção iremos explicar estes comandos.

penup

-     penup

  O `penup` 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 `pendown`. O `penup` pode ser abreviado para `pu`.

pendown

-     pendown

  O `pendown` carrega no 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 `penup`. O `pendown` pode ser abreviado para `pd`.

penwidth

-     penwidth X

  O `penwidth` configura a espessura do traço para X pixels. O `penwidth` pode ser abreviado para `pw`.

pencolor

-     pencolor R,G,B

  O `pencolor` configura a cor do traço. O `pencolor` recebe uma combinação de RGB como parâmetro. O `pencolor` pode ser abreviado para `pc`.

### Comandos para controlar a área de desenho

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

canvassize

-     canvassize X,Y

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

canvascolor

-     canvascolor R,G,B

  O `canvascolor` define a cor da área de desenho. O `canvascolor` recebe uma combinação RGB como parâmetro. O `canvascolor` pode ser abreviado para `cc`.

wrapon

-     wrapon

  Com o comando `wrapon` você poderá activar a envolvência para a área de desenho. Por favor veja o glossário para saber o que é a envolvência.

wrapoff

-     wrapoff

  Com o comando `wrapoff` você poderá desactivar a envolvência para a área de desenho. Isto significa que a tartaruga poder-se-á mover para fora da área de desenho e perder-se. Por favor veja o glossário se quiser saber o que é a envolvência.

### Comandos para limpar

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

clear

-     clear

  Com o `clear`, você poderá limpar todos os desenhos da área respectiva. Tudo 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. O `clear` pode ser abreviado para `ccl`.

reset

-     reset

  O `reset` limpa tudo de forma mais abrangente que o comando `clear`. Depois de um comando `reset`, tudo fica tal e qual estava quando você iniciou o &kturtle;. A tartaruga é posicionada no meio do ecrã, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho.

### A tartaruga é uma imagem móvel

Muitas das pessoas não sabem o que são as imagens móveis ('sprites'), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer o ecrã (para mais informações, veja o glossário sobre as imagens móveis). Deste modo, a tartaruga é uma imagem móvel!

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

[A versão actual do &kturtle; não suporta ainda o uso de imagens móveis que não apenas a tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa ao seu gosto!]

show

-     show

  O `show` torna tartaruga a tartaruga visível de novo depois de ter ficado escondida. O `show` pode ser abreviado para `ss`.

hide

-     hide

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

### Será que as tartarugas escrevem texto?

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

print

-     print X

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

      ano = 2004
      utilizador = "Ze"
      print "O KTurtle foi usado em " + ano + " pelo " + utilizador

fontsize

-     fontsize X

  O `fontsize` configura o tamanho da letra que é usado pelo `print`. O `fontsize` recebe um parâmetros que deverá ser um número. O tamanho é definido em pixels.

### Um comando que joga aos dados por si

Aqui está um comando que lança um dado para si

random

-     random X,Y

  O `random` é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, em que 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:

            repeat 500 [
              x = random 1,20
              forward x
              turnleft 10 - x
            ]

  Com o comando 'random', você poderá adicionar um pouco de confusão ao seu programa.

## Contentores

Os contentores são letras ou palavras que podem ser usadas pelo programador para guardar algum número ou algum texto. Os contentores que contêm um número chamam-se variáveis, enquanto que os que contêm texto chamam-se cadeias de caracteres.

Os contentores que não são usados ainda são iguais a 0, por omissão. Por exemplo, o:

    print N

Irá imprimir um 0.

### Variáveis: contentores de números

Vamos começar com um exemplo:

    x = 3
    print x

Na primeira linha, a letra `x` passou a ser uma variável (contentora de números). Como poderá ver, o valor da variável `x` passou a 3. Na segunda linha, o valor é impresso.

Lembre-se que, se quisesse imprimir um x, então deveria ser escrito

    print "x"

Isso foi fácil, mas agora há um exemplo um pouco mais difícil:

    A = 2004
    B = 25
    AB = A + B

    # o próximo comando imprime "2029"
    print AB
    backward 30
    # o próximo comando imprime "2004 mais 25"
    print A + " mais " + B
    backward 30
    # o próximo comando imprime "1979"
    print A - B

Nas duas primeiras linhas, as variáveis `A` e `B` são configuradas como sendo iguais a 2004 e 25. Na terceira linha, a variável `AB` fica igual a `A + B`, o que dá 2029. O resto do exemplo consiste em 3 comandos `print` com `backward 30` no meio. O `backward 30` está lá para garantir que cada resultado fica numa linha diferente. Neste exemplo, você vê também que as variáveis podem ser usadas nos cálculos matemáticos.

### Cadeias de Caracteres: contentores de texto

As cadeias de caracteres são bastante parecidas com as variáveis. A maior diferença é que as cadeias de caracteres não podem ser usadas em cálculos matemáticos e perguntas. Um exemplo da utilização das cadeias de caracteres:

    x = "Olá "
    nome = inputwindow "por favor indique o seu nome..."
    print x + nome + ", como é que está?

Na segunda linha, a cadeia de caracteres `x` fica igual a Olá . Na segunda linha, a cadeia de caracteres `nome` é configurada como o resultado do comando `inputwindow`. Na terceira linha, o programa imprime uma composição de três cadeias de caracteres na área de desenho.

Este programa pede-lhe para introduzir o seu nome. Quando você, por exemplo, introduzir o nome Zé, o programa irá imprimir Olá Zé, como é que está?. Lembre-se que o sinal de mais (+) é o único símbolo matemático que você poderá usar com as cadeias de caracteres.

## Será que a Tartaruga Pode Fazer Contas?

Sim, o &kturtle; sabe fazer contas para si. Você poderá somar (+), subtrair (-), multiplicar (*) e dividir (/). Aqui está um exemplo no qual iremos usar todas as operações:

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

Será que sabe o valor de 'a', 'b', 'c' e 'd'?

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

    print 2004-12

Agora, um exemplo com parêntesis:

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

O que estiver entre parêntesis 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).

## Fazer perguntas, obter respostas...

O `if` e o `while` são controladores de execução que iremos discutir na próxima secção. Nesta secção iremos usar o comando `if` para explicar as perguntas.

Um exemplo simples de perguntas:

    x = 6
    if x > 5 [
      print "olá"
    ]

Neste exemplo, a pergunta é `x > 5`, se a resposta a esta pergunta for true (verdadeira), o código entre parêntesis rectos será executado. As perguntas são uma parte importante da programação e são usadas normalmente em conjunto com os controladores de execução, como o `if`. Todos os números e variáveis (contentores de números) poderão ser comparados uns com os outros nas perguntas.

Aqui estão todas as perguntas possíveis:

## Tipos de perguntas

`a == b` | é igual a | a resposta é true (verdadeira) se o `a` for igual ao `b`
`a != b` | é diferente de | a resposta é true (verdadeira) se o `a` não for igual ao `b`
`a > b` | maior que | a resposta é true (verdadeira) se o `a` for maior que o `b`
`a < b` | menor que | a resposta é true (verdadeira) se o `a` for menor que o `b`
`a >= b` | maior ou igual a | a resposta é true (verdadeira) se o `a` for maior ou igual ao `b`
`a <= b` | menor ou igual a | a resposta é true (verdadeira) se o `a` for menor ou igual ao `b`

As perguntas também podem ser coladas umas às outras com palavras de colagem de perguntas onde, desta forma, algumas perguntas tornam-se uma pergunta maior.

    a = 1
    b = 5
    if a < 5 and b == 5 [
      print "olá"
    ]

Neste exemplo, a palavra de colagem `and` é usada para colar 2 perguntas (`a < 5`, `b == 5`) em conjunto. Se um lado do `and` der uma resposta false (falsa), a pergunta toda irá responder false, porque, com a palavra de colagem `and`, ambos os lados precisam de ser true para que a resposta seja true (verdadeira).

O `and` não é a única palavra de colagem; ainda existem mais outras duas. Todas elas se encontram na próxima tabela:

## Palavras de colagem de perguntas

`and` | ambos os lados têm de ser true (verdadeiros) para a resposta ser true (verdadeira)
`or` | se um dos lados for true (verdadeiros) a resposta é true (verdadeira)
`not` | se a pergunta for false (falsa), a resposta é verdadeira

## Controlar a execução

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

### Fazer a tartaruga esperar

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

wait

-     wait X

  O `wait` faz a tartaruga esperar X segundos.

      repeat 36 [
        forward 5
        turnright 10
        wait 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 o "if"

if

-     if pergunta [ ... ]

  O código que é colocado no ... só será executado se (`if`) a resposta à pergunta for true (verdadeira). Por favor leia, para obter mais informações sobre perguntas, a secção de perguntas.

      x = 6
      if x > 5 [
        print "O x é maior que cinco!"
      ]

  Na primeira linha, o `x` é inicializado a 6. Na segunda linha, a pergunta `x > 5` é feita. Dado que a resposta a esta pergunta é verdadeira, o controlador de execução `if` irá permitir que o código entre parêntesis rectos seja executado

### Executar o "while"

while

-     while pergunta [ ... ]

  O controlador de execução `while` é um pouco como o `if`. A diferença é que o `while` continua a repetir o código entre parêntesis até que a resposta à pergunta seja false (falsa).

      x = 1
      while x < 5 [
        forward 10
        wait 1
        x = x + 1
      ]

  Na primeira linha, o `x` fica igual a 1. Na segunda, a pergunta `x < 5` é feita. Dado que a resposta a esta pergunta é true (verdadeira), o controlador de execução `while` começa a execução do código entre parêntesis até que a resposta à pergunta seja false (falsa). Neste caso, o código entre parêntesis será executado 4 vezes, dado que, de cada vez que a quinta linha é executada, o `x` fica um número acima.

### Se não, por outras palavras: "else"

else

-     if pergunta [ ... ] else [ ... ]

  O `else` pode ser usado para além do controlador de execução `if`. O código entre parêntesis a seguir ao `else` só é executado se a resposta à pergunta que é feita for false (falsa).

      x = 4
      if x > 5 [
        print "O x é maior que cinco!"
      ] else [
        print "O x é menor que seis!"
      ]

  A pergunta testa se o `x` é maior que 5. Dado que o `x` fica igual a 4 na primeira linha, a resposta à pergunta é false (falsa). Isto significa que o código entre parêntesis a seguir ao `else` é executado.

### O ciclo "for"

for

-     for ponto inicial a ponto final [ ... ]

  O ciclo `for` é um ciclo de contagem, ou seja, faz de contador para si.

      for x = 1 to 10 [
        print x * 7
        forward 15
      ]

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

## Crie os seus próprios comandos!

O `learn` é 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 é que é criado um novo comando.

    learn circunferencia (x) [
      repeat 36 [
        forward x
        turnleft 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:

    learn circunferencia (x) [
      repeat 36 [
        forward x
        turnleft 10
      ]
    ]

    go 30,30
    circle 20

    go 40,40
    circle 50

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

    learn multiplicarPeloProprio (n) [
      r = n * n
      return r
    ]
    i = inputwindow "Por favor indique um número e carregue em OK"
    print "O " + i + " multiplicado por ele própirio é igual a: " + multiplicarPeloProprio (i)

Neste exemplo, existe agora um comando novo chamado `multiplicarPeloProprio`. O parâmetro deste comando é multiplicado por ele próprio e é então devolvido, usando o comando `return`. O comando `return` é a forma de devolver um resultado de uma função criada.