Tutoriel 3 : Les procédures

NetLogo 4.0.4   Manuel de l'utilisateur  

Ce tutoriel vous conduit à travers le processus de réalisation d'un modèle complet, construit étape par étape, chaque étape étant expliquée pas à pas.

Agents et procédures

Dans le Tutoriel 2, vous avez appris à utiliser le Centre de commande et les Moniteurs d'agent pour inspecter et modifier les agents et les obliger à faire certaines choses. Nous sommes maintenant prêts pour apprendre à utiliser le véritable coeur des modèles NetLogo : le panneau des Procédures "Procedures".

Vous avez déjà utilisé des types d'agents auxquels vous pouvez donner des commandes en NetLogo : les patches, les tortues, les liens et l'observateur. Les patches sont immobiles et disposés sur une grille. Les tortues se déplacent sur cette grille. Les liens établissent une connection entre deux tortues. L'observateur surveille (et voit) tout ce qui se passe et fait tout ce que les tortues, les patches ou les liens ne peuvent pas faire eux-mêmes.

Tous les agents appartenant à ces quatre types peuvent exécuter des primitives NetLogo. Et tous les quatre peuvent aussi exécuter des procédures. Une procédure, que vous devez définir, réunit une série de commandes NetLogo pour n'en former plus qu'une seule.

Vous allez maintenant apprendre à écrire des procédures qui font bouger les tortues, les font manger, se reproduire et mourir. Vous allez aussi apprendre comment créer des moniteurs, des curseurs et des trapceurs de courbes. Le modèle que nous allons construire est un modèle d'un écosystème simple, un peu dans le genre du modèle Prédation Loups-Moutons du Tutoriel 1.

Créer le bouton PREPARER (setup)

Pour créer un nouveau modèle, sélectionnez "New" dans le menu "File". Puis commencez par créer un bouton d'initialisation "PREPARER" :

Vous avez maintenant un bouton "PREPARER" (setup). Presser ce bouton devrait déclencher l'exécution d'une procédure PREPARER. Une procédure est une séquence de commandes NetLogo à laquelle un nouveau nom a été donné. Mais nous n'avons pas encore défini cette procédure (nous le ferons bientôt). Puisque le bouton fait référence à une procédure qui n'existe pas encore, son intitulé est rouge (tout comme le texte de l'onglet "Interface") :

screen shot

Si vous voulez voir le message d'erreur, cliquez le bouton.

Nous allons maintenant créer la procédure PREPARER, ce qui fera disparaître le message d'erreur :

Quand vous avez terminé, le panneau "Procedures" ressemble à ceci :

screen shot

Notez que certaines lignes sont indentées à différents degrés. La plupart des programmeurs trouvent utile d'indenter leur code de cette manière, mais ce n'est pas une obligation. Cela rend le code plus facile à lire (et donc à comprendre) et à modifier. La procédure commence par le mot to et se termine par le mot end. Toute nouvelle procédure que vous créez devra commencer et se terminer par ces deux mots.

Examinons ce que vous avez écrit et voyons ce que fait chaque ligne de cette procédure :

Quand vous aurez fini d'écrire, revenez dans le panneau "Interface". Remarquez que les intitulés rouges sont redevenus noirs car le bouton "PREPARER" a maintenant une procédure PREPARER à laquelle s'adresser.

Pressez le bouton "PREPARER" et vous verrez toutes les tortues se disperser dans leur monde.

screen shot

Pressez le bouton "PREPARER" encore quelques fois et observez comment les positions des tortues sont à chaque fois différentes. Notez que certaines tortues peuvent se retrouver « à cheval » sur d'autres tortues.

Réfléchissez un petit peu à ce que vous avez dû faire pour arriver à ce résultat. Vous avez dû placer un bouton dans l'interface et créer une procédure que ce bouton utilise (appelle). Le bouton ne fonctionne qu'une fois ces deux opérations distinctes achevées. Dans la suite de ce tutoriel, vous aurez souvent à accomplir deux ou plusieurs étapes semblables pour ajouter une nouvelle fonctionnalité au modèle. Si quelque chose semble ne pas fonctionner une fois terminé ce qui vous semble être la dernière étape de l'élaboration d'une nouvelle fonctionnalité, continuez de lire plus loin pour voir s'il n'y a pas encore quelque chose à faire. Une fois que vous aurez lu quelques paragraphes, reprenez en sens inverses les différentes directives pour voir si vous n'auriez pas oublié une étape.

Créer le bouton GO

Créez maintenant un bouton appelé "GO". Suivez les mêmes étapes que celles accomplies pour créer le bouton "PREPARER", sauf :

screen shot

L'activation du bouton "Forever" force le bouton "GO" à rester enfoncé une fois qu'il a été pressé, ce qui fait que ses commandes seront exécutées en boucle (encore et encore) et pas seulement une fois.

Mais qu'est-ce que bouge-tortues? Est-ce une primitive (en d'autres mots, une commande prédéfinie de NetLogo), comme l'est clear-all? Non, il s'agit d'une autre procédure que vous devrez créer. Jusqu'ici, vous avez déjà ajouté deux procédure que vous avez créées : PREPARER et GO.

Notez qu'il n'y a pas d'espaces autour du tiret dans bouge-tortues. Dans le Tutoriel 2 nous avions utilisé red - 2 avec des espaces autour du signe moins dans le but de soustraire deux nombres, mais ici, nous devons écrire bouge-tortues sans espaces. Le tiret "-" réunit les mots bouge et tortues en un seul mot.

Voici ce que fait chaque commande de la procédure bouge-tortues :

Pourquoi ne pourrions-nous pas tout simplement écrire toutes ces commandes dans la procédure GO plutôt que dans une procédure séparée? Nous aurions pu le faire, mais au cours du développement du projet, il est presque sûr que vous y ajouterez bien d'autres parties. Nous aimerions garder GO aussi simple que possible de manière à ce que cette procédure soit facilement compréhensible. Par la suite, ce modèle comportera bien d'autres choses que vous voudrez voir se faire quand la simulation tournera, telles que le calcul de certaines valeurs ou l'affichage de résultats. Chacune de ces choses à faire aura sa propre procédure et chaque procédure devra avoir son propre nom, unique dans le programme.

Le bouton "GO" que vous avez créé dans le panneau interface est un bouton « pour toujours », ce qui signifie qu'il exécutera continuellement ses commandes jusqu'à ce que vous le déclenchiez (en le cliquant une seconde fois). Après avoir pressé le bouton "PREPARER" une fois pour créer les tortues, pressez le bouton "GO". Observez ce qui se passe. Désactivez-le, et vous verrez que toutes les tortues s'arrêtent instantanément sur leur chemin.

Notez que si une tortue se déplace au-delà du bord du monde, elle «s'enroule», ce qui signifie qu'elle réapparaît au côté opposé. (C'est le comportement des tortues par défaut qui peut être modifié. Consultez à ce sujet la section Topologie du Guide de la programmation pour en savoir plus.)

Expérimenter avec les commandes

Nous vous suggérons d'essayer d'autres commandes de tortue.

Écrivez des commandes (telles que turtles> set color red) dans le Centre de commande ou ajoutez des commandes aux procédures PREPARER, GO, ou bouge-tortues.

Notez que quand vous entrez des commandes dans le Centre de commande, vous devez sélectionner "turtles>", "patches>", ou "observer>" dans le menu placé à gauche, en fonction du type d'agents qui devra exécuter ces commandes. Cette manière de faire revient au même que de taper ask turtles ou ask patches, mais épargne des frappes claviers. Vous pouvez aussi utiliser la touche Tab pour passer d'un type d'agents à l'autre, ce que vous trouverez certainement plus pratique que l'utilisation du menu.

Essayer de taper turtles> pen-down dans le Centre de commande puis de pressez le bouton "GO".

De même, dans la procédure bouge-tortues , essayez de remplacer right random 360 par right random 45.

Amusez-vous. C'est facile et les résultats sont immédiatement visibles (caractéristique qui est l'un des nombreux points forts de NetLogo).

Quand vous aurez l'impression d'avoir fait (pour le moment) toutes les expérimentations que vous souhaitez, vous êtes prêts pour poursuivre l'amélioration du modèle que vous êtes en train de construire.

Patches et variables

Nous avons maintenant 100 tortues qui errent sans but, ignorant absolument tout ce qui les entoure. Rendons les choses un peu plus intéressantes en donnant à ces tortues un joli arrière-plan sur lequel se déplacer.

La procédure prepare-patches donne d'abord la couleur verte à chaque patch. (La variable servant à spécifier la couleur d'une tortue est color, celle pour la couleur d'un patch est pcolor.)

La seule partie encore non définie de notre nouvelle procédure "PREPARER" est prepare-tortues.

Avez-vous remarqué que la nouvelle procédure prepare-tortues a presque les même commandes que l'ancienne procédure PREPARER ?

Et voila! Un paysage NetLoGO luxuriant avec des tortues colorées et des patches verts apparaît :

screen shot

Après avoir observé quelques fois le fonctionnement de la nouvelle procédure PREPARER, il ne serait pas inutile de relire encore une fois les définitions de toutes les procédures.

Les variables tortue

Nous avons maintenant quelques tortues qui courent encore et toujours sans buts dans toute la verte campagne, mais qui ne font rien de plus et ignorent complètement leur environnement. Ajoutons donc quelques interactions entre les tortues et les patches.

Nous allons faire en sorte que les tortues mangent de l'herbe (les patches verts), se reproduisent et meurent après un certain temps. L'herbe devra repousser petit à petit après avoir été mangée.

Nous avons besoin d'un moyen pour contrôler quand une tortue se reproduit et quand elle meurt. Nous allons déterminer ces moments en gardant la trace de la quantité « d'énergie » que possède chaque tortue. Cette valeur devra être stockée dans une variable tortue que nous appellerons energie.

Nous avons déjà rencontré des variables tortue prédéfinies telles que color. Toutefois, NetLogo ne connaît pas de variable tortue energie mais nous permet d'en créer une. en ajoutant la déclaration turtles-own au tout début du code (dans le panneau "Procedures"), avant les définitions de toutes les procédures : 

turtles-own [energie]

Utilisons cette nouvelle variable (energie) pour permettre aux tortue de manger.

Nous utilisons la commande if pour la première fois. Examinez attentivement le code. Chaque tortue, quand elle exécute cette commande, compare la valeur de la couleur du patch (pcolor) sur lequel elle se trouve à la valeur de green, valeur numérique spécifiant la couleur verte de base dans NetLogo. (Une tortue a un accès direct aux variables du patch sur lequel elle se trouve.) Si la couleur du patch est green, la comparaison retourne true, et dans ce cas seulement la tortue exécutera les commandes qui sont entre les crochets (sinon, elle les saute). Ces commandes font que la tortue change la couleur du patch en noir et augmente sa réserve d'énergie de 10 unités. La patch devient noir pour montrer que l'herbe qu'il portait a été mangée et que la tortue a gagné de l'énergie car elle vient de manger l'herbe.

Puis faisons en sorte que les mouvements des tortues consomment un peu de cette énergie.

Maintenant, quand une tortue se déplace, elle perd une unité d'énergie à chaque pas.

Vous verrez les patches devenir noirs quand les tortues leur passent dessus.

screen shot

Les moniteurs

Nous allons ensuite placer deux moniteurs dans le panneau "Interface" à l'aide de la barre d'outils. (Ils se construisent exactement de la même manière que les boutons et les curseurs, en utilisant le menu déroulant de la barre d'outils). Créons le premier moniteur.

Une boîte de dialogue apparaît.

screen shot

Dans ce que vous venez d'écrire turtles est un « ensemble d'agents », ici, l'ensemble de toutes les tortues et count nous indique combien d'agents il y a dans cet ensemble.

Construisons maintenant le second moniteur :

Une boîte de dialogue apparaît.

screen shot

Ici, nous utilisons encore une fois count pour voir combien il y a d'agents dans un ensemble d'agents. patches est l'ensemble de tous les patches, mais nous ne voulons justement pas savoir combien il y a de patches au total; nous voulons savoir combien de patches ont de l'herbe, donc combien il y a de patches verts. C'est ce que fait with. Il construit un sous-ensemble d'agents constitué uniquement des agents pour lesquels la condition formulée entre crochets est vraie. Cette condition étant pcolor = green, with nous retourne bien le nombre de patches verts.

Il y a maintenant deux moniteurs qui vont nous indiquer combien de tortues et combien de patches verts nous avons, dans le but de nous aider à suivre ce qui se passe au cours de la simulation. Les valeurs affichées dans les moniteurs sont automatiquement mises à jours tout au long de la simulation.

Commutateurs et étiquettes

Les tortues ne se contentent pas de changer la couleur des patches en noir, elles gagnent et perdent aussi de l'énergie. Essayez d'utiliser un moniteur tortue pour voir l'augmentation ou la diminution d'énergie d'une tortue au cours de la simulation.

Ce serait une bonne chose de pouvoir prendre connaissance à tout moment de l'énergie propre à chaque tortue. Et c'est exactement ce que nous allons faire en ajoutant un commutateur (switch) afin de pouvoir activer ou désactiver l'affichage de ces informations.

Une boîte de dialogue apparaît.

screen shot

La procédure mange-herbe utilise la commande ifelse. Examinez soigneusement le code. Chaque tortue, quand elle exécute cette nouvelle commande, teste la valeur de AFFICHER_ENERGIE? (qui est déterminée par la position du commutateur). Si le commutateur est enclenché, la comparaison est vraie et la tortue exécute les commandes qui sont à l'intérieur de la première paire de crochets. Dans ce cas, elle transmet la valeur de l'énergie de la tortue à l'étiquette de cette tortue. Si la comparaison est fausse (le commutateur est déclenché), la tortue exécute les commandes placées dans le seconde paire de crochets. Dans ce cas, elle efface le texte de l'étiquette (en demandant à l'étiquette d'afficher une chaîne de caractères vide)

En NetLogo, un bout de texte est appelé une chaîne de caractères ou plus simplement une chaîne (string). Une chaîne est une suite de lettres et/ou d'autres caractères, écrits entre des guillemets anglais doubles. Ici, nous avons deux doubles guillemets qui se suivent sans aucun espace entre eux. C'est une chaîne vide. Si une étiquette de tortue reçoit une chaîne vide, elle n'affiche rien et aucun texte n'est attaché à la tortue.)

Quand ce commutateur est enclenché, vous verrez l'énergie de chaque tortue augmenter chaque fois qu'elle mange de l'herbe. Vous verrez aussi son énergie diminuer chaque fois qu'elle se déplace.

screen shot

Encore des procédures

Maintenant que nos tortues peuvent manger, faisons en sorte qu'elles puissent aussi se reproduire et même mourir. Il serait bien aussi que l'herbe puisse repousser. Nous allons ajouter ces trois comportements en créant trois procédures distinctes, une pour chaque comportement.

Chacune de ces procédures utilise la commande if. Chaque tortue, quand elle exécute reproduire-mouton, teste la valeur de la variable energie de la tortue. Si cette valeur est plus grande que 50, alors la tortue exécute les commandes placées à l'intérieur de la première paire de crochets. Dans ce cas, ces commandes diminuent l'énergie de la tortue de 50 unités puis font naître une nouvelle tortue dotée de 50 unités d'énergie. La commande hatch est une primitive NetLogo qui s'utilise selon le schéma : hatch nombre [ commandes ]. Cette tortue crée nombre nouvelles tortues, chacune identique à son parent, et demande à la (aux) nouvelle(s) tortue(s) qui a (ont) été créée(s) d'exécuter les commandes. Vous pouvez utiliser ces commandes pour donner aux nouvelles tortues d'autres couleurs, d'autres caps ou n'importe quoi d'autre. Dans notre cas, nous n'exécutons qu'une seule commande : nous donnons à la nouvelle tortue 50 unités d'énergie.

Quand chaque tortue exécute teste-mort, elle fait un test pour voir si son énergie est inférieure ou égale à 0. Si le test est vrai, la tortue doit exécuter die (c'est-à-dire mourir). (die est une primitive de NetLogo.)

Quand chaque patch exécute repousse-herbe, il fait un test pour voir si un nombre entier, généré aléatoirement entre 0 et 99, est inférieur à 3. Si c'est le cas, le patch retrouve une couleur verte. La probabilité de ce changement de couleur est en moyenne de 3%. Un patch « passe » 3% de son temps à verdir, puisqu'il y a trois nombres (0, 1 et 2), sur les 100 possibles, qui sont inférieurs à 3.

Vous devriez maintenant observer un certain nombre de comportements intéressants au cours de la simulation. Certaines tortues meurent, d'autres sont créées (naissent) et l'herbe de certains patches repousse. C'est exactement ce que nous avons essayé d'obtenir.

Si vous observez les moniteurs pendant un certain temps, vous verrez que les valeurs affichées dans "Nombre d'animaux" et dans "Carrés d'herbe" varient au cours de la simulation. Est-ce que ces fluctuations obéissent à un certain schéma et est-ce que ce schéma est prévisible? Y a-t-il un lien de cause à effet entre ces deux variables?

Il serait intéressant d'avoir un moyen plus pratique de suivre les fluctuations de certaines variables du modèle au cours du temps. NetLogo nous offre la possibilité d'afficher les données sous forme de courbes en fonction du temps, et ce pendant tout le déroulement de la simulation. Ce sera notre prochaine étape.

Représentation graphique

Pour pouvoir afficher des graphiques, nous devons d'abord créer un «grapheur» dans le panneau "Interface" et y faire quelques réglages. Nous devrons aussi ajouter une procédure supplémentaire dans le panneau "Procedures", procédure dont la fonction sera de tenir le graphique à jour.

Commençons par le panneau Procédure.

Notez que nous utilisons la commande plot pour ajouter le point suivant au graphique. Toutefois, avant de pouvoir le faire, nous devons dire deux choses à NetLogo. Premièrement, nous devons spécifier quel traceur nous voulons utiliser (puisque par la suite notre modèle pourrait avoir plus d'un traceur), et deuxièmement nous devons spécifier quel crayon nous voulons utiliser pour tracer la courbe (nous utiliserons deux crayons dans ce traceur).

La commande plot déplace le crayon de la courbe courante sur le point dont la coordonnée X est d'une unité supérieure à la coordonnée X du point précédent et dont la coordonnée Y correspondant à la valeur transmise à la commande plot (dans le premier cas, le nombre de tortues, dans le second cas, le nombres de patches verts). Quand les crayons se déplacent, ils dessinent chacun leur propre ligne.

Pour que la commande set-current-plot "Totaux" puisse fonctionner, vous devez ajouter un traceur dans le panneau "Interface" du modèle, puis le paramétrer de manière à ce que son nom soit le même que le nom utilisé dans la procédure, ici Totaux. Même un espace non prévu dans le nom suffit à le faire rejeter : il doit être orthographié exactement de la même manière aux deux endroits.

screen shot

Vous devez ensuite créer les deux crayons.

screen shot

Notez que, quand vous créez et paramétrez un traceur, vous pouvez aussi spécifier les valeurs maximales et maximales pour les axes X et Y. Vous pouvez aussi laisser la coche dans la case à cocher "Autoplot?" de manière à ce que si les valeurs à représenter dépassent les valeurs minimales et/ou maximales de ces axes, l'échelle de ceux-ci s'adapte automatiquement afin que toutes les données puissent êtres affichées.

Vous pouvez maintenant voir les graphiques se dessiner au fur et à mesure que la simulation se déroule. Le traceur devrait ressembler à celui montré ci-dessous, mais il ne doit pas en être la copie conforme.

Rappelez-vous que nous avions laissé "Autoplot?" actif, ce qui permet au graphe de se réajuster lorsque les valeurs deviennent trop grandes.

screen shot

Remarque : La case à cocher "Show legend" de la boîte de dialogue "Plot" permet d'activer ou de désactiver l'affichage des légendes des courbes dans la marge droite du grapheur. Cette boîte de dialogue peut en tout temps être ouverte par un clic droit sur le grapheur et la sélection de la commande "Edit..." dans le menu qui s'affiche.

Vous devriez faire tourner la simulation plusieurs fois de suite pour voir quels aspects des courbes sont constants et quels aspects changent au gré des simulations.

Le compteur de cycles

Pour pouvoir comparer les graphes obtenus par plusieurs simulations successives, il est souvent utile de comparer des simulations de même durée. Savoir comment stopper ou démarrer une action à un moment spécifique peut y contribuer en arrêtant la simulation au même endroit lors chaque passe. Garder la trace du nombre de fois que la procédure GO a été exécutée est un moyen utile pour intercaler de telles actions.

Pour garder cette trace, nous utiliserons le compteur de cycles interne de NetLogo.

Maintenant, la simulation et le dessin des graphiques ne se poursuivent plus jusqu'à l'infini. Ils s'arrêtent automatiquement lorsque le compteur de cycles de la barre d'outils du panneau "Interface" atteint 500.

La commande tick avance le compteur de cycles par pas de 1. ticks est un reporter qui retourne la valeur courante du compteur de cycle. clear-all de la procédure PREPARER se charge de remettre de compteur de cycles à 0 quand on démarre une nouvelle simulation.

Notez que nous avons mis tick avant dessine-graphes. Nous procédons ainsi car si nous écrivons du code pour un traceur qui utilise la valeur du compteur de cycle, il verra la nouvelle valeur, pas l'ancienne. (Dans ce tutoriel, nous ne voulons pas écrire un code de ce type, mais quoi qu'il en soit, c'est une bonne habitude que d'appeler tick après que les agents aient fait leur travail mais avant que vous n'actualisiez les graphes.)

Maintenant que votre modèle utilise les cycles, vous voudrez probablement utiliser le menu placé dans le haut du panneau "Interface" pour passer d'une mise à jour continue ("continuous") à une mise à jour basée sur les cycles ("on ticks"). Cela signifie que NetLogo ne mettra à jour (c'est-à-dire ne redessinera) la Vue (autrement dit la zone dans laquelle vous voyez les agents) qu'à la fin de chaque cycle, jamais au milieu d'un cycle. Ce réglage permet une simulation plus rapide et assure une apparence consistante des résultats (puisque les rafraîchissements ne se font qu'à des moments précis). Voir le Guide de Programmation pour une discussion complète et approfondie du rafraîchissement de la vue.

Encore quelques détails

Premièrement, plutôt que d'avoir toujours 100 tortues, vous pouvez spécifier un nombre de tortues variable.

Testez cette modification et comparez comment le fait d'avoir plus ou moins de tortues initiales affecte les courbes en fonction du temps.

Deuxièmement, ne serait-il pas intéressant de pouvoir modifier les quantités d'énergie que les tortues gagnent ou perdent quand elles mangent de l'herbe ou se reproduisent?

Finalement, quel autre curseur pourriez-vous ajouter pour agir sur la repousse de l'herbe? Y a-t-il des règles que vous pourriez ajouter aux déplacements des tortues ou au comportement des tortues nouveaux-nés qui ne s'appliqueraient qu'à certains moments? Essayez de les écrire.

Et ensuite ?

Vous avez maintenant un modèle simple d'un écosystème. Les patches font pousser de l'herbe, les tortues se promènent, mangent de l'herbe, se reproduisent et meurent. Vous avez créé une interface contenant des boutons, des curseurs, des commutateurs et un traceur. Vous avez même écrit une série de procédures pour donner quelque chose à faire aux tortues.

C'est donc ici que ce tutoriel s'achève.

Si vous voulez consulter plus de documentation au sujet de NetLogo, la section Guide de l'interface de ce manuel vous emmène visiter tous les éléments de l'interface de NetLogo et vous en explique le fonctionnement. Pour une description détaillée sur la manière d'écrire des procédures, référez-vous au Guide de la programmation. Toutes les primitives sont décrites dans le Dictionnaire NetLogo.

Vous pouvez aussi continuer d'expérimenter et de compléter ce modèle si vous le désirez, en testant différentes variables et différents comportements pour les agents.

Mais vous pouvez aussi revoir le premier modèle de ces tutoriels, la Prédation Loups-Moutons. Il s'agit du modèle utilisé dans le Tutoriel 1. Dans ce modèle Prédation Loups-Moutons, vous avez vu des moutons se déplacer, consommer des ressources qui sont occasionnellement renouvelées (l'herbe), se reproduire dans certaines conditions, et mourir quand ils viennent à manquer de ressources. Mais ce modèle possède aussi un autre type de créatures, les loups. L'entrée en scène des loups demande quelques procédures supplémentaires et l'utiliation de quelques nouvelles primitives. Les loups et les moutons sont deux différentes « races » de tortues. Pour voir comment utiliser les races, étudiez le modèle Prédation Loups-Moutons.

Vous avez encore la possibilité d'étudier d'autres modèles (y compris les nombreux modèles de la section "Code Examples" de la Bibliothèque des modèles) ou même d'aller de l'avant et de construire vos propres modèles. Vous n'avez même pas besoin de modéliser quoi que ce soit. Il peut aussi être intéressant de simplement observer les patches et les tortues former des dessins, d'essayer de créer des jeux, ou encore de faire «n'importe quoi».

Espérons que vous avez appris certaines choses, aussi bien en langage NetLogo que dans la manière de s'y prendre pour créer des modèles. Toutes les procédures créées au cours de ce tutoriel sont regroupées (et commentées) ci-dessous.

Appendice : le code complet

Le code complet de ce modèle est aussi disponible dans la "Bibliothèque des modèles NetLogo", dans la section "Code Examples". Il est intitulé "Tutorial 3". Sa version française "Tutorial 3_fr.nlogo" se trouve dans le dossier "Code Examples-fr".

Notez que ce code est plein de commentaires, qui commencent par un point-virgule. Les commentaires permettent de placer des explications dans le code lui-même, aux endroits où elles sont le plus utiles. Vous pouvez utiliser les commentaires pour aider les autres à comprendre le fonctionnement de votre modèle ou tout simplement comme notes pour votre usage personnel.

Dans le panneau "Procedures", les commentaires sont affichés en gris afin qu'ils puissent être facilement repérés. 

turtles-own [energie] ;; pour savoir quand la tortue est prête 
                      ;; pour se reproduire et quand elle doit mourir
 
to PREPARER
  clear-all
  prepare-patches
  prepare-tortues
  dessine-graphes
end
 
to prepare-patches
  ask patches [ set pcolor green ]
end
 
to prepare-tortues
  create-turtles Nombre_tortues    ;; utilise la valeur du curseur Nombre_tortues pour créer les tortues
  ask turtles [ setxy random-xcor random-ycor ]
end
 
to GO
  if ticks >= 500 [ stop ]  ;; stoppe après 500 cycles
  bouge-tortues
  mange-herbe
  reproduit-tortue
  teste-mort
  repousse-herbe
  tick                    ;; augmente le compteur de cycle de 1 à chaque cycle
  dessine-graphes
end
 
to bouge-tortues
  ask turtles [
    right random 360
    forward 1
    set energie energie - 1  ;; quand la tortue se déplace, elle perd 1 unité d'énergie
  ]
end
 
to mange-herbe
  ask turtles [
    if pcolor = green [
      set pcolor black
           ;; la valeur du curseur energie-herbe est ajoutée à energie
      set energie (energie + energie-herbe)
    ]
  ifelse AFFICHER_ENERGIE?
    [ set label energie ] ;; l'étiquette est réglée pour afficher la valeur de energie
    [ set label "" ]      ;; l'étiquette reçoit une chaîne vide pour s'effacer
  ]
end
 
to reproduit-tortue
  ask turtles [
    if energie > energie-reproduction [
      set energie energie - energie-reproduction    ;; ôte energie-reproduction pour donner une naissance
      hatch 1 [ set energie energie-reproduction ]  ;; donne cette energie-reproduction au nouveau-né
    ]
  ]
end
 
to teste-mort
  ask turtles [
    if energie <= 0 [ die ] ;; enlève la tortue si elle n'a plus d'énergie
  ]
end
 
to repousse-herbe
  ask patches [                            ;; 3 cycles sur 100, la patch reçoit une couleur verte
    if random 100 < 3 [ set pcolor green ]
  ]
end
 
to dessine-graphes
  set-current-plot "Totaux"                ;; quel traceur utiliser
  set-current-plot-pen "tortues"           ;; quel crayon utiliser
  plot count turtles                       ;; ce qui sera dessiné avec le crayon courant
  set-current-plot-pen "herbe"             ;; quel crayon utiliser 
  plot count patches with [pcolor = green] ;; ce qui sera dessiné avec le crayon courant
end

Et voici le code original, non traduit : 

turtles-own [energy] ;; for keeping track of when the turtle is ready
                     ;; to reproduce and when it will die
 
to setup
  clear-all
  setup-patches
  setup-turtles
  do-plots
end
 
to setup-patches
  ask patches [ set pcolor green ]
end
 
to setup-turtles
  create-turtles number    ;; uses the value of the number slider to create turtles
  ask turtles [ setxy random-xcor random-ycor ]
end
 
to go
  if ticks >= 500 [ stop ]  ;; stop after 500 ticks
  move-turtles
  eat-grass
  reproduce
  check-death
  regrow-grass
  tick                    ;; increase the tick counter by 1 each time through
  do-plots
end
 
to move-turtles
  ask turtles [
    right random 360
    forward 1
    set energy energy - 1  ;; when the turtle moves it looses one unit of energy
  ]
end
 
to eat-grass
  ask turtles [
    if pcolor = green [
      set pcolor black
           ;; the value of energy-from-grass slider is added to energy
      set energy (energy + energy-from-grass)
    ]
  ifelse show-energy?
    [ set label energy ] ;; the label is set to be the value of the energy
    [ set label "" ]     ;; the label is set to an empty text value
  ]
end
 
to reproduce
  ask turtles [
    if energy > birth-energy [
    set energy energy - birth-energy  ;; take away birth-energy to give birth
    hatch 1 [ set energy birth-energy ] ;; give this birth-energy to the offspring
    ]
  ]
end
 
to check-death
  ask turtles [
    if energy <= 0 [ die ] ;; removes the turtle if it has no energy left
  ]
end
 
to regrow-grass
  ask patches [ ;; 3 out of 100 times, the patch color is set to green
    if random 100 < 3 [ set pcolor green ]
  ]
end
 
to do-plots
  set-current-plot "Totals" ;; which plot we want to use next
  set-current-plot-pen "turtles" ;; which pen we want to use next
  plot count turtles ;; what will be plotted by the current pen
  set-current-plot-pen "grass" ;; which pen we want to use next
  plot count patches with [pcolor = green] ;; what will be plotted by the current pen
end