La programmation d'un jeu de rôle est quelque chose de complexe. Cet article explique certains principes de base utilisés dans des jeux comme Ultima et Dungeon Master.
Dans les jeux de rôle informatiques, un joueur dirige les actions d'une équipe de personnages dans un monde particulier. Elles peuvent être variées : exploration, combat, discussion, commerce, etc. Les personnages sont définis par des caractéristiques physiques, mentales et des compétences, La manière dont ils agissent sur le monde extérieur dépend de ces dernières {un personnage très fort physiquement se battra bien, un personnage très intelligent apprendra vite); Chaque personnage peut posséder un certain nombre d'objets divers et variés (vêtements et armures pour se protéger des dangers du monde extérieur, armes pour combattre, argent, nourriture, etc.)
Les personnages sont définis par des caractéristiques numériques. Leur nombre peut varier selon le degré de simulation. Je vous propose ici un système simplifié comportant trois caractéristiques physiques (Force, Agilité, Constitution) et trois autres mentales (Intelligence, Volonté, Pouvoir). Le Pouvoir représente la capacité d'un personnage à percevoir la nature véritable de l'univers. C'est une caractéristique qui ne sert que pour la magie (univers médiéval fantastique) ou pour les pouvoirs mentaux (univers de science-fiction).
Une valeur numérique ne signifie pas grand-chose sans une échelle de référence. Pour donner une base de comparaison entre les caractéristiques et la réalité, on considère que la valeur 10 correspond à la moyenne humaine. Un personnage avec une Force, une Dextérité et une Constitution de 10 est un homme tout à fait normal, Des personnages exceptionnels tels que Conan ou Rambo ont une force de 17 ou 18.
Nous venons de voir sont les caractéristiques principales. Un personnage possède aussi un ensemble de caractéristiques secondaires, calculées à partir des principales. Elles définissent les réactions du personnage dans un cas précis. Ces caractéristiques secondaires peuvent être : le nombre de points de vie, le bonus au dommage, la résistance au poison, la résistance aux maladies, etc.
Le nombre de points de vie correspond à la vigueur d'un personnage, Plus il est robuste, plus il peut encaisser de coups avant de mourir. Un personnage chétif (avec une faible Constitution) meurt d'un coup un peu violent. Plus un personnage est fort, plus il cause de dommages à son adversaire. Le bonus au combat simule cet effet, il s'ajoute aux dommages causés par une arme.
La résistance au poison est un pourcentage qui détermine les chances qu'a un personnage de résister aux effets d'un poison. De même, la résistance à la maladie est un pourcentage qui détermine les chances qu'a un personnage de ne pas attraper une maladie.
Les caractéristiques principales et secondaires de tous les personnages sont stockées dans un tableau numérique.
DIM def_perso(4,50) ' ------------------------- ' 1 = Force perso ' 2 = Dextérité perso ' 3 = Constitution ' 4 = Intelligence ' 5 = Volonté ' 6 = Pouvoir ' ------------------------- ' 7 = Points de vie ' 8 = Bonus dommage ' 9 = résistance au poison ' … ' -------------------------
Les caractéristiques secondaires sont calculées par le programme. Le bonus au dommage est en fonction de la Force, Le nombre de points de vie peur être égal à la Constitution, La résistance au poison peut dépendre de la Constitution & de la Volonté, La valeur du bonus aux dommages est stockée dans un tableau. Cette technique permet de changer facilement la valeur d'un coefficient. Dans cet exemple, les bonus de dommages ne montent pas au-delà de 18, mais rien ne nous empêche d'aller plus loin, Il peut servir pour des créatures non humaines (un éléphant à une force de 30).
DIM bonus_degat(18) ' PROCEDURE init_bonus LOCAL 1 RESTORE bonus_dommage FOR i=1 TO 18 READ bonus_degat(i) NEXT i RETURN ' Bonus_dommage: DATA 0,0,0,0,0,0,0,0,0,0,0,1,1,2,3,4,5,7 Bonus_dommage = bonus_degat(force) Points_vie = constitution Resist_poison = constitution+(volonte/2) Resist_maladies = constitution*volonte
Les valeurs sont stockées dans le tableau def_perso() à la suite des caractéristiques principales.
Lorsqu'un personnage reçoit des dégâts (combat, empoisonnement, chute, etc.), le programme diminue son nombre de points de vie, 51 celui-ci combe à zéro, le personnage est mort. 5i le personnage blessé reçoit des soins (guérisseur où potions), le programme remonte le nombre. Les points de vie pouvant varier en cours de jeu, 1l faut séparer les points de vie théoriques des points de vie variables, Ceux-ci sont stockés dans un tableau spécial.
DIM points_vie(4)
Supposons qu'un personnage se fasse empoisonner à un moment quelconque du jeu, le programme doit alors déterminer l'effet du poison: il peut Être sans effet sur le personnage ou le foudroyer sur place. La caractéristique Résistance au Poison est un pourcentage. Le programme tire un chiffre compris entre 1 et 100.
Si le résultat est inférieur où égal à la résistance au poison du personnage, tout va bien. Dans le cas contraire, il perd un certain nombre de points de vie (dépendant de la puissance du poison).
En plus de ces caractéristiques physiques, un personnage sait faire un certain nombre de choses: se battre, soigner les blessures, évaluer là valeur d’un objet, etc. Ce sont des compétences. Elles sont définies sous la forme de pourcentages. Un personnage débutant à 10% de chance de toucher un ennemi au combat, alors qu’un combattant expérimenté a 90% de chance d'y parvenir. Les compétences les plus courantes dans un jeu de rôle basé sur un univers médiéval-fantastique sont: combattre, soigner, fabriquer des potions, chasser, trouver des herbes, dérober discrètement des objets, déceler les pièges et ouvrir des serrures.
Les compétences des personnages sont stockées dans un tableau numérique. Chacune a son numéro d'ordre, Le premier indice du tableau correspond au numéro du personnage.
DIM compétence(4,100) ' 1 = Compétence combat ' 2 = Compétence soins ' 3 = Compétence trouver herbes ' 4 = Compétence fabriquer potions ' 5 = Compétence voler objets
Le degré de compétence d'un personnage dépend de ses dons naturels. Plus ses caractéristiques sont élevées, plus ses compétences de base sont importantes. La capacité de combat de base peut dépendre de la Force, de la Dextérité de l’Intelligence, La capacité de base de soins peur dépendre de la Dextérité et de l'Intelligence, etc.
Lors de la création d'un personnage, une routine spécifique détermine ses compétences de base à partir de ses caractéristiques. Dans l'exemple suivant, I compétence de combat de base est calculée en faisant la moyenne de la Forée, la Dextérité et l'Intelligence, puis en comparant cette moyenne à une série de chiffres précis. Toutes les compétences de base sont calculées de la même manière
' COMPETENCE DE COMBAT DE BASE moyenne=(force+dexterite+intelligence)/3 SELECT moyenne CASE 3 TO 11 combat base=0 CASE 12 TO 14 combat base=10 CASE 15 TO 16 combat base=15 CASE 17 combat base=20 CASE 18 combat base=30 EMDSELECT
En plus des compétences de base qui dépendent des caractéristiques, les personnages disposent de compétences professionnelles qu'ils ont appris dans leur jeunesse Pour simplifier la programmation, on considère qu'il n'existe qu'un petit nombre de métiers. Chacun augmente certaines compétences. Les personnages doivent obligatoirement choisir l'un des métiers proposés. La nature de ces derniers dépend de l'univers du jeu. Par exemple, on peut trouver les métiers suivants dans un univers médiéval-fantastique: guerrier, guérisseur et voleur.
Celui de guerrier apporte des compétences de combat, celui de guérisseur des compétences de soins et le métier de voleur des compétences de combat limitées, ainsi que des facilités pour dérober des objets et trouver des pièges. On trouve souvent le métier de sorcier, mais la gestion de là magie est trop compliquée pour être abordée dans cet article. Nous y reviendrons ultérieurement.
Le tableau métier() sert à mémoriser le métier de base des personnages. La procédure INIT_METIER initialise automatiquement les compétences professionnelles d'un personnage selon le métier choisi. Les guerriers augmentent leurs compétences de combat de 40%. Les guérisseurs augmentent leurs compétences de soins, pour chercher des herbes et fabriquer des potions de 20%. Les voleurs augmentent leurs compétences de 10% en combat et de 30% sur le vol. Les compétences professionnelles s'ajoutent à celles de base.
DIM metier(4) FROCEDURE init_metier(perso) LOCAL metier% ' metier%=metier(perso) SELECT metier% CASE 1 ! TEST GUERRIER ADD competence(perso,1},40 CASE 2 ! TEST GUERISSEUR ADD competence(perso,2},20 ADD competence(perso,3),20 ADD competence(perso,4},20 CASE 3 ! TEST VOLEUR ADD competence(perso,1),10 ADD competence(perso,5),30 ENDSELECT RETURN
Les compétences peuvent augmenter avec le temps. Lorsqu'un personnage à vécu quelques aventures (explorer la région, tuer des monstres, trouver des trésors, etc.), il à acquis des points d'expérience utilisables pour améliorer ses capacités, Il doit se rendre dans un lieu précis (université, professeur d'escrime) et échanger ses points d’expérience contre des points de compétences.
Si un personnage veut frapper un ennemi, le programme doit lire la compétence de combat du personnage et faire un tirage aléatoire. Si lé résultat est inférieur ou égal à la compétence de combat, le coup porte. il faut alors calculer sa force. Le calcul est fait en tenant compte du type d'arme utilisé pour frapper et du type de protection porté par l'ennemi. Lorsqu'un personnage veut accomplir une action particulière, le programme suivra toujours la même démarche: calcul des chances de réussite de l'action, tirage d'une valeur aléatoire pour déterminer si l’action a réussi et traitement du résultat. Ce dernier point débouche sur des situations différentes, selon que l'action est réussie ou non. Prenons un exemple où un personnage essaye de trouver des plantes dans un coin de foret. En cas de réussite, le programme détermine quelle a été la plante trouvée. En cas d'échec, il ne se passe rien. Et maintenant, prenons Un autre exemple où un personnage tente de voler la bourse d'un passant. En cas de réussite, il s'en empare sans problèmes. En cas d'échec, le passant s’aperçoit de la tentative de vol et peut décider de frapper le voleur.
La création d'un personnage se fait en plusieurs étapes: tirage aléatoire des caractéristiques, calcul des caractéristiques secondaires, calcul des compétences de base et définition du métier du personnage.
Les caractéristiques sont tires au hasard afin de donner des personnages différents, La technique de tirage la plus utilisée met en œuvre 3 tirages différents: on tire 3 fois au hasard un nombre compris entre 1 et 6. On additionne ensuite le tour. Le résultat et un nombre qui varie entre 3 et 18, Cette technique permet d’obtenir un maximum de résultats moyens (9,10,11) et un minimum de chiffres extrêmes (3,4,17,18) Cela correspond bien à la réalité où la majeure partie des gens ont des caractéristiques moyennes et où les extrêmes (force fabuleuse, faiblesse pathologique, très grande dextérité, etc.) sont rares.
Elle pose de nombreux problèmes, il faut définir leurs caractéristiques et les stocker quelque part en mémoire. Les personnages peuvent posséder divers objets et en porter plusieurs sur eux (habillement,armes, armures, etc.)
Les objets sont définis par leurs effets sur l'environnement, Une arme est quelque chose qui fait mal. Un habit ou une armure est un objet qui exerce une fonction de protection. La nourriture est un objet qui redonne des forces, etc. Il existe des classes d'objets. Une épée et une hache sont des armes Un morceau de pain, de la viande grillée, un ragoût de mouton et des épinards sont de la nourriture. Un objet à une classe [Arme, Nourriture, Habits, etc.), et un type (Epée, Hache, Pain, Viande, etc.). Les objets d'une même classe ont la même fonction (toute les armes font des dégâts), mais la manière dont ils agissent dépend de leurs caractéristiques propre (un couteau cause moins de dégâts qu'une Épée, un morceau de pain sec nourrie moins bien qu’un morceau de viande, etc.).
L’avantage de travailler avec des classes d’objets, c'est que le programme n'a besoin que d'une seule routine de traitement par classe d’objet. Prenons comme exemple la nourriture, La fonction de la nourriture est de redonner force & vitalité à celui qui en mange.
Considérons qu'un homme moyen à 20 points de vie. Après un jeûne d'une journée et diverses actions {déplacement, combat, etc.), il à perdu des forces. Il ne lui reste plus que 12 points de vie Il à le choix entre plusieurs types de nourriture : pain sec, viande, ou fruits. Une portion de pain permet de récupérer 2 points de vie, une de viande 6 points et de fruits 3 points. La nourriture est définie par un nom et un chiffre représentant son effet.
Pour la routine de traitement de la nourriture, la seule chose qui compte, c'est l'effet de la nourriture sur la vitalité-du personnage, On peur donc s’amuser à définir un grand nombre de nourritures différentes: On peut rajouter des caractéristiques supplémentaires afin d'améliorer le degré de réalisme la nourriture peut avoir un prix. Il est possible qu'un personnage préfère manger 3 portions de pain plutôt qu'une de viande si la viande coûte trop cher. Le prix peut être calculé dans n'importe quelle monnaie.
Les caractéristiques des objets sont stockées dans des tableaux de données. Chaque classe d’objet a son propre tableau, La classe d'un objet indique le tableau où il faut chercher ces caractéristiques, et le type de l'objet indique la position des caractéristiques dans le tableau.
Les caractéristiques des objets sont définies initialement par le programmeur dans des lignes de DATA, Une routine d'initialisation spécifique charge les informations dans les tableaux de données correspondants. Afin de vous donner quelques exemples, nous allons définir les classes d’objets NOURRITURE, ARME, et ARMURE.
Les objets de type NOURRITURE sont définis par un nom, un chiffre représentant leur effet sur un personnage et un prix. Il faut deux tableaux pour mémoriser les objets de ce type. Le premier tableau contient le nom, le second la valeur de l'effet “restaurateur” et le prix du produit.
DIM def_nourriture$(100) DIM def_nourriture(100,2) ' def_nourriture$(n) = Nom nourriture n ' def_nourriture(n,1) = Effet “restaurateur” ' def_nourriture(n,2) = Prix
Les objets de type NOURRITURE sont définis dans des lignes de DATA Les tableaux de données sont remplis par la routine INIT_NOURRITURE Cette routine stockera lé nombre d’objets lus dans la variable globale nb_nourritures.
PROCEDURE init_nourriture LOCAL nom$,n n=0 RESTORE nourritures DO READ nom$ EXIT IF nom$="#FIN" INC n def_nourriture$(n)=nom$ READ def_nourriture(n,l) READ def nourriture(n,2) LOOP nb_nourritures=n RETURN ' nourritures: DATA PAIN SEC,2,1 DATA VIANDE GRILLEE,6,10 DATA FRUITS,3,5 DATA *FIN
Le pain aura le numéro 1, la viande grillée aura le numéro 2, et les fruits porteront le numéro 3. Vous pouvez vous amuser à en définir bien d'autres types.
Les armes servent à infliger des dégats. L'importance des dommages dépend du type d'arme (un canif ne fait pas autant de dégâts qu’une hache de bataille). Pour définir le potentiel destructeur des armes, nous nous sommes basés sur le nombre de points de vie moyen des personnages, Avec une moyenne de 10 points de vie par personnage, nous avons défini les armes suivantes : poignard (2 points de dégâts), épée (5 points de dégâts), hache (5 points de dégâts) et hache de bataille (7 points de dégâts). Les armes sont définies par leur nom, leurs points de dégâts et leur prix. Elles sont stockées dans les tableaux def_arme$() et def_arme().
DIM def arme$(100) DIM def arme(100,2) ' def_arme(n) = Hom arme n ' def_arme(n.1) = Dégat arme n ' def_arme(n,2) = Prix arme n
Les armes sont définies par le programmeur dans des lignes de DATA. La procédure INIT_ARMES remplie les tableaux def_arme$() et def_arme().
PROCEDURE init_armes LOCAL nom$,n n=0 RESTORE armes D0 READ nom$ EXIT IF nom$="*FIN" INC n def_armes(n)=nom$ READ def_arme(n,1) READ def_arme(n,2) LOOP nb_armes=n RETURN armes: ' DATA nom, dégat, prix DATA POIGNARD, 3,0 DATA MASSE,3,20 DATA EPEE,5,200 DATA EPEE LONGUE,6,500 DATA HACHE,5,130 DATA HACHE DE BATAILLE,7,750 DATA *FIN
Les créatures rencontrées par les personnages ont des armes, Celles-ci peuvent être des objets manufacturés tels que des épées, des gourdins, des haches, mais aussi des armes naturelles comme des griffes, des crocs, des tentacules, etc.
DATA GRIFFES,4,-1 DATA CROCS,5,-1 DATA TENTACULES,3,-1 DATA *FIN
La valeur numérique -1 indique au programme qu'il s'agit d'armes naturelles, que l’on trouve uniquement sur des créatures, Les personnages ne peuvent pas les acheter et s'en servir. Le programme aura besoin d'informations sur les armes en cours de jeu. Les fonctions DOMMAGE_ARME e PRIX_ARME permettent d'obtenir facilement ces informations.
FUNCTION dommage_arme(arme) RETURN def_arme(arme,1) ENDFUNC ' FUNCTION prix_arme(arme) RETURN def_arme(arme,2) ENDFUNC
Les armures sont des systèmes défensifs. Au point de vue simulation, elles encaissent un certain nombre de points de dégàts.
Une armure est définie par un nom, un potentiel de protection et un prix.
DIM def armure${100) DIM def armure(100,2) ' def armure$(n} = Nom armure n ' def armure(n,1) = Protection armure n ' def armure(n,2) = Prix armure n
Lorsqu'un personnage reçoit ds points de dégâts suite à une attaque, le programme doit tenir compte de la présence éventuelle d'une armure et diminuer les dégâts en fonction du type d'armure:
Dommages reçus = Dommages Reçus - Protection armure
Les caractéristiques des armurés sont définies dans des lignes de DATA, puis chargées dans les tableaux de données par une routine d'intialisation spécifique.
PROCEDURE init_armures LOCAL nom$,n ' n=0 RESTORE armures DO READ nom$ EXIT IF nom$="#FIN" INC n def_armure$(n)=nom$ READ def_armure(n,1) READ def_armure(n,2) LOOP nb_armures=n RETURN ' armures: ' DATA Nom, Protection, Prix DATA HABITS DE MENDIANT,1,10 DATA VESTE DE TOILE,O,20 DATA VETEMENTS DE CUIR,1,100 DATA ARMURE DE CUIR,2,300 DATA COTTES DE MAILLES,3,1000 DATA ARMURE DE PLAQUES,5,4000 DATA *FIN
Les créatures rencontrées par les personnages peuvent avoir des armures. Si ce sont des créatures intelligentes, elles peuvent avoir le même type d'armure que les personnages. Si ce sont des créatures non-intelligentes, l'armure peut faire parté de leur morphologie (écailles, fourrure épaisse, cuir épais, etc.).
DATA PEAU EN ECAILLES,2,-1 DATA CUIR EPAIS,2,-1 DATA FOURRURE EPAISSE,1,-1 DATA *FIN
La valeur -1 indique que ces armures sont naturelles et les personnages ne peuvent pas les acheter où les utiliser.
Les fonctions PROTECTION_ARMURE et PRIX_ARMURE fournissent au programme les informations dont 1l à besoin pour une armure particulière.
FUNCTION protection_armure(armure) RETURN def_armure(armure,1) ENDFUNC ' FUNCTION prix_armure(armure) RETURN def_armure(armure,2) ENDFUNC
Voici quelques autres types d’objet que vous pouvez définir: bouclier(nom,protection,prix), médicaments (nom, type de maladies soignées, puissance, prix), objets précieux (nom, prix} documents(nom, texte, prix), boissons (nom, effet, prix), anneaux magiques(nom, prix), poisons (nom, puissance du poison, prix), etc.
Pendant le déroulement du jeu, les personnages possèdent des objets, ils peuvent les acheter, les voler, les trouver dans un trésor où sur le cadavre d'un ennemi.
Le programme doit donc conserver la liste des possessions. Celles-ci sont de 2 types: les objets que les personnages portent sur eux (des armes, des vêtements, des armures, etc.) et les objets conserves dans un sac (de la nourriture, des objets précieux, des armes, des parchemins, des médicaments, etc.)
Les sacs peuvent être gérés selon plusieurs techniques. Chacune à ses avantage et ses inconvénients. La méthode la plus simple est d’avoir une variable pour chaque type d'objet, Cela n'est valable qu’avec un petit nombre d’objets différents.
Les armes sont mémorisées dans le tableau sac_arme(). Ce tableau est commun à tous les personnages. Le premier indice indique le personnage concerné Les dimensions du tableau dépendent du nombre de personnages dans l'équipe et du nombre maximal d'armes (100 dans l'exemple suivant).
DIM sac arme(4,100)
La variable sac_arme(n,1) contient le nombre de POIGNARDS possédé par le personnage n. La variable sac_arme(n,2) contient le nombre de MASSES détenu par le personnage n, etc. Le numéro des armes est celui de création dans les lignes de DATA, Le POIGNARD est la première arme définie, il porte lé numéro 1, La MASSE est la seconde arme définie, elle porte donc le numéro 2, etc. Attention: en changeant la position d’une arme en DATA, on modifie son numéro.
Pour augmenter le nombre d'armes possédé par un personnage, il suffit d'incrémenter l'élément de tableau correspondant. La procédure AJOUT_ARME ajoute une arme de type arme aux possessions du personnage perso.
PROCEDURE ajout_arme(perso,arme) INC sac arme(perso,arme) RETURN
La fonction TST_ARME permet de connaître le nombre d'armes d'un type quelconque possède par un personnage.
FUNCTION tst_arme(perso,arme) RETURN sac_arme(perso,arme) ENDFUNC
La procédure PRENDRE_ARME permet de prendre une arme d'un type précis dans le sac d'un personnage. Pour éviter les erreurs, il est préférable d’utiliser TST_ARME afin de savoir si il y a au moins une arme de ce type dans le sac.
PROCEDURE prendre_arme(perso,arme) IF sac_arme(perso,arme)<>0 DEC sac_arme(perso,arme) ENDIF RETURN
Les armures sont gérées de la même manière que les armes, Le tableau sac_armure() contient les armures des personnages de l'équipe.
DIM sac_armure(4,100)
La procédure AJOUT_ARMURE permet d'ajouter une armure à un personnage. Elle fonctionne selon le même principe que la procédure AJOUT_ARME Les routines TST_ARMURE et PRENDRE_ARMURE permettent de tester le nombre d'armures possédées, et de retirer une armure à un personnage.
PROCEDURE ajout_armure(perso,armure) INC sac_armure(perso,armure) RETURN ' FUNCTION tst_armure(perso,armure) RETURN sac_armure(perso,armure) ENDFUNC ' PROCEDURE prendre_armure(perso,armure) IF sac_armure(perso,armure)<=0 DEC sac_armure(perso,armure) ENDIF RETURN
Tous les types d'objets peuvent être stockés de la même manière que les armes et les armures: avec un tableau spécifique et quelques routines de manipulation d'objets.
DIM sac_bouclier(4,100) DIM sac_nourriture(4,100) DIM sac_boisson(4,100) DIM sac_potion(4,100) DIM sac_anneaux(4,100) DIM sac_bijoux(4,100)
Cette méthode est simple à mettre en œuvre, mais elle à le défaut de multiplier le nombre de tableaux. La place mémoire perdue peut devenir très importante.
L’équipement des personnages de notre petit programme d'exemple se limite à une arme et à une armure. Cet équipement est stocke dans le tableau equipement_perso(). Lorsqu'une case de ce tableau contient 0, le personnage n'a pas l'équipement correspondant.
DIM equipement_perso(4,2) ' eguipement_perso(p,1) = Arme perso p ' equipement_perso(p,2) = Armure perso p
Le joueur doit pouvoir mettre ou enlever de l'équipement à ces personnages. Il faut donc avoir des routines dé manipulation de l'équipement. La procédure METTRE_ARME permet de donner une arme particulière à un personnage. Si celui-ci à déjà une arme en main, elle est stockée dans ses possessions.
PROCEDURE mettre_arme(perso,arme) LOCAL old_arme ' old arme=equipement_perso(perso,1) IF old_arm==0 @ajout_arme(perso,old_arme) ENDIF equipement_perso(perso,1)=arme RETURN
La procédure ENLEVER_ARME retire l'arme présente dans les mains d'un personnage et met celle-ci dans ses possessions.
PROCEDURE enlever_arme(perso) LOCAL arme armes=equipement_perso(perso,1) IF arme<>0 @ajout_arme(perso,arme) equipement_perso(perso,1)=0 ENDIF RETURN
La fonction ARME_PERSO fournit au programme l'arme utilisée par un personnage. Si le personnage n'a aucune arme en main, elle donne la valeur O.
FUNCTION arme_perso(perso) RETURN equipement_perso(perso,1) ENDFUNC
Les armures peuvent être manipulées de la même manière que les armes. Les procédures METTRE_ARMURE et ENLEVER_ARMURE permettent de revêtir une armure et de la retirer.
PROCEDURE mettre_armure(perso,armure) LOCAL old_armure ' old_armure=equipement_perso(perso,2) IF old_armure<>0 @ajout_armure(perso,old_armure) ENDIF equipement_perso(perso,2)=armure RETURN ' PROCEDURE enlever_armure(perso) LOCAL armure ' armure=equipement_perso(perso,2) IF armure<>0 @ajout_armure(perso,armure) equipement_perso(perso,2)=0 ENDIF RETURN
La fonction ARMURE_PERSO permet de connaître l'armure portée par le personnage. Si celui-ci n'a pas d'armure, elle donne la valeur 0.
FONCTION armure_perso(perso) RETURN equipement_perso(perso,2) ENDFUNC
Dans cet exemple, l'équipement est réduit au minimum (une arme et une armure). Rien n'empêche d'améliorer le système et de permettre aux personnages d’avoir des poches, un objet à la ceinture, une amulette autour du cou, des anneaux aux doigts, etc. Vous pouvez même détailler l'habillement (pantalons, vestes, chaussures, etc.).
Les combats que livrent les personnages font intervenir les compétences (compétence de combat), les caractéristiques secondaires (bonus de dommage et points de vie) et l'équipement (armes et armures), Un personnage frappant sur une créature quelconque lui cause des dégâts qui sont calculés en fonction du type d'arme, de la force du personnage et de la protection de la créature. La routine DOMMAGE_CREATURE calcule les dégâts reçue par une créature lorsqu'elle reçoit un coup du personnage perso.
FUNCTION bonus perso(perso) RETURN def_perso(perso,8) ENDFUNC ' FUNCTTON dommage_creature(perso,creature) LOCAL arme, dommage arme=@arme_perso(perso) dommage=@dommage_arme(arme) ADD dommage, @bonus_perso(perso) SUB dommage,@protection_creature(creature) IF dommage=<0 dommage=0 ENDIF RETURN dommage ENDFUNC
La routine PROTECTION_CREATURE n'est pas définie dans cet article. Elle fait partie-du module de gestion des créatures qui n'est pas détaillé ici, faute de place. Les créatures se gèrent comme les personnages, mais d'une manière moins détaillée.
Cet article vous à présenté quelques notions indispensables pour comprendre le fonctionnement interne des Jeux de rôle, C'est un article incomplet car le sujet est vaste.
dans un univers virtuel, des dialogues avec les créatures, des problèmes de représentation graphique, sujets traités dans les autres articles de la série.
