Bienvenue dans le tutoriel « Booléens et Variables », réalisé par Vanivan !

Ce tutoriel fait suite au Tutoriel de Symbiose.

Avant toute chose, je tiens à faire une mise en garde : les variables et les booléens utilisés ici servent à titre d'exemple. Si vous avez besoin d'un booléen ou d'une variable unique, la démarche à suivre est de demander à EditeurSO un numéro que vous pourrez utiliser.

Les variables et booléens suivants sont dits “publics”, c'est-à-dire utilisables ponctuellement, dans le cadre d'un mini-jeu ou autre, mais ces variables et booléens doivent impérativement être remis à 0 à la sortie de la carte.

Il existe également certains booléens et variables qui sont utilisables par tout le monde mais leurs valeurs ne peuvent être modifiées ! Il s'agit des booléens et variables dits “partagés”.

Exemple : le booléen 511 permet de connaître le genre du personnage (masculin ou féminin).

La liste complète est présente sur la page suivante : Variables et booléens partagés.

Un booléen est avant tout une variable, c'est-à-dire une inconnue dont on peut changer la valeur (voir la définition d'une variable). Mais c'est une variable qui peut prendre seulement deux valeurs différentes. Dans la vie courante, les deux valeurs d'un booléen sont le “vrai” et le “faux”, ou encore le “oui” et le “non”, mais sur l'éditeur, ce sont le “0” et le “1”. Donc un booléen vaut soit 0, soit 1, et c'est ce qui va nous permettre de changer des états dans le jeu.

Etant donné qu'il n'a que deux valeurs possibles (0 ou 1), on pourra l'utiliser pour, par exemple :

• Savoir si un joueur a ouvert un coffre,
• Savoir si le joueur a un ticket de bateau,
• Savoir si le joueur a appuyé sur un bouton pour débloquer une porte,
• …

Le booléen va fonctionner comme une réponse à une question fermée (question dont la réponse est “oui” ou “non”). On va donc interpréter ses valeurs comme étant “oui” et “non” :

• 0 → non
• 1 → oui

Evidemment, un booléen est à 0 par défaut (effectivement, si on veut savoir si le joueur a ouvert un coffre dès le début du jeu, alors la réponse sera non, donc le booléen à 0). Prenons un exemple : un joueur doit appuyer sur un bouton pour permettre de débloquer une porte.

• Au début, le joueur n'a touché à rien, et le booléen est à 0.
• Le joueur a deux choix, avec le booléen à 0 :
  1. Si le joueur essaye d'ouvrir la porte, il ne peut pas.
  2. Si le joueur appuie sur le bouton, le booléen passe à 1.
• Lorsque le booléen est à 1, le joueur a à nouveau deux choix :
  1. Si le joueur appuie sur le bouton, il ne peut pas, le booléen est déjà à 1.
  2. Si le joueur essaye d'ouvrir la porte, la porte s'ouvre.

Pour résumer, on peut définir l'évènement de la porte comme une question, dont la réponse est le booléen : “Le joueur a-t-il appuyé sur le bouton ?” * “oui” (booléen = 1) → ouverture de la porte * “non” (booléen = 0) → rien

L'utilisation d'un booléen se fait grâce à la variable Bool[XX], XX étant un nombre (chaque booléen dans le jeu a son propre numéro) à demander à EditeurSO.

NB : lorsque vous avez plusieurs booléens à modifier dans vos CE, il est vivement conseillé de les inscrire de la façon suivante : Bool[3..6]=0. Cette solution est bien plus rapide que la modification ligne par ligne.
/!\ Cela ne fonctionne que pour les CE et pas pour les CD /!\

Pour ceux qui veulent des exemples concrets, je vais donner deux exemples d'évènements qui utilisent les booléens.

Le premier sera l'évènement "Coffre".

Voici le second, l'évènement "Bouton".

Maintenant que vous avez compris le principe des booléens, et en vous inspirant des exemples donnés, je vais vous donner une petite liste d'évènements que vous pouvez gérer avec un booléen, en ordre croissant de difficulté :

1. La porte : suite du bouton. L'évènement pour le bouton étant déjà fait, vous n'avez plus qu'à faire l'évènement pour la porte (en utilisant le même booléen que précédemment).
2. Le ticket de bateau : l'évènement du PNJ qui accepte ou non de vous amener sur l'île en bateau (si le booléen est à 0, le joueur n'a pas de ticket, mais s'il est à 1, alors le joueur a un ticket et peut prendre le bateau). Ne pas oublier le système des Query (voir aussi le Tutoriel de Symbiose).

Envie de défi ? Essaye de reproduire ce que tu vois sur la vidéo ci-dessous !

Solution : télécharge-moi !

Comme je le disais précédemment, dans la définition d'un booléen, une variable est une inconnue. Rappelez-vous de vos cours de maths, les inconnues sont ces “x” que l'on retrouve dans des équations de type “x-2=0” (dans cet exemple, x vaut 2, évidemment). x n'est donc pas définie, c'est une inconnue qui peut prendre plusieurs valeurs. Par exemple, si on a “x*x=4”, alors x peut prendre deux valeurs différentes, qui sont 2 et -2. Par x on va désigner une certaine valeur, que l'on ne connaît donc pas directement.

Pour résumer, la variable est une inconnue rattachée à une valeur qui peut changer, varier (d'où son nom). Sur l'éditeur, la valeur initiale d'une variable est 0 comme un booléen, et on peut la modifier de deux façons différentes :

1. soit en lui attribuant une certaine valeur, par exemple : Variable[44]=52
2. soit en l'incrémentant, c'est-à-dire en la modifiant selon son ancienne valeur, exemple : Variable[44]=Variable[44]+1

Dans tous mes exemples, nous utiliserons la Variable[44], mais c'est arbitraire : ne l'utilisez pas sans l'autorisation de EditeurSO.

NB : comme pour les booléens, lorsque vous avez plusieurs variables à modifier dans vos CE, il est vivement conseillé de les inscrire de la façon suivante : Variable[3..6]=0. Cette solution est bien plus rapide que la modification ligne par ligne.
/!\ Cela ne fonctionne que pour les CE et pas pour les CD /!\

Tout simplement comme un booléen, mais qui peut prendre une panoplie de valeurs différentes, pas seulement deux. Cela implique beaucoup plus de tests en conditions, et une variable qui peut être utilisée pour beaucoup d'états différents, pas seulement deux. Les variables sont nécessaires à un jeu comme celui-ci, et sont utilisées, par exemple pour :

1. La quête principale
2. Les mini-jeux
3. Les quêtes secondaires

Comme prévu, je vais vous donner quelques “exercices” de pratique, ne vous inquiétez pas, vous ne serez pas notés dessus ! . Ce sont simplement des exemples d'utilisation de variables pour l'éditeur de Slayers-Online (la liste est loin d'être exhaustive…). Evidemment, les exercices vont en ordre croissant de difficulté, donc commencez par le début

• La sphère de vie : vous pouvez faire le début de la quête, lorsque le roi vous envoie chercher la sphère de vie. Ici, il y aurait deux évènements : celui du roi et celui du prêtre. Pour cet exemple nous pourrons dire que le prêtre donne effectivement la sphère au joueur. Pour aller plus loin, vous pouvez également faire jouer l'évènement “roi” dans la quête du paysan et dans celle la. Cela devient un peu plus complexe, mais ce n'est pas si dur .
• Boucle presque infinie : Qu'est-ce qu'une boucle? C'est un état qui se répète à l'infini, comme l'évènement clignotement. Quelle utilisation cela peut-il avoir ? Par exemple pour faire des quêtes qui contiennent quelque chose de répétitif, et dont on ne peut sortir que si on effectue une autre action. Si vous avez des idées de boucles, vous pouvez essayer de les réaliser . Pour le moment, je vous en donne une… Lisez bien !

Pour cet exercice, vous pourrez implémenter une petite quête : le joueur devra parler à un PNJ qui l'enverra chercher son chien. Une fois le chien attrapé, le joueur revient voir le PNJ, qui lui dit qu'il s'est encore enfuit. Et ça continue tant que le joueur ira chercher son chien. La boucle s'arrête si le joueur va chercher l'os du chien avant d'aller chercher le chien (l'os se trouvant dans un placard du PNJ). Le principe de la boucle est le suivant : une fois l'action accomplie (le chien ramené), vous allez remettre la variable à la valeur qu'elle avait juste avant que l'action se fasse. Mais à partir du moment où on va chercher l'os, la variable changera, et ne reviendra pas à son état précédent.

• Jeu de dés : essayer de réaliser un jeu de dés entre le joueur et un PNJ, en deux manches gagnantes (donc trois manches au pire), en utilisant trois variables et trois booléens.

Les trois variables serviront à stocker le résultat courant du joueur, celui du PNJ, et le nombre de manches déjà jouées. Les booléens serviront à dire que la manche courante est finie, dire si le joueur a gagné une manche et dire si le PNJ a gagné une manche. N'oubliez pas de prendre en compte les matchs nuls !

Comme on l'a vu précédemment, les variables joueurs contiennent des entiers (des numéros, des chiffres, bref, un nombre). On sait également que certaines variables, comme %String1% ou autres, contiennent des string (des chaînes de caractères). Chaque variable avait donc un type associé bien défini. Or pour les variables serveur, c'est totalement différent. On peut les utiliser comme une chaîne de caractères, comme un entier ou encore comme un booléen (au choix). De plus, on peut faire exactement les mêmes opérations que sur les variables classiques. L'incrémentation par exemple, si on veut stocker des entiers dans la variable serveur :

Serveur[VariableExemple] = Serveur[VariableExemple] + 1

Ou encore le inputstring ou le concat, si l'on veut y stocker des chaînes de caractères (voir la partie sur les commandes) :

Serveur[VariableExemple] = InputString('Rentrez le nom de la variable')

Une autre chose à savoir, les variables serveur sont différentes des variables joueurs sur un autre point. Dans le jeu, les variables joueurs n'influent que sur le personnage (si votre personnage fait une quête, la variable de sa quête n'est modifiée que pour lui). Alors que les variables serveur influent sur le serveur, donc sur TOUS les personnages. Le principe d'une variable serveur est de faire des quêtes où tout le monde peut agir sur le jeu. Un exemple : Si un personnage rentre dans une pièce, qu'il appuie sur un bouton pour ouvrir une porte, alors les effets sont différents selon le type de variable :
→ variable joueur : la porte ne s'ouvre que pour ce joueur.
→ variable serveur : la porte s'ouvre pour tout le monde.

On peut utiliser les variables serveur pour bon nombre de quêtes, ou beaucoup d'autre choses. Par exemple, on peut les utiliser pour :

• Limiter l'accès d'une pièce à un certain nombre de joueurs,
• Pouvoir se marier,
• Pouvoir faire une quête où seul le premier personnage qui trouve gagne,
• Faire un mini jeu où plusieurs personnages peuvent participer,
• …

Les variables serveur sont très utiles pour une maison de guilde, un mini-jeux et d'autres fonctionnalités… Ce n'est pas tant dans les quêtes que les variables serveur vont servir, mais plutôt dans la conception de mini-jeux ou d'évènements utiles aux joueurs et qui renforcent le Role Play.

Comme pour les variables et booléens joueurs, il y a aussi des variables serveurs dits “partagées”, dont la lecture est possible mais la modification non, sauf demande spécifique…

Exemple : la variable serveur permet de connaitre le mois actuel dans la langue de Vesperae.

Voici la liste de ces variables : Variables et booléens partagés.

Lorsque l'on utilise des variables serveur, on peut en créer en appelant des variables joueurs. Par exemple (les exemples sont plus parlants dans ces cas-là), on va pouvoir créer une (enfin une multitude de) variable(s) serveur Serveur[VariableServeur%Name%]. Il existera alors autant de variables serveur que de noms de personnages différents.

Évidemment, ces manipulations demandent beaucoup de place mémoire. Il faut donc en parler à EditeurSO avant toute chose (mais ceci est réservé aux grosses quêtes, ou aux projets assez conséquents, donc inutile d'utiliser ce type de manipulation pour une maison de guilde, par exemple).

Donc pour l'exemple, on va prendre le système de l'église et du mariage. Supposons que la variable utilisée est, si le personnage s'appelle Test, Serveur[MariageTest]. Comment créer cette variable simplement, en tenant compte du nom du joueur? Tout simplement en appelant cette fonction : Serveur[Mariage%Name%]. Cette variable est initialisée à 0, comme toutes les autres. En fonction de sa valeur, on va donc pouvoir en déduire si le personnage est marié ou non.
→ Si la variable vaut 0, alors il n'est pas marié, donc lorsqu'il va s'adresser au prêtre, ce dernier va lui demander s'il veut se marier.
→ Si la variable est différente de 0, elle contient donc une chaîne de caractères, qui est en fait le pseudo de la personne avec laquelle le joueur est marié.

NB : on peut tout à fait incorporer des fonctions dans la construction de nouvelles variables. Par exemple, la variable Serveur[InputString('Rentrez le nom de la variable')] aura comme nom ce que le joueur aura écrit. Oui, ça paraît dingue, mais ça marche !

Il est possible d'utiliser des variables qui se modifient toute seule en dehors de tout schéma de code de l'éditeur. C'est la machine qui héberge le jeu qui va s'en occuper.

Vous pouvez demander à ce que la variable serveur fasse plusieurs actions comme vous pouvez le voir ci dessous.

Fonctionnement :

1. Se réinitialise à 0 à chaque relance du jeu :
   → Intégration manuelle à communiquer à EditeurSo
   
   
2. S'incrémente à chaque relance journalière (ou : par semaine, saison, année) :
   → Intégration par préfixe de la variable : Serveur[IncrementJour_Name], Serveur[IncrementSemaine_Name, Serveur[IncrementMois_Name] et Serveur[IncrementAnnee_Name]
   
   
3. Se modifie avec un aléatoire N à N2 à chaque relance journalière (ou : par semaine, saison, année) :
   → Intégration par préfixe de la variable + paramètre N et N2 pour les bornes de l'aléatoire : Serveur[RamdomJour_0_500_Name], Serveur[RamdomSemaine_0_500_Name], Serveur[RamdomMois_0_500_Name] et Serveur[RamdomAnnee_0_500_Name]