FANDOM


Les scripts ne font essentiellement que traiter de l'information. Ils en reçoivent via les contrôles sur lesquels agit le joueur (qui appuie sur la touche "avancer" par exemple) ainsi qu'en lisant l'état des différents éléments que composent le jeu (la position du joueur par exemple). Les scripts vont ainsi traiter (calculer, lire, écrire, mettre à jour, ...) toutes ces informations afin d'en déduire comment il doit agir sur le jeu

Même si ce n'est que pendant quelques millièmes de secondes, il va falloir stocker ces différentes informations afin de les transporter d'un bout de code à un autre. Ceci est réalisé grâce aux variables.

Les variables sont des conteneurs d'information. Elles possèdent un nom unique ainsi qu'une valeur qui représente une information. Cette information peut être simple comme du texte ou un nombre ou bien plus compliquée comme une représentation d'un objet de jeu dans votre scène.

Une variable va donc servir à stocker et transporter de l'information, telle que la vie de votre joueur par exemple, ou bien à représenter quelque chose tel qu'un model ou encore l'objet de jeu que constitue votre joueur.

C'est en lisant des variables, en écrivant dans des variables ainsi qu'en agissant sur les variables qui représentent quelque chose que votre jeu va pouvoir se dérouler tel que vous le voulez.

Nommer ses variablesModifier

Le nom des variables peut être constitué de lettres capitales ou minuscules, de chiffres et d'underscores _ (le tiret bas, touche 8) mais ne peut pas commencer par un chiffre.

-- exemple de noms valides :
ma_variable
maVariable
mavariable
_ma_var1a61e
-- rappelez vous simplement qu'une variable ne peut commencer par un chiffre.

D'autre part le nom des variables est sensible à la casse, c'est à dire qu'il fait la différence en les lettre majuscules et minuscules. Ainsi, dans l'exemple plus haut mavariable et maVariable sont deux variables différentes.

Lire et écrire dans une variableModifier

Pour assigner une valeur à une variable, c'est à dire pour écrire dans une variable il suffit d'utiliser le signe égal entre le nom de la variable et la valeur :

ma_variable = 50 -- un nombre
monAutreVariable = "une super valeur" -- du texte, aussi appelé une chaîne de caractère ou en anglais un String (concentrez vous au lieu de rigoler petits malins !)

Pour lire une variable, il suffit d'écrire son nom. Notez que la variable n'est pas vidée de son contenu lorsqu'elle est lue. Les variables ne changent de contenu que lorsque l'on écrit en elles, lire une variable ne produit aucun effet sur elle.

print(ma_variable) -- affiche 50
print(monAutreVariable) -- affiche une super valeur

Vous pouvez également écrire dans une variable à partir d'une autre variable :

ma_variable = monAutreVariable
print(ma_variable) -- affiche une super valeur car on a écrit la valeur de monAutreVariable dans ma_variable

Les variables en Lua sont dites dynamiquement typées. C'est à dire que la nature de l'information que contient une variable peut changer au cours du temps, si vous ou le programme la fait changer. Ce n'est pas le cas dans tous les langages.

Outre la nature de l'information, il est bien sur possible de modifier n'importe quand la valeur d'une variable (d'où le nom).

ma_variable = 50
print(ma_variable) -- affiche 50
ma_variable = "une autre valeur"
print(ma_variable) -- affiche une autre valeur
ma_variable = false -- false n'est pas un string, c'est un booléen, voir ci-dessous
print(ma_variable) -- affiche false

La plupart des autres langages de programmation possèdent la notion de constantes, qui sont des variables particulières dont la valeur ne peut être modifiée une fois qu'elle a été définie mais celles-ci n'existent pas en Lua.

Notez qu'il est possible d'écrire dans plusieurs variables à la fois ainsi :

variable1, variable2, variable3 = valeur1, valeur2, valeur3
-- variable1 vaut valeur1, variable2 vaut valeur2, ...

Les types de donnéesModifier

En Lua l'information que peut contenir une variable peut être de 5 types (natures) différents.

  • String : pour du texte.
  • Number : pour tout ce qui est numérique.
  • Boolean : un booléen ne peut avoir que deux valeurs : soit false, soit true
  • Tables : Les tables sont en quelque sorte des tableaux qui vont pouvoir contenir d'autres variables. Comme c'est un peu compliqué, un chapitre entier leurs est consacré.
  • Fonctions : Les fonctions vont contenir des morceaux de code, qui vont ainsi pouvoir être réutilisés à plusieurs endroits sans devoir le réécrire. La aussi comme c'est une notion déjà avancée, un chapitre entier leurs est également consacré.
  • nil : nil est une sorte de valeur que possèdent les variables qui n'ont justement pas de valeur ou qui n'existent pas (ce qui revient au même en Lua)

String (chaîne de caractères)Modifier

Comme dit plus haut, les strings servent à stocker du texte. Un string peut donc contenir n'importe quels lettres, signes et chiffres présents sur votre clavier (et même beaucoup plus en fait).

Vous l'avez déjà vu dans les exemples plus haut, pour créer un string il suffit d'entourer le texte avec des guillemets :

mon_string = "avec des guillemets double"
-- cela marche également avec des guillemets simples (l'apostrophe)
mon_string = 'avec des guillemets simples'

Vous aurez noté sur les exemples ci-dessus que les guillemets ne sont pas affichés dans la console en même temps que le string.

Échappement de caractèresModifier

Si vous voulez utiliser des guillemets à l'intérieur d'un string, cela va poser problème car le deuxième guillemet rencontré dans la ligne sera alors interprété par le programme comme étant le guillemet sensé clore le string. Du coup le programme ne va pas comprendre le reste de la ligne et afficher une erreur.

Pour remédier à ce problème, il est nécessaire d'échapper les guillemets pour modifier leur signification. Les guillemets seront alors considérés comme des caractères "normaux". Mais l'effet de l’échappement dépend du caractère. Ainsi, échappez la lettre n (\n), va créer un retour à la ligne et écrire le string sur deux lignes dans la console.

Pour échapper un caractère il suffit de le faire immédiatement précéder d'un anti-slash (\, touche AltGr+8) :

mon_string = "un string qui \"contient\" des guillemets"
print(mon_string) -- affiche : un string qui "contient" des guillemets

Notez que cela n'est nécessaire que lorsque vous voulez placer des guillemets double dans un string créé avec des guillemets double (idem pour les guillemets simple). Exemples :

mon_string = 'besoin d\'échapper les apostrophes' -- ici, les guillemets sont identiques, comme dans l'exemple au dessus, il y a donc besoin d'échapper ceux qui sont à l'intérieur du string
mon_string = 'pas besoin d\'échapper les "guillemets doubles"' -- ici, pas besoin d'échapper les guillemets puisque ce ne sont pas les même
print(mon_string) -- affiche : pas besoin d’échapper les "guillemets doubles"
mon_string = "pas besoin d’échapper les 'guillemets simples'" -- ici non plus, pas besoin d'échapper les guillemets puisque ce ne sont pas les même

ConcaténationModifier

Il est très souvent utile de joindre deux strings afin par exemple d'insérer la valeur d'une variable dans une phrase. Cette opération s'appelle la concaténation. En Lua, il suffit de séparer les bouts de string (ou les variables qui les contiennent) par deux points côte à côte :

mon_string = "un".." string"
-- mon_string vaut alors "un string"
mon_autre_string = mon_string .. " | " .. mon_string
print(mon_autre_string) -- affiche : un string | un string

Transformer d'autre types en stringModifier

Il est possible de transformer un nombre ou un booléen en string au moyen de la fonction tostring(). Elle s'utilise comme la fonction print(), il faut indiquer la valeur à transformer entre les parenthèses :

mon_string = tostring(123) -- mon_string vaut "123" et non 123
mon_string = tostring(false) -- mon_string vaut "false" et non false

Il est à noter que le Lua est suffisamment intelligent pour effectuer cette transformation automatiquement lorsqu'il en a besoin, par exemple pour concaténer.

En effet, concaténer un string et un nombre n'a pas de sens, on ne peut concaténer que deux strings. Mais si le programme rencontre le signe de concaténation, il sait qu'il ne peut utiliser que deux strings et va donc tenter de transformer les deux cotés du signe en string. Ce qu'il va réussir à faire sans problème avec les nombres, mais pas avec les booléens.

mon_string = 123 .. 456 -- mon_string vaut "123456" car dans ce cas le Lua va considérer les nombres comme des strings afin de pouvoir les concaténer.

Number (nombre)Modifier

Voici quelques exemples de nombres :

mon_nombre = 1.23 -- nombre à virgule, qui utilise un point à la place de la virgule

mon_nombre = 12e3 -- puissance de 10, est équivalente à 12000. L'écriture [nombre]e[nombre] est équivalente à [nombre]*10^[nombre]
mon_nombre = 12E3 -- autre écriture possible
mon_nombre = 12e-3 -- cette fois l'exposant est négatif et le nombre est équivalent à 0.012 (marche aussi avec 12E-3)

mon_nombre = 12^3 -- puissance, équivalent à 12*12*12

Qui dit nombre dit mathématiques et donc opérateurs mathématiques. Mais j'ose imaginer qu'il n'y aura pas grand chose de nouveau pour vous, ce sont les même qu'à l'école et sur les calculatrices :

1 + 2 -- addition, vaut 3
1 - 2 -- soustraction, vaut -1
1 * 2 -- multiplication, vaut 2 (le signe est l'étoile, sur le pavé numérique ou au dessus de la touche Maj et à gauche de Entrée, et non le x)
1 / 2 -- division, vaut 0.5

-- le dernier opérateur vous est peu être inconnu, il s'agit du modulo (signe de pourcentage)
mon_nombre = 12 % 5 -- mon_nombre vaut 2 car 2 est le reste de la division de 12 par 5
-- le modulo sera positif si le résultat de la division correspondante n'est pas un nombre entier

On peut sans problème transformer un string (qui ne contient que des chiffres) en nombre avec la fonction tonumber(). Mais on l'a vu avec les strings, le Lua sait faire cela tout seul lorsqu'il se trouve dans une situation nécessitant des chiffres.

mon_nombre = "123" + "456" -- mon_nombre vaut ici 579 car les strings ont été transformés automatiquement en nombre puisque l'on cherchait à faire une addition.

En plus de ces quelques opérateurs, le Lua nous met à disposition toute une série de fonctions et variables (ci-dessous) pour effectuer des opérations telles que le cosinus, la génération aléatoire d'un nombre, l’arrondi etc...

math.abs   math.acos  math.asin  math.atan math.atan2 math.ceil
math.cos   math.cosh  math.deg   math.exp  math.floor math.fmod
math.frexp math.huge  math.ldexp math.log  math.log10 math.max
math.min   math.modf  math.pi    math.pow  math.rad   math.random
math.randomseed       math.sin   math.sinh math.sqrt  math.tanh
math.tan

Voyons quelques exemples :

print(math.abs(-5)) -- valeur absolue, affiche 5
print(math.ceil(12.3)) -- arrondi à l'entier supérieur, vaut 13
print(math.floor(12.7)) -- arrondi à l'entier inférieur, vaut 12
math.huge représente un nombre infiniment grand
print(math.pi) -- math.pi représente la valeur exacte du nombre PI, c'est à dire environ 3.1415...
print(math.sqrt(25)) -- racine carrée, vaut 5
-- etc...

Boolean (booléen)Modifier

Un booléen ne peut avoir que deux valeurs : true (qui signifie vrai) ou false (qui signifie faux). Notez bien que ce ne sont pas des strings.

Les booléens sont surtout utilisés pour exprimer et tester facilement un état ou pour répondre à une question. Par exemple on peut imaginer que votre joueur possède une variable appelée "est_en_vie". Cette variable vaut true sauf lorsque la vie du joueur sera descendue en dessous de 0 où elle vaudra false. L'idée est simplement que si l'on veut savoir si le joueur est en vie, il est plus intuitif de poser la question 'Le joueur est-t-il en vie ?' en vérifiant que la variable est_en_vie vaut true que 'La vie du joueur est-elle strictement supérieure à 0 ?' en lisant la variable qui contient la vie.

Nous verrons également dans le chapitre suivant que les booléens sont au cœur du fonctionnement des conditions dont le but est justement de poser des questions et d'exécuter du code en fonction de la réponse.

ConclusionModifier

Voilà ce gros chapitre terminé, vous devez à présent avoir compris l'importance des variables dans votre programme ainsi que quand et comment les utiliser en fonction du type de l'information qu'elle contiennent.

Nous n'avons pas encore vu les tableaux et les fonctions bien que ces types soient tout aussi importants car ils sont également plus compliqués à comprendre.

Dans le prochain chapitre vous allez apprendre ce que sont les conditions, quelles sont les structures conditionnelles et comment bien s'en servir. Le tout sera bien sur agrémenté d'exemples utilisant ce que nous avons déjà vu (les variables, les strings, les nombres et les booléens) vous permettant ainsi d'assimiler complètement ces notions.

Interférence d'un bloqueur de publicité détectée !


Wikia est un site gratuit qui compte sur les revenus de la publicité. L'expérience des lecteurs utilisant des bloqueurs de publicité est différente

Wikia n'est pas accessible si vous avez fait d'autres modifications. Supprimez les règles personnalisées de votre bloqueur de publicité, et la page se chargera comme prévu.

Sur le réseau FANDOM

Wiki au hasard