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 variables
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 variable
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ées
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)
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ères
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énation
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 string
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)
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)
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.
Conclusion
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.