Les variables dans l'éditeur de Slayers-Online


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.

/!\NEW/!\ : 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.

  1. Introduction

  2. Booléens

  3. Variables

  4. Variables serveur

  5. Annexe

Introduction

¤ Introduction
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.

¤ Rapport avec le tutorial de Symbiose
Les tutoriaux de Symbiose seront plus que nécessaires pour les exemples, la manipulation de l'editeur, et évidemment pour la construction de quêtes.
Ce cours/tutorial sera donc un complément et une suite du tuto de Symbiose, et non une pâle copie.

¤ Plan
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.

retour au titre

Booléens

¤ Définition
- 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 :

retour au titre

¤ Utilisation
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" : 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. 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 !

retour au titre

¤ Exemples
Pour ceux qui veulent des exemples concrets, je vais donner deux exemples d'événements qui utilisent les booléens.
¤ Premier exemple
Le premier sera l'événement "coffre", pour l'ouverture d'un coffre.
Note 1 : Des commentaires sont écrits après //, ce sont des lignes qui peuvent être intégrées aux pages événements, mais ce ne sont que des commentaires que je trouve utiles pour que vous compreniez bien de quoi on parle. Pour plus d'infos sur les commentaires, voir ici.
Note 2 : le booléen utilisé sera ici le booléen 44, ou Bool[44], numéro déjà utilisé sur le jeu donc en aucun cas à utiliser dans votre projet.


/*événement coffre :*/
Page 1 :

Conditions :
Appuie sur bouton
Bool[44]=0
//Dans la première page, on va d'abord regarder que faire si le booléen n'a pas été activé. C'est donc la première fois que le joueur appuie sur le coffre

Commandes :
AddObject('potion de vie')
//Bien sûr, on peut remplacer l'objet, ce n'est qu'un exemple ;-). Mais si vous voulez faire un événement de ce type, demandez d'abord à frostfall si vous pouvez donner un objet...
Bool[44]=1
//On met le booléen à 1, ce qui veut dire que le joueur a déjà regardé dans le coffre.
 Page 2 :

Conditions :
Appuie sur bouton
Bool[44]=1
//Dans la seconde page, on va ensuite donner les instructions si le joueur a déjà pris l'objet (il ne faut pas qu'il puisse le prendre plusieurs fois, d'où l'utilité du booléen)

Commandes :
Message('Vous avez déjà pris le contenu du coffre')


Voilà, c'est fini, vous venez de créer la liste des conditions et des commandes qui permettent d'ouvrir un coffre. Mais vous me direz, pourquoi utiliser un booléen ? Et bien tout simplement pour "bloquer" le joueur, pour éviter qu'il prenne plusieurs fois le contenu du coffre.
Si vous considérez l'événement coffre comme suit, le contenu du coffre pourra être gagné par le joueur autant de fois qu'il le voudra ... NE PAS FAIRE CE QUI SUIT !

/*événement coffre :*/
Page 1 :

Conditions :
Appuie sur bouton

Commandes :
AddObject('potion de vie')

Vous l'aurez compris, cet exemple est à éviter ! Ne le faites pas, on vous accusera de tricherie !

retour au titre

¤ Deuxième exemple
Le deuxième exemple est en deux événements : le joueur doit appuyer sur un bouton pour ouvrir une porte. Je vais vous écrire l'événement du bouton, vous pourrez vous exercer en faisant l'événement de la porte.

/*événement bouton :*/
Page 1 :

Conditions :
Appuie sur bouton
Bool[44]=0

Commandes :
Message('Vous appuyez sur le bouton')
Bool[44]=1
 Page 2 :

Conditions :
Appuie sur bouton
Bool[44]=1

Commandes :
Message('Vous avez déjà appuyé sur le bouton')

Voilà pour l'événement "bouton", à vous de voir comment on peut faire l'événement "porte" ;-).

retour au titre

¤ Exercices
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 si il est à 1, alors le joueur a un ticket et peut prendre le bateau). Ne pas oublier le système des Query (voir tuto de Symbiose).
  3. Une fois que vous avez fait l'événement de validation du ticket, vous pouvez vous mettre à l'événement d'achat du ticket, le plus compliqué des deux. Le ticket coûte 7,000 PO, donc il ne faut pas oublier de tester si le joueur les a. Le booléen est le même que celui de "validation du ticket".

retour au titre

Variables

¤ Définition et utilisation
- 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) :

- Comment l'utiliser ?
Hé bien 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 : Dans la prochaine partie nous verrons des exemples détaillés, et enfin vous aurez droit à quelques exercices ...

retour au titre

¤ Exemples
Effectivement, pour la quête principale, il faut absolument des variables. Nous allons voir quelques utilisations des variables.

¤ Evénement bouton.
Pour cet exemple, je vais en reprendre un vu avec les booléens : l'événement bouton. Dans ce cas, manier une variable, c'est comme manier un booléen. A quelques points près.
Je vous explique. Ici, avec une variable, il suffit d'augmenter la variable de 1, par exemple, pour passer à un stade différent de la quête. Pour ce cas-ci, l'ouverture d'une porte en appuyant sur un bouton, la solution est simple : il suffit d'augmenter la variable de 1 lorsque le joueur appuie sur le bouton, ce qui signifiera que la porte pourra être ouverte.
Mais je vais passer à l'exemple, vous comprendrez certainement mieux.
Dans cet événement, on va considérer la variable 44. On va estimer qu'elle a une valeur de 4 avant que le joueur appuie sur le bouton. Elle aura donc une valeur de 5 une fois la porte ouverte.
Evidemment, il faudra tester plusieurs choses. Le booléen n'a que deux valeurs, donc deux tests. Mais la variable peut avoir beaucoup de valeurs, donc les tests vont être plus nombreux.
/*événement bouton_avec_variable :*/
Page 1 :

Conditions :
Appuie sur bouton
Variable[44]<4
//Là on teste si la variable n'a pas encore la valeur nécessaire pour appuyer sur le bouton.

Commandes :
Message('Le bouton est bloqué...') 		Page 2 :

Conditions :
Appuie sur bouton
Variable[44]=4
//La valeur qui permet d'appuyer sur le bouton

Commandes :
Message('Vous appuyez sur le bouton... Cela a déclenché quelque chose.')
Variable[44]=5
La valeur qui permet au joueur de passer la porte 		Page 3 :

Conditions :
Appuie sur bouton
Variable[44]>4
//On teste toutes les autres valeurs, lorsque le joueur a déjà appuyé sur le bouton

Commandes :
Message('Vous avez déjà appuyé sur le bouton. Cela ne sert plus à rien maintenant.')

Voilà pour le premier exemple. C'était un exemple facile. Comme je vous l'ai dit auparavant, essayez de faire l'événement porte qui correspond à l'ouverture de la porte en fonction de la valeur de la Variable[44] ;-)

retour au titre

¤ Le paquet du fermier
Nous allons maintenant voir un exemple, beaucoup plus explicatif pour les variables.
Au tout début du jeu, vous avez la possibilité d'aller voir un paysan (que nous appelleront PNJ 1), qui vous demandera de porter un paquet à son ami (que nous appelleront PNJ 2). Une fois porté le paquet, vous pouvez revenir voir le paysan qui vous donnera une récompense.
La question qui se pose : comment sait-il que vous êtes allé porter le paquet à son ami ? Réponse : tout simplement parce que la valeur de la variable n'était pas la même. Nous allons supposer que la variable utilisée est la variable 44 (Variable[44]), et nous allons faire un récapitulatif de ses états.
Je vous conseille fortement de faire un tableau récapitulatif de tous les états différents de la variable et de l'avancement de la quête qu'ils représentent, comme suit (je ne prétends pas détenir la solution ultime pour ce qui est de la présentation du tableau, donc faites-le comme vous voulez, mais en faire un facilite grandement les choses) :

Variable[44]
valeurs événement lié avancement dans la quête
avant changement après changement
0->1 PNJ 1 on commence la quête PNJ 1 a donné le paquet
1->2 PNJ 2 on a le paquet PNJ 2 a receptionné le paquet
2->3 PNJ 1 on a donné le paquet PNJ 1 nous donne la récompense


Maintenant, on va passer aux événements. Ici il y aura donc deux événements, PNJ 1 et PNJ 2. Dans le premier, on va devoir tester plusieurs valeurs de la variable : si elle est à 0, à 2, ou plus grande que 3. Je ferai donc 4 pages différentes, pour les différentes valeurs de la variable.

/*événement PNJ 1*/
Page 1 :

Conditions :
Appuie sur bouton
Variable[44]=0

Commandes :
InputQuery('PNJ 1 : Voulez-vous porter ce paquet à mon ami PNJ 2 s'il vous plaît ?','oui','non')
OnResultQuery('non')
Message('PNJ 1 : Tant pis, revenez me voir si vous voulez...')
OnResultQuery('oui')
Message('PNJ 1 : Merci, tenez.')
Variable[44]=1
QueryEnd 		Page 2 :

Conditions :
Appuie sur bouton
Variable[44]=1

Commandes :
Message('PNJ 1 : Hé bien allez-y, il vous attend!')
Page 3 :

Conditions :
Appuie sur bouton
Variable[44]=2

Commandes :
Message('PNJ 1 : Merci de lui avoir apporté le paquet, tenez ceci pour votre récompense')
Message('Vous gagnez un petit bouclier en bois.')
AddObject('petit bouclier en bois')
Variable[44]=Variable[44]+1
//On peut aussi mettre Variable[44]=3, mais c'est pour vous montrer qu'ici, le résultat est le même. 		Page 4 :

Conditions :
Appuie sur bouton
Variable[44]>=3
//On va supposer que le PNJ 1 ne servira plus dans le restant du jeu, donc que cette page englobe le reste des possibilités...

Commandes :
Message('Merci de m'avoir aidé l'autre jour, je n'oublierai pas!')


Maintenant passons à l'événement du PNJ 2 : ici, il faut reconnaître seulement trois états : 0, 1, et le reste (plus grand que 2) :

/*événement PNJ 2*/
Page 1 :

Conditions :
Appuie sur bouton
Variable[44]=0

Commandes :
Message('PNJ 2 : Je ne suis qu'un pauvre garde forestier....') 		Page 2 :

Conditions :
Appuie sur bouton
Variable[44]=1

Commandes :
Message ('PNJ 2 : Merci de me rapporter ce paquet !! Revenez voir PNJ 1, il vous en sera gré.')
Variable[44]=2 		Page 3 :

Conditions :
Appuie sur bouton
Variable[44]>=2
//De même que pour le PNJ 1, on va supposer ici que le PNJ 2 ne srevira plus pour le reste du jeu.

Commandes :
Message('PNJ 2 : Merci de m'avoir apporté le paquet, l'autre jour.')


Voilà pour le deuxième exemple.

retour au titre

¤ Un jeu de dés.
Le dernier exemple que je vous montrerai n'utilise pas les variables de la même façon... En fait, il s'agit ici de réaliser un mini-jeu ;-). Nous allons réaliser un jeu tout bête, un jeu de dés, par exemple, entre un PNJ et un joueur. Celui qui fait le plus gagne, et il y a match nul en cas d'égalité.
Pour cela nous allons utiliser deux événements. Un événement PNJ, bien sûr, mais aussi un événement automatique, placé n'importe où sur la carte. Et nous allons utiliser deux variables, pour les scores de chaque joueur.
Nous allons donc nous servir de deux variables : 44 et 45, par exemple. La variable 44 contiendra le score du joueur, alors que la variable 45 contiendra celui du PNJ. Nous allons également utiliser le booléen 2, qui passera à 1 lorsque les scores seront distribués dans les variables, pour permettre à l'événement automatique de commencer. Nous allons commencer par faire l'événement "PNJ", puis nous ferons l'événement Automatique, qui indiquera le vainqueur.

/*événement PNJ*/
Page 1 :

Conditions :
Appuie sur bouton

Commandes :
Message('PNJ : Nous allons commencer à jouer !')
Message('PNJ : Allez-y lancez le dé...')
Variable[44]=rand(6)
Message('PNJ : Vous faites Variable[44]. A mon tour.')
Variable[45]=rand(6)
Message('PNJ : Je fais Variable[45]')
Bool[12]=1

/*événement résultat*/
Page 1 :

Conditions :
Automatique
Bool[12]=1
//C'est ce qui provoque le déclenchement de cet événement
Variable[44]=Variable[45]
//On va maintenant tester quelle variable est la plus grande

Commandes :
Message('PNJ : Il y a match nul.')
Variable[44..45]=0
//Pour réinitialiser des variables ou des booléens qui se suivent, il faut les écrire comme ça.
//L'optimisation est meilleure pour le serveur, car une seule ligne est envoyée.
Bool[12]=0 		Page 2 :

Conditions :
Automatique
Bool[12]=1
Variable[44]>Variable[45]

Commandes :
Message ('PNJ : Vous avez gagné, bravo !')
Variable[44..45]=0
Bool[12]=0 		Page 3 :

Conditions :
Automatique
Bool[12]=1
Variable[44]< Variable[45]

Commandes :
Message('PNJ : Vous avez perdu. Retentez votre chance !')
Variable[44..45]=0
Bool[12]=0


Voilà pour cet exemple de jeu. Sachez que c'est assez facile de faire des jeux, et personnellement j'aime bien! Si vous avez des idées de jeux à me donner, ou si vous en avez fait, je me ferai un plaisir de les regarder :-)

retour au titre

¤ 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 ;-)
  1. 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.
  2. 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 ;-).
  3. Comme troisième exemple, je vous propose de faire une "boucle". Qu'est-ce qu'une boucle? Et bien 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.
  4. 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 !

retour au titre

Variables serveur

¤ Définitions et explications
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.
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 : 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

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

retour au titre

¤ Une autre spécificité
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 serveurs 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. 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 !

retour au titre

¤ Exemples
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.

¤ Panneau d'affichage de guilde
Ici nous allons voir comment mettre un panneau d'affichage modifiable par certaines personnes, dans une maison de guilde. Le message pourra être lisible par tout le monde, mais seules quelques personnes (ou seulement une seule) pourra la modifier.
Nous aurons donc besoin ici d'une et une seule variable, qui contiendra le ou les message(s), ou qui sera vide. Les fonctions que nous allons faire pourront ajouter un message, et vider le panneau de tous les messages qu'il contient. Il faudra bien évidemment également un événement pour le panneau d'affichage.
Ici nous allons utiliser la variable (par exemple), Serveur[GuildeAdminsPanneauAffichage], que nous allons utiliser dans deux événements, l'événement "affichage_panneau" et l'événement "modification_panneau"

/*événement affichage_panneau :*/
Page 1 :

Conditions :
Appuie sur bouton

Commandes :
Message('Serveur[GuildeAdminsPanneauAffichage]')
//Hé oui, c'est tout pour afficher le contenu de la variable :-)

/*événement modification_panneau :*/
Page 1 :

Conditions :
Appuie sur bouton
%Name%=Vanivan
//Ici vous pouvez mettre la condition pour laquelle on peut changer le panneau. On peut aussi le faire en fonction de la guilde et du rang du personnage au sein de cette guilde, pour réserver ceci aux chefs...

Commandes :
InputQuery('Que voulez-vous faire?','ajouter un message','tout effacer','rien')
OnResultQuery('rien')
Message('Tant pis, au revoir')
OnResultQuery('tout effacer')
Serveur[GuildeAdminsPanneauAffichage]=
Message('Voilà, c'est fait !)
OnResultQuery('ajouter un message')
Serveur[GuildeAdminsPanneauAffichage]=Concat(' Message de %Name% : InputString('Veuillez mettre votre message')')
Message('Voilà, c'est fait !')
QueryEnd
 Page 2 :

Conditions :
Appuie sur bouton
%Name%!=Vanivan

Commandes :
Message('Vous n'avez pas accès au panneau d'affichage.')

retour au titre

¤ Course de cochons

retour au titre

¤ Mariage
Pour cet exemple du mariage, le système est légèrement plus compliqué que les autres. En effet, chaque joueur a plusieurs possibilités, et il va falloir manier les variables et les appels de fonctions à l'intérieur de celles-ci, et sans se tromper, si possible !
Ce que je vais vous donner sera, je pense, correct. Si toutefois vous trouvez une erreur, signalez-le moi.
Donc pour en revenir à l'exemple, soit le personnage est déjà marié, soit il adresse sa demande à un autre personnage, soit un autre personnage le demande le mariage. Nous allons donc utiliser trois variables serveur, respectivement pour les trois raisons que je viens de citer (il est possible d'en utiliser moins, mais dans un souci de compréhension, je le ferai avec trois variables), et qui contiendront à chaque fois le nom de l'autre personnage concerné : Ensuite, nous pouvons faire un tableau résumant les possibilités du personnage, en fonction de la valeur des trois variables qui lui sont associées. Pour établir ce tableau, nous allons mettre des "priorités" : si le personnage est déjà marié, alors il ne peut demander ni recevoir de demande en mariage. S'il a reçu une demande en mariage, il peut soit l'annuler, soit l'accepter, mais il ne peut pas en faire une. S'il a effectué une demande en mariage, il peut l'annuler ou la laisser. Enfin, s'il n'a rien reçu ni envoyé, il ne peut qu'envoyer une demande en mariage.
NB : le "= 0" signifie que la variable est vide (une variable serveur est vide quand il y a 0 dedans), le "!= 0" signifie que la variable contient un nom, donc qu'elle n'est pas vide. le "XXXX" signifie que quelque soit la valeur de cette variable, ça ne change pas l'état du joueur.

Mariage
Serveur [Mariage%Name%] Serveur [MariageReception%Name%] Serveur [MariageDemande%Name%] Etat du joueur
!= 0 XXXX XXXX Le personnage est marié avec Serveur[Mariage%Name%].
= 0 != 0 XXXX Le personnage n'est pas marié, mais a reçu une demande de mariage de la part de Serveur[MariageReception%Name%].
= 0 != 0 Le joueur n'est pas marié, mais a demandé en mariage [MariageDemande%Name%].
= 0 Le joueur n'est pas marié, et n'a demandé en mariage ni reçu de demande en mariage de personne.

Voilà, nous avons notre tableau. Maintenant, l'événement qui va en découler va suivre effectivement la structure de ce dernier, tout en appliquant les changements, et en mettant en place le reste des fonctions et des changements de variables à gérer.

/*événement Mariage*/
Page 1 :

Conditions :
Appuie sur bouton
Serveur[Mariage%Name%]!=0

Commandes :
Message('Prêtre: Comment va Serveur[Mariage%Name%] ? Passez-lui le bonjour de ma part !')
 Page 2 :

Conditions :
Appuie sur bouton
Serveur[Mariage%Name%]=0
Serveur[MariageReception%Name%]!=0

Commandes :
InputQuery('Prêtre : Serveur[MariageReception%Name%] vous demande en mariage. Acceptez-vous ?','oui','non')
OnResultQuery('non')
Message('Prêtre : J'espère que Serveur[MariageReception%Name%] ne sera pas trop déçu(e)...')
Serveur[MariageDemandeServeur[MariageReception%Name%]]=0
//Remise à 0 de la variable MariageDemande%Name% du personnage qui a fait sa demande en mariage
Serveur[MariageReception%Name%]=0
//Remise à 0 de la variable MariageReception%Name% du personnage qui parle au prêtre
OnResultQuery('oui')
Serveur[Mariage%Name%]=Serveur[MariageReception%Name%]
Serveur[MariageServeur[Mariage%Name%]]=%Name%
Serveur[MariageDemandeServeur[Mariage%Name%]]=0
Serveur[MariageReception%Name%]=0
Message('Serveur[Mariage%Name%] et %Name% sont déclarés mariés !')
QueryEnd
Page 3 :

Conditions :
Appuie sur bouton
Serveur[Mariage%Name%]=0
Serveur[MariageReception%Name%]=0
Serveur[MariageDemande%Name%]!=0

Commandes :
InputQuery('Prêtre : Nous transmettons le message à Serveur[MariageDemande%Name%]. Vous voulez peut-être annuler cette demande ?','oui','non')
OnResultQuery('non')
Message('Prêtre : Bonne continuation !')
OnResultQuery('oui')
Serveur[MariageReceptionServeur[MariageDemande%Name%]]=0
Serveur[MariageDemande%Name%]=0
QueryEnd
 Page 4 :

Conditions :
Appuie sur bouton
Serveur[Mariage%Name%]=0
Serveur[MariageReception%Name%]=0
Serveur[MariageDemande%Name%]=0

Commandes :
InputQuery('Prêtre : Voulez-vous vous marier ?','oui','non')
OnResultQuery('non')
Message('Prêtre : Bonne continuation !')
OnResultQuery('oui')
Serveur[MariageDemande%Name%]=InputQuery('A qui voulez-vous faire votre demande ?')
Serveur[MariageReceptionServeur[MariageDemande%Name%]]=%Name%
Message('Nous lui transmettons la demande.')
QueryEnd


retour au titre

Annexe

¤ Commandes

retour au titre

¤ Variables relatives aux événements
Tout d'abord, il faut savoir qu'à chaque fois qu'il y a écrit NomEv, cela se réfère au nom de l'événement. Il faut donc remplacer NomEv par le nom de l'événement sur lequel vous travaillez.

retour au titre

¤ Variables relatives aux joueurs

retour au titre
Dernière MAJ le 14 Octobre 2007
© Vanivan - 2004-2007 pour Slayers-Online