Tutorial de Vanivan

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, d'une variable ou autre, la démarche à suivre est de demander à frostfall un numéro de variable que vous pourrez utiliser.

En ce qui concerne les variables 13 à 16, et les booléens 1 à 5 et 35 à 87, ces variables et booléens sont publics, c'est-à-dire utilisables ponctuellement, dans le cadre d'un mini-jeu ou autre, du moment que ces variables et booléens sont remis à 0 à la sortie de la carte.

Pour permettre à tous de bien manier l'éditeur, dans l'optique de faire des quêtes et uniquement pour ça, j'ai été chargé de vous expliquer le fonctionnement des variables, des booléens etc. J'essaierai d'être le plus clair possible. Si vous avez des questions, envoyez-moi un mail, j'ouvrirai une FAQ.

Le Tutorial de Symbiose sera plus que nécessaire pour les exemples, la manipulation de l'editeur, et évidemment pour la construction de quêtes. Ce cours/tutorial sera donc un complément de ce dernier, et non une pâle copie.

Techniquement, je commencerai par les booléens, qui sont un moyen facile d'expliquer les variables. Ensuite nous verrons les variables tant attendues, puis les principes des quêtes. Enfin, je mettrai une annexe pour expliquer chaque variable de l'éditeur.

• Qu'est-ce que c'est ?

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.

• A quoi sert-il ? Etant donné qu'il n'a que deux valeurs possibles, (0 ou 1), on pourra l'utiliser pour, par exemple :
  1. pour savoir si un joueur a ouvert un coffre
  2. pour savoir si le joueur a un ticket de bateau
  3. pour savoir si le joueur a appuyé sur un bouton, pour débloquer une porte
  4. etc.

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 à frostfall. Il y a une chose à savoir également, c'est sur la modification de plusieurs booléens en une seule commande : écrire :Bool[3..5]=0 équivaut à écrire Bool[3]=0, Bool[4]=0 et Bool[5]=0, et la première solution est beaucoup plus rapide pour le serveur. Utilisez-les !

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", pour l'ouverture d'un coffre. C'est ici que ça se passe.

Voici le second, l'événement "bouton". A voir ici.

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. Tout d'abord, la suite du bouton et de la porte. L'événement pour le bouton est 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. Ensuite, il y a un événement intéressant dans le jeu : le ticket de bateau. En premier lieu, vous pourrez faire l'événement de “validation du ticket” : 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 Tutorial de Symbiose).

• 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 (NB : dans tous mes exemples, nous utiliserons la Variable[44], mais c'est arbitraire : ne l'utilisez pas sans l'autorisation de frostfall) :

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
3. on peut également modifier plusieurs variables en une commande, comme pour les booléens : écrire Variable[3..5]=0 équivaut à écrire Variable[3]=0, Variable[4]=0 et Variable[5]=0, et la première solution est beaucoup plus rapide pour le serveur.

• Comment l'utiliser ?

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

Dans la prochaine partie nous verrons des exemples détaillés, et enfin vous aurez droit à quelques exercices …

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

• Vous pouvez, comme pour les booléens, faire la suite de l'événement du bouton et de la porte. Vous pouvez faire l'événement de la porte, avec la variable déjà vue dans l'événement bouton.
• Ensuite, en vous inspirant de l'événement du paysan, vous pouvez faire la suite 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 .
• Comme troisième exemple, je vous propose de faire une “boucle”. 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. Si vous avez un quelconque problème de compréhension ou de conception de cet exemple, vous pouvez me demander via mail (Vanivan) ou demander sur le forum.

• Enfin pour le dernier exercice que je vous propose, je vais reprendre le jeu de dés du troisième exemple. 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. Pour compléter ceci, vous pouvez aller voir le petit paragraphe écrit ici. Si vous avez d'autres questions, envoyez-moi un mail, ou postez dans le forum éditeur du jeu ! retour au titre

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,

• pour pouvoir se marier,
• pour pouvoir montrer son animal de compagnie aux autres (j'y travaille actuellement ),
• pour pouvoir faire une quête où seul le premier personnage qui trouve gagne,
• pour faire un mini jeu où plusieurs personnages peuvent participer, etc.

Lorsque l'on utilise des variables serveur, on peut en créer en appelant des fonctions. 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. Evidemment, ces manipulations demandent beaucoup de place mémoire. Il faut donc en parler à frostfall 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 !

Nous allons maintenant nous intéresser à quelques exemples. Evidemment, ils sont beaucoup plus parlants que la théorie. De plus, vous pourrez voir que l'on peut faire vraiment beaucoup de choses grâce à ces variables serveur ! Une option utile pour maison de guilde, mini-jeux, 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.