Planet Samuro
Messages
Guest_31015
Planet Samuro
 
Messages
3D Chat
Mini-Chat

Message Panels : General : **** Cours de script *****
<<<First<<prev.>next.>>>Last>RepReply^Discussion ^vDiscussion vDelDelete the discussion
SamuroSamuro28/03Sent: 28/03/2021 22:54:181 / 3Message 1 from 3
==========================
**** Cours de script *****
==========================

Ce cours va vous apprendre à écrire des scripts simples pour Planet.
Dans chaque objet 3D, vous pouvez ajouter des scripts qui s'exécutent et rendent l'objet vivant.


Chapitre 1 : premier script
===========================

Pour créer un script :
- éditer un objet (menu Objet > Editer), aller dans l'onglet "Scripts" et cliquer "Ajouter".
- sélectionner la ligne du script "1 SCR Script" et cliquer "Editer".
- écrire votre script dans l'éditeur, par exemple celui-ci :
  (vous pouvez copier-coller avec Control C, Control V)


      // mon premier script

      event start ()
      {
        say ("Salut les amis !");
      }


et cliquer sur le bouton "Appliquer".
Le script se compile puis s'exécute alors et affiche sur la fenêtre Conversation :

  Salut les amis !

Voilà, vous avez écrit votre premier script !


Chapitre 2 : les erreurs
========================

Durant la compilation du script, celui-ci est entièrement vérifié
et contrôlé, ce qui peut faire apparaitre des erreurs de syntaxe.

Par exemple si vous aviez oublié l'accolade finale } à la fin,
vous auriez eu tout en bas un message d'erreur
qui vous indique exactement où le problème se situe :

line 5 col 1 : syntax error : '}' expected here

Il suffit alors de corriger le texte et de recliquez sur "Appliquer".



Chapitre 3 : style
==================

Pour éviter les erreurs de syntaxe et aussi faciliter la lecture,
il est important d'avoir un style d'écriture clair.

Exemple :


// mon 2ème script

event start ()
{
  string(32) s;
  int        i;

  s = "";
  for (i=0; i<16; i++)
  {
    s = s + chr(0,i);
  }
  say ("icons : " + s);
}


Vous voyez, dans l'exemple ci-dessus, que les lignes
entres accolades {  }  sont à chaque fois décalées de
deux blancs à droite. En plus, une accolade {
se trouve toujours à la verticale d'une accolade }.
C'est une habitude que vous devez absolument prendre,
cela vous évite d'oublier des accolades !

Le script suivant fonctionne aussi mais est tout à fait
déconseillé parce qu'on n'y comprend plus rien !

Exemple :


// mon 3ème script (déconseillé)

event start ()
{
string(32) s;
int        i;

s = "";
for (i=0; i<16; i++)
{
s = s + chr(0,i);
}
say ("icons : " + s);
}

Quand vous postez un script sur un groupe ou un forum,
changez le font en "Courier New" car avec ce font
les décalages sont conservés.


l'importance des commentaires
-----------------------------

N'hésitez pas, pour clarifier un script, à ajouter plein de lignes de commentaires
n'importe où dans votre script. Il suffit pour cela de commencer une ligne par //
Ces lignes sont ignorées par la compilation.


Exemple:

// voici mon premier script
// que j'ai créé pour animer
// un peu ma salle.

// Copyright le scripteur

event start ()
{
  // la commande say va afficher un texte sur le chat !
  say ("Salut les amis !");
}



Chapitre 4 : les variables numériques
=====================================

Une variable est une case de la mémoire RAM du PC à laquelle on donne un nom.
Chaque variable numérique contient une valeur entre -2147483648 et +2147483647.
Celle valeur change généralement au fur et à mesure que le programme se déroule.

Pour créer une variable numérique, il faut la 'déclarer', c'est-à-dire réserver
de la place mémoire pour son contenu, à l'aide de la commande 'int'.


exemple:

  int compteur;    // je crée mon compteur


Pour changer la valeur d'une variable, on écrit une 'assignation'
qui ressemble à ceci :


exemple:

  compteur = 2;   // maintenant, compteur a la valeur 2



Pour changer la valeur d'une variable, il suffit de lui donner
une nouvelle valeur :


exemple:

  compteur = 5;   // maintenant, compteur a la valeur 5



On peut faire des calculs aussi. Dans les exemples suivants, on peut voir :
- à droite du signe égal la valeur à calculer,
- à gauche du signe égal la variable où sera stocké le résultat du calcul.


exemples:

  compteur = 2 + 5*7;      // maintenant, compteur a la valeur 37
  compteur = (5 + 4) * 7;  // maintenant, compteur a la valeur 49
  compteur = -45;          // maintenant, compteur a la valeur -45
  compteur = 100 - 101;    // maintenant, compteur a la valeur -1



Voici comment augmenter la valeur d'une variable de 1 :

exemple:

  compteur = compteur + 1;     // calcule compteur + 1 et stocke le résultat dans compteur



Il existe cependant une manière abbréviée de faire la même chose, l'incrémentation :

exemple:

  compteur++;     // augmente compteur de 1




De la même façon, pour diminuer une variable de 1, on fait une décrémentation.


exemple:

  compteur--;     // diminue compteur de 1




Voici comment augmenter la valeur d'une variable de 10 :

exemple:

  compteur = compteur + 10;     // calcule compteur + 10 et stocke le résultat dans compteur



Il existe cependant une manière abbréviée de faire la même chose, l'assignation avec addition :

exemple:

  compteur += 10;     // augmente compteur de 10




De la même façon, pour diminuer une variable de 10 :


exemple:

  compteur -= 10;     // diminue compteur de 10





Chapitre 5 : les variables chaines de caractères
================================================

Il existe une 2ème sorte de variable : les variables chaines de caractères,
appelées 'string' en anglais.

Celles-ci ne contiennent pas de nombres mais des chaines de caractères
(lettres, chiffres, ponctuation, etc ..).

exemple:


  string(100) nom;        // je crée une variable string de maximum 100 caractères



Pour changer la valeur d'une variable string, on fait une 'assignation'
qui ressemble à ceci :


exemple:

  nom = "Bonjour";     // maintenant, nom a la valeur "Bonjour"



Pour changer la valeur d'une variable, il suffit de lui donner
une nouvelle valeur :


exemple:

  nom = "Bonsoir";      // maintenant, nom a la valeur "Bonsoir"



On peut coller plusieurs chaines ensembles avec l'opérator "+".

exemple:

  nom = "Bon" + "soir";      // maintenant, nom a la valeur "Bonsoir"
  nom = nom + " mes amis";   // maintenant, nom a la valeur "Bonsoir mes amis"



Attention: la longueur d'une variable string ne peut pas dépasser 1024 caractères.


Pour effacer une variable string, vous pouvez leur assigner une chaine vide.

exemple:

  nom = "";       // maintenant, nom est vide





Chapitre 6 : conversions
========================

On peut convertir une variable numérique en variable string à l'aide
de la fonction itos()


exemple:

  int        compteur;
  string(32) nom;

  compteur = 12;

  nom = itos(compteur);    // maintenant, nom contient "12"

  nom = "compteur = " + itos(compteur);    // maintenant, nom contient "compteur = 12"



A l'inverse, on peut convertir une variable string en variable numérique
à l'aide de la fonction stoi()

exemple:

  int        compteur;
  string(32) nom;

  nom = "12";

  compteur = stoi (nom);      // maintenant, compteur égale 12

  compteur = stoi ("13");     //  maintenant, compteur égale 13

  compteur = stoi ("ab");     //  ceci va donner une erreur qui arrête le script,
                              //  car "ab" ne peut être converti en valeur numérique !



Chapitre 7 : affichages à l'écran
=================================

L'affichage dans la fenêtre Conversation se fait à l'aide de la procédure say()

exemple:

  say ("Bonjour !");
  say (nom);



Il n'est pas permis de donner à say() une variable numérique, par exemple
ceci ne va pas fonctionner :

exemple:

  say (compteur);         // erreur



Pour afficher la valeur de compteur, il faut le convertir d'abord en chaine de caractères :

exemple:

  say (itos(compteur));
  say ("la valeur de compteur égale " + itos(compteur));




Chapitre 8 : les tableaux
=========================

A la place de réserver une seule variable, on peut réserver tout un tableau de variables.

exemple:

  int[100] compteur;       // je crée 100 compteurs



En fait, l'exemple ci-dessus crée les 100 compteurs suivants :


  compteur[0]
  compteur[1]
  compteur[2]
  compteur[3]
  ...
  compteur[99]


Pour effacer le tableau (mettre tous les compteurs à zéro), on utilise l'instruction clear :

exemple:

  clear compteur;


On peut stocker des valeurs dans ces compteurs, comme ceci :


exemple:

  compteur[5] = 12;    // stocker 12 dans le compteur numéro 5

  compteur[5]++;       // augmenter le compteur 5 de 1

  compteur[i] = 13;    // stocker 13 dans le compteur i



Le dernier exemple ci-dessus va donner une erreur si la variable "i"
n'a pas de valeur comprise entre 0 et 99.



Chapitre 9 : l'instruction IF
=============================

Les conditions servent à "tester" des variables.

On peut par exemple dire "Si la variable machin est égale à 50, fais ceci"...

Mais ce serait dommage de ne pouvoir tester que l'égalité !

Il faudrait aussi pouvoir tester si la variable est inférieure à 50,
inférieure ou égale à 50, supérieure, supérieure ou égale...

Ne vous inquiétez pas, le langage script a tout prévu (mais vous n'en doutiez pas hein)

Avant de voir comment on écrit une condition de type "if... else",
il faut donc que vous connaissiez 2-3 symboles de base.
Ces symboles sont indispensables pour réaliser des conditions.


Voici un petit tableau de symboles à connaître par coeur :

  Symbole Signification
  ======= =============
     ==    Est égal à
     >     Est supérieur à
     <     Est inférieur à
     >=    Est supérieur ou égal à
     <=    Est inférieur ou égal à
     !=    Est différent de

Faites très attention, il y a bien 2 symboles "==" pour tester l'égalité.
Une erreur courante que font les débutants et de ne mettre qu'un symbole =.
Je vous en reparlerai un peu plus bas.


Un if simple
------------

Attaquons maintenant sans plus tarder. Nous allons faire un test simple, qui va dire à l'ordinateur :

SI la variable vaut ça
ALORS fais ceci

Par exemple, on pourrait tester une variable "age" qui contient votre âge.
Tenez pour s'entraîner, on va tester si vous êtes majeur,
c'est-à-dire si votre âge est supérieur ou égal à 18 :

exemple:

  if (age >= 18)
  {
    say ("Vous êtes majeur !");
  }


Le symbole >= signifie "Supérieur ou égal", comme on l'a vu dans le tableau tout à l'heure.

S'il n'y a qu'une instruction entre les accolades, alors celles-ci deviennent facultatives.
Vous pouvez donc écrire :


exemple:

  if (age >= 18)
    say ("Vous êtes majeur !");



Si vous voulez tester les codes précédents pour voir comment le if fonctionne,
il faudra placer le if à l'intérieur d'un évenement start et ne pas oublier de déclarer
une variable age à laquelle on donnera la valeur de notre choix.

Ca peut paraître évident pour certains, mais apparemment ça ne l'était pas pour tout le monde
aussi ai-je rajouté cet exemple :


  // exemple:

  event start ()
  {
    int age;

    age = 20;

    if (age >= 18)
      say ("Vous êtes majeur !");
  }



Ici, la variable age vaut 20, donc le "Vous êtes majeur !" s'affichera.

Essayez de changer la valeur initiale de la variable pour voir.
Mettez par exemple 15 : la condition sera fausse, et donc "Vous êtes majeur !" ne s'affichera pas cette fois.

Servez-vous de ce code de base pour tester les prochains exemples du chapitre.


Une question de propreté
------------------------

La façon dont vous ouvrez les accolades n'est pas importante,
votre programme marchera aussi bien si vous écrivez tout sur une même ligne.

Par exemple :

  if (age >= 18) {  say ("Vous etes majeur !"); }

Pourtant, même si c'est possible d'écrire comme ça, c'est ultra déconseillé !!
En effet, tout écrire sur une même ligne rend votre code difficilement lisible.

Si vous ne prenez pas dès maintenant l'habitude d'aérer votre code,
plus tard quand vous écrirez de plus gros programmes vous ne vous y retrouverez plus !

Essayez donc de présenter votre code source de la même façon que moi :
une accolade sur une ligne, puis vos instructions (précédées de deux blancs
pour les "décaler vers la droite"), puis l'accolade de fermeture sur une ligne.

Il existe plusieurs bonnes façons de présenter son code source.

Ca ne change rien au fonctionnement du programme final, mais c'est une question
de "style informatique" si vous voulez. Si vous voyez un code de quelqu'un d'autre
présenté un peu différemment, c'est qu'il code avec un style différent.

Le principal, c'est que son code reste aéré et lisible.



Le "else" pour dire "sinon"
---------------------------

Maintenant que nous savons faire un test simple, allons un peu plus loin :
si le test n'a pas marché (il est faux), on va dire à l'ordinateur
d'exécuter d'autres instructions.

En français, nous allons donc écrire quelque chose qui ressemble à cela :

SI la variable vaut ça
ALORS fais ceci
SINON fais cela

Il suffit de rajouter le mot else après l'accolade fermante du if.
Petit exemple :

  if (age >= 18) // Si l'âge est supérieur ou égal à 18
  {
    say ("Vous etes majeur !");
  }
  else   // Sinon...
  {
    say ("Ah c'est bête, vous etes mineur !");
  }


Les choses sont assez simples : si la variable age est supérieure ou égale à 18,
on affiche le message "Vous êtes majeur !", sinon on affiche "Vous êtes mineur".


Le "else if" pour dire "sinon si"
---------------------------------

On a vu comment faire un "si" et un "sinon".
Il est possible aussi de faire un "sinon si".


On dit dans ce cas à l'ordinateur :

SI la variable vaut ça ALORS fais ceci
SINON SI la variable vaut ça ALORS fais ça
SINON fais cela


Traduction:

  if (age >= 18)       // Si l'âge est supérieur ou égal à 18
  {
    say ("Vous etes majeur !");
  }
  else if (age > 4)    // Sinon, si l'âge est au moins supérieur à 4
  {
    say ("Bon t'es pas trop jeune quand meme...");
  }
  else                 // Sinon...
  {
    say ("Aga gaa aga gaaa gaaa");   // Langage Bébé, vous ne pouvez pas comprendre ;o)
  }



L'ordinateur fait les tests dans l'ordre :

D'abord il teste le premier if : si la condition est vraie, alors il exécute
ce qui se trouve entre les premières accolades.

Sinon, il va au "sinon si" et fait à nouveau un test : si ce test est vrai,
alors il exécute les instructions correspondantes entre accolades.

Enfin, si aucun des tests précédents n'a marché, il exécute les instructions du "sinon".

Le "else" et le "else if" ne sont pas obligatoires. Pour faire une condition,
il faut juste au moins un "if" (logique me direz-vous, sinon il n'y a pas de condition !)

Notez qu'on peut mettre autant de "else if" que l'on veut. On peut donc écrire :

SI la variable vaut ça
ALORS fais ceci
SINON SI la variable vaut ça ALORS fais ça
SINON SI la variable vaut ça ALORS fais ça
SINON SI la variable vaut ça ALORS fais ça
SINON fais cela


Plusieurs conditions à la fois
------------------------------
Il peut aussi être utile de faire plusieurs tests à la fois dans votre if.
Par exemple, vous voudriez tester si l'âge est supérieur à 18 ET si l'âge est inférieur à 25.
Pour faire cela, il va falloir utiliser de nouveaux symboles :


  Symbole Signification
  ======= =============
    &&       ET
    ||       OU
    !        NON


Test ET
-------
Si on veut faire le test que j'ai mentionné plus haut, il faudra écrire :


exemple:

  if (age > 18 && age < 25)

Les deux symboles "&&" signifient ET.

Notre condition se dirait en français :

"Si l'âge est supérieur à 18 ET si l'âge est inférieur à 25"


Test OU
-------
Pour faire un OU, on utilise les 2 signes ||. Je dois avouer que ce signe
n'est pas facilement accessible sur nos claviers. Pour le taper sur un
clavier AZERTY français, il faudra faire Alt Gr + 6. Sur un clavier belge,
il faudra faire Alt Gr + &.

Imaginons un programme débile qui décide si une personne a le droit
d'ouvrir un compte en banque. C'est bien connu, pour ouvrir un compte en banque,
il vaut mieux ne pas être trop jeune (on va dire arbitrairement qu'il faut avoir
au moins 30 ans) ou bien avoir plein d'argent (parce que là même à 10 ans
on vous acceptera à bras ouverts)

Notre test pour savoir si le client a le droit d'ouvrir un compte en banque
pourrait être :

  if (age > 30 || argent > 100000)
  {
    say ("Bienvenue chez Picsou Banque !");
  }
  else
  {
    say ("Hors de ma vue, misérable !");
  }

Ce test n'est valide que si la personne a plus de 30 ans ou si elle possède plus de 100 000 euros


Test NON
--------
Le dernier symbole qu'il nous reste à tester est le point d'exclamation.
En informatique, le point d'exclamation signifie "Non".
Vous devez mettre ce signe avant votre condition pour dire "Si cela n'est pas vrai" :

exemple:

  if (!(age < 18))

Cela pourrait se traduire par "Si la personne n'est pas mineure".
Si on avait enlevé le "!" devant, cela aurait signifié l'inverse : "Si la personne est mineure".


Quelques erreurs courantes de débutant
--------------------------------------

N'oubliez pas les 2 signes ==
-----------------------------

Si on veut tester si la personne a tout juste 18 ans, il faudra écrire :

exemple:

  if (age == 18)
  {
    say ("Vous venez de devenir majeur !");
  }

N'oubliez pas de mettre 2 signes "égal" dans un if, comme ceci : ==


Le point-virgule de trop
------------------------
Une autre erreur courante de débutant : vous mettez parfois un point-virgule
à la fin de la ligne d'un if. Or, un if est une condition, et on ne met de point-virgule
qu'à la fin d'une instruction et non d'une condition.
Le code suivant ne marchera pas comme prévu car il y a un point-virgule à la fin du if :

exemple:

  if (age == 18); // Notez le point-virgule ici qui ne devrait PAS être là
  {
    say ("Tu es tout juste majeur");
  }



Les booléens, le coeur des conditions
-------------------------------------
Nous allons maintenant rentrer plus en détail dans le fonctionnement d'une condition de type if... else.
En effet, les conditions font intervenir quelque chose qu'on appelle les booléens en informatique.

C'est un concept très important, donc ouvrez grand vos oreilles (euh vos yeux plutôt)


Quelques petits tests pour bien comprendre
------------------------------------------
En cours de Physique-Chimie, mon prof avait l'habitude de nous faire commencer
par quelques petites expériences avant d'introduire une nouvelle notion.
Je vais l'imiter un peu aujourd'hui.


Voici un code source très simple que je vous demande de tester :


exemple:

  if (true)
  {
    say ("C'est vrai");
  }
  else
  {
    say ("C'est faux");
  }


Résultat :

  C'est vrai


Mais ??? On n'a pas mis de condition dans le if, juste true (vrai en français).
Qu'est-ce que ça veut dire ça n'a pas de sens ?

Si ça en a, vous allez comprendre.
Faites un autre test maintenant en remplaçant le true par un false :

exemple:

  if (false)
  {
    say ("C'est vrai");
  }
  else
  {
    say ("C'est faux");
  }


Résultat :

  C'est faux


Des explications s'imposent
---------------------------
En fait, à chaque fois que vous faites un test dans un if,
ce test renvoie la valeur true s'il est vrai, et false s'il est faux.

Par exemple :

  if (age >= 18)

Ici, le test que vous faites est "age >= 18".

Supposons que age vaille 23. Alors le test est vrai,
et l'ordinateur "remplace" en quelque sorte "age >= 18" par true.

Ensuite, l'ordinateur obtient (dans sa tête) un "if (true)".

Quand la valeur est true, comme on l'a vu, l'ordinateur dit que la condition
est vraie, donc il affiche "C'est vrai" !

De même, si la condition est fausse, il remplace age >= 18 par false,
et du coup la condition est fausse : l'ordinateur va lire les instructions du "else".


Un test avec une variable
-------------------------

Testez maintenant un autre truc : envoyez le résultat de votre condition dans une variable,
comme si c'était une opération (car pour l'ordinateur, c'est une opération !).


exemple:

  int  age;
  bool majeur;

  age = 20;

  majeur = age >= 18;

  if (majeur)
    say ("majeur");
  else
    say ("mineur");



Comme vous le voyez, la condition age >= 18 a renvoyé true car elle est vraie.
Du coup, notre variable majeur vaut true.

Faites le même test en mettant age = 10 par exemple. Cette fois, majeur vaudra false.


Cette variable "majeur" est un booléen !  Vous voyez qu'on l'a déclarée avec :

  bool majeur;


Retenez bien ceci :

On dit qu'une variable à laquelle on fait prendre les valeurs false et true est un booléen.



Les booléens dans les conditions
--------------------------------

Souvent, on fera un test "if" sur une variable booléenne :

exemple:

  bool majeur;

  majeur = true;

  if (majeur)
  {
    say ("Tu es majeur !");
  }
  else
  {
    say ("Tu es mineur");
  }


Comme majeur vaut true, la condition est vraie, donc on affiche "Tu es majeur !".

Ce qui est très pratique, c'est que la condition se lit facilement par un être humain.
On voit "if (majeur)", ce que peut traduire par "Si tu es majeur".

Les tests sur des booléens sont donc faciles à lire et à comprendre,
pour peu que vous ayez donné des noms clairs à vos variables
comme je vous ai dit de le faire depuis le début.

Tenez, voici un autre test imaginaire :


exemple:

  if (majeur && garcon)


Ce test signifie "Si tu es majeur ET que tu es un garçon".
garcon est ici une autre variable booléenne qui vaut true si vous êtes un garçon,
et false si vous êtes... une fille ! Bravo, vous avez tout compris !

Les booléens servent donc à exprimer si quelque chose est vrai ou faux.
C'est très utile, et ce que je viens de vous expliquer vous permettra
de comprendre bon nombre de choses par la suite.

--------------------------------------------------------------------------------

La condition "if... else" que l'on vient de voir est le type de condition le plus souvent utilisé.
En fait, il n'y a pas 36 façons de faire une condition. Le "if... else" permet de gérer tous les cas.

exemple:

  if (age == 2)
  {
    say ("Salut bebe !");
  }
  else if (age == 6)
  {
    say ("Salut gamin !");
  }
  else if (age == 12)
  {
    say ("Salut jeune !");
  }
  else if (age == 16)
  {
    say ("Salut ado !");
  }
  else if (age == 18)
  {
    say ("Salut adulte !");
  }
  else if (age == 68)
  {
    say ("Salut papy !");
  }
  else
  {
    say ("Je n'ai aucune phrase de prete pour ton âge ");
  }



--------------------------------------------------------------------------------

Chapitre 10 : les boucles
=========================

Qu'est-ce qu'une boucle ?
C'est une technique permettant de répéter les mêmes instructions plusieurs fois.

Tout comme pour les conditions, il y a plusieurs façons de réaliser des boucles.
Au bout du compte, cela revient à faire la même chose :
répéter les mêmes instructions un certain nombre de fois.

Dans tous les cas, le schéma est le même :

        <----------
  Instructions     ^
  Instructions     ^
  Instructions     ^
  Instructions     ^
        -----------^


Voici ce qu'il se passe dans l'ordre :

L'ordinateur lit les instructions de haut en bas (comme d'habitude)
Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction
Il recommence alors à lire les instructions de haut en bas...
... Et il repart au début de la boucle.


Le problème dans ce système c'est que si on ne l'arrête pas,
l'ordinateur est capable de répéter les instructions à l'infini !
Il n'est pas du genre à se plaindre vous savez, il fait ce qu'on lui dit de faire ..

Et c'est là qu'on retrouve... des conditions !
Quand on crée une boucle, on indique toujours une condition.

Cette condition signifiera "Répète la boucle tant que cette condition est vraie".

Il y a plusieurs manières de s'y prendre comme je vous l'ai dit.
Voyons voir sans plus tarder comment on réalise une boucle de type "while".

--------------------------------------------------------------------------------

La boucle while
---------------


Voici comment on construit une boucle while :

exemple:

  while ( Condition )
  {
      // Instructions à répéter
  }

C'est aussi simple que cela. While signifie "Tant que".
On dit donc à l'ordinateur "Tant que la condition est vraie : répète les instructions entre accolades".

On veut que notre boucle se répète un certain nombre de fois.
On va pour cela créer une variable "compteur" qui vaudra 0 au début du programme
et que l'on va incrémenter au fur et à mesure.

Vous vous souvenez de l'incrémentation ? Ca consiste à ajouter 1 à la variable en faisant "variable++;".

Regardez attentivement ce bout de code et, surtout, essayez de le comprendre :


exemple:

  int compteur;

  compteur = 0;

  while (compteur < 5)
  {
    say ("Salut !");
    compteur++;
  }


Résultat :

  Salut !
  Salut !
  Salut !
  Salut !
  Salut !

Ce code répète 5 fois l'affichage de "Salut !".

Comment ça marche exactement ?


Au départ, on a une variable compteur initialisée à 0. Elle vaut donc 0 au début du programme.

La boucle while ordonne la répétition TANT QUE compteur est inférieur à 5.
Comme compteur vaut 0 au départ, on rentre dans la boucle.

On affiche la phrase "Salut !" via un say.

On incrémente la valeur de la variable compteur, grâce à l'instruction "compteur++;".
Compteur valait 0, il vaut maintenant 1.
On arrive à la fin de la boucle (accolade fermante), on repart donc au début,
au niveau du while.

On refait le test du while : "Est-ce que compteur est toujours inférieur à 5 ?".
Ben oui, compteur vaut 1  Donc on recommence les instructions de la boucle.

Et ainsi de suite... Compteur va valoir progressivement 0, 1, 2, 3, 4, 5.

Lorsque compteur vaut 5, la condition "compteur < 5" est fausse.
Comme l'instruction est fausse, on sort de la boucle.

On pourrait voir d'ailleurs que la variable compteur augmente au fur
et à mesure dans la boucle, en l'affichant dans le say :

exemple:

  int compteur;

  compteur = 0;

  while (compteur < 5)
  {
    say ("la variable compteur vaut " + itos(compteur));
    compteur++;
  }


La variable compteur vaut 0
La variable compteur vaut 1
La variable compteur vaut 2
La variable compteur vaut 3
La variable compteur vaut 4


Voilà, si vous avez compris ça, vous avez tout compris.
Vous pouvez vous amuser à augmenter la limite du nombre de boucles
 ("< 10" au lieu de "< 5").


Attention aux boucles infinies
------------------------------
Lorsque vous créez une boucle, assurez-vous toujours qu'elle peut s'arrêter
à un moment ! Si la condition est toujours vraie, votre programme ne s'arrêtera jamais !

Voici un exemple de boucle infinie :

exemple:

  while (true)
  {
    say ("Boucle infinie");
  }

Souvenez-vous des booléens. Ici, la condition est toujours vraie,
donc ce programme affichera "Boucle infinie" sans arrêt !

Faites donc très attention : évitez à tout prix de tomber dans une boucle infinie.

--------------------------------------------------------------------------------


La boucle for
-------------
En théorie, la boucle while permet de réaliser toutes les boucles que l'on veut.
Toutefois, il est dans certains cas utiles d'avoir un autre système de boucle
plus "condensé", plus rapide à écrire.

Les boucles for sont très très utilisées en programmation.
Je n'ai pas de statistiques sous la main, mais sachez que vous utiliserez
certainement autant de for que de while, donc il vous faudra savoir manipuler
ces deux types de boucles.

Comme je vous le disais, les boucles for sont juste une autre façon de faire
une boucle while.

Voici un exemple de boucle while que nous avons vu tout à l'heure :


exemple:

  int compteur;

  compteur = 0;

  while (compteur < 10)
  {
    say ("Salut !");
    compteur++;
  }


Voici maintenant l'équivalent en boucle for :


exemple:

  int compteur;

  for (compteur = 0 ; compteur < 10 ; compteur++)
  {
    say ("Salut !");
  }



Quelles différences ?


Il y a beaucoup de choses entre les parenthèses après le for (nous allons détailler ça après)
Il n'y a plus de compteur++; dans la boucle.

Intéressons-nous à ce qui se trouve entre les parenthèses, car c'est là que réside
tout l'intérêt de la boucle for. Il y a 3 instructions condensées,
séparée chacune par un point-virgule :

La première est l'initialisation : cette première instruction est utilisée
pour préparer notre variable compteur. Dans notre cas, on initialise la variable à 0.

La seconde est la condition : comme pour la boucle while, c'est la condition qui dit
si la boucle doit être répétée ou pas. Tant que la condition est vraie, la boucle for continue.

Enfin, il y a l'incrémentation : cette dernière instruction est exécutée à la fin
de chaque tour de boucle pour mettre à jour la variable compteur.
La quasi-totalité du temps on fera une incrémentation, mais on peut aussi
faire une décrémentation (variable--;) ou encore n'importe quelle autre opération
(variable += 2; pour avancer de 2 en 2 par exemple).

Bref, comme vous le voyez la boucle for n'est rien d'autre qu'un condensé du while.
Sachez vous en servir, vous en aurez besoin plus d'une fois !

--------------------------------------------------------------------------------

Chapitre 11 : procédures et fonctions de base
=============================================

Qu'est-ce qu'une procédure ?  ben par exemple "say" que vous connaissez bien.
Mais il en existe bien d'autres !

Vous connaissez déjà deux fonctions aussi : itos et stoi, qui permettent
de convertir entre string et valeur numérique.

En fait la différence entre procédure et fonction, c'est qu'une procédure
c'est une commande, tandis qu'une fonction ça calcule quelque chose et le renvoie
comme résultat.

Nous allons étudier quelques fonctions courantes pour voir comment ça marche :


d = now ();             // fonction qui calcule la date du jour

s = mid(s,a,N);         // renvoie N caractères de s commençant au 'a'ième
                        // exemple: mid("ABCDEF",2,3) == "BCD"

n = rnd (a,b);          // renvoie un nombre aléatoire entre a et b
                        // exemple: rnd(1,50) == 12



La fonction now() est simple : elle renvoie la date et l'heure du PC.
Par exemple on peut écrire :

exemple:

event start()
{
  date_time  ma_date;

  ma_date = now();   // mettre la date dans ma_date

  say (itos(ma_date.day, 2, "0")
        + "/"
        + itos(ma_date.month, 2, "0")
        + "/"
        + itos(ma_date.year, 2, "0"));
}

ce qui va imprimer par exemple:

  02/12/2020



La fonction rnd() permet de tirer un nombre au hasard, ce qui est très utile pour les jeux.


exemple:

  int i;

  i = rnd (1, 100);   // choisir un nombre de 1 à 100 à mettre dans i

  say ("on choisit " + itos(i));


Dans la documentation du langage script, vous trouverez des listes
de toutes les procédures et fonctions prédéfinies.


--------------------------------------------------------------------------------


Chapitre 12 : le texte qui se répète
====================================

Voici un script qui répète un texte toutes les 10 secondes.


event start()
{
  start_timer (0, 10.0);
}

event timer (int nr)
{
  say ("Salut les amis !");
  say ("J'espère que vous allez bien :p");

  start_timer (0, 10.0);
}


La procédure start_timer(0, 10.0); signifie:

"déclenchez la minuterie numéro 0 dans 10 secondes"

Quand event timer est exécuté, elle écrit le texte, et le start_timer la redéclenche
pour dans 10 secondes, etc ... et ça tourne en boucle !



Chapitre 13 : plusieurs répétitions
===================================

Comment faire pour répéter une phase toutes les 10 secondes
et une autre toutes les 20 secondes ?


event start()
{
  start_timer (0, 10.0);
}

event timer (int nr)
{
  say ("Salut les amis !");
  start_timer (0, 10.0);

  say ("J'espère que vous allez bien :p");
  start_timer (0, 20.0);
}

Le script ci-dessus est incorrect !
En effet, seul le dernier start_timer est utilisé pour la répétition.
Ce script va donc se dérouler en ignorant complètement le premier start_timer !

Il n'est pas permis non plus d'avoir plusieurs event timer() dans le même script !

Par contre, ceci est possible :


// Exemple de répétition à plusieurs branches

event start()
{
  start_timer (0, 10.0);
  start_timer (1, 20.0);
}

event timer (int nr)
{
  if (nr == 0)
  {
    say ("Salut les amis !");
    start_timer (0, 10.0);
  }
  else  // nr égale 1
  {
    say ("J'espère que vous allez bien :p");
    start_timer (1, 20.0);
  }
}

Cet exemple, déjà assez complexe, montre plusieurs techniques très utilisées.

Tout d'abord, remarquez les deux start_timer qui lancent les deux minuteries 0 et 1,
la première après 10 secondes et la deuxième après 20 secondes.

Dans l'event timer, on teste le paramètre nr pour voir quelle minuterie a expiré (la 0 ou la 1),
et en fonction de cela, on exécute une action.

Donc si vous avez bien compris l'exemple, la 1ère phrase s'affiche toutes les 10 secondes,
et la 2ème phrase toutes les 20 secondes.



Chapitre 14 : les évènements
============================

Aux chapitres précédents, vous avez pu écrire des scripts qui tournaient tout
seuls en ignorant complètement les avatars.

Maintenant, nous allons passer à un autre genre de script :
ceux qui interagissent avec les avatars et qui leur répondent !


En effet, les avatars provoquent des actions, par exemple :

- ils cliquent sur l'objet
- ils écrivent des lignes de texte

etc ...


Il faut savoir que pendant 99% du temps, un script ne fait rien, il dort !

Mais dès qu'un avatar provoque une action, le script se réveille !
Il exécute alors quelques instructions (par exemple il affiche un message),
et quand c'est terminé, le script se remet à dormir en attendant la prochaine
action.

Entre deux actions, donc pendant qu'il dort, le script a complètement perdu
la mémoire, c'est-à-dire que toutes les variables sont remises à zéro !
Il y a une seule exception à cette règle, ce sont les variables qui sont déclarées
tout en haut du script. Ces dernières sont donc très utiles car elles gardent
leur valeur tant que le script tourne !

A chaque fois qu'une action se produit, un évènement 'event' est exécuté.

Exemple :

  // régir par un message quand le chatteur touche l'objet
  event touch()
  {
    say ("Bienvenue " + avatar_name(touched_avatar()));
  }

Dès qu'une action se produit, event est exécuté. Elle reçoit
tout un tas de paramètres concernant l'action :

touched_avatar() par exemple renvoie une clé sur l'avatar.
On peut le passer dans la fonction avatar_name() pour récupérer le nom de l'avatar qui a touché.


Chapitre 15 : compteurs
=======================

Le script suivant dit à chaque avatar combien d'avatars ont touché l'objet avant lui.
Pour cela, il utilise une variable déclarée en haut du script.


Exemple :


  // un script qui compte les chatteurs

  int g_compteur = 0;

  event touch()
  {
    say ("Bienvenue " + avatar_name(touched_avatar()));
    g_compteur++;
    say ("tu es la " + itos(g_compteur) + " personne qui me touche depuis que mon script tourne");
  }


Souvent, les variables déclarées tout en haut du script commencent par g_ pour indiquer global.
Ce n'est pas obligatoire mais c'est une convention parmi les informaticiens.


Chapitre 16 : la procédure say
================================

La procédure say() permet d'afficher un texte en salle, par exemple :

  say ("Bonjour !");



On peut coller plusieurs morceaux de textes ensembles en utilisant
l'opérateur + (plus), par exemple:

  say ("Bonjour "    +    "Chers Amis !");


bon, dans ce cas-ci, on aurait pu écrire aussi :

  say ("Bonjour Chers Amis !");



Mais voici un cas plus intéressant :

  say ("Bonjour "   +   userid   +   " !");

ici, on colle le bonjour et le nom du chatteur ensembles.


Notez que si vous écrivez :

    say (count);

vous allez avoir une erreur car say() n'accepte que des variables string !


Pour afficher une valeur, il faut d'abord la convertir en texte
avec la fonction itos(). Exemple :

    say ("tu es la " + itos(count) + " personne qui me touche depuis que mon script tourne");



Chapitre 17 : Ecriture en différentes polices et couleurs
=========================================================

Pour écrire en différents style, vous pouvez utiliser les fonctions :

    color (0xFFFFFF)                                          : changer de couleur
    font (5)                                                  : numéro de font
    style (underlined => true, italic => true, bold => true)  : changer de style souligné italique ou gras

Exemple:

  // message d'accueil

  string font(int f)                                     { return chr(1, f); }
  string style(bool underlined, bool italic, bool bold)  { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4;  return chr(2, s); }
  string color(int col)                                  { return chr(4, col & 0xFFFF, col>>16); }

  event touch ()
  {
    say ("big "
       + color(0x8080FF)
       + "kiss"
       + font(9)
       + color(0x00FF00)
       + style(underlined => true, italic => true, bold => true)
       + " from Didi");
  }


Cet exemple affiche le message de bienvenue en rouge !

Mais bon, si vous affichez beaucoup de texte rouge ce n'est pas pratique.

Car le jour où vous voulez changer de couleur, vous devez changer tous les color(0x8080FF) dans votre programme.

Ce que vous pouvez faire c'est d'écrire votre propre fonction de changement de couleur.


Exemple:


  // message d'accueil

  string font(int f)                                     { return chr(1, f); }
  string style(bool underlined, bool italic, bool bold)  { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4;  return chr(2, s); }
  string color(int col)                                  { return chr(4, col & 0xFFFF, col>>16); }

  string ftitle ()
  {
    return color(0x8080FF) + font(8);  // couleur rouge + font Impact
  }

  event touch ()
  {
    say (ftitle() + "Bonjour !");
  }


Voilà donc si vous voulez changer les couleurs ou le font,
il vous suffit de modifier la fonction ftitle.


Voici un autre exemple qui montre qu'on peut mettre tout un texte en fonction :


Exemple:


  // message d'accueil

  string font(int f)                                     { return chr(1, f); }
  string style(bool underlined, bool italic, bool bold)  { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4;  return chr(2, s); }
  string color(int col)                                  { return chr(4, col & 0xFFFF, col>>16); }

  string red ()
  {
    return color(0x8080FF);
  }

  string Impact ()
  {
    return font(8);
  }

  string Bienvenue (string userid)
  {
    return red() + Impact() + "Bienvenue " + userid + " !";
  }

  event touch ()
  {
    say (Bienvenue (avatar_name(touched_avatar())));
  }


Remarquez dans l'exemple ci-dessus qu'on a passé le paramètre userid
à la fonction Bienvenue() car elle en avait besoin !

Une autre solution aurait été d'utiliser une procédure au lieu d'une fonction.
La différence entre les deux est très mince : une fonction renvoie une valeur
ou un texte, une procédure ne renvoie rien !

Exemple:

  // message d'accueil

  string font(int f)                                     { return chr(1, f); }
  string style(bool underlined, bool italic, bool bold)  { int s=0; if (underlined) s++; if (italic) s+=2; if (bold) s+=4;  return chr(2, s); }
  string color(int col)                                  { return chr(4, col & 0xFFFF, col>>16); }

  string red ()
  {
    return color(0x8080FF);
  }

  string Impact ()
  {
    return font(8);
  }

  void Bienvenue (string userid)
  {
    say (red() + Impact() + "Bienvenue " + userid + " !");
  }

  event touch ()
  {
    Bienvenue (avatar_name(touched_avatar()));
  }


Ci-dessus, vous pouvez remarquer que la procédure say() n'est plus
dans l'évènement touch, mais dans la procédure Bienvenue.



Chapitre 18 : tirer un nombre au hasard
=======================================

Comment afficher un message de bienvenue aléatoire ?

A l'aide de la fonction rnd() !


Exemple:

  // message de bienvenue aléatoires

  event touch ()
  {
    int n;

    n = rnd (1, 3);   // tire un nombre aléatoire entre 1 et 3

    if (n == 1)
      say ("salut, ça va ?");
    else if (n == 2)
      say ("oula, toi je ne t'aime pas !");
    else
      say ("reviens plus tard, j'suis pas là :p");
  }


Remarquez ici que la variable 'n' n'a pas été déclarée en haut du script
comme d'habitude mais dans la procédure : elle perd donc sa valeur
entre deux actions pendant que le script dort, mais cela n'est pas grave
puisqu'on ne souhaite pas la garder.



Chapitre 19 : lire un fichier
=============================

Le script suivant va choisir un texte de bienvenue au hasard dans un fichier
que vous avez placé dans le dossier script de l'objet :


Exemple:

  // message de bienvenue aléatoires

  event touch ()
  {
    // compte le nombre de lignes dans le fichier bienvenue.txt
    int count = count_lines ("bienvenue.txt");

    // tire un nombre aléatoire entre 1 et count
    int n = rnd (1, count);

    // extrait la ligne choisie du fichier
    string(128) s = read_line ("bienvenue.txt", n);

    // affiche la ligne
    say (s);
  }




Chapitre 20 : stocker des infos sur le serveur
==============================================

Vous savez que les variables déclarées en haut du script gardent leur
valeur entre deux actions. Mais que se passe-t-il lorsque le script est changé ?
Elles sont évidemment effacées ..

Ce qu'il faudrait, c'est un moyen de garder des données de façon
permanente, sur le disque dur ...

On utilise pour cela les fonctions store et fetch qui permettent d'écrire
des informations sur le serveur Planet puis de les relire plus tard.


store (tiroir, valeur);   // stocke la valeur dans le tiroir du serveur
                          // exemple: store ("JEU-DEVINE", "1 35 16 32 89 12");

s = fetch (tiroir);       // renvoie la valeur contenue dans le tiroir
                          // exemple: fetch ("JEU-DEVINE") == "1 35 16 32 89 12"


Comment cela fonctionne-il ?

Imaginez que vous êtes dans une grande bibliothèque avec un mur de tiroirs devant vous.

Sur chaque tiroir est écrit un nom.

Quand vous ouvrez un tiroir vous pouvez y mettre une valeur et le refermer.
Plus tard, vous pouvez ouvrir le tiroir à nouveau et récupérer la valeur que vous y avez mise.

C'est exactement comme cela que fonctionnent store et fetch.

Vous êtes évidemment libre de mettre la valeur que vous voulez dans le tiroir.
Cela peut être un score, des points, le nombre de fois qu'un chatteur est entré
en salle, la date et l'heure de sa dernière venue, ou toute autre info.


Fin
===


SamuroSamuro18/10Sent: 18/10/2021 10:31:002 / 3Message 2 from 3
up

Invité_25893Invité_2589328/10Sent: 28/10/2021 16:12:233 / 3Message 3 from 3ReportReport
 poir ceux qui n'aime pas lire bon chanche 
<<<First<<prev.>next.>>>Last>RepReply^Discussion ^vDiscussion vDelDelete the discussion