Mon approche des jeux d'aventures.
----------------------------------

Comment faire un jeu d'aventure ? Voila une bonne question !
Voici donc mon approche, qui est biensur personnelle, mais qui je pense
convient dans pas mal de cas de jeux d'aventures.

Mais tout d'abord, qu'est ce qu'un jeu d'aventures ?
Pour moi, un jeu d'aventure est un jeu dans lequel le joueur volue
dans un univers compose de "pices" ou de "salles".
Le joueur peut se dplacer de salles en salles, y dcouvrir des objets,
les prendres, les posers.
Il dispose d'un minimum d'actions possibles  ffectuer (les dplacements,
prendre/poser des objets, examiner la salle, et d'autres actions simples.)
Il peut galement interagir sur les salles : par exemple, le fait
d'ouvrir une porte avec une cl permet de librer un passage bloqu
auparavent.
Il se dplace d'un point de dpart  un point d'arrive, et pour parvenir
au point d'arrive, il devra rsoudre plusieurs nigmes.
Voici donc ma petite dfinition d'un jeu d'aventures.

Les variables et les constantes
-------------------------------
Dfinissons d'abord ce que sont les variables et les constantes:
les variables peuvent voluer au cours du jeu, et lorsque le joueur
demande  faire une sauvegarde de sa partie en cours, c'est ces variables
que nous devons sauvegarder.
Les constantes, par contre, n'voluent pas au cours du jeu, mais dfinissent
la trame du jeu : le scnario.

Voyons ce que nous pouvons classer dans l'une ou l'autre des catgories...

Tout d'abord, les constantes :
- Le plan du jeu: les diffrentes salles, la position de dpart du joueur
et la position d'arrive,
- Les objets existants dans le jeu,
- Les images reprsentant chaque salles,
- Les diffrents textes  afficher au cours du jeu.

Ensuite, les variables :
- La position du joueur (la salle ou il se trouve  l'instant T),
- L'inventaire du joueur (les objets qu'il porte),
- Les objets prsents dans chaque salles,
- Le plan du jeu: les directions possibles de chaque salle.
Cette dernire variable mrite une explication : oui, le plan du jeu
est une variable, car, au cours du jeu, une direction, auparavant impossible,
peut se librer sur une action prcise du joueur (la cl dans la porte...)

Plus loin dans les structures
-----------------------------
Oui, mais avant d'aller plus loin, quelques petites prcisions :
J'ai cod P.J.A. en C. Pourquoi le C ? Pour plusieurs raisons :
- C'est un language que je connais bien ;-),
- C'est un language  la fois de haut niveau, et assez proche du coeur
du systme,
- C'est un language bien adapt pour dfinir des structures,
- C'est un language qui permet un portage facile sur d'autres plate-formes,
- C'est le language le mieux adapt  la programmation sous Windows. (Enfin,
c'est mon avis personnel.)
Donc, j'espre que vous avez de bonnes notions de programmation en language
C pour pouvoir continuer... Dsol pour les autres, mais c'est une doc.
oriente "technique"...
J'aurai galement pu m'orienter vers le C++, mais j'ai prfr gader le C
classique pour d'autres raisons:
- le C++ est plus difficilement "transposable" en assembleur (pour passer
sur CPC, il vaux mieux utiliser l'assembleur,  mon avis),
- le C++ n'est pas aussi rpandu que le C sur d'autres plate-formes,
- Je ne suis pas aussi bon en C++ qu'en C...
Cette petite mise au point effectue, continuons...

Voici la structure que j'ai utilis pour dfinir une salle :

typedef struct
    {
    BYTE Nord, Sud, Est, Ouest, Haut, Bas;
    StObj ObjetsVisibles[ MAX_OBJETS_VISIBLES ];
    StObj ObjetsDecor[ MAX_OBJETS_DECOR ];
    BYTE Cmd[ MAX_COMMANDES ];
    BYTE NumVue;
    BYTE VarBit;
    } StLieu;

Et les explications....
- Les directions : Nord, Sud... Bas : contiennent le numro de salle vers
laquelle on se dirrige en allant dans la direction choisie.
Par exemple, si nous nous trouvons dans la salle 1, et que le membre Nord
de la structure contient 2, nous allous nous dplacer  la salle 2 en allant
vers le Nord.
Si une direction est interdite, le membre contient 255.
Cela nous donne une limite aux nombres de salles : tout d'abord, le type
BYTE reprsente un octet non sign, donc variant de 0  255, ce qui limite
le nombre de salles  256. Et comme 255 est utilis pour indiquer une
direction impossible, on ramne le nombre de salles possibles  255 (de
0  254). Dans P.J.A, je me suis limit  220, ce qui fait dj un beau
jeu d'aventures je crois...
- Les ObjetsVisibles : une structure StObj, que nous verrons plus bas.
Avec une constante : MAX_OBJETS_VISIBLES. Ces objets dit "visibles" sont
les objets que le joueur pourra prendre et poser dans les salles.
- Les ObjetsDecor : mme structure StObj, avec une autre constante :
MAX_OBJETS_DECOR. Ces objets dit "decor" sont des objets que le joueur ne
pourra pas prendre. Par exemple, une porte, un mur...
- Cmd : tableau de MAX_COMMANDES. Contient les commandes que le joueur
peut excuter dans la salle.
- NumVue : indique le numro de vue  charger (=numro d'image)
- VarBit : variable teste par les actions, que nous verrons plus bas.

Bon, voyons la structure StObj :

typedef struct
    {
    BYTE NumObj;
    BYTE ModeObj;
    } StObj;

- NumObj : reprsente le numro de l'objet. Les objets serons numrots
de 0  255.
- ModeObj : reprsente le mode de l'objet. Les modes d'objets possibles
seront les suivants : rien, ferm, ouvert, eteind, allum, rempli, vide.
(Par exemple, une porte ouverte par une cl doit rester ouverte tant que
le joueur ne l'a pas referme...)

J'ai utilis un tableau de strutures StLieu pour dfinir la "carte" dans
laquelle le joueur peut voluer. C'est cette carte ainsi que quelques
autres variables qui peuvent tre sauvegardes/recharges au cours du jeu.

Voici une autre structure contenant le reste de ces variables :

typedef struct
    {
    char Identite[ 16 ];
    USHORT Version;
    char NomJeu[ 32 ];
    USHORT Taille;
    BYTE Position;
    StObj Inventaire[ MAX_OBJETS_INVENTAIRE ];
    } StJeu;

- Identite : Indique l'identit du jeu, permet de savoir que l'on se trouve
en prsence d'une sauvegarde d'un jeu.
- Version : Indique la version du jeu.
- NomJeu : Indique le nom du jeu.
- Taille : Indique la taille du reste des donnes (cette taille varie en
fonction du nombre de salles dfinies pour le jeu).
- Position : contient la position du joueur (numro de salle)  l'instant T.
- Inventaire : une structure StObj contenant les objets ports par le joueur.

Voila, pour rsumer, nos variables se composent de :
- une variable de type StJeu,
- un tableau de 220 lments de type StLieu.

Passons maintenant  nos constantes...
Voici la structure qui dfinit les constantes du jeu :

typedef struct
    {
    char Identite[ 16 ];
    USHORT Version;
    char NomJeu[ 32 ];
    BYTE DepartMin, DepartMax;
    BYTE Arrivee;
    StCmdFixe CmdLieu[ MAX_LIEU ];
    StDeclObj Obj[ MAX_OBJETS ];
    StVue Vue[ MAX_VUES ];
    StAction Action[ MAX_LIEU ][ MAX_ACTIONS ];
    StSound Mus[ MAX_MUS ];
    StSound Snd[ MAX_SND ];
    USHORT PosLibelle;
    char Libelle[ TAILLE_LIBELLE ];
    } StConstantes;

- Identite : Indique l'identit du jeu, permet de savoir que l'on se trouve
en prsence d'une sauvegarde d'un jeu.
- Version : Indique la version du jeu.
(Ces 3 constantes permettent de savoir si l'on a relu une sauvegarde
correspondant  notre jeu en cours...)
- DepartMin : position de dpart du joueur (numro de salle)
- DeparMax : position de dpart maxi du joueur. En fait, j'avais pens
dfinir une position alatoire de dpart du jeu, entre DepartMin et
DepartMax. Mais je ne sais pas si c'est facilement utilisable, et, par dfaut,
DepartMax est gal  DepartMin.
- Arrivee : position d'arrive du jeu : lorsque le joueur atteind cette salle,
le jeu est termin, le joueur est arriv au terme de son aventure.
- CmdLieu : structure de type StCmdFixe (que nous verrons plus bas), qui
permet de dfinir les commandes possibles dans chaque salles.
- Obj : structure de type StDeclObj, dcrivant tous les objets du jeu.
- Vue : structure de type StVue, dcrivant les vues de chaque salle.
- Action : structure de type StAction, qui permet d'excuter une action en
fonction du rsultat du test d'une variable et d'un masque de bits.
- Mus : structure de type StSound, pas utilise pour le moment.
- Snd : structure de type StSound, pas utilise pour le moment.
- PosLibelle : indique la dernire position libre dans le tableau des libells
- Libelle : tableau de caractres contenant tous les libells du jeu : les
libells dcrivang les salles, ainsi que les libells dcrivant les objets
(les noms des objets).

Voyons maintenant les structures utilises dans StConstantes...


typedef struct
    {
    StCommande Cmd[ MAX_COMMANDES ];
    } StCmdFixe;


typedef struct
    {
    BYTE TypeCommande;                      // Type de commande
    BYTE ObjCommande1;                      // Objets associs  la commande
    BYTE ObjCommande2;                      // Objets associs  la commande
    BYTE Resultat1;                         // Resultat obtenu
    BYTE ObjResultat1;                      // Objets associ au rsultat
    BYTE Resultat2;                         // Resultat obtenu
    BYTE ObjResultat2;                      // (apparition, changement mode...)
    } StCommande;

StCmdFixe est donc un tableau de MAX_COMMANDES structures StCommande.
StCommande contient les champs suivants :
- TypeCommande : type de commande,
- ObjCommande1 : premier objet associ  la commande,
- ObjCommande2 : second objet associ  la commande,
- Resultat1 : premier rsultat  effectuer si la commande est ralise,
- ObjResultat1 : objet associ au premier rsutat,
- Resultat2 : second rsultat  effectuer si la commande est ralise,
- ObjResultat1 : objet associ au second rsutat.

typedef struct
    {
    BYTE Type;
    USHORT PtLibelle;
    } StDeclObj;

- Type : indique le type d'objet (masculin ou fminin),
- PtLibelle : un pointeur vers le tableau de caractres, dcrivant le nom
de l'objet.

typedef struct
    {
    BYTE Face;
    USHORT PtLibelle;
    } StVue;

- Face : indique le numro de face sur laquelle se trouve l'image associe
 la salle,
- PtLibelle : un pointeur vers le tableau de caractres, dcrivant le
libell associe  la salle.


typedef struct
    {
    BYTE VarBit;
    BYTE TypeAction;
    BYTE ValParam;
    } StAction;

StAction permet d'excuter une action particulire en fonction du rsultat
de l'oprateur "AND" entre une variable et un masque de bits.
Si le rsultat est diffrent de zro, l'action est excute.
- VarBit : contient le masque de bits qui sera compar avec la variable,
- TypeAction : contient le type d'action  effectuer,
- ValParam : contient un paramtre ventuellement associ  l'action.

Remarque : Si le bit 7 de TypeAction est  1, le test s'effectue sur une
variable globale au jeu, si le bit 7 de TypeAction est  0, le test
s'effectue sur une variable locale  la salle en cours.


typedef struct
    {
    USHORT Adr;             // Adresse dbut son ou musique
    } StSound;

StSound sert  indiquer l'adresse des diffrents sons/musiques pouvant tre
jou au cours du jeu. Les sons et musiques sont au format Starkos.

Voila donc un bref descriptif des structures utilises dans P.J.A.
Voyons maintenant l'algorithme du moteur de jeu...
Premire chose  faire : lire nos donnes.
Nous allons donc lire un fichier contenant notre structure StConstantes,
et un fichier contenant une variable de type StJeu et un tableau de
x lments de type StLieu.
Ensuite, initialiser la position de dpart du joueur.
Puis, vient la boucle principale.
En fait, deux mthodes sont possibles :
- la mthode itrative (la boucle),
- la mthode vnementielle.
Sur PC, j'ai utilis la mthode vnementielle, car Windows se programme
gnralement de cette manire. Par contre, le moteur de jeu sur CPC est lui
programm de faon itrative, la boucle se contentant d'attendre une action
du joueur pour la traiter.

Donc, la boucle principale se contente de :
- excuter les actions dfinies dans la salle,
- attendre une action du joueur
- dcoder l'action que le joueur a fait,
- excuter cette action,
- vrifier si le joueur se trouve dans la salle d'arrive
- si pas arrive, alors on reboucle.



Starkos et le player Starkos sont cr par Targhan/Arkos


Pour me contacter :

http://cpc-pja.forumactif.com
