Chapitre 11 : Création script

Bienvenue dans la catégorie niveau 2 !! Ici, vous pourrez apprendre à créer des scripts !!!
Tout d'abord, le cours n°1 =
Ce cours explique ce qu'est une variable, comment l'initialiser et comment commencer à l'utiliser.



Les variables, en premier lieu, comme son nom l'indique, c'est quelque chose qui change.

Je vais, pour simplifier la compréhension, dire qu'une variable c'est comme une bouteille, on peut y mettre n'importe quoi. Liquide (eau, bierre..), poudre (farine, sucre, sel...)

Jusque là, logiquement, tout va bien.

Je veux une bouteille contenant de l'eau, je vais lui donner un nom me permettant de ne pas la confondre avec les autres bouteilles "maBouteille_Eau"

On peut donc dire, en terme de programmation, que la variable "maBouteille_Eau" est de type 'Liquide' et qu'elle contient de l'eau. Mais attention : une fois que l'on a mis un liquide dedans, on ne peut mettre que du liquide, impossible d'y mettre du solide.

En ruby, les types simples que l'on utilise pour des variables, sont les nombres (entiers, reel), ou les chaines (caracteres, phrases)


En algorythme, pour faire un Whysky coca

Code:

 
Fonction : Boire_un_WhiskyCoca

Variables :
  maBouteille_Whysky contient du liquide
  maBouteille_Coca contient du liquide
  monVerre contient du liquide

Début :
 | maBouteille_Whysky <- Whisky
 | maBouteille_Coca <- Coca
 | monVerre <- maBouteille_Whysky + maBouteille_Coca
 |
 | Boire monVerre
Fin

ou bien, plus simple :
Code:

Code:

Fonction : Boire_un_WhiskyCoca

Variables :
  monVerre contient du liquide
Début :
 | monVerre <- Coca + Whisky
 |
 | Boire monVerre
Fin

Boire peut être considéré comme une action (une autre Fonction)

Maintenant on va passer ça avec des entiers, on veut faire une adition de deux variables :

en algo :

Code:

Fonction : Additionner

Variables :
  monEntier est un entier
  monReel est un reel
  monResultat est un reel

Début :
 | monEntier <- 153
 | monReel <- 20.42
 | monResultat <- monEntier + monReel
 |
 | Afficher MonResultat
Fin

Ce qui nous affiche 173.42


Maintenant la même chose en Ruby :
Code:

Code:

def Additionner

  monEntier = 153
  monReel = 20.42
  monResultat = monEntier + monReel
 
  Afficher( MonResultat )
End

Afficher est une fonction permettant d'afficher la variable, pour le moment, on a pas besoin de s'occuper de son fonctionnement.

Vous constatez que le type de variable n'est pas définit lors de sa création, mais seulement lors de son initialisation :

maVariable1 = -150 ; sera un entier
maVariable2 = 15.23 ; sera un réel
maVariable3 = "Ma petite Phrase" ; sera une chaine de caractére
maVariable4 = "45" ; sera une chaine de caractére (attention)
maVariable5 ; sera un Type Nil, qui n'existe pas (source d'erreur fréquente)
maVariable5 = nil; sera un Type Nil, qui n'est pas initialisé (source d'erreur fréquente)

Il faut bien faire attention car manipuler des variables de types diférents dans un calcul ou une conquatanétion, engendrera des erreurs.


Il existe des commandes pour transtyper des variables, les plus courantes sont 'to_i' et 'to_s' :
- to_i permet de changer une chaine en nombre
- to_s permet de changer un nombre en chaine

exemple:
Code:

Code:

def Additionner

  monEntierChaine = "153" # de type chaine
  monReelNombre = 20.42
  monResultat = monEntierChaine.to_i + monReelNombre  # mon résultat de type réél
 
  AfficherUneChaine( MonResultat.to_s ) # La fonction affiche une chaine, on transtype le résultat
End

Ce sont déjà des petites bases à avoir absolument pour les variables.

Ce cours, vous montre comment fonctionne un tableau de variables et les piéges à éviter.


Donc reprenons, l'histoire de nos bouteilles, un tableau ç'est comme un pannier comportant plusieur bouteille de n'importe quel type (liquide, solide..).
La seule diférence c'est que l'on a un nom pour le pannier, mais pas pour les bouteilles, elles sont dans le pannier, dans un ordre stricte qui ne bougera pas, donc pas besoin de connaitre leur nom, si on connait le nom du pannier et de la position de la bouteille dans ce pannier, c'est emplement suffisant.

On peut avoir autant de bouteilles que l'on veut dans ce pannier.

Exemple, je prend mon pannier de bouteille vide qui contiennent des liquides, on va les remplir.

En Algorythme :

Code:

Fonction : RemplirMesBouteilles

Variables :
  monPannier est un pannier de bouteille liquide
  monVerre contient du liquide

Début :
 | monPannier[0] <- Jux d'orange
 | monPannier[1] <- Eau
 | monPannier[2] <- Bierre
 | monPannier[3] <- Vin Rouge
 | monVerre <- monPannier[0] + monPannier[1]
 |
 | Boire monVerre
Fin

J'obtiens un verre de jus d'orange dilué avec de l'eau.

Vous constatez une chose flagrante, c'est que la premiere bouteille du pannier est considéré comme la bouteille 0... Pourquoi pas la bouteille 1.

Je vais tenter de vous expliquer cette bizarerie, Attention, c'est des notions de programmation bas niveau (fonctionnement interne) :
Quelque soit la variable, cela reste un endroit sur votre disque dur, où est inscrit une information, dont le type permet de connaitre la place que l'information prend en terme d'octet. Un tableau dans la mémoire, se sont donc, plusieurs informations de même type qui sont écrites à la suite, le nom du tableau défini la position de la première information stocké, ensuite il faut se décalé pour atteindre les autres informations.
Dans mon exemple de pannier, c'est comme si on me disait, va prendre une bouteille, hop, j'attrape directement la premiere, si je veux la deuxieme, je décale 1 fois le nombre que l'on met entre crochet pour un tableau correspond au décalage à effectué.

Ce qu'il faut retenir c'est que le premier élément du tableau a l'index 0 et que son nom est son adresse mémoire

Petit exemple d'addition en ruby, avec des tableaux :

Code:

def Additionner
  tabReel = [12, 34, -24, 0.25, -3.75]  # là, le tableau est typé Reel

  monResultat = tabReel[1] + tabReel[4]
end

monResultat est égale à 30.25

Je le répete encore une fois, faites très attention à l'index du tableau, ne pas savoir ce repérer dedans, c'est une grande source d'erreur.
Cela marche de la même façon, pour tous les types de variable.


* Exercices, ceux qui veulent les faires, envoyez moi vos réponses par MP, à chaque exo, il s'agit de trouver la valeur de la variable 'monResultat'

Exo 1 :

Code:

def Exercice
  monTableau = []  # Attention, initialisé, mais pas typé
  tabEntier = [-50, 21, 12, 2, -8, -25]
  tabReel = [1.5, 2.8, 3.7, 2.6]

  monTableau[0] = tabReel[1]
  monTableau[1] = tabEntier[2]

  monResultat = monTableau[0] + monTableau[1]

end

Exo 2 :
Code:

Code:

def Exercice
  monTableau = []  # Attention, initialisé, mais pas typé
  tabEntier = [2,3,4,5,6,7]
  tabReel = [1.5, 2.8, 3.7, 2.6, 7.5, 4.1, 1.8, 2.2]

  monResultat = tabReel[ tabEntier[3] ]

end

Exo 3 :
[code][code]Code:
def Exercice
tabChaine = ["1", "21", "-23"]
maVariable = 15.7
monResultat = tabChaine[2].to_i - maVariable

end
[/code]

Cours 3 : Les booléens
Le booléen, pas évident à dire ça, cependant c'est assez simple à expliquer. Vous en utilisez pratiquement tout le temps dans les events, il s'agit des Switch ou interrupteur.
Le booléen est un type de variable le plus élémentaire, car il n'a que 2 états , soit Vrai soit Faux. Les interrupteurs utilisés dans les commandes événementielles, sont définis dans un tableau de booléens, se nommant :

Code:

$game_switches

Le plus simple pour imaginer le fonctionnement d'un booleen, est le fonctionnement d'un interrupteur, pour une lampe par exemple. Mais attention, ne pas confondre l'état de l'interrupteur (ON,OFF) et le résultat (Allumé, etteint), car dans vos couloir, il ya plusieur interrupteur pour une meme lampe, certains sont ON d'autre OFF, et pourtant la lampe, n'est pas forcément etteinte ou allumée.

En Ruby, les valeurs d'un booléen sont true ou false (Vrai ou faux)

Le type booléen est dans le principe quelque chose de très simple, du point de vue variable. Hors son utilisation peut s'avérer parfois complexe, car il permet de répondre à des conditions. Toutes les comparaison de valeurs amméne à un résultat booléen :

Par exemple : j'ai un sac contenant 4 pommes et 2 bierres.
Une personne me dit : tu as exactement 3 pommes dans ton sac.
Je lui réponds : Faux
Une personne me dit : tu as plus de 3 pommes dans ton sac.
Je lui réponds : Vrai
Une personne me dit : Tu as exactement 3 pommes et exactement 2 bierres.
Je lui réponds : Faux
Une personne me dit : Tu as exactement 3 pommes ou exactement 2 bierres.
Je lui réponds : Vrai

Maintenant les mêmes exemples en Ruby :

Code:

def comparaison1
  iNbPomme = 4
  iNbBierre = 2

  bResultat = iNbPomme == 3
  # bResultat contient false
end

def comparaison2
  iNbPomme = 4
  iNbBierre = 2

  bResultat = iNbPomme > 3
  # bResultat contient true
end

def comparaison3
  iNbPomme = 4
  iNbBierre = 2

  bResultat = iNbPomme == 3 and iNbBierre == 2
  # bResultat contient false
end

Code:

def comparaison4
  iNbPomme = 4
  iNbBierre = 2

  bResultat = iNbPomme == 3 or iNbBierre == 2
  # bResultat contient true
end

Peut-être que certains sont déjà largué, je vais donc vous expliquez les opérateurs logiques (==, <, >, or, and,...). Ces opérateurs permettent de faire des calculs sur des variables et d'en ressortir un résultat booléen :
X > Y sera égale à true si X est supérieur à Y, et false si ce n'est pas le cas. C'est le même fonctionnement pour les comparaison de valeur.
/!\ Attention, une très grande source d'erreur réside dans le == souvent remplacé par inadvertence par =, ce qui aulieu de faire une comparaison, provoque une affectation.

Les comparateurs :
== : égale
!= : diférent
< : Strictemet inférieur
<= : Inférieur ou égale
> : Strictement Supérieur
>= : Supérieur ou égale

Les tables opérateurs :
- and
false and false donne false
false and true donne false
true and false donne false
true and true donne true

- or
false or false donne false
false or true donne true
true or false donne true
true or true donne true

- xor
false xor false donne false
false xor true donne true
true xor false donne true
true xor true donne false

- not
not false donne true
not true donne false

- ? :
true ? X : Y donne X
false ? X : Y donne Y


Avec ceci, vous avez l'ensemble des possiblités de calcul en booléen, mais je vais mettre quelques exemples sumplémentaires, pour plus de clarté.

Code:

def exemple1
  iNbPomme = 5
  iNbBierre = 6
  iNbVerre = 4

  bResultat = iNbBierre > iNbVerre
  # bResultat contient true
end

Code:

def exemple2
  iNbPomme = 5
  iNbBierre = 6
  iNbVerre = 4

  bResultat = iNbBierre > 4 and iNbVerre > 4
  # bResultat contient false, car true and false donne false
end

Code:

def exemple3
  iNbPomme = 5
  iNbBierre = 6
  iNbVerre = 4

  [code]bResultat = iNbBierre > 4 or iNbVerre > 4
  # bResultat contient true, car true or false donne true
end[/code]
def exemple4
  iNbPomme = 5
  iNbBierre = 6
  iNbVerre = 4

  bResultat = ( iNbBierre > iNbVerre  ? iNbPomme : 0 )
  # bResultat contient 5
end

Les exercices que je pourrais faire serait exactement de la même forme que les exemples ci-dessus, donc, je ne vois pas trop l'interret d'en mettre.

Mais si il ya des questions, il ne faut pas hésiter à les poser.


Prochain cours : la strusture if

Nous allons donc maintenant attaquer les diférentes structures, en commençant par celle que l'on voit le plus souvent : 'if' (en français, 'si')

Tout le monde sait faire des phrases au conditionnel...
Ex, Si j'ai 250 Euro, j'irais m'acheter une PSP, sinon, je continuerais à économiser.

Et bien, on traduit directement en Algorythme, ce qui nous donne ceci :

Code:

Code:

Fonction AcheterPSP

Variables :
  mesEuros est un réél

Début
 | mesEuros <- CompterMonnai
 | Si mesEuros supérieur ou égale à 250
 | Alors
 |  | AllerAuMagasin
 | Sinon
 |  | Economiser
 | FinSi
 

[/code]

CompterMonnai est une fonction me donnant la valeur de mes économis, mais son fonctionnement n'est pas interressante pour ce cours, comme les fonctions AllerAuMagasin et Economiser.

Regardez bien comment cela est construit :

|

Code:

 Si [condition]
 | Alors 
 |  | // action réalisé si la condition est vrai
 | Sinon
 |  | // action réalisé si la condition est fausse
 | FinSi

Les conditions ont été vu dans le cours précédent avec les booléens, la même fonction en ruby donnerai ceci :

Code:

def AcheterPSP
  mesEuros = CompterMonnai()
  if mesEuros <= 250
  then
    AllerAuMagasin()
  else
    Economiser()
  end
end

Je prierais à tout nouveau développeur de bien comprendre que les indentations (espaces mis pour définir les structures) dans les structures, ne sont pas obligatoires pour le bon fonctionnement du programme, mais très très conséillées, pour la bonne compréhension, et donc maintenance du code.

Dans la structure si, il n'est pas obligatoire de faire des actions si la condition est fausse :

Code:

 | Si [condition]
 | Alors 
 |  | // action réalisé si la condition est vrai
 | FinSi

Code:

  if condition
  then 
    # action réalisé si la condition est vrai
  end

Comme on peut chainer les 'si' sur une condition fausse (SinonSi) :

Code:

 | Si [condition1]
 | Alors 
 |  | // action réalisé si la condition1 est vrai
 | SinonSi [condition2]
 |  | // action réalisé si la condition1 est fausse et condition2 est vrai
 | Sinon
 |  | // action réalisé si la condition2 est fausse
 | FinSi

Code:

  if condition1
  then 
    # action réalisé si la condition1 est vrai
  elsif condition2
    # action réalisé si la condition1 est fausse et condition2 est vrai
  else
    #  action réalisé si la condition2 est fausse
  end

De plus si l'action faite en cas de condition vrai ne fait qu'une seule ligne, on peut l'écrire sous cette forme :

Code:

  monEntier = 0 if monEntier > 100

Prochain cours : Structure case

"case" peut se traduire par "selon", et permet donc de faire des actions selon la valeur de la variable.
Supposons que j'ai une bouteille contenant un liquide, selon ce liquide, je ne vais pas le boire de la même façon (café, coca, soupe..)

Code:

Fonction : BoireUnTruc

Variables :
  maBouteille contient un liquide

Début :
 | maBouteille <- AllerAuDistributeur
 |
 | Selon maBouteille
 | Cas : contient du café
 |  | VerserDansTasse
 |  | FaireChauffer
 |  |
 | Cas : contient du coca
 |  | BoireALaBouteille
 |  |
 | Autre Cas
 |  | JeterLaBouteille
 |  |
 | FinSelon
 |
Fin

"AllerAuDistributeur" est une fonction remplissant ma bouteille

"Autre Cas" permet de faire des actions selon une valeur qui n'est pas prévu

A chaque cas, on peut effectuer des actions diférentes, concrétement dans un jeu, c'est utilisé dans un menu : Selon le choix du choir, faire tel ou tel chose. Et pour plein d'autre chose nécessitant de faire des actions diférentes selon la valeur d'un variable.

Le même code en ruby :

Code:

def BoireUnTruc

  maBouteille = ""
  maBouteille = AllerAuDistributeur

  case maBouteille
  when "café"
    VerserDansTasse
    FaireChauffer
   
  when "coca"
    BoireALaBouteille
 
  else
    JeterLaBouteille
 
  end
 
end

Cette structure est très simple, mais permet de faire beaucoup de chose.


Prochain cours : Boucle while

Dans ce cours, nous allons voir le fonctionnement d'une structure dite 'boucle'. Il existe plusieur fonction permettant de réaliser des boucles en programmation. Pourquoi boucle? C'est très simple, car une fois arrivé à la fin de la structure, le déroulement du programme reprend au début de cette structure, on peut sortir de cette boucle sous certaine condition, en fonction de la structure utilisée.

Nous allons donc voir pour commencer, la struture 'loop do' litéralement en français, 'boucle faire'.

En Ruby, c'est la boucle la plus simple, car elle fonctionne sans condition, une fois que le programme est dans cette boucle, le seul moyen de l'interrompre est de la casser 'break'

Aller hop, encore un exemple simple en algorythme avec une bouteille et un verre :

Code:

Fonction : RemplirMonVerre

Variables :
  maBouteille contient liquide
  monVerre contient du liquide

Début :
 | maBouteille <- jus d'orange
 | monVerre <- rien
 | Boucle faire
 |  | monVerre <- monVerre + 5 cl de maBouteille
 |  | Si monVerre est plein
 |  |  | Casser la boucle
 |  | FinSi
 | FinBoucle
 | Boire monVerre
Fin

Vous constaterez qu'une condition est nécessaire pour pouvoir sortir de la boucle, sinon je continuerai a verser du jus d'orange dans mon verre.
Vous aurez remarqué une petite subtilité dans l'algorythme étant cette ligne : 'monVerre <- monVerre + 5 cl de maBouteille' cela veut dire que je rajoute 5cl de jus d'orange à mon verre, si j'avais juste écris 'monVerre <- 5 cl de maBouteille', le contenue du verre n'aurait jamais changé.

Voici le même exemple, mais cette fois ci, codé en ruby, on utilisera les volumes de la bouteille et du verre comme variable.

Code:

def remplirMonVerre
  contenuBouteille = 100
  contenuVerre = 0
  volumeVerreMax = 30
  loop do
    contenuVerre += 5
    contenuBouteille -= 5
    if contenuVerre == volumeVerreMax
      break
    End
  End
  boire( contenuVerre)
Fin

Il y a eu quelque modification apporté vis a vis de l'algorythme, car nous avons utilisé des volumes, facile à calculer.
'variable += x' incrémente la variable de x
'variable -= x' décrémente la variable de x

Nous allons donc voir pour continuer, la struture 'while' litéralement en français, 'Tant Que'. Elle difére de la fonction 'loop do' par le fait qu'elle peut être conditionné

Aller hop, encore un exemple simple en algorythme avec une bouteille :

Code:

Fonction : RemplirMonVerre

Variables :
  maBouteille contient liquide
  monVerre contient du liquide

Début :
 | maBouteille <- jus d'orange
 | monVerre <- rien
 | TantQue monVerre n'est pas plein
 |  | monVerre <- monVerre + 10 cl de maBouteille
 | FinTantQue
 | Boire monVerre
Fin

Cela peut paraitre un peu compliqué au premier coup d'oeil, je vais expliquer en détail la structure :

Code:

 | TantQue monVerre n'est pas plein
 |  | monVerre <- monVerre + 10 cl de maBouteille
 | FinTantQue

La ligne 'TantQue monVerre n'est pas plein' litéralement, permet une action jusqu'a ce qu'une condition soit vérifié. En gros, TantQue condition est fausse faire les actions de la boucle.

Je reprend le même exemple en ruby, en utilisant là aussi les volumes :

Code:

def remplirMonVerre
  contenuBouteille = 100
  contenuVerre = 0
  volumeVerreMax = 30
  while contenuVerre != volumeVerreMax
    contenuVerre += 5
    contenuBouteille -= 5
  End
  boire( contenuVerre)
Fin

Cela permet par rapport à la boucle loop do, de directement conditionner la sortie de boucle. Mais attention, regarder bien la diférence au niveau de la condition, pour 'while' : TantQue condition est fausse.

Prochain cours : Boucle for

La boucle for ("Pour" en français) est sensiblement identique aux autres structures de boucle. Elle permet juste en plus de modifier une variable définit dans sa structure.

Retournons dans la cuisine, pour trouvez un lot de bouteilles vides. J'ai 5 bouteilles numérotées de 0 à 4. Je souhaite toutes les remplir d'eau, je vais donc faire ces actions :

Code:

Fonction : RemplirMesBouteilles

Variables :
  mesBouteilles est un lot de bouteille contenant du liquide

Début :
 | mesBouteilles[0] <- eau
 | mesBouteilles[1] <- eau
 | mesBouteilles[2] <- eau
 | mesBouteilles[3] <- eau
 | mesBouteilles[4] <- eau
Fin

Heureusement que je n'en ai pas touvé 50, sinon ça devient très vite répétitif. Cependant, on constate que chaque ligne est identique, sauf pour le numéro de mes bouteilles, c'est là que l'on va pouvoir voir l'avantage de la boucle 'For'.

Je revide mes bouteilles pour recommencer le remplissage, mais en algorythme, je vais utiliser 'for' (Pour) :

Code:

Fonction : RemplirMesBouteilles

Variables :
  mesBouteilles est un lot de bouteille contenant du liquide
  numBouteille est un entier

Début :
 | Pour numBouteille allant de 0 à 4 par pas de 1
 |  | mesBouteilles[numBouteille] <- eau
 | FinPour
Fin

Vous pouvez constater que cela prend moins de place en écriture. Bon d'accord, avec 5 bouteilles, c'est pas vraiment flagrant, mais imaginez avec 50!!

Et hop en Ruby, voila ce que ça donne :

Code:

def remplirMesBouteilles
  mesBouteilles = []
  numBouteille = 0

  for numBouteille in 0..4
    mesBouteilles[numBouteille] = "eau"
  end
end

donc pour la syntaxe :
for [nom de la variable] in [valeur de départ]..[valeur de fin]
[Action]

end

Lors de l'entrée dans la structure la variable prend la valeur de début, puis à chaque boucle, la valeur est incrémenté d'un. Dans ce cas la valeur de fin est prise en compte. Si l'on met :
for [nom de la variable] in [valeur de départ]...[valeur de fin]
[Action]
end
La valeur de fin n'est pas prise en compte. Attention donc au nombre de '.', c'est souvent une grande source d'incompréhension dans cette structure de boucle.

On peut trouver aussi une autre utilité à la boucle For. Supposons que je reprenne un pannier de bouteilles, et que ma fonction consiste à vider chaque bouteille.

Code:

Fonction : ViderMesBouteilles

Variables :
  monPannier est un pannier de bouteille contenant du liquide
 
Debut :
 | Pour chaque bouteille de monPannier
 |  | vider la bouteille
 | FinPour
Fin

Dans cette algorythme, il n'y a plus de notion de valeur de fin ou de début pour la boucle. La boucle 'Pour', va parcourir chaque élément d'un tableau et mettre son contenu dans la variable utilisé. Le même exemple en ruby :

Code:

def viderMesBouteilles

  monPannier = ["eau","vin rouge", "jus d'orange", "cola", "lait"]

  for maBouteille in monPannier
    vider(maBouteille)
  end
end

Dans ce cas, à chaque boucle, la variable prend pour valeur le contenue d'un élément successif du tableau, du premier élément au dernier.


pour le prochain cours : fonction et procédure