|
|
<!--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
|
|
|
>Référence de programmation du &logo; de &kturtle;</title>
|
|
|
<para
|
|
|
>Ceci est le manuel de référence du logiciel de programmation &logo; &kturtle;. Dans ce chapitre, nous verrons d'abord brièvement tous les <link linkend="different-instructions"
|
|
|
>différents types d'instructions</link
|
|
|
>. Les <link linkend="commands"
|
|
|
>commandes</link
|
|
|
> seront alors expliquées une par une. Les <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>, les <link linkend="math"
|
|
|
>mathématiques</link
|
|
|
>, les <link linkend="questions"
|
|
|
>questions</link
|
|
|
> et <link linkend="controlling-execution"
|
|
|
>contrôleurs d'exécution</link
|
|
|
> seront ensuite expliqués. Enfin, nous vous montrerons comment créer vos propres commandes avec <link linkend="learn"
|
|
|
>Apprends</link
|
|
|
></para>
|
|
|
|
|
|
<sect1 id="different-instructions">
|
|
|
<title
|
|
|
>Différents types d'instructions</title>
|
|
|
<para
|
|
|
>Comme dans tout langage, le LOGO a différents types de mots et de symboles. Les différences entre les types sont expliquées brièvement ici.</para>
|
|
|
|
|
|
<sect2 id="command">
|
|
|
<title
|
|
|
>Commandes</title>
|
|
|
<para
|
|
|
>En utilisant les commandes, vous dites à la tortue ou à &kturtle; de faire quelque chose. Certaines commandes ont besoin d'une entrée. <screen
|
|
|
># avance est une commande qui nécessite une entrée, ici le nombre 100 :
|
|
|
avance 100
|
|
|
</screen>
|
|
|
</para>
|
|
|
<para
|
|
|
>Pour une étude détaillée de toutes les commandes gérées par &kturtle;, allez <link linkend="commands"
|
|
|
>ici</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="number">
|
|
|
<title
|
|
|
>Nombres</title>
|
|
|
<para
|
|
|
>Vous savez probablement certaines choses sur les nombres. La façon dont ils sont utilisés dans &kturtle; n'est pas très différente de la façon dont on les utilise dans le langage parlé, ou avec les mathématiques. </para>
|
|
|
<para
|
|
|
>Nous avons les nombres appelés nombre naturels : <userinput
|
|
|
>0</userinput
|
|
|
>, <userinput
|
|
|
>1</userinput
|
|
|
>, <userinput
|
|
|
>2</userinput
|
|
|
>, <userinput
|
|
|
>3</userinput
|
|
|
>, <userinput
|
|
|
>4</userinput
|
|
|
>, <userinput
|
|
|
>5</userinput
|
|
|
>, etc. Les nombres négatifs : <userinput
|
|
|
>-1</userinput
|
|
|
>, <userinput
|
|
|
>-2</userinput
|
|
|
>, <userinput
|
|
|
>-3</userinput
|
|
|
>, etc. Enfin les nombres décimaux, où nombres à virgule, par exemple : <userinput
|
|
|
>0.1</userinput
|
|
|
>, <userinput
|
|
|
>3.14</userinput
|
|
|
>, <userinput
|
|
|
>33.3333</userinput
|
|
|
>, <userinput
|
|
|
>-5.05</userinput
|
|
|
>, <userinput
|
|
|
>-1.0</userinput
|
|
|
>. </para>
|
|
|
<para
|
|
|
>Les nombres peuvent être utilisés dans des <link linkend="math"
|
|
|
>calculs mathématiques</link
|
|
|
> et dans des <link linkend="questions"
|
|
|
>questions</link
|
|
|
>. Ils peuvent également être placés dans des <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>.</para>
|
|
|
<para
|
|
|
>Les nombres sont <glossterm
|
|
|
>colorés</glossterm
|
|
|
> en bleu dans l'<link linkend="the-code-editor"
|
|
|
>éditeur de code</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="string">
|
|
|
<title
|
|
|
>Chaînes</title>
|
|
|
<para
|
|
|
>Tout d'abord un exemple : <screen>
|
|
|
écris "Bonjour, je suis une chaîne."
|
|
|
</screen
|
|
|
> Dans cet exemple, <userinput
|
|
|
>écris</userinput
|
|
|
> est une commande où <userinput
|
|
|
>Bonjour, je suis une chaîne.</userinput
|
|
|
> est une chaîne. Les chaînes commencent et se terminent par un symbole <userinput
|
|
|
>"</userinput
|
|
|
>. Grâce à ces symboles, &kturtle; sait qu'il s'agit d'une chaîne.</para>
|
|
|
<para
|
|
|
>Les chaînes peuvent être placées dans des <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>. Cependant, elles ne peuvent pas être utilisées dans des <link linkend="math"
|
|
|
>calculs mathématiques</link
|
|
|
> ou dans des <link linkend="questions"
|
|
|
>questions</link
|
|
|
>.</para>
|
|
|
<para
|
|
|
>Les chaînes sont <glossterm
|
|
|
>colorées</glossterm
|
|
|
> en rouge sombre dans l'<link linkend="the-code-editor"
|
|
|
>éditeur de code</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
|
|
|
<sect2 id="name">
|
|
|
<title
|
|
|
>Noms</title>
|
|
|
<para
|
|
|
>Lorsque vous programmez en langage &logo;, vous créez de nouvelles choses. Si vous écrivez un programme, vous aurez probablement besoin de <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>, et dans certains cas vous aurez à utiliser <link linkend="learn"
|
|
|
>Apprends</link
|
|
|
> pour créer de nouvelles commandes. Lorsque vous faites un <link linkend="containers"
|
|
|
>conteneur</link
|
|
|
> ou une nouvelle commande avec <link linkend="learn"
|
|
|
>Apprends</link
|
|
|
>, vous devez spécifier un nom.</para>
|
|
|
<para
|
|
|
>Vous pouvez choisir ce que vous voulez, à partir du moment où ce nom n'a pas déjà une signification. Par exemple, vous ne pouvez pas nommer un conteneur <link linkend="forward"
|
|
|
>avance</link
|
|
|
> puisque ce nom est déjà utilisé pour une commande, et a donc déjà un sens. <screen>
|
|
|
# ici avance est utilisé comme conteneur, mais il a déjà une significtion
|
|
|
# donc cela produira une erreur :
|
|
|
avance = 20
|
|
|
|
|
|
# ceci fonctionne :
|
|
|
avance 20
|
|
|
</screen
|
|
|
> Les noms peuvent contenir des lettres, des chiffres et des caractères de soulignement (_). Cependant, ils doivent commencer par une lettre. </para>
|
|
|
<para
|
|
|
>Veuillez lire la documentation sur les <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
> et sur la commande <link linkend="learn"
|
|
|
>Apprends</link
|
|
|
> pour davantage d'explications et d'autres exemples. </para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="assignment">
|
|
|
<title
|
|
|
>Affectation</title>
|
|
|
<para
|
|
|
>Les affectations sont faites avec le symbole <userinput
|
|
|
>=</userinput
|
|
|
>. Dans les langages de programmation, il est conseilllé de lire un <userinput
|
|
|
>=</userinput
|
|
|
> unique comme « devient » au lieu de « est égal à ». L'expression « est égal à » est plus approprié pour <userinput
|
|
|
>==</userinput
|
|
|
> qui est une <link linkend="questions"
|
|
|
>question</link
|
|
|
>.</para>
|
|
|
<para
|
|
|
>Les affectations sont généralement utilisées pour deux raisons : (1) pour ajouter du contenu aux <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>, et (2) pour modifier le contenu d'un conteneur. Par exemple : <screen
|
|
|
>x = 10
|
|
|
# le conteneur x contient maintenant le nombre 10
|
|
|
W = "Mon âge est : "
|
|
|
# le conteneur W contient maintenant la chaîne "Mon âge est : "
|
|
|
# ceci affiche le contenu des conteneurs « W » et « x » sur le canevas
|
|
|
print W + x
|
|
|
</screen>
|
|
|
</para>
|
|
|
<para
|
|
|
>Pour d'autres exemples, voyez la section qui traite des <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="math-symbols">
|
|
|
<title
|
|
|
>Symboles mathématiques</title>
|
|
|
<para
|
|
|
>&kturtle; gère tous les symboles mathématiques de base : addition (<userinput
|
|
|
>+</userinput
|
|
|
>), soustraction (<userinput
|
|
|
>-</userinput
|
|
|
>), multiplication (<userinput
|
|
|
>*</userinput
|
|
|
>), division (<userinput
|
|
|
>/</userinput
|
|
|
>) et les parenthèses (<userinput
|
|
|
>(</userinput
|
|
|
> et <userinput
|
|
|
>)</userinput
|
|
|
>.</para>
|
|
|
<para
|
|
|
>Pour une explication complète et d'autres exemples, voyez la section <link linkend="math"
|
|
|
>mathématiques</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="question">
|
|
|
<title
|
|
|
>Questions</title>
|
|
|
<para
|
|
|
>Nous pouvons poser des questions simples pour lesquelles la réponse sera « vrai » ou « faux ».</para>
|
|
|
<para
|
|
|
>L'utilisation des questions est largement décrite dans la section <link linkend="questions"
|
|
|
>question</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="questions-glue">
|
|
|
<title
|
|
|
>Mots collants pour questions</title>
|
|
|
<para
|
|
|
>Les questions peuvent être collées ensemble avec des « mots collants ». Les mots collants sont <userinput
|
|
|
>et</userinput
|
|
|
>, <userinput
|
|
|
>ou</userinput
|
|
|
>, et le mot collant spécial <userinput
|
|
|
>non</userinput
|
|
|
>.</para>
|
|
|
<para
|
|
|
>L'utilisation des mots collants est expliquée dans la section <link linkend="question-glue"
|
|
|
>mots collants</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
|
|
|
<sect2 id="comment">
|
|
|
<title
|
|
|
>Commentaires</title>
|
|
|
<para
|
|
|
>Les commentaires sont des lignes qui commencent par un <userinput
|
|
|
>#</userinput
|
|
|
>. Par exemple : <screen>
|
|
|
# ceci est un commentaire !
|
|
|
print "ceci n'est pas un commentaire"
|
|
|
# la ligne précédente n'est pas un commentaire, mais la ligne suivant en est un :
|
|
|
# print "ceci n'est pas un commentaire"
|
|
|
</screen
|
|
|
> Vous pouvez ajouter des commentaires dans le code pour vous-même ou pour quelqu'un d'autre. Les commentaires sont utilisés pour : (1) ajouter des descriptions courtes au programme, (2) expliquer comment un morceau de code fonctionne s'il est un eu obscur, et (3) commenter des lignes de code qui doivent être (temporairement) ignorées (voir la dernière ligne de l'exemple).</para>
|
|
|
<para
|
|
|
>Les lignes commentées sont <glossterm
|
|
|
>colorées</glossterm
|
|
|
> en jaune foncé dans l'<link linkend="the-code-editor"
|
|
|
>éditeur de code</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
</sect1>
|
|
|
|
|
|
|
|
|
<sect1 id="commands">
|
|
|
<title
|
|
|
>Commandes</title>
|
|
|
<para
|
|
|
>En utilisant les commandes, vous dites à la tortue ou à &kturtle; de faire quelque chose. Certaines commandes ont besoin d'une entrée, d'autres donnent une sortie. Dans ce chapitre nous expliquons toutes les commandes qui peuvent être utilisées dans &kturtle;. Notez que toutes les commandes de base que nous discutons ici sont <glossterm
|
|
|
>colorées</glossterm
|
|
|
> dans l'<link linkend="the-code-editor"
|
|
|
>éditeur de code</link
|
|
|
>. Ceci peut vous aider à les distinguer.</para>
|
|
|
|
|
|
<sect2 id="moving-the-turtle">
|
|
|
<title
|
|
|
>Déplacer la tortue</title>
|
|
|
<para
|
|
|
>Il y a plusieurs commandes qui déplacent la tortue sur l'écran.</para>
|
|
|
|
|
|
<sect3 id="forward">
|
|
|
<title
|
|
|
>avance (av)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>avance</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>avance X</screen>
|
|
|
<userinput
|
|
|
>avance</userinput
|
|
|
> fait avancer la tortue sur l'écran de X pixels. Lorsque le crayon est baissé, la tortue laisse une trace (dessine une ligne). <userinput
|
|
|
>avance</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>av</userinput
|
|
|
></para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="backward">
|
|
|
<title
|
|
|
>recule (re)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>recule</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>recule X</screen>
|
|
|
<userinput
|
|
|
>recule</userinput
|
|
|
> fait reculer la tortue sur l'écran de X pixels. Lorsque le crayon est baissé, la tortue laisse une trace (dessine une ligne). <userinput
|
|
|
>recule</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>re</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="turnleft">
|
|
|
<title
|
|
|
>tournegauche (tg)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>tournegauche</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>tournegauche X</screen>
|
|
|
<userinput
|
|
|
>tournegauche</userinput
|
|
|
> dit à la tortue de se tourner vers la gauche de X degrés. <userinput
|
|
|
>tournegauche</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>tg</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="turnright">
|
|
|
<title
|
|
|
>tournedroite (td)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>tournedroite</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>tournedroite X</screen>
|
|
|
<userinput
|
|
|
>tournedroite</userinput
|
|
|
> dit à la tortue de se tourner vers la droite de X degrés. <userinput
|
|
|
>tournedroite</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>td</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="direction">
|
|
|
<title
|
|
|
>direction (dir)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>direction</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>direction X</screen>
|
|
|
<userinput
|
|
|
>direction</userinput
|
|
|
> fixe la direction de la tortue de X degrés en comptant de zéro, et donc ne dépend pas de la position et de la direction précédentes de la tortue. <userinput
|
|
|
>direction</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>dir</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="center">
|
|
|
<title
|
|
|
>centre</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>centre</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>centre</screen>
|
|
|
<userinput
|
|
|
>centre</userinput
|
|
|
> déplace la tortue au centre du canevas.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="go">
|
|
|
<title
|
|
|
>va</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>va</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>va X,Y</screen>
|
|
|
<userinput
|
|
|
>va</userinput
|
|
|
> commande à la tortue d'aller à un certain endroit sur le canevas. Cet endroit est à X <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
> depuis la gauche du canevas et à Y <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
> depuis le haut du canevas. Veuillez noter qu'en utilisant la commande <userinput
|
|
|
>va</userinput
|
|
|
>, la tortue ne va pas dessiner de ligne.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="gox">
|
|
|
<title
|
|
|
>vax</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>vax</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>vax X</screen>
|
|
|
<userinput
|
|
|
>vax</userinput
|
|
|
> : en utilisant cette commande, la tortue va se déplacer de X <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
> depuis la gauche du canevas tandis qu'elle restera à la même hauteur.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="goy">
|
|
|
<title
|
|
|
>vay</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>vay</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>vay Y</screen>
|
|
|
<userinput
|
|
|
>vay</userinput
|
|
|
> : en utilisant cette commande, la tortue va se déplacer de Y <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
> depuis le haut du canevas tandis qu'elle restera à la même distance de la bordure gauche du canevas.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="pen">
|
|
|
<title
|
|
|
>La tortue a un crayon</title>
|
|
|
<para
|
|
|
>La tortue a un crayon qui trace une ligne lorsque la tortue se déplace. Il y a peu de commandes pour contrôler le crayon. Nous expliquons ces commandes dans ce paragraphe.</para>
|
|
|
<sect3 id="penup">
|
|
|
<title
|
|
|
>lèvecrayon (lc)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>lèvecrayon</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>lèvecrayon</screen>
|
|
|
<userinput
|
|
|
>lèvecrayon</userinput
|
|
|
> relève le crayon du canevas. Lorsque le crayon est <quote
|
|
|
>levé</quote
|
|
|
>, aucune ligne ne sera tracée lorsque la tortue se déplace. Voir aussi <userinput
|
|
|
>baissecrayon</userinput
|
|
|
>. <userinput
|
|
|
>lèvecrayon</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>lc</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="pendown">
|
|
|
<title
|
|
|
>baissecrayon (bc)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>baissecrayon</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>baissecrayon</screen>
|
|
|
<userinput
|
|
|
>baissecrayon</userinput
|
|
|
> abaisse le crayon sur le canevas. Lorsque le crayon est <quote
|
|
|
>baissé</quote
|
|
|
> sur le canevas, une ligne sera tracée lorsque la tortue se déplace. Voir aussi <userinput
|
|
|
>lèvecrayon</userinput
|
|
|
>. <userinput
|
|
|
>baissecrayon</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>bc</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="setpenwidth">
|
|
|
<title
|
|
|
>taillecrayon (ftc)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>taillecrayon</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>taillecrayon X</screen>
|
|
|
<userinput
|
|
|
>taillecrayon</userinput
|
|
|
> fixe l'épaisseur (la largeur du trait) du crayon à X <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
>. <userinput
|
|
|
>taillecrayon</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>ftc</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="setfgcolor">
|
|
|
<title
|
|
|
>couleurcrayon (fcc)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>couleurcrayon</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>couleurcrayon R,G,B</screen>
|
|
|
<userinput
|
|
|
>couleurcrayon</userinput
|
|
|
> fixe la couleur du crayon. <userinput
|
|
|
>couleurcrayon</userinput
|
|
|
> demande une <glossterm linkend="rgb"
|
|
|
>combinaison RGB</glossterm
|
|
|
> comme entrée. <userinput
|
|
|
>couleurcrayon</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>fcc</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="canvas">
|
|
|
<title
|
|
|
>Commandes pour contrôler le canevas</title>
|
|
|
<para
|
|
|
>Voici les différentes commandes pour contrôler le canevas.</para>
|
|
|
<sect3 id="resizecanvas">
|
|
|
<title
|
|
|
>taillecanevas (tca)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry>
|
|
|
<term
|
|
|
>taillecanevas</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>taillecanevas X,Y</screen>
|
|
|
Avec la commande <userinput
|
|
|
>taillecanevas</userinput
|
|
|
> vous pouvez fixer la taille du canevas. Elle reçoit X et Y comme entrée, où X est la nouvelle largeur du canevas en <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
>, et Y est la nouvelle hauteur du canevas en <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
>. <userinput
|
|
|
>taillecanevas</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>tca</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="setbgcolor">
|
|
|
<title
|
|
|
>couleurcanevas (cca)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>couleurcanevas</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>couleurcanevas R,G,B</screen>
|
|
|
<userinput
|
|
|
>couleurcanevas</userinput
|
|
|
> fixe la couleur du canevas. <userinput
|
|
|
>couleurcanevas</userinput
|
|
|
> reçoit une <glossterm linkend="rgb"
|
|
|
>combinaison RGB</glossterm
|
|
|
> comme entrée. <userinput
|
|
|
>couleurcanevas</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>cca</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="wrapon">
|
|
|
<title
|
|
|
>enroule</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>enroule</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>enroule</screen>
|
|
|
Avec la commande <userinput
|
|
|
>enroule</userinput
|
|
|
> vous pouvez fixer le <glossterm linkend="wrapping"
|
|
|
>bouclage</glossterm
|
|
|
> sur <quote
|
|
|
>on</quote
|
|
|
> pour le canevas. Veuillez regarder le glossaire pour savoir ce qu'est le <glossterm linkend="wrapping"
|
|
|
>bouclage</glossterm
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="wrapoff">
|
|
|
<title
|
|
|
>déroule</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>déroule</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>déroule</screen>
|
|
|
Avec la commande <userinput
|
|
|
>déroule</userinput
|
|
|
> vous pouvez fixer le <glossterm linkend="wrapping"
|
|
|
>bouclage</glossterm
|
|
|
> sur <quote
|
|
|
>off</quote
|
|
|
> pour le canevas. Cela signifie que que la tortue peut sortir du canevas et se <quote
|
|
|
>perdre</quote
|
|
|
>. Veuillez regarder le glossaire si vous voulez savoir ce qu'est le <glossterm linkend="wrapping"
|
|
|
>bouclage</glossterm
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="clean">
|
|
|
<title
|
|
|
>Commandes pour nettoyer</title>
|
|
|
<para
|
|
|
>Il existe deux commandes pour nettoyer le canevas après avoir mis le désordre.</para>
|
|
|
<sect3 id="clear">
|
|
|
<title
|
|
|
>nettoietout (ntt)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>nettoietout</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>nettoietout</screen>
|
|
|
Avec <userinput
|
|
|
>nettoietout</userinput
|
|
|
>, vous pouvez nettoyer tous les dessins sur le canevas. Toutes les autres choses restent : la position et l'angle de la tortue, la couleur du canevas, la visibilité de la tortue et la taille du canevas. <userinput
|
|
|
>nettoietout</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>ntt</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="reset">
|
|
|
<title
|
|
|
>initialise</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>initialise</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>initialise</screen>
|
|
|
<userinput
|
|
|
>initialise</userinput
|
|
|
> nettoie beaucoup plus profondément que la commande <userinput
|
|
|
>nettoietout</userinput
|
|
|
>. Après la commande <userinput
|
|
|
>initialise</userinput
|
|
|
>, tout redevient comme lorsque vous avez juste lancé &kturtle;. La tortue se place au milieu du canevas, la couleur du canevas est blanche et la couleur du trait de la tortue est noire.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="sprites">
|
|
|
<title
|
|
|
>La tortue est un lutin (<foreignphrase
|
|
|
>sprite</foreignphrase
|
|
|
>)</title>
|
|
|
<para
|
|
|
>La plupart des personnes ne savent pas ce qu'un lutin (<foreignphrase
|
|
|
>sprite</foreignphrase
|
|
|
>) est, voici donc une courte explication : les lutins sont de petites images qui peuvent se déplacer sur l'écran. (pour plus d'information, voir le glossaire sur <glossterm linkend="sprites"
|
|
|
>lutins</glossterm
|
|
|
>). Donc la tortue est un lutin ! </para>
|
|
|
<para
|
|
|
>Ce qui suit est un aperçu des commandes relatives aux lutins.</para>
|
|
|
<para
|
|
|
>[La version actuelle de &kturtle; ne supporte pas encore l'utilisation des lutins autres que la tortue. Dans des versions futures vous pourrez changer la tortue en quelque chose de votre propre conception ! ]</para>
|
|
|
<sect3 id="spriteshow">
|
|
|
<title
|
|
|
>montre</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>montre (mi)</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>montre</screen>
|
|
|
<userinput
|
|
|
>montre</userinput
|
|
|
> rend la tortue à nouveau visible après qu'elle ait été cachée. <userinput
|
|
|
>montre</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>mi</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="spritehide">
|
|
|
<title
|
|
|
>cache (ci)</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>cache</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>cache</screen>
|
|
|
<userinput
|
|
|
>cache</userinput
|
|
|
> cache la tortue. Ceci peut être utilisé si la tortue n'est pas souhaitable sur votre dessin. <userinput
|
|
|
>cache</userinput
|
|
|
> peut se contracter en <userinput
|
|
|
>ci</userinput
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="writing">
|
|
|
<title
|
|
|
>Est-ce que la tortue peut écrire du texte ?</title>
|
|
|
<para
|
|
|
>La réponse est : <quote
|
|
|
>oui</quote
|
|
|
>. La tortue peut écrire, elle écrit tout ce que vous lui commander d'écrire.</para>
|
|
|
<sect3 id="print">
|
|
|
<title
|
|
|
>écris</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>écris</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>écris X</screen>
|
|
|
La commande <userinput
|
|
|
>écris</userinput
|
|
|
> est utilisée pour commander à la tortue d'écrire quelque chose sur le canevas. <userinput
|
|
|
>écris</userinput
|
|
|
> reçoit des nombres et des chaînes de caractères comme entrée. Vous pouvez utiliser <userinput
|
|
|
>écris</userinput
|
|
|
> pour imprimer plusieurs nombres et chaînes en utilisant le symbole <quote
|
|
|
>+</quote
|
|
|
>. Voici un petit exemple : <screen
|
|
|
>année = 2003
|
|
|
auteur = "Cies"
|
|
|
écris "auteur + " a commencé de projet KTurtle en " + année + " et prend toujours du plaisir à travailler dessus ! "
|
|
|
</screen>
|
|
|
</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="fontsize">
|
|
|
<title
|
|
|
>taillepolice</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>taillepolice</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>taillepolice X</screen>
|
|
|
<userinput
|
|
|
>taillepolice</userinput
|
|
|
> fixe la taille de la police qui est utilisée par la commande <userinput
|
|
|
>écris</userinput
|
|
|
>. <userinput
|
|
|
>taillepolice</userinput
|
|
|
> reçoit une entrée qui doit être un nombre. La taille est fixée en <glossterm linkend="pixels"
|
|
|
>pixels</glossterm
|
|
|
>.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="random">
|
|
|
<title
|
|
|
>Une commande qui lance un dé pour vous</title>
|
|
|
<para
|
|
|
>Il existe une commande qui lance un dé pour vous, elle s'appelle <userinput
|
|
|
>hasard</userinput
|
|
|
>, et est très utile pour des résultats inattendus.</para>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>hasard</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>hasard X,Y</screen>
|
|
|
<userinput
|
|
|
>hasard</userinput
|
|
|
> est une commande qui demande une entrée et qui vous donne une sortie. Comme entrée sont requis deux nombres, le premier (X) donne la sortie minimale, et le second (Y) fixe le maximum. La sortie est un nombre choisi au hasard qui est égal ou plus grand que le minimum et égal ou plus petit que le maximum. Voici un petit exemple : <screen>
|
|
|
répète 500 [
|
|
|
x = hasard 1,20
|
|
|
avance x
|
|
|
tournedroitee 10 - x
|
|
|
]
|
|
|
</screen
|
|
|
> En utilisant la commande <userinput
|
|
|
>hasard</userinput
|
|
|
>, vous pouvez ajouter un peu de chaos dans votre programme.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="dialogs">
|
|
|
<title
|
|
|
>Entrée et retour avec les boîtes de dialogue</title>
|
|
|
<para
|
|
|
>Une boîte de dialogue est une petite fenêtre surgissante qui fournit du retour ou demande des choses en entrée. &kturtle; possède deux commandes pour les boîtes de dialogue : <userinput
|
|
|
>message</userinput
|
|
|
> et <userinput
|
|
|
>fenêtreentrée</userinput
|
|
|
></para>
|
|
|
<sect3 id="message">
|
|
|
<title
|
|
|
>message</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>message</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>message X</screen>
|
|
|
La commande <userinput
|
|
|
>message</userinput
|
|
|
> prend une <link linkend="string"
|
|
|
>chaîne</link
|
|
|
> en entrée. Elle affiche une boîte de dialogue contenant le texte de la <link linkend="string"
|
|
|
>chaîne</link
|
|
|
>. <screen
|
|
|
>année = 2003
|
|
|
auteur = "Cies"
|
|
|
écris "auteur + " a commencé de projet KTurtle en " + année + " et prend toujours du plaisir à travailler dessus ! "
|
|
|
</screen>
|
|
|
</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
<sect3 id="inputwindow">
|
|
|
<title
|
|
|
>fenêtreentrée</title>
|
|
|
<variablelist>
|
|
|
<varlistentry
|
|
|
>
|
|
|
<term
|
|
|
>fenêtreentrée</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>fenêtreentrée X</screen>
|
|
|
<userinput
|
|
|
>fenêtreentrée</userinput
|
|
|
> prend une <link linkend="string"
|
|
|
>chaîne</link
|
|
|
> en entrée. Elle affiche une boîte de dialogue contenant le texte de la chaîne, tout comme la commande <link linkend="message"
|
|
|
>message</link
|
|
|
>. Mais en plus, elle affiche un champ d'entrée dans la boîte de dialogue. Vous pouvez alors saisir grâce à ce champ un <link linkend="number"
|
|
|
>nombre</link
|
|
|
> ou une <link linkend="string"
|
|
|
>chaîne</link
|
|
|
> qui sera stocké dans un <link linkend="containers"
|
|
|
>conteneur</link
|
|
|
>. Par exemple, <screen>
|
|
|
entrée = fenêtreentrée "Quel est votre âge ? "
|
|
|
sortie = 2005 - entrée
|
|
|
écris "En 2005, vous aviez " + sortie + " ans."
|
|
|
</screen
|
|
|
> Lorsqu'un utilisateur annule la boîte de dialogue, ou ne met rien du tous, le <link linkend="containers"
|
|
|
>conteneur</link
|
|
|
> est vidé.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect3>
|
|
|
</sect2>
|
|
|
|
|
|
</sect1>
|
|
|
|
|
|
|
|
|
|
|
|
<sect1 id="containers">
|
|
|
<title
|
|
|
>Conteneurs</title>
|
|
|
<para
|
|
|
>Les conteneurs sont des lettres ou des mots qui peuvent être utilisés par le programmeur pour stocker un nombre ou un texte. Les conteneurs qui contiennent un nombre sont appelés des <link linkend="variables"
|
|
|
>variables</link
|
|
|
> et les conteneurs qui contiennent du texte sont appelés des <link linkend="string"
|
|
|
>chaînes</link
|
|
|
>.</para>
|
|
|
|
|
|
<para
|
|
|
>Les conteneurs qui ne sont pas encore utilisés valent 0 par défaut. Un exemple : <screen>
|
|
|
écris N
|
|
|
</screen
|
|
|
> Cela n'écrira rien. Si nous essayons de faire des <link linkend="math"
|
|
|
>calculs mathématiques</link
|
|
|
> avec des conteneurs vides, nous aurons une erreur. </para>
|
|
|
|
|
|
<sect2 id="variables">
|
|
|
<title
|
|
|
>Variables : conteneurs de nombres</title>
|
|
|
<para
|
|
|
>Commençons avec un exemple : <screen>
|
|
|
x = 3
|
|
|
écris x
|
|
|
</screen
|
|
|
> À la première ligne, la lettre <userinput
|
|
|
>x</userinput
|
|
|
> est utilisée comme une variable (un conteneur de nombres). Comme vous le voyez, la valeur de la variable <userinput
|
|
|
>x</userinput
|
|
|
> est fixée sur 3. La deuxième ligne imprime la valeur.</para>
|
|
|
<para
|
|
|
>Veuillez noter que si nous avions voulu imprimer un <quote
|
|
|
>x</quote
|
|
|
>, nous aurions du écrire <screen
|
|
|
>écris "x"
|
|
|
</screen>
|
|
|
</para>
|
|
|
<para
|
|
|
>Ce fut facile, voyons maintenant un exemple plus difficile : <screen>
|
|
|
A = 2004
|
|
|
B = 25
|
|
|
AB = A + B
|
|
|
|
|
|
# la commande suivante imprime "2029"
|
|
|
écris AB
|
|
|
recule 30
|
|
|
# la commande suivante imprime "2004 plus 25"
|
|
|
écris "" + A + " plus " + B
|
|
|
recule 30
|
|
|
# la commande suivante imprime "1979"
|
|
|
écris A - B
|
|
|
</screen
|
|
|
> Dans les deux premières lignes, les variables <userinput
|
|
|
>A</userinput
|
|
|
> et <userinput
|
|
|
>B</userinput
|
|
|
> sont fixées à 2004 et 25. À la troisième ligne, la variable <userinput
|
|
|
>AB</userinput
|
|
|
> est fixée <userinput
|
|
|
>A + B</userinput
|
|
|
>, qui vaut 2029. Le reste de l'exemple consiste en trois commandes <userinput
|
|
|
>écris</userinput
|
|
|
> avec les <userinput
|
|
|
>recule 30</userinput
|
|
|
> entre. Les lignes <userinput
|
|
|
>recule 30</userinput
|
|
|
> sont là pour assurer que chaque sortie est imprimée sur une nouvelle ligne. Dans cet exemple, vous voyez aussi que les variables peuventêtre utilisées dans des <link linkend="math"
|
|
|
>calculs mathématiques</link
|
|
|
>.</para>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="strings">
|
|
|
<title
|
|
|
>Conteneurs contenant du texte (chaînes)</title>
|
|
|
<para
|
|
|
>Dans un programme, le texte commence et se termine généralement par des guillemets. Comme vous l'avez déjà vu : <screen>
|
|
|
écris "Bonjour programmeur ! "
|
|
|
</screen
|
|
|
> Le texte est délimité par des guillements. Ce texte est appelé une <link linkend="strings"
|
|
|
>chaîne</link
|
|
|
>.</para>
|
|
|
<para
|
|
|
>Les chaînes peuvent également être stockées dans des <link linkend="containers"
|
|
|
>conteneurs</link
|
|
|
>, tout comme les <link linkend="number"
|
|
|
>nombres</link
|
|
|
>. La plus grosse différence est que les chaînes ne peuvent pas être utilisées dans des <link linkend="math"
|
|
|
>calculs mathématiques</link
|
|
|
> et des <link linkend="questions"
|
|
|
>questions</link
|
|
|
>. Voici un exemple d'utilisation des chaînes : <screen>
|
|
|
x = "Bonjour "
|
|
|
nom = fenêtreentrée "Veuillez saisir votre nom..."
|
|
|
écris x + nom + ", comment allez vous ? "
|
|
|
</screen
|
|
|
> À la première ligne, la variable <userinput
|
|
|
>x</userinput
|
|
|
> est fixée à <quote
|
|
|
>Bonjour </quote
|
|
|
>. À la deuxième ligne, la chaîne <userinput
|
|
|
>nom</userinput
|
|
|
> est fixée sur la sortie de la commande <userinput
|
|
|
>fenêtreentrée</userinput
|
|
|
>. À la troisième ligne, le programme imprime une concaténation des trois chaînes sur le canevas.</para>
|
|
|
<para
|
|
|
>Ce programme vous demande de saisir votre nom. Lorsque par exemple vous saisissez le nom <quote
|
|
|
>Paul</quote
|
|
|
>, le programme imprime <quote
|
|
|
>Bonjour Paul, comment allez vous ?</quote
|
|
|
>. Veuillez noter que le signe plus (+) est le seul symbole mathématique que vous pouvez utiliser avec des chaînes.</para>
|
|
|
</sect2>
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="math">
|
|
|
<title
|
|
|
>Est ce que la tortue peut faire des maths ?</title>
|
|
|
<para
|
|
|
>Oui, &kturtle; va aussi faire vos maths. Vous pouvez ajouter (+), soustraire (-), multiplier (*) et diviser (/). Voici un exemple dans lequel nous allons tous les utiliser : <screen>
|
|
|
a = 20 - 5
|
|
|
b = 15 * 2
|
|
|
c = 30 / 30
|
|
|
d = 1 + 1
|
|
|
écris "a : "+a+", b : "+b+", c : "+c+", d : "+d
|
|
|
</screen
|
|
|
> Savez vous quelles valeurs ont a, b, c et d ? Notez le symbole d'<link linkend="assignment"
|
|
|
>affectation</link
|
|
|
> <userinput
|
|
|
>=</userinput
|
|
|
>.</para>
|
|
|
<para
|
|
|
>Si vous voulez faire simplement un calcul, vous pouvez le faire de la façon suivante : <screen
|
|
|
>écris 2004-12
|
|
|
</screen
|
|
|
></para>
|
|
|
<para
|
|
|
>Voici maintenant un exemple avec des parenthèses : <screen>
|
|
|
écris ( ( 20 - 5 ) * 2 / 30 ) + 1
|
|
|
</screen
|
|
|
> Les expressions dans les parenthèses vont être calculées les premières. Dans cet exemple, 20-5 sera calculé, puis multiplié par 2, divisé par 30, puis 1 est ajouté (ce qui donne 2).</para>
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="questions">
|
|
|
<title
|
|
|
>Poser des questions, recevoir des réponses...</title>
|
|
|
<para
|
|
|
><link linkend="if"
|
|
|
><userinput
|
|
|
>si</userinput
|
|
|
></link
|
|
|
> et <link linkend="while"
|
|
|
><userinput
|
|
|
>pendant</userinput
|
|
|
></link
|
|
|
> sont des <link linkend="controlling-execution"
|
|
|
>contrôleurs d'exécution</link
|
|
|
> dont nous allons discuter dans le prochain paragraphe. Dans ce paragraphe nous utilisons la commande <link linkend="if"
|
|
|
><userinput
|
|
|
>si</userinput
|
|
|
></link
|
|
|
> pour expliquer les questions.</para>
|
|
|
<sect2 id="q">
|
|
|
<title
|
|
|
>Questions</title>
|
|
|
<para
|
|
|
>Un simple exemple de question : <screen>
|
|
|
x = 6
|
|
|
si x > 5 [
|
|
|
écris "bonjour"
|
|
|
]
|
|
|
</screen
|
|
|
> Dans cet exemple, la question est la partie <userinput
|
|
|
>x > 5</userinput
|
|
|
>. Si la réponse à cette question est <quote
|
|
|
>vraie</quote
|
|
|
>, le code entre les crochets sera exécuté. Les questions sont une partie importante en programmation et sont souvent utilisées avec des <link linkend="controlling-execution"
|
|
|
>contrôleurs d'exécution</link
|
|
|
>, comme <link linkend="if"
|
|
|
><userinput
|
|
|
>si</userinput
|
|
|
></link
|
|
|
>. Tous les nombres et <link linkend="variables"
|
|
|
>variables</link
|
|
|
> (conteneurs de nombres) peuvent être comparés les uns aux autres grâce à des questions.</para>
|
|
|
<para
|
|
|
>Voici toutes les questions possibles : <table>
|
|
|
<title
|
|
|
>Types de questions</title>
|
|
|
<tgroup cols="3">
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>a == b</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>égal</entry>
|
|
|
<entry
|
|
|
>la réponse est <quote
|
|
|
>vraie</quote
|
|
|
> si <userinput
|
|
|
>a</userinput
|
|
|
> est égal à <userinput
|
|
|
>b</userinput
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>a != b</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>non égal</entry>
|
|
|
<entry
|
|
|
>la réponse est <quote
|
|
|
>vraie</quote
|
|
|
> si <userinput
|
|
|
>a</userinput
|
|
|
> n'est pas égal à <userinput
|
|
|
>b</userinput
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>a > b</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>plus grand que</entry>
|
|
|
<entry
|
|
|
>la réponse est <quote
|
|
|
>vraie</quote
|
|
|
> si <userinput
|
|
|
>a</userinput
|
|
|
> est plus grand que <userinput
|
|
|
>b</userinput
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>a < b</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>plus petit que</entry>
|
|
|
<entry
|
|
|
>la réponse est <quote
|
|
|
>vraie</quote
|
|
|
> si <userinput
|
|
|
>a</userinput
|
|
|
> est plus petit que <userinput
|
|
|
>b</userinput
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>a >= b</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>plus grand ou égal</entry>
|
|
|
<entry
|
|
|
>la réponse est <quote
|
|
|
>vraie</quote
|
|
|
> si <userinput
|
|
|
>a</userinput
|
|
|
> est plus grand ou égal à <userinput
|
|
|
>b</userinput
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>a <= b</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>plus petit ou égal</entry>
|
|
|
<entry
|
|
|
>la réponse est <quote
|
|
|
>vraie</quote
|
|
|
> si <userinput
|
|
|
>a</userinput
|
|
|
> est plus petit ou égal à <userinput
|
|
|
>b</userinput
|
|
|
></entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</table>
|
|
|
</para>
|
|
|
<para
|
|
|
>Les questions sont <glossterm
|
|
|
>colorées</glossterm
|
|
|
> en bleu clair dans l'<link linkend="the-code-editor"
|
|
|
>éditeur de code</link
|
|
|
>.</para
|
|
|
>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="question-glue">
|
|
|
<title
|
|
|
>Mots collants pour questions</title>
|
|
|
<para
|
|
|
>Les mots collants pour les questions nous permettent d'assembler plusieurs questions pour n'en former plus qu'une.<screen>
|
|
|
a = 1
|
|
|
b = 5
|
|
|
si (a < 5) et (b == 5) [
|
|
|
écris "bonjour"
|
|
|
]
|
|
|
</screen
|
|
|
>Dans cet exemple, le mot collant <userinput
|
|
|
>et</userinput
|
|
|
> est utilisé pour rassembler deux questions (<userinput
|
|
|
>a < 5</userinput
|
|
|
>, <userinput
|
|
|
>b == 5</userinput
|
|
|
>) ensemble. Si un côté de <userinput
|
|
|
>et</userinput
|
|
|
> répondait <quote
|
|
|
>faux</quote
|
|
|
> toute la question aurait pour réponse <quote
|
|
|
>faux</quote
|
|
|
>, parce qu'avec le mot collant <userinput
|
|
|
>et</userinput
|
|
|
> les deux côtés doivent être <quote
|
|
|
>vrai</quote
|
|
|
> pour répondre <quote
|
|
|
>vrai</quote
|
|
|
>. N'oubliez pas d'utiliser les parenthèses autour des questions ! </para>
|
|
|
|
|
|
<para
|
|
|
>Voici un aerçu schématique, une explication plus détaillée suit plus bas : <table>
|
|
|
<title
|
|
|
>Mots collants pour questions</title>
|
|
|
<tgroup cols="2">
|
|
|
<tbody>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>et</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>les deux côtés doivent être <quote
|
|
|
>vrai</quote
|
|
|
> pour que la réponse soit <quote
|
|
|
>vrai</quote
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>ou</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>si l'un des côtés est <quote
|
|
|
>vrai</quote
|
|
|
> la réponse est <quote
|
|
|
>vrai</quote
|
|
|
></entry>
|
|
|
</row>
|
|
|
<row>
|
|
|
<entry
|
|
|
><userinput
|
|
|
>non</userinput
|
|
|
></entry>
|
|
|
<entry
|
|
|
>Cas particuliers : ne fonctionne que sur une question ! change « vrai » en « faux » et « faux » en « vrai ».</entry>
|
|
|
</row>
|
|
|
</tbody>
|
|
|
</tgroup>
|
|
|
</table>
|
|
|
</para>
|
|
|
<para
|
|
|
>Les mots collants pour questions sont <glossterm
|
|
|
>colorés</glossterm
|
|
|
> en violet dans l'<link linkend="the-code-editor"
|
|
|
>éditeur de code</link
|
|
|
>.</para>
|
|
|
|
|
|
<sect3 id="and">
|
|
|
<title
|
|
|
>et</title>
|
|
|
<para
|
|
|
>Lorsque deux questions sont assemblées avec <userinput
|
|
|
>et</userinput
|
|
|
>, les deux côtés du <userinput
|
|
|
>et</userinput
|
|
|
> doivent être « vrai » pour que le résultat soit « vrai ». Un exemple : <screen>
|
|
|
a = 1
|
|
|
b = 5
|
|
|
si ((a < 10) et (b == 5)) et (a < b) [
|
|
|
écris "bonjour"
|
|
|
]
|
|
|
</screen
|
|
|
> Dans cet exemple, vous avez deux questions collées, assemblées à une troisième question.</para>
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="or">
|
|
|
<title
|
|
|
>ou</title>
|
|
|
<para
|
|
|
>Si une des deux questions qui sont assemblées avec <userinput
|
|
|
>ou</userinput
|
|
|
> est « vrai », le résultat sera « vrai ». Un exemple : <screen>
|
|
|
a = 1
|
|
|
b = 5
|
|
|
si ((a < 10) ou (b == 10)) ou (a == 0) [
|
|
|
écris "bonjour"
|
|
|
]
|
|
|
</screen
|
|
|
> Dans cet exemple, vous voyez un assemblage de deux questions combiné avec unee troisieme question.</para>
|
|
|
</sect3>
|
|
|
|
|
|
<sect3 id="not">
|
|
|
<title
|
|
|
>non</title>
|
|
|
<para
|
|
|
><userinput
|
|
|
>non</userinput
|
|
|
> est un mot-colle spécial car il ne fonctionne qu'avec une question à la fois. <userinput
|
|
|
>non</userinput
|
|
|
> change « vrai » en « faux » et « faux » en « vrai ». Un exemple :<screen>
|
|
|
a = 1
|
|
|
b = 5
|
|
|
si non ((a < 10à et (b == 5)) [
|
|
|
écris "bonjour"
|
|
|
]
|
|
|
sinon
|
|
|
[
|
|
|
écris "pas bonjour ;-)"
|
|
|
]
|
|
|
</screen
|
|
|
> Dans cet exemple, la question collée est « vrai », pourtant le <userinput
|
|
|
>non</userinput
|
|
|
> le change en « faux ». Ainsi, en fin de compte, <userinput
|
|
|
>"pas bonjour ;-)"</userinput
|
|
|
> est affiché sur le <link linkend="the-canvas"
|
|
|
>canevas</link
|
|
|
>.</para>
|
|
|
</sect3>
|
|
|
|
|
|
</sect2>
|
|
|
|
|
|
</sect1>
|
|
|
|
|
|
<sect1 id="controlling-execution">
|
|
|
<title
|
|
|
>Contrôler l'exécution</title>
|
|
|
<para
|
|
|
>Les contrôleurs d'exécution vous permettent, — comme leur nom l'indique — de contrôler l'exécution.</para>
|
|
|
<para
|
|
|
>Les commandes de contrôle d'exécution sont <glossterm
|
|
|
>colorées</glossterm
|
|
|
> en vert foncé en utilisant une police en gras. Les crochets sont principalement utilisés avec les contrôleurs d'exécution et sont <glossterm
|
|
|
>colorés</glossterm
|
|
|
> en vert clair.</para>
|
|
|
|
|
|
<sect2 id="wait">
|
|
|
<title
|
|
|
>Faite attendre la tortue</title>
|
|
|
<para
|
|
|
>Si vous avez exécuté quelques programmes dans &kturtle; vous pouvez avoir remarqué que la tortue se déplace très rapidement pour dessiner. La commande suivante ralentit la tortue.</para>
|
|
|
<variablelist>
|
|
|
<varlistentry>
|
|
|
<term
|
|
|
>attends</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>attends X</screen>
|
|
|
<userinput
|
|
|
>attends</userinput
|
|
|
> fait attendre la tortue pendant X secondes. <screen>
|
|
|
répète 36 [
|
|
|
avance 5
|
|
|
tournedroite 10
|
|
|
attends 0.5
|
|
|
]
|
|
|
</screen
|
|
|
> Ce code dessine un cercle mais la tortue va attendre une demi-seconde après chaque étape. Cela donne l'impression d'une tortue qui va moins vite.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="if">
|
|
|
<title
|
|
|
>Exécute "si"</title>
|
|
|
<variablelist>
|
|
|
<varlistentry>
|
|
|
<term
|
|
|
>si</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>si <link linkend="questions"
|
|
|
>question</link
|
|
|
> [ ... ]</screen>
|
|
|
Le code qui est placé entre les crochets sera exécuté seulement <userinput
|
|
|
>si</userinput
|
|
|
> la réponse à la <link linkend="questions"
|
|
|
>question</link
|
|
|
> est <quote
|
|
|
>vrai</quote
|
|
|
>. Pour plus d'information, veuillez lire le paragraphe sur les <link linkend="questions"
|
|
|
>questions</link
|
|
|
> dans la page des <link linkend="questions"
|
|
|
>questions</link
|
|
|
>. <screen>
|
|
|
nettoietout
|
|
|
x = 6
|
|
|
si x > 5 [
|
|
|
écris "x est plus grand que cinq ! "
|
|
|
]
|
|
|
</screen
|
|
|
> À la première ligne, <userinput
|
|
|
>x</userinput
|
|
|
> est fixé à 6. À la seconde ligne, la <link linkend="questions"
|
|
|
>question</link
|
|
|
> <userinput
|
|
|
>x > 5</userinput
|
|
|
> est posée. Comme la réponse à la question est <quote
|
|
|
>vraie</quote
|
|
|
>, le contrôleur d'exécution <userinput
|
|
|
>si</userinput
|
|
|
> va permettre au code entre crochets d'être exécuté.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="while">
|
|
|
<title
|
|
|
>La boucle "pendant"</title>
|
|
|
<variablelist>
|
|
|
<varlistentry>
|
|
|
<term
|
|
|
>pendant</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>pendant <link linkend="questions"
|
|
|
>question</link
|
|
|
> [ ... ]</screen>
|
|
|
Le contrôleur d'exécution <userinput
|
|
|
>pendant</userinput
|
|
|
> ressemble beaucoup à <link linkend="if"
|
|
|
><userinput
|
|
|
>si</userinput
|
|
|
></link
|
|
|
>. La différence est que <userinput
|
|
|
>pendant</userinput
|
|
|
> répète le code entre crochets jusqu'à ce que la réponse à la <link linkend="questions"
|
|
|
>question</link
|
|
|
> soit <quote
|
|
|
>faux</quote
|
|
|
>. <screen>
|
|
|
x = 1
|
|
|
pendant x < 5 [
|
|
|
avance 10
|
|
|
attends 1
|
|
|
x = x + 1
|
|
|
]
|
|
|
</screen
|
|
|
> À la première ligne, <userinput
|
|
|
>x</userinput
|
|
|
> est fixé à 1. À la seconde ligne, la <link linkend="questions"
|
|
|
>question</link
|
|
|
> <userinput
|
|
|
>x < 5</userinput
|
|
|
> est posée. Comme la réponse à cette question est <quote
|
|
|
>vraie</quote
|
|
|
>, le contrôleur d'exécution <userinput
|
|
|
>pendant</userinput
|
|
|
> commence à exécuter le code entre les crochets jusqu'à ce que la réponse à la <link linkend="questions"
|
|
|
>question</link
|
|
|
> soit <quote
|
|
|
>faux</quote
|
|
|
>. Dans ce cas, le code entre les crochets sera exécuté 4 fois, à chaque fois que la cinquième ligne est exécutée, <userinput
|
|
|
>x</userinput
|
|
|
> augmente de 1.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="else">
|
|
|
<title
|
|
|
>Si non, en d'autres mots : "sinon"</title>
|
|
|
<variablelist>
|
|
|
<varlistentry>
|
|
|
<term
|
|
|
>sinon</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>si question [ ... ] sinon [ ... ]</screen>
|
|
|
<userinput
|
|
|
>sinon</userinput
|
|
|
> peut être utilisé en plus du contrôleur d'exécution <link linkend="if"
|
|
|
><userinput
|
|
|
>si</userinput
|
|
|
></link
|
|
|
>. Le code entre les crochets après <userinput
|
|
|
>sinon</userinput
|
|
|
> n'est exécuté que si la réponse à la <link linkend="questions"
|
|
|
>question</link
|
|
|
> qui est posée est <quote
|
|
|
>fausse</quote
|
|
|
>. <screen>
|
|
|
initialise
|
|
|
x = 4
|
|
|
si x > 5 [
|
|
|
écris "x est plus grand que cinq ! "
|
|
|
] sinon [
|
|
|
écris "x est plus petit que six ! "
|
|
|
]
|
|
|
</screen
|
|
|
> La <link linkend="questions"
|
|
|
>question</link
|
|
|
> demande si <userinput
|
|
|
>x</userinput
|
|
|
> est plus grand que 5. Comme <userinput
|
|
|
>x</userinput
|
|
|
> est fixé à 4 à la première ligne, la réponse à la question est <quote
|
|
|
>fausse</quote
|
|
|
>. Cela signifie que le code entre les crochets après <userinput
|
|
|
>sinon</userinput
|
|
|
> est exécuté.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="for">
|
|
|
<title
|
|
|
>La boucle "pour", une boucle de comptage</title>
|
|
|
<variablelist>
|
|
|
<varlistentry>
|
|
|
<term
|
|
|
>pour</term>
|
|
|
<listitem
|
|
|
><para
|
|
|
><screen
|
|
|
>pour <userinput
|
|
|
>point de départ</userinput
|
|
|
> à <userinput
|
|
|
>point d'arrivée</userinput
|
|
|
> [ ... ]</screen>
|
|
|
La boucle <userinput
|
|
|
>pour</userinput
|
|
|
> est une <quote
|
|
|
>boucle de comptage</quote
|
|
|
>, par exemple elle garde le compte pour vous. <screen>
|
|
|
pour x = 1 à 10 [
|
|
|
écris x * 7
|
|
|
avance 15
|
|
|
]
|
|
|
</screen
|
|
|
> Chaque fois que le code entre crochets est exécuté, la valeur de <userinput
|
|
|
>x</userinput
|
|
|
> augmente de 1, jusqu'à ce que <userinput
|
|
|
>x</userinput
|
|
|
> atteigne la valeur 10. Le code entre les parenthèses écrit <userinput
|
|
|
>x</userinput
|
|
|
> multiplié par 7. Après que ce programme ait fini son exécution, vous allez voir la table de multiplication de 7 imprimée sur le canevas.</para
|
|
|
></listitem>
|
|
|
</varlistentry>
|
|
|
</variablelist>
|
|
|
</sect2>
|
|
|
|
|
|
</sect1>
|
|
|
|
|
|
|
|
|
<sect1 id="learn">
|
|
|
<title
|
|
|
>Créez vos propres commandes !</title>
|
|
|
<para
|
|
|
><userinput
|
|
|
>apprends</userinput
|
|
|
> est une commande très spéciale, car elle est utilisée pour créer vos propres commandes. La commande que vous créez peut recevoir des <glossterm linkend="input-output"
|
|
|
>entrées</glossterm
|
|
|
> et retourner des <glossterm linkend="input-output"
|
|
|
>sorties</glossterm
|
|
|
>. Regardons maintenant comment une nouvelle commande est créée : <screen>
|
|
|
apprends cercle (x) [
|
|
|
répète 36 [
|
|
|
avance x
|
|
|
tournegauche 10
|
|
|
]
|
|
|
]
|
|
|
</screen
|
|
|
> La nouvelle commande est appelée <userinput
|
|
|
>cercle</userinput
|
|
|
>. <userinput
|
|
|
>cercle</userinput
|
|
|
> reçoit une <glossterm linkend="input-output"
|
|
|
>entrée</glossterm
|
|
|
>, un nombre, qui fixe la taille du cercle. <userinput
|
|
|
>cercle</userinput
|
|
|
> ne retourne aucune <glossterm linkend="input-output"
|
|
|
>sortie</glossterm
|
|
|
>. La commande <userinput
|
|
|
>cercle</userinput
|
|
|
> peut maintenant être utilisée comme une commande normale dans la suite du programme. Voyez cet exemple : <screen
|
|
|
>apprends cercle X [
|
|
|
répète 36 [
|
|
|
avance X
|
|
|
tournegauche 10
|
|
|
]
|
|
|
]
|
|
|
|
|
|
va 30,30
|
|
|
cercle 20
|
|
|
|
|
|
va 40,40
|
|
|
cercle 50
|
|
|
</screen>
|
|
|
</para>
|
|
|
<para
|
|
|
>Dans l'exemple suivant, une commande avec une valeur de retour est créée. <screen>
|
|
|
apprends multiplierParSoi (n) [
|
|
|
r = n * n
|
|
|
retourne r
|
|
|
]
|
|
|
i = fenêtreentrée "Veuillez saisir un nombre et appuyer sur OK"
|
|
|
écris i + " multiplié par lui-même est : " + multiplierParSoi (i)
|
|
|
</screen
|
|
|
> Dans cet exemple, une nouvelle commande appelée <userinput
|
|
|
>multiplierParSoi</userinput
|
|
|
> est créée. L'entrée de cette commande est multipliée par elle-même puis retournée, en utilisant la commande <anchor id="return"/><userinput
|
|
|
>retourne</userinput
|
|
|
>. La commande <userinput
|
|
|
>retourne</userinput
|
|
|
> est le seul moyen de sortir une valeur de la fonction que vous avez créée. </para>
|
|
|
</sect1>
|
|
|
|
|
|
</chapter>
|
