You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1725 lines
42 KiB
1725 lines
42 KiB
<!--Dear translator: please NEVER translate the id or anything inside the tags as they are needed in english by the application
|
|
Thanks a lot in advance.-->
|
|
<chapter id="reference">
|
|
<title
|
|
>Referência de Programação em &logo; do &kturtle;</title>
|
|
<para
|
|
>Esta é a referência para o &logo; do &kturtle;. Neste capítulo iremos tocar brevemente em todos os <link linkend="different-instructions"
|
|
>tipos de instruções diferentes</link
|
|
>. Depois, serão explicados os <link linkend="commands"
|
|
>comandos</link
|
|
>, um por um. De seguida, serão explicados os <link linkend="containers"
|
|
>contentores</link
|
|
>, a <link linkend="math"
|
|
>matemática</link
|
|
>, as <link linkend="questions"
|
|
>questões</link
|
|
> e os <link linkend="controlling-execution"
|
|
>controladores de execução</link
|
|
>. Por último, ser-lhe-á mostrado como criar os seus próprios comandos com o <link linkend="learn"
|
|
>learn</link
|
|
>.</para>
|
|
|
|
<sect1 id="different-instructions">
|
|
<title
|
|
>Tipos Diferentes de Instruções</title>
|
|
<para
|
|
>Como em qualquer linguagem, o LOGO tem diferentes tipos de palavras e símbolos. Aqui, será explicada a diferença entre os vários tipos.</para>
|
|
|
|
<sect2 id="command">
|
|
<title
|
|
>Comandos</title>
|
|
<para
|
|
>Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados introduzidos, enquanto outros trazem resultados. <screen
|
|
># o 'forward' é um comando que necessita de dados de entrada, neste caso o número 100:
|
|
forward 100
|
|
</screen>
|
|
</para>
|
|
<para
|
|
>Para uma ideia geral de todos os comandos que o &kturtle; suporta, venha <link linkend="commands"
|
|
>aqui</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
<sect2 id="number">
|
|
<title
|
|
>Números</title>
|
|
<para
|
|
>O mais provável é que você já conheça alguma coisa sobre os números. A forma como estes são usados no &kturtle; não é muito diferente da língua falada ou da matemática. </para>
|
|
<para
|
|
>Temos então os números conhecidos por naturais: <userinput
|
|
>0</userinput
|
|
>, <userinput
|
|
>1</userinput
|
|
>, <userinput
|
|
>2</userinput
|
|
>, <userinput
|
|
>3</userinput
|
|
>, <userinput
|
|
>4</userinput
|
|
>, <userinput
|
|
>5</userinput
|
|
>, etc. Os números negativos: <userinput
|
|
>-1</userinput
|
|
>, <userinput
|
|
>-2</userinput
|
|
>, <userinput
|
|
>-3</userinput
|
|
>, etc. Finalmente, os números decimais ou fraccionários, como por exemplo: <userinput
|
|
>0.1</userinput
|
|
>, <userinput
|
|
>3.14</userinput
|
|
>, <userinput
|
|
>33.3333</userinput
|
|
>, <userinput
|
|
>-5.05</userinput
|
|
>, <userinput
|
|
>-1.0</userinput
|
|
>. </para>
|
|
<para
|
|
>Os números podem ser usados em <link linkend="math"
|
|
>cálculos matemáticos</link
|
|
> e <link linkend="questions"
|
|
>perguntas</link
|
|
>. Também podem ser colocados em <link linkend="containers"
|
|
>contentores</link
|
|
>.</para>
|
|
<para
|
|
>Os números ficam <glossterm
|
|
>realçados</glossterm
|
|
> a azul no <link linkend="the-code-editor"
|
|
>editor de código</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
<sect2 id="string">
|
|
<title
|
|
>Cadeias de caracteres</title>
|
|
<para
|
|
>Primeiro um exemplo: <screen>
|
|
print "Olá, sou uma cadeia de caracteres."
|
|
</screen
|
|
> Neste exemplo, o <userinput
|
|
>print</userinput
|
|
> é um comando, enquanto o <userinput
|
|
>"Olá, sou uma cadeia de caracteres."</userinput
|
|
> é, de facto, uma cadeia de caracteres. Estas começam e terminam com o símbolo <userinput
|
|
>"</userinput
|
|
>; com estes símbolos, o &kturtle; sabe que é uma cadeia de caracteres.</para>
|
|
<para
|
|
>As cadeias de caracteres podem ser colocadas em <link linkend="containers"
|
|
>contentores</link
|
|
>. Porém, não podem ser usadas em <link linkend="math"
|
|
>cálculos matemáticos</link
|
|
> nem em <link linkend="questions"
|
|
>questões</link
|
|
>.</para>
|
|
<para
|
|
>As cadeias de caracteres ficam <glossterm
|
|
>realçadas</glossterm
|
|
> a vermelho escura no <link linkend="the-code-editor"
|
|
>editor de código</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="name">
|
|
<title
|
|
>Nomes</title>
|
|
<para
|
|
>Ao usar a linguagem de programação &logo;, pode criar coisas novas. Se criar um programa irá necessitar normalmente de <link linkend="containers"
|
|
>contentores</link
|
|
> e, em alguns casos, do <link linkend="learn"
|
|
>learn</link
|
|
> para criar novos comandos. Ao criar um <link linkend="containers"
|
|
>contentor</link
|
|
> ou um novo comando com o <link linkend="learn"
|
|
>learn</link
|
|
>, terá de indicar um nome.</para>
|
|
<para
|
|
>Poderá escolher qualquer nome, desde que este não tenha já algum significado. Por exemplo, não poderá chamar a um contentor <link linkend="forward"
|
|
>forward</link
|
|
>, dado que esse nome já é usado para um comando e, como tal, já tem um significado.<screen>
|
|
# Aqui o forward é usado como contentor, mas já tem um significado
|
|
# pelo que irá produzir um erro:
|
|
forward = 20
|
|
|
|
# isto funciona:
|
|
forward 20
|
|
</screen
|
|
> Os nomes só poderão conter letras, números e sublinhados (_). De qualquer forma, têm de começar por uma letra. </para>
|
|
<para
|
|
>Por favor, leia a documentação sobre os <link linkend="containers"
|
|
>contentores</link
|
|
> e o comando <link linkend="learn"
|
|
>learn</link
|
|
> para uma melhor explicação e mais exemplos. </para>
|
|
</sect2>
|
|
|
|
<sect2 id="assignment">
|
|
<title
|
|
>Atribuições</title>
|
|
<para
|
|
>As atribuições são feitas com o símbolo <userinput
|
|
>=</userinput
|
|
>. Nas linguagens de programação é melhor ler o <userinput
|
|
>=</userinput
|
|
> simples não como um 'é igual a' mas sim como um 'fica igual a'. O termo 'é igual a' é mais apropriado para o <userinput
|
|
>==</userinput
|
|
>, que é uma <link linkend="questions"
|
|
>pergunta</link
|
|
>.</para>
|
|
<para
|
|
>As atribuições são usadas normalmente por duas razões, (1) para adicionar conteúdo aos <link linkend="containers"
|
|
>contentores</link
|
|
> e (2) para modificar o conteúdo de um contentor. Por exemplo: <screen
|
|
>x = 10
|
|
# o contentor 'x' contém agora o número 10
|
|
W = "A minha idade é: "
|
|
# o contentor W contém agora o texto "A minha idade: "
|
|
# isto imprime o conteúdo dos contentores 'W' e 'x' na área de desenho
|
|
print W + x
|
|
</screen>
|
|
</para>
|
|
<para
|
|
>Para mais exemplos, veja a secção que explica os <link linkend="containers"
|
|
>contentores</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
<sect2 id="math-symbols">
|
|
<title
|
|
>Símbolos Matemáticos</title>
|
|
<para
|
|
>O &kturtle; suporta todos os símbolos matemáticos básicos: a adição (<userinput
|
|
>+</userinput
|
|
>), a subtracção (<userinput
|
|
>-</userinput
|
|
>), a multiplicação (<userinput
|
|
>*</userinput
|
|
>), a divisão (<userinput
|
|
>/</userinput
|
|
>) e os parêntesis <userinput
|
|
>(</userinput
|
|
> e <userinput
|
|
>)</userinput
|
|
>.</para>
|
|
<para
|
|
>Para uma explicação completa e mais exemplos, veja a secção de <link linkend="math"
|
|
>matemática</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
<sect2 id="question">
|
|
<title
|
|
>Perguntas</title>
|
|
<para
|
|
>Podem ser feitas algumas perguntas simples, onde nesse caso a resposta será 'true' (verdadeira) ou 'false' (falsa).</para>
|
|
<para
|
|
>A utilização das perguntas é explicada de forma extensa na secção de <link linkend="questions"
|
|
>perguntas</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
<sect2 id="questions-glue">
|
|
<title
|
|
>Palavras de Colagem de Perguntas</title>
|
|
<para
|
|
>As perguntas podem ser coladas em conjunto com o que se denomina por 'cola das perguntas'. As palavras de colagem são o <userinput
|
|
>and</userinput
|
|
> (e), o <userinput
|
|
>or</userinput
|
|
> (ou) e uma palavra especial: a <userinput
|
|
>not</userinput
|
|
> (não).</para>
|
|
<para
|
|
>A utilização da colagem de perguntas é explicada na secção de <link linkend="question-glue"
|
|
>Colagem de Perguntas</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="comment">
|
|
<title
|
|
>Comentários</title>
|
|
<para
|
|
>Os comentários são linhas que começam por um <userinput
|
|
>#</userinput
|
|
>. Por exemplo: <screen>
|
|
# isto é um comentário!
|
|
print "isto não é um comentário"
|
|
# a linha anterior não é um comentário, mas a próxima é:
|
|
# print "isto não é um comentário"
|
|
</screen
|
|
> Nas linhas comentadas, poderão ser adicionadas notas ao código, para nós ou para outra pessoa ler. Os comentários são usados para: (1) adicionar uma pequena descrição ao programa, (2) para explicar como é que funciona um determinado excerto de código se este for ligeiramente complicado e (3) para 'desactivar' linhas de código que deverão ser (temporariamente) ignoradas (veja a última linha do exemplo).</para>
|
|
<para
|
|
>As linhas comentadas ficam <glossterm
|
|
>realçadas</glossterm
|
|
> com um amarelo escuro no <link linkend="the-code-editor"
|
|
>editor de código</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="commands">
|
|
<title
|
|
>Comandos</title>
|
|
<para
|
|
>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;. Repare que todos os comandos incorporados ficam <glossterm
|
|
>realçados</glossterm
|
|
> a verde escuro no <link linkend="the-code-editor"
|
|
>editor de código</link
|
|
>, para que possa ajudar a distingui-los.</para>
|
|
|
|
<sect2 id="moving-the-turtle">
|
|
<title
|
|
>Mover a tartaruga</title>
|
|
<para
|
|
>Existem vários comandos para mover a tartaruga pelo ecrã.</para>
|
|
|
|
<sect3 id="forward">
|
|
<title
|
|
>forward (fw)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>forward</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>forward X</screen>
|
|
O <userinput
|
|
>forward</userinput
|
|
> move a tartaruga para a frente X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O <userinput
|
|
>forward</userinput
|
|
> pode ser abreviado para <userinput
|
|
>fw</userinput
|
|
></para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="backward">
|
|
<title
|
|
>backward (bw)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>backward</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>backward X</screen>
|
|
O <userinput
|
|
>backward</userinput
|
|
> move a tartaruga para trás X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O <userinput
|
|
>backward</userinput
|
|
> pode ser abreviado para <userinput
|
|
>bw</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="turnleft">
|
|
<title
|
|
>turnleft (tl)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>turnleft</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>turnleft X</screen>
|
|
O <userinput
|
|
>turnleft</userinput
|
|
> diz à tartaruga para se virar X graus para a esquerda. O <userinput
|
|
>turnleft</userinput
|
|
> pode ser abreviado para <userinput
|
|
>tl</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="turnright">
|
|
<title
|
|
>turnright (tr)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>turnright</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>turnright X</screen>
|
|
O <userinput
|
|
>turnright</userinput
|
|
> diz à tartaruga para se virar X graus para a direita. O <userinput
|
|
>turnright</userinput
|
|
> pode ser abreviado para <userinput
|
|
>tr</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="direction">
|
|
<title
|
|
>direction (dir)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>direction</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>direction X</screen>
|
|
O <userinput
|
|
>direction</userinput
|
|
> 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 <userinput
|
|
>direction</userinput
|
|
> pode ser abreviado para <userinput
|
|
>dir</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="center">
|
|
<title
|
|
>center</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>center</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>center</screen>
|
|
O <userinput
|
|
>center</userinput
|
|
> move a tartaruga para o centro da área de desenho.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="go">
|
|
<title
|
|
>go</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>go</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>go X,Y</screen>
|
|
O <userinput
|
|
>go</userinput
|
|
> manda a tartaruga ir para um dado local da área de desenho. Este local está a X <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
> do lado esquerdo da área de desenho e a Y <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
> do topo da área. Lembre-se que, ao usar o comando <userinput
|
|
>go</userinput
|
|
>, a tartaruga não irá desenhar nenhuma linha.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="gox">
|
|
<title
|
|
>gox</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>gox</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>gox X</screen>
|
|
Ao usar o comando <userinput
|
|
>gox</userinput
|
|
>, a tartaruga irá mover-se X <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
> a partir da esquerda da área de desenho, mantendo à mesma a sua altura.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="goy">
|
|
<title
|
|
>goy</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>goy</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>goy Y</screen>
|
|
Ao usar o comando <userinput
|
|
>goy</userinput
|
|
>, a tartaruga irá mover-se Y <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
> a partir do topo da área de desenho, mantendo à mesma a sua distância ao lado esquerdo da área de desenho.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
<sect2 id="pen">
|
|
<title
|
|
>A tartaruga tem um traço</title>
|
|
<para
|
|
>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.</para>
|
|
<sect3 id="penup">
|
|
<title
|
|
>penup (pu)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>penup</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>penup</screen>
|
|
O <userinput
|
|
>penup</userinput
|
|
> levanta o traço da área de desenho. Quando o traço está <quote
|
|
>em cima</quote
|
|
>, não é desenhada nenhuma linha à medida que a tartaruga se move. Veja também o <userinput
|
|
>pendown</userinput
|
|
>. O <userinput
|
|
>penup</userinput
|
|
> pode ser abreviado para <userinput
|
|
>pu</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="pendown">
|
|
<title
|
|
>pendown (pd)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>pendown</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>pendown</screen>
|
|
O <userinput
|
|
>pendown</userinput
|
|
> carrega no traço para baixo na área de desenho. Quando o traço está <quote
|
|
>em baixo</quote
|
|
>, é desenhada uma linha à medida que a tartaruga se move. Veja também o <userinput
|
|
>penup</userinput
|
|
>. O <userinput
|
|
>pendown</userinput
|
|
> pode ser abreviado para <userinput
|
|
>pd</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="setpenwidth">
|
|
<title
|
|
>penwidth (pw)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>penwidth</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>penwidth X</screen>
|
|
O <userinput
|
|
>penwidth</userinput
|
|
> configura a espessura do traço para X <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
>. O <userinput
|
|
>penwidth</userinput
|
|
> pode ser abreviado para <userinput
|
|
>pw</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="setfgcolor">
|
|
<title
|
|
>pencolor (pc)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>pencolor</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>pencolor R,G,B</screen>
|
|
O <userinput
|
|
>pencolor</userinput
|
|
> configura a cor do traço. O <userinput
|
|
>pencolor</userinput
|
|
> recebe uma <glossterm linkend="rgb"
|
|
>combinação de RGB</glossterm
|
|
> como parâmetro. O <userinput
|
|
>pencolor</userinput
|
|
> pode ser abreviado para <userinput
|
|
>pc</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
<sect2 id="canvas">
|
|
<title
|
|
>Comandos para controlar a área de desenho</title>
|
|
<para
|
|
>Existem vários comandos para controlar a área de desenho.</para>
|
|
<sect3 id="resizecanvas">
|
|
<title
|
|
>canvassize (cs)</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term
|
|
>canvassize</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>canvassize X,Y</screen>
|
|
Com o comando <userinput
|
|
>canvassize</userinput
|
|
> 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 <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
>, e o Y é a nova altura da mesma área em <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
>. O <userinput
|
|
>canvassize</userinput
|
|
> pode ser abreviado para <userinput
|
|
>cs</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="setbgcolor">
|
|
<title
|
|
>canvascolor (cc)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>canvascolor</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>canvascolor R,G,B</screen>
|
|
O <userinput
|
|
>canvascolor</userinput
|
|
> define a cor da área de desenho. O <userinput
|
|
>canvascolor</userinput
|
|
> recebe uma <glossterm linkend="rgb"
|
|
>combinação RGB</glossterm
|
|
> como parâmetro. O <userinput
|
|
>canvascolor</userinput
|
|
> pode ser abreviado para <userinput
|
|
>cc</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="wrapon">
|
|
<title
|
|
>wrapon</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>wrapon</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>wrapon</screen>
|
|
Com o comando <userinput
|
|
>wrapon</userinput
|
|
> você poderá activar a <glossterm linkend="wrapping"
|
|
>envolvência</glossterm
|
|
> para a área de desenho. Por favor veja o glossário para saber o que é a <glossterm linkend="wrapping"
|
|
>envolvência</glossterm
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="wrapoff">
|
|
<title
|
|
>wrapoff</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>wrapoff</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>wrapoff</screen>
|
|
Com o comando <userinput
|
|
>wrapoff</userinput
|
|
> você poderá desactivar a <glossterm linkend="wrapping"
|
|
>envolvência</glossterm
|
|
> para a área de desenho. Isto significa que a tartaruga poder-se-á mover para fora da área de desenho e <quote
|
|
>perder-se</quote
|
|
>. Por favor veja o glossário se quiser saber o que é a <glossterm linkend="wrapping"
|
|
>envolvência</glossterm
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
<sect2 id="clean">
|
|
<title
|
|
>Comandos para limpar</title>
|
|
<para
|
|
>Existem dois comandos para limpar a área de desenho, depois de você ter deixado tudo confuso.</para>
|
|
<sect3 id="clear">
|
|
<title
|
|
>clear (cr)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>clear</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>clear</screen>
|
|
Com o <userinput
|
|
>clear</userinput
|
|
>, 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 <userinput
|
|
>clear</userinput
|
|
> pode ser abreviado para <userinput
|
|
>cr</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="reset">
|
|
<title
|
|
>reset</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>reset</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>reset</screen>
|
|
O <userinput
|
|
>reset</userinput
|
|
> limpa tudo de forma mais abrangente que o comando <userinput
|
|
>clear</userinput
|
|
>. Depois de um comando <userinput
|
|
>reset</userinput
|
|
>, 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.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
<sect2 id="sprites">
|
|
<title
|
|
>A tartaruga é uma imagem móvel</title>
|
|
<para
|
|
>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 <glossterm linkend="sprites"
|
|
>imagens móveis</glossterm
|
|
>). </para>
|
|
<para
|
|
>A seguir você irá encontrar uma apresentação completa de todos os comandos que lidam com imagens móveis.</para>
|
|
<para
|
|
>[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]</para>
|
|
<sect3 id="spriteshow">
|
|
<title
|
|
>show</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>show (ss)</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>show</screen>
|
|
O <userinput
|
|
>show</userinput
|
|
> torna a tartaruga visível de novo depois de ter ficado escondida. O <userinput
|
|
>show</userinput
|
|
> pode ser abreviado para <userinput
|
|
>ss</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="spritehide">
|
|
<title
|
|
>hide (sh)</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>hide</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>hide</screen>
|
|
O <userinput
|
|
>hide</userinput
|
|
> esconde a tartaruga. Isto pode ser usado se a tartaruga não couber no seu desenho. O <userinput
|
|
>hide</userinput
|
|
> pode ser abreviado para <userinput
|
|
>sh</userinput
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
<sect2 id="writing">
|
|
<title
|
|
>Será que as tartarugas escrevem texto?</title>
|
|
<para
|
|
>A resposta é: <quote
|
|
>sim</quote
|
|
>. A tartaruga sabe escrever e pode escrever tudo o que lhe disser para escrever.</para>
|
|
<sect3 id="print">
|
|
<title
|
|
>print</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>print</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>print X</screen>
|
|
O comando <userinput
|
|
>print</userinput
|
|
> é usado para dizer à tartaruga para escrever algo na área de desenho. O <userinput
|
|
>print</userinput
|
|
> recebe números e texto como parâmetros. Você poderá executar o <userinput
|
|
>print</userinput
|
|
> para vários parâmetros com o sinal <quote
|
|
>+</quote
|
|
>. Veja aqui um pequeno exemplo: <screen
|
|
>ano = 2004
|
|
autor = "Ze"
|
|
print "O " + autor + " iniciou o projecto do KTurtle em " + ano + " e ainda continua a gostar de trabalhar nele!"
|
|
</screen>
|
|
</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="fontsize">
|
|
<title
|
|
>fontsize</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>fontsize</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>fontsize X</screen>
|
|
O <userinput
|
|
>fontsize</userinput
|
|
> configura o tamanho da letra que é usado pelo <userinput
|
|
>print</userinput
|
|
>. O <userinput
|
|
>fontsize</userinput
|
|
> recebe um parâmetros que deverá ser um número. O tamanho é definido em <glossterm linkend="pixels"
|
|
>pixels</glossterm
|
|
>.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
<sect2 id="random">
|
|
<title
|
|
>Um comando que joga aos dados por si</title>
|
|
<para
|
|
>Existe um comando que lança os dados para si, que se chama <userinput
|
|
>random</userinput
|
|
> e é muito útil para alguns resultados inesperados.</para>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>random</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>random X,Y</screen>
|
|
O <userinput
|
|
>random</userinput
|
|
> é 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: <screen>
|
|
repeat 500 [
|
|
x = random 1,20
|
|
forward x
|
|
turnleft 10 - x
|
|
]
|
|
</screen
|
|
> Com o comando 'random', você poderá adicionar um pouco de confusão ao seu programa.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect2>
|
|
|
|
<sect2 id="dialogs">
|
|
<title
|
|
>Entrada de dados e reacção através de janelas</title>
|
|
<para
|
|
>Uma janela poderá pedir alguma alguma reacção em especial ou a introdução de determinados dados. O &kturtle; tem dois comandos para janelas, nomeadamente o <userinput
|
|
>message</userinput
|
|
> e o <userinput
|
|
>inputwindow</userinput
|
|
></para>
|
|
<sect3 id="message">
|
|
<title
|
|
>message</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>message</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>message X</screen>
|
|
O comando <userinput
|
|
>message</userinput
|
|
> recebe uma <link linkend="string"
|
|
>cadeia de caracteres</link
|
|
> à entrada. Mostra então uma janela que contém o texto da <link linkend="string"
|
|
>cadeia de caracteres</link
|
|
>. <screen
|
|
>ano = 2004
|
|
autor = "Ze"
|
|
print "O " + autor + " iniciou o projecto do KTurtle em " + ano + " e ainda continua a gostar de trabalhar nele!"
|
|
</screen>
|
|
</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
<sect3 id="inputwindow">
|
|
<title
|
|
>inputwindow</title>
|
|
<variablelist>
|
|
<varlistentry
|
|
>
|
|
<term
|
|
>inputwindow</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>inputwindow X</screen>
|
|
O <userinput
|
|
>inputwindow</userinput
|
|
> recebe uma <link linkend="string"
|
|
>cadeia de caracteres</link
|
|
> à entrada. Mostra uma janela que contém o texto da cadeia de caracteres, tal como acontece no <link linkend="message"
|
|
>message</link
|
|
>. Contudo, para além disso, também mostra um campo de texto na janela. Através deste campo, o utilizador poderá introduzir um <link linkend="number"
|
|
>número</link
|
|
> ou uma <link linkend="string"
|
|
>cadeia de caracteres</link
|
|
> que poderá ser guardada num <link linkend="containers"
|
|
>contentor</link
|
|
>. Por exemplo <screen>
|
|
in = inputwindow "Que idade tem?"
|
|
out = 2003 - in
|
|
print "Em 2003, você tinha " + out + " anos a dada altura."
|
|
</screen
|
|
> Quando um utilizador cancelar a janela ou não introduzir nada de todo, o <link linkend="containers"
|
|
>contentor</link
|
|
> fica vazio.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect3>
|
|
</sect2>
|
|
|
|
</sect1>
|
|
|
|
|
|
|
|
<sect1 id="containers">
|
|
<title
|
|
>Contentores</title>
|
|
<para
|
|
>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 <link linkend="variables"
|
|
>variáveis</link
|
|
>, enquanto que os que contêm texto chamam-se <link linkend="strings"
|
|
>cadeias de caracteres</link
|
|
>.</para>
|
|
|
|
<para
|
|
>Os contentores que não são usados não contêm nada. Por exemplo, um: <screen>
|
|
print N
|
|
</screen
|
|
> Isto não irá imprimir nada. Se tentar fazer <link linkend="math"
|
|
>operações matemáticas</link
|
|
> com contentores vazios, irá obter erros. </para>
|
|
|
|
<sect2 id="variables">
|
|
<title
|
|
>Variáveis: contentores de números</title>
|
|
<para
|
|
>Vamos começar com um exemplo: <screen>
|
|
x = 3
|
|
print x
|
|
</screen
|
|
> Na primeira linha, a letra <userinput
|
|
>x</userinput
|
|
> passou a ser uma variável (um contentor de números). Como poderá ver, o valor da variável <userinput
|
|
>x</userinput
|
|
> passou a 3. Na segunda linha, o valor é impresso.</para>
|
|
<para
|
|
>Lembre-se que, se quisesse imprimir um <quote
|
|
>x</quote
|
|
>, então deveria ser escrito <screen
|
|
>print "x"
|
|
</screen>
|
|
</para>
|
|
<para
|
|
>Isso foi fácil, mas agora há um exemplo um pouco mais difícil: <screen>
|
|
A = 2004
|
|
B = 25
|
|
C = A + B
|
|
|
|
# o próximo comando imprime "2029"
|
|
print C
|
|
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
|
|
</screen
|
|
> Nas duas primeiras linhas, as variáveis <userinput
|
|
>A</userinput
|
|
> e <userinput
|
|
>B</userinput
|
|
> são configuradas como sendo iguais a 2004 e 25. Na terceira linha, a variável <userinput
|
|
>C</userinput
|
|
> fica igual a <userinput
|
|
>A + B</userinput
|
|
>, o que dá 2029. O resto do exemplo consiste em 3 comandos <userinput
|
|
>print</userinput
|
|
> com <userinput
|
|
>backward 30</userinput
|
|
> no meio. O <userinput
|
|
>backward 30</userinput
|
|
> 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 <link linkend="math"
|
|
>cálculos matemáticos</link
|
|
>.</para>
|
|
</sect2>
|
|
|
|
<sect2 id="strings">
|
|
<title
|
|
>Contentores de texto (cadeias de caracteres)</title>
|
|
<para
|
|
>No código do programa, o texto normal é iniciado e termina normalmente com aspas. Como já foi visto: <screen>
|
|
print "Olá programador!"
|
|
</screen
|
|
> O texto fica delimitado com as aspas. Estes pedaços de texto normal são chamados então de <link linkend="strings"
|
|
>cadeias de caracteres</link
|
|
>.</para>
|
|
<para
|
|
>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 <link linkend="math"
|
|
>cálculos matemáticos</link
|
|
> e <link linkend="questions"
|
|
>perguntas</link
|
|
>. Um exemplo da utilização das cadeias de caracteres: <screen>
|
|
x = "Olá "
|
|
nome = inputwindow "por favor indique o seu nome..."
|
|
print x + nome + ", como é que está?
|
|
</screen
|
|
> Na segunda linha, a cadeia de caracteres <userinput
|
|
>x</userinput
|
|
> fica igual a <quote
|
|
>Olá </quote
|
|
>. Na segunda linha, a cadeia de caracteres <userinput
|
|
>nome</userinput
|
|
> é configurada como o resultado do comando <userinput
|
|
>inputwindow</userinput
|
|
>. Na terceira linha, o programa imprime uma composição de três cadeias de caracteres na área de desenho.</para>
|
|
<para
|
|
>Este programa pede-lhe para introduzir o seu nome. Quando você, por exemplo, introduzir o nome <quote
|
|
>Zé</quote
|
|
>, o programa irá imprimir <quote
|
|
>Olá Zé, como é que está?</quote
|
|
>. Lembre-se que o sinal de mais (+) é o único símbolo matemático que você poderá usar com as cadeias de caracteres.</para>
|
|
</sect2>
|
|
</sect1>
|
|
|
|
<sect1 id="math">
|
|
<title
|
|
>Será que a Tartaruga Pode Fazer Contas?</title>
|
|
<para
|
|
>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: <screen>
|
|
a = 20 - 5
|
|
b = 15 * 2
|
|
c = 30 / 30
|
|
d = 1 + 1
|
|
print "a: "+a+", b: "+b+", c: "+c+", d: "+d
|
|
</screen
|
|
> Será que sabe o valor de 'a', 'b', 'c' e 'd'? Repare por favor no uso do símbolo <userinput
|
|
>=</userinput
|
|
> de <link linkend="assignment"
|
|
>atribuição</link
|
|
>.</para>
|
|
<para
|
|
>Se você somente queria fazer um cálculo simples, você poderá fazer algo semelhante a isto: <screen
|
|
>print 2004-12
|
|
</screen
|
|
></para>
|
|
<para
|
|
>Agora, um exemplo com parêntesis: <screen>
|
|
print ( ( 20 - 5 ) * 2 / 30 ) + 1
|
|
</screen
|
|
> 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).</para>
|
|
</sect1>
|
|
|
|
<sect1 id="questions">
|
|
<title
|
|
>Fazer perguntas, obter respostas...</title>
|
|
<para
|
|
>O <link linkend="if"
|
|
><userinput
|
|
>if</userinput
|
|
></link
|
|
> e o <link linkend="while"
|
|
><userinput
|
|
>while</userinput
|
|
></link
|
|
> são <link linkend="controlling-execution"
|
|
>controladores de execução</link
|
|
> que iremos discutir na próxima secção. Nesta secção iremos usar o comando <userinput
|
|
>if</userinput
|
|
> para explicar as perguntas.</para>
|
|
<sect2 id="q">
|
|
<title
|
|
>Perguntas</title>
|
|
<para
|
|
>Um exemplo simples de perguntas: <screen>
|
|
x = 6
|
|
if x > 5 [
|
|
print "olá"
|
|
]
|
|
</screen
|
|
> Neste exemplo, a pergunta é <userinput
|
|
>x > 5</userinput
|
|
>, se a resposta a esta pergunta for <quote
|
|
>true</quote
|
|
> (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 <link linkend="controlling-execution"
|
|
>controladores de execução</link
|
|
>, como o <link linkend="if"
|
|
><userinput
|
|
>if</userinput
|
|
></link
|
|
>. Todos os números e <link linkend="variables"
|
|
>variáveis</link
|
|
> (contentores de números) poderão ser comparados uns com os outros nas perguntas.</para>
|
|
<para
|
|
>Aqui estão todas as perguntas possíveis: <table>
|
|
<title
|
|
>Tipos de perguntas</title>
|
|
<tgroup cols="3">
|
|
<tbody>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>a == b</userinput
|
|
></entry>
|
|
<entry
|
|
>igual a</entry>
|
|
<entry
|
|
>a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira) se o <userinput
|
|
>a</userinput
|
|
> for igual ao <userinput
|
|
>b</userinput
|
|
></entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>a != b</userinput
|
|
></entry>
|
|
<entry
|
|
>é diferente de</entry>
|
|
<entry
|
|
>a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira) se o <userinput
|
|
>a</userinput
|
|
> não for igual ao <userinput
|
|
>b</userinput
|
|
></entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>a > b</userinput
|
|
></entry>
|
|
<entry
|
|
>maior que</entry>
|
|
<entry
|
|
>a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira) se o <userinput
|
|
>a</userinput
|
|
> for maior que o <userinput
|
|
>b</userinput
|
|
></entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>a < b</userinput
|
|
></entry>
|
|
<entry
|
|
>menor que</entry>
|
|
<entry
|
|
>a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira) se o <userinput
|
|
>a</userinput
|
|
> for menor que o <userinput
|
|
>b</userinput
|
|
></entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>a >= b</userinput
|
|
></entry>
|
|
<entry
|
|
>maior ou igual a</entry>
|
|
<entry
|
|
>a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira) se o <userinput
|
|
>a</userinput
|
|
> for maior ou igual ao <userinput
|
|
>b</userinput
|
|
></entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>a <= b</userinput
|
|
></entry>
|
|
<entry
|
|
>menor ou igual a</entry>
|
|
<entry
|
|
>a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira) se o <userinput
|
|
>a</userinput
|
|
> for menor ou igual ao <userinput
|
|
>b</userinput
|
|
></entry>
|
|
</row>
|
|
</tbody>
|
|
</tgroup>
|
|
</table>
|
|
</para>
|
|
<para
|
|
>As perguntas ficam <glossterm
|
|
>realçadas</glossterm
|
|
> com azul claro no <link linkend="the-code-editor"
|
|
>editor de código</link
|
|
>.</para
|
|
>
|
|
</sect2>
|
|
|
|
<sect2 id="question-glue">
|
|
<title
|
|
>Colagem de Perguntas</title>
|
|
<para
|
|
>As perguntas também podem ser coladas umas às outras com <quote
|
|
>palavras de colagem de perguntas</quote
|
|
> onde, desta forma, algumas perguntas tornam-se uma pergunta maior. <screen>
|
|
a = 1
|
|
b = 5
|
|
if (a < 5) and (b == 5) [
|
|
print "olá"
|
|
]
|
|
</screen
|
|
> Neste exemplo, a palavra de colagem <userinput
|
|
>and</userinput
|
|
> é usada para colar 2 perguntas (<userinput
|
|
>a < 5</userinput
|
|
>, <userinput
|
|
>b == 5</userinput
|
|
>) em conjunto. Se um lado do <userinput
|
|
>and</userinput
|
|
> der uma resposta <quote
|
|
>false</quote
|
|
> (falsa), a pergunta toda irá responder <quote
|
|
>false</quote
|
|
>, porque, com a palavra de colagem <userinput
|
|
>and</userinput
|
|
>, ambos os lados precisam de ser <quote
|
|
>true</quote
|
|
> para que a resposta seja <quote
|
|
>true</quote
|
|
> (verdadeira). Por favor não se esqueça de usar os parêntesis à volta das perguntas!</para>
|
|
|
|
<para
|
|
>Segue-se uma vista esquemática; pode encontrar uma explicação mais detalhada de seguida: <table>
|
|
<title
|
|
>Palavras de colagem de perguntas</title>
|
|
<tgroup cols="2">
|
|
<tbody>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>and</userinput
|
|
></entry>
|
|
<entry
|
|
>ambos os lados têm de ser <quote
|
|
>true</quote
|
|
> (verdadeiros) para a resposta ser <quote
|
|
>true</quote
|
|
> (verdadeira)</entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>or</userinput
|
|
></entry>
|
|
<entry
|
|
>se um dos lados for <quote
|
|
>true</quote
|
|
> (verdadeiros) a resposta é <quote
|
|
>true</quote
|
|
> (verdadeira)</entry>
|
|
</row>
|
|
<row>
|
|
<entry
|
|
><userinput
|
|
>not</userinput
|
|
></entry>
|
|
<entry
|
|
>Caso especial: só funciona com uma pergunta! Muda o 'true' para 'false' e o 'false' para 'true'.</entry>
|
|
</row>
|
|
</tbody>
|
|
</tgroup>
|
|
</table>
|
|
</para>
|
|
<para
|
|
>As palavras de colagem ficam <glossterm
|
|
>realçadas</glossterm
|
|
> a púrpura no <link linkend="the-code-editor"
|
|
>editor de código</link
|
|
>.</para>
|
|
|
|
<sect3 id="and">
|
|
<title
|
|
>and</title>
|
|
<para
|
|
>Quando são coladas duas perguntas em conjunto com o <userinput
|
|
>and</userinput
|
|
>, ambos os lados do <userinput
|
|
>and</userinput
|
|
> terão ser 'true' para que o resultado também seja 'true' (verdadeiro). Por exemplo: <screen>
|
|
a = 1
|
|
b = 5
|
|
if ((a < 10) and (b == 5)) and (a < b) [
|
|
print "olá"
|
|
]
|
|
</screen
|
|
> Nestes exemplo, poderá ver uma pergunta colada a outra pergunta também colada.</para>
|
|
</sect3>
|
|
|
|
<sect3 id="or">
|
|
<title
|
|
>or</title>
|
|
<para
|
|
>Se uma das duas perguntas coladas em conjunto com o <userinput
|
|
>or</userinput
|
|
> for 'true' (verdadeira), o resultado será também 'true'. Por exemplo: <screen>
|
|
a = 1
|
|
b = 5
|
|
if ((a < 10) or (b == 10)) or (a == 0) [
|
|
print "olá"
|
|
]
|
|
</screen
|
|
> Neste exemplo, irá ver uma pergunta colada a outra pergunta, também esta colada.</para>
|
|
</sect3>
|
|
|
|
<sect3 id="not">
|
|
<title
|
|
>not</title>
|
|
<para
|
|
>O <userinput
|
|
>not</userinput
|
|
> é uma palavra de colagem de perguntas especial que só funciona para uma pergunta de cada vez. O <userinput
|
|
>not</userinput
|
|
> muda o 'true' para 'false' e o 'false' para 'true'. Por exemplo: <screen>
|
|
a = 1
|
|
b = 5
|
|
if not ((a < 10) and (b == 5)) [
|
|
print "olá"
|
|
]
|
|
else
|
|
[
|
|
print "não olá ;-)"
|
|
]
|
|
</screen
|
|
> Neste exemplo, a pergunta colada é igual a 'true', embora o <userinput
|
|
>not</userinput
|
|
> a mude para 'false'. Como tal, no fim, será impresso o <userinput
|
|
>"não olá ;-)"</userinput
|
|
> na <link linkend="the-canvas"
|
|
>área de desenho</link
|
|
>.</para>
|
|
</sect3>
|
|
|
|
</sect2>
|
|
|
|
</sect1>
|
|
|
|
<sect1 id="controlling-execution">
|
|
<title
|
|
>Controlar a execução</title>
|
|
<para
|
|
>Os controladores de execução permitem-lhe — como o nome deles indica — controlar a execução.</para>
|
|
<para
|
|
>Os comandos de controlo da execução ficam <glossterm
|
|
>realçados</glossterm
|
|
> a verde escuro e a negrito. Os parêntesis rectos, que são mais usados em conjunto com os controladores de execução, ficam <glossterm
|
|
>realçados</glossterm
|
|
> a verde claro.</para>
|
|
|
|
<sect2 id="wait">
|
|
<title
|
|
>Fazer a tartaruga esperar</title>
|
|
<para
|
|
>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.</para>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term
|
|
>wait</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>wait X</screen>
|
|
O <userinput
|
|
>wait</userinput
|
|
> faz a tartaruga esperar X segundos. <screen>
|
|
repeat 36 [
|
|
forward 5
|
|
turnright 10
|
|
wait 0.5
|
|
]
|
|
</screen
|
|
> 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.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect2>
|
|
|
|
<sect2 id="if">
|
|
<title
|
|
>Executar o "if"</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term
|
|
>if</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>if <link linkend="questions"
|
|
>pergunta</link
|
|
> [ ... ]</screen>
|
|
O código que é colocado no <quote
|
|
>...</quote
|
|
> só será executado se (<userinput
|
|
>if</userinput
|
|
>) a resposta à <link linkend="questions"
|
|
>pergunta</link
|
|
> for <quote
|
|
>true</quote
|
|
> (verdadeira). Por favor leia, para obter mais informações sobre perguntas, a <link linkend="questions"
|
|
>secção de perguntas</link
|
|
>. <screen>
|
|
x = 6
|
|
if x > 5 [
|
|
print "O x é maior que cinco!"
|
|
]
|
|
</screen
|
|
> Na primeira linha, o <userinput
|
|
>x</userinput
|
|
> é inicializado a 6. Na segunda linha, a <link linkend="questions"
|
|
>pergunta</link
|
|
> <userinput
|
|
>x > 5</userinput
|
|
> é feita. Dado que a resposta a esta pergunta é verdadeira, o controlador de execução <userinput
|
|
>if</userinput
|
|
> irá permitir que o código entre parêntesis rectos seja executado</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect2>
|
|
|
|
<sect2 id="while">
|
|
<title
|
|
>O ciclo "while"</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term
|
|
>while</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>while <link linkend="questions"
|
|
>pergunta</link
|
|
> [ ... ]</screen>
|
|
O controlador de execução <userinput
|
|
>while</userinput
|
|
> é um pouco como o <link linkend="if"
|
|
><userinput
|
|
>if</userinput
|
|
></link
|
|
>. A diferença é que o <userinput
|
|
>while</userinput
|
|
> continua a repetir o código entre parêntesis até que a resposta à <link linkend="questions"
|
|
>pergunta</link
|
|
> seja <quote
|
|
>false</quote
|
|
> (falsa). <screen>
|
|
x = 1
|
|
while x < 5 [
|
|
forward 10
|
|
wait 1
|
|
x = x + 1
|
|
]
|
|
</screen
|
|
> Na primeira linha, o <userinput
|
|
>x</userinput
|
|
> fica igual a 1. Na segunda, a <link linkend="questions"
|
|
>pergunta</link
|
|
> <userinput
|
|
>x < 5</userinput
|
|
> é feita. Dado que a resposta a esta pergunta é <quote
|
|
>true</quote
|
|
> (verdadeira), o controlador de execução <userinput
|
|
>while</userinput
|
|
> começa a execução do código entre parêntesis até que a resposta à <link linkend="questions"
|
|
>pergunta</link
|
|
> seja <quote
|
|
>false</quote
|
|
> (falsa). Neste caso, o código entre parêntesis será executado 4 vezes, dado que, de cada vez que a quinta linha é executada, o <userinput
|
|
>x</userinput
|
|
> fica um número acima.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect2>
|
|
|
|
<sect2 id="else">
|
|
<title
|
|
>Se não, por outras palavras: "else"</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term
|
|
>else</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>if pergunta [ ... ] else [ ... ]</screen>
|
|
O <userinput
|
|
>else</userinput
|
|
> pode ser usado para além do controlador de execução <link linkend="if"
|
|
><userinput
|
|
>if</userinput
|
|
></link
|
|
>. O código entre parêntesis a seguir ao <userinput
|
|
>else</userinput
|
|
> só é executado se a resposta à <link linkend="questions"
|
|
>pergunta</link
|
|
> que é feita for <quote
|
|
>false</quote
|
|
> (falsa). <screen>
|
|
x = 4
|
|
if x > 5 [
|
|
print "O x é maior que cinco!"
|
|
] else [
|
|
print "O x é menor que seis!"
|
|
]
|
|
</screen
|
|
> A <link linkend="questions"
|
|
>pergunta</link
|
|
> testa se o <userinput
|
|
>x</userinput
|
|
> é maior que 5. Dado que o <userinput
|
|
>x</userinput
|
|
> fica igual a 4 na primeira linha, a resposta à pergunta é <quote
|
|
>false</quote
|
|
> (falsa). Isto significa que o código entre parêntesis a seguir ao <userinput
|
|
>else</userinput
|
|
> é executado.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect2>
|
|
|
|
<sect2 id="for">
|
|
<title
|
|
>O ciclo "for", um ciclo de contagem</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term
|
|
>for</term>
|
|
<listitem
|
|
><para
|
|
><screen
|
|
>for <userinput
|
|
>ponto inicial</userinput
|
|
> a <userinput
|
|
>ponto final</userinput
|
|
> [ ... ]</screen>
|
|
O ciclo <userinput
|
|
>for</userinput
|
|
> é um <quote
|
|
>ciclo de contagem</quote
|
|
>, ou seja, faz de contador para si. <screen>
|
|
for x = 1 to 10 [
|
|
print x * 7
|
|
forward 15
|
|
]
|
|
</screen
|
|
> De cada vez que o código entre parêntesis é executado, o <userinput
|
|
>x</userinput
|
|
> é incrementado de uma unidade, até que o valor do <userinput
|
|
>x</userinput
|
|
> chegue a 10. O código entre parêntesis imprime o valor de <userinput
|
|
>x</userinput
|
|
> multiplicado por 7. Depois de este programa terminar a sua execução, você irá ver a tabuada dos 7 na área de desenho.</para
|
|
></listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</sect2>
|
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="learn">
|
|
<title
|
|
>Crie os seus próprios comandos com o <quote
|
|
>learn</quote
|
|
></title>
|
|
<para
|
|
>O <userinput
|
|
>learn</userinput
|
|
> é um comando muito especial, porque é usado para criar os seus próprios comandos. O comando que criar poderá receber <glossterm linkend="input-output"
|
|
>parâmetros</glossterm
|
|
> e devolver <glossterm linkend="input-output"
|
|
>resultados</glossterm
|
|
>. Vamos ver como é que é criado um novo comando. <screen>
|
|
learn circunferencia x [
|
|
repeat 36 [
|
|
forward x
|
|
turnleft 10
|
|
]
|
|
]
|
|
</screen
|
|
> O novo comando chama-se <userinput
|
|
>circunferencia</userinput
|
|
>. O <userinput
|
|
>circunferencia</userinput
|
|
> recebe um <glossterm linkend="input-output"
|
|
>parâmetro</glossterm
|
|
>, um número, para definir o tamanho da circunferência. O <userinput
|
|
>circunferencia</userinput
|
|
> não devolve nenhum <glossterm linkend="input-output"
|
|
>resultado</glossterm
|
|
>. O comando <userinput
|
|
>circunferencia</userinput
|
|
> pode agora ser usado como um comando normal. Veja este exemplo: <screen
|
|
>learn circunferencia X [
|
|
repeat 36 [
|
|
forward X
|
|
turnleft 10
|
|
]
|
|
]
|
|
|
|
go 30,30
|
|
circunferencia 20
|
|
|
|
go 40,40
|
|
circunferencia 50
|
|
</screen>
|
|
</para>
|
|
<para
|
|
>No próximo exemplo, vai ser criado um comando com um valor de resultado devolvido. <screen>
|
|
learn multiplicarPeloProprio n [
|
|
r = n * 1
|
|
r = n * n
|
|
return r
|
|
]
|
|
i = inputwindow "Por favor indique um número e carregue em OK"
|
|
print "O " + i + " multiplicado por ele próprio é igual a: " + multiplicarPeloProprio i
|
|
</screen
|
|
> Neste exemplo, existe agora um comando novo chamado <userinput
|
|
>multiplicarPeloProprio</userinput
|
|
>. O parâmetro deste comando é multiplicado por ele próprio e é então devolvido, usando o comando <anchor id="return"/><userinput
|
|
>return</userinput
|
|
>. O comando <userinput
|
|
>return</userinput
|
|
> é a forma de devolver um resultado de uma função criada. </para>
|
|
</sect1>
|
|
|
|
</chapter>
|