La programmation d'un jeu de rôle façon Ultima passe par la réalisation d'un éditeur capable de définir la carte d'un monde médiéval fantastique.

Dans les jeux de rôle de type Ultima ou Fantaisy (liste non limitative), le joueur gère les actions d'une équipe de personnages. Celle-ci se déplace sur une grande carte représentant l’ensemble du monde de jeu. Seule une partie de la carte est affichée à l'écran. C’est une sorte de fenêtre de visualisation qui se déplace sûr là carte totale. Lorsque que les personnages se déplacent, la fenêtre montre une nouvelle position.

L'univers de jeu doit être vaste pour que le joueur ait le plaisir de l'explorer. Cela nous empêche de stocker le dessin de la carte sous la forme d'une image, pour des raisons de place mémoire. une image de 320×220 pixels en basse résolution occupe 32 Ko. Une image de 1600×800 pixels, équivalent à un espace de 5×4 images écrans, occupe une place mémoire de 640 Ko. C'est beaucoup trop pour un 520 ST et même pour un 1040 ST, en tenant compte de la taille prise par le programme et les autres données graphiques.

Au lieu de stocker l’image de la carte en mémoire, on peut la redessiner avec des éléments de base. Une foret peut être dessinée avec 6 ou 7 éléments, une rivière ou un plan d'eau n'ont pas non plus besoin de de beaucoup d’éléments différents. A la rigueur, une forêt peut être dessiné avec une seule petite image représentant un arbre, et la montagne avec un seul élément représentant la silhouette d'une cime. c'est le procédé utilisé par bon nombre de logiciels de jeu du commerce. Pour des raisons techniques qui tiennent plus à l'organisation des mémoires vidéos, les éléments ont le plus souvent une taille de lôx16 pixels ou 32×32 pixels.

Une carte est alors mémorisée sous la forme d'une liste d’éléments graphiques. On peut stocker cette liste dans un tableau numérique à deux dimensions, dont le type dépend du nombre d'éléments possibles. Avec moins de 256 éléments, ce qui est déjà énorme, on peut utiliser un tableau de type BYTE (symbole |), chaque élément du tableau n'occupant qu'un octet en mémoire.

Avec des éléments de 16×16, une carte de 1600×800 pixels peut être stockée dans un tableau de 100×50 cléments, occupant une place mémoire de 5000 octets. Sa déclaration se fait de la manière suivante:

OPTION BASE 1
DIM carte<PIPE>(100,50)

L'instruction OPTION BASE 1 force le basic à numéroter ces tableaux à partir de l’indice 1 et non 0. Pour calculer le gain de mémoire entre les deux méthodes, il faut prendre en compte la place mémoire prisé par les éléments graphiques.

Un élément graphique de 16×16 pixels stocké dans une variable alphanumérique grâce à l'instruction GET occupe une place de 134 octets, ce calcul ayant été fait avec l'instruction LEN qui détermine la taille d'une variable alphanumérique.

GET 1,1,16,16,varf
PRINT LEN(vars)

L’expérience montre que l'on peut dessiner des cartes complètes avec bien moins de 200 éléments différents. C'est donc une valeur limite acceptable pour faire quelques calculs. Vous utiliserez certainement moins de 200 élements pour créer vos propres cartes. Pour la petite histoire, les premiers jeux Ultima ont été dessinés avec seulement quelques dizaines d'éléments. Le stockage de 200 éléments graphiques prend 26800 octets.

DIM element$(200)

En additionnant la place prise par le codage de la carte t par 200 élements graphique, on arrive à un total de 31800 octets (5000+26800), Dans notre cas particulier, le gain de place apporté par le codage de la carte est de 20, mais s'améliore considérablement si la carte est plus grande que 100×50 cléments ou si le nombre d'objets graphique est plus petit que 200.

Cette technique offre un gros avantage pour le développement d'un logiciel: la carte est facile à dessiner une fois que les éléments de base sont créés.

Même un non-graphiste peut réaliser une jolie carte à partir de beaux éléments de base.

La portion de carte affichée par les jeux Ultima a une dimension de 176×176 pixels, et se constitue de 11×11 éléments de 16×16 pixels. La position de l'équipe de personnages est visualisée par une silhouette en noir affichee au milieu de l'écran.

Lors des déplacements, l'image de la carte est redessinée de manière à ce que l'équipe soit toujours au centre de l'image visible.

Pour réaliser un systéme de déplacement similaire à celui d'Ultima en GFA Basic, il faut résoudre un certain nombre de problèmes techniques. Nous avons déjà vu que le codage de la carte peut être stocké dans un tableau numérique et les éléments graphiques de base dans un tableau alphanumérique, mais il reste bien des questions à étudier. Comment est-ce que les éléments graphiques sont stockes dans le tableau alphanumérique? Comment afficher rapidement là carte aussi bien sur un STF que sur un STE? Comment stocker les différentes données sur disque? Comment gérer les déplacements de l'équipé sur la carte?

Toutes ces questions sont trop difficiles à gérer dans un seul article, c'est pourquoi ce texte est séparé en deux parties: la première est consacrée à la création d'une carte et la seconde traite de son utilisation pour gérer les déplacements de l'équipe.

On suppose que les éléments graphiques de base ont été dessinés par un graphiste avec un logiciel de dessin type Degas Elite où équivalent. Nos précieux éléments sont donc stockés sur disque dans une image au format Degas, Le programme GENELEM,GFA lit l'image Degas ELEMENTS.P11 et stocke les éléments graphiques dans un fichier binaire ELEMENTS.BIN réutilisable par un autre programme.

La structure du fichier binaire est la suivante: 32 octets contenant la palette de couleur des éléments graphiques, un octet unique contenant le nombre d’éléments du fichier et le codage des éléments, chacun occupant 134 octets. La position (x,y) des éléments sur l'image est définie dans une série de DATA à la fin du programme, la fin des données étant signalé par la valeur -l

' ******************************
' * GENÉRATEUR FICHIER BINAIRE *
' *    ELEMENTS GRAPHIQUES     *
' ******************************
RESERVE 100000
DIM element$(200)
nb_elements%=0
palette$=SPACE$(32)
'
@load_dzgas("ELEMENTS.PI1")
@saisie_elements
@sauve_elements({"ELEMENTS.BIN")
END
'
' ******************************
' * CHARGEMENT IMAGE           *
' *    DEGAS ELITE             *
' ****************************** 
'
' **********************************
' * La palette est stockée dans la *
' * variable globale palette$      *
' **********************************
PROCEDURE load_degas(nom$)
  palette$=SPACE$(32)
  OPEN "1",#1,nom$
  SEEK #1,2
  BGET #1,VARPTR(palette$),32
  VOID XBIOS(6,L:VARPTR(palette$))
  BGET #1,XBIOS(2),3#000
  CLOSE #l
RETURN
' 
' **********************************
' * GENERATION FICHIER BINAIRE     *
' * ELEMENTS GRAPHIQUES            *
' **********************************
PROCEDURE sauve_elements{fichier$)
  LOCAL i%
  OPEN "o",#1,fichier$
  BPUT #1,VARPTR(palette$),32
  OUT #1,nb_elements%
  FOR i%=1 TO nb_elements%
    BPUT #1 ,VARPTR(element$(1%)},134
  NEXT i%
  CLOSE #1
RETURN
'
' **********************************
' * CHARGEMENT DES                 *
' * ELEMENTS GRAPHIQUES            *
' **********************************
PROCEDURE saisie__elements
  LOCAL n%
  LOCAL px%, py%
  LOCAL px2%,py2%
  '
  n%=0
  RESTORE def_elements
  DO
    READ px%
    EXIT IF pa%=-1
    READ py%
    INC n%
    px2%=px%+15
    py2%=py%+15
    GET px%,py%,px2%,py2%,element$(n%)
  LOOP
  nb_elements%=n%
RETURN
'
' *********************************
' * POSITION DES                  *
' * ÉLEMENTS GRAPHIQUES           *
' *********************************
def_elements:
DATA 1,1
DATA 18,1
DATA 35,1
DATA 52,1
DATA 69,1
DATA 86,1
DATA 1,18
DATA 18,18
DATA 35,18
DATA 52,18
DATA 69,18
DATA -1

Le programime EDITCART est un éditeur de carte virtuelle écrit entièrement en GFA Basic. Tl sauve les cartes éditées dans des fichiers binaires, pouvant être relus et exploités par d’autres programmes.

Ses fonctions sont: lecture d’une carte à partir du disque, sauvegarde de la carte courante sur disque, déplacement sur la carte, modification d'un élément quelconque de la carte, sélection d'un élément graphique, affichage d'une boîte d'informations et option pour quitter le programme. Le tout est entièrement géré à la souris.

Attention: l'éditeur à besoin d'un fichier d’éléments graphiques pour fonctionner. Exécutez le programme GENELEM avant d'utiliser EDITCART. Le nom du fichier d’éléments graphiques est ELEMENTS.BIN par défaut, mais vous pourrez le modifier dans le code source d'EDITCART, ou ajouter une fonction permettant de charger n'importe quel fichier d'éléments graphiques.

Initialement, cet éditeur a Été conçu pour être simple à utiliser et à comprendre. Hélas, il s'est avéré impossible d'écrire des routines d’affichages simples et performantes aussi bien sur STE que STF [dommage que tous les ST ne soient pas dotés de blitter). Les routines d'affichage de EDITCART utilisent donc des techniques de programmation un peu complexes à comprendre pour un programmeur debutant.

La première méthode qui vient à l'esprit est de ré afficher entièrement l'écran après chaque déplacement. Dans l’exemple qui suit, le codage de la carte est stocké dans le tableau CARTE|() et les éléments graphiques de base dans le tableau ELEMENT$(). La procédure aff_carte dessine la carte sur l'écran.

La position du morceau de carte visible par rapport à la carte virtuelle cst contenu dans les variables ligne_carte et colonne_carte.

En mettant ligne_carte et colonne_carte à 1, le côté haut gauche de la carte est affiche sur l'ecran.

Pour déplacer la carte d’une position vers la droite, il faut incrémenter la variable colonne_carte de 1 et appeler de nouveau aff_carte.

Pour déplacer la carte d'une position vers le bas, il faut incrémenter ligne_carte et exécuter aff_carte.

Remarque: la position (1, 1) correspond au premier indice du tableau contenant la carte, grâce à l’instruction OPTION BASE 1 Sans celle-ci, le premier indice du tableau a la position (0,0).

Le morceau de carte visible est affiché à l'écran à la position définie par les variables xcarte% et ycarte%. Etant donné là structure interne de la mémoire vidéo et la manière dont fonctionnent les instructions graphiques du GFA Basic, il est préférable d'utiliser une position d'affichage en x multiple de 16, afin d'accélérer la vitesse d'exécution.

OPTION BASE 1
'
xcarte%=16
ycarte%=5
'
ligne carte%=30
colonne_carte%=67
'
@aff_carte
END
 
PROCEDURE aff_carte
  LOCAL l%,c%
  LOCAL ligne%
  LOCAL colonne%
  LOCAL num%
  LOCAL posx%
  LOCAL posy%
  '
  posy%=ycarte%
  ligne%=ligne_carte%
  FOR l%=1 TO 11
    posx%=xcarte%
    colonne%=colonne_carte%
    FOR c%=1 TO 11
      num%=carte<PIPE>(colonne%, ligne%)
      PUT posx%,posy%,element${(num%)
      INC colonne%
      ADD posx%,16
    NEXT c%
    INC ligne%
    ADD posy%,16
  NEXT l%
RETURN

Pour gérer les déplacements, il suffit d’avoir une série de procédures modifiant les variables de position en fonction de la direction de déplacement. Pour des misons de sécurité, ces procédures doivent contrôler que le déplacement ne se fasse pas en dehors des limites de la carte.

PROCEDURE aller_haut
  IF ligne_carte%<>1
    DEC ligne_carte%
    @aff_carte
  ENDIF
RETURN
'
PROCEDURE aller_bas
  IF ligne_carte%<>ligne_max%
    INC ligne_carte%
    @aff_carte
  ENDIF
RETURN
'
PROCEDURE aller_gauche
  IF colonne_carte%<>1
    DEC colonne_carte%
    @aff_carte
  ENDIF
RETURN
'
PROCEDURE aller_droite
  IF colonne_carte%<>1
    INC colonne_carte%
    @aff_carte
  ENDIF
RETURN

Ce système est parfait sur le papier, mais une fois mis en oeuvre, il se révèle trop lent pour une utilisation pratique, cas de figure fréquent en informatique. La solution passe par une amélioration du principe de base.

On peut gagner du temps en ne redessinant qu'une partie de la carte. Lors d'un déplacement vers la droite, la colonne 1 disparaît de l'écran et les colonnes 2 à 11 sont décalées d'une position vers la gauche, le programme ne dessine vraiment que la nouvelle colonne 11, De la même manière, lors d'un déplacement vers la droite, seule la colonne 1 est nouvelle, Puisqu'une partie de la carte est juste décalée, au lieu de le redessiner, on peut la déplacer en une seule opération graphique. L'une des solutions possible est de lire la portion de carte avec l'instruction GET et de l’afficher à sa nouvelle position avec PUT.

Cette technique fonctionne, mais présente un inconvénient d'ordre esthétique, L'oeil humain est un outil très perfectionné qui est capable d'analyser et de décomposer la structure d'un mouvement rapide. C'est souvent un avantage, mais dans notre cas particulier, c’est un inconvénient: si la routine d'affichage travaille en deux étapes, cela produit un effet graphique nuisible visible. Pour éviter cela, il faut que l’affichage s’effectue en une seule fois et le plus rapidement possible.

La seule manière d'obtenir un affichage rapide est de réaliser les opérations graphiques en mémoire et de les recopier rapidement sur l'écran en une seule opération. Afin d’obtenir un résultat graphique encore meilleur, le programme EDITCART utilise une variante de cette technique: il dessine la carte dans un écran virtuel, puis change l’adresse de la mémoire écran par l'adresse de cet écran virtuel. Ainsi, on évite de recopier l'image sur l'écran.

La fonction XBIOS(5) permet de changer l'adresse de la mémoire écran. Sur un STE cette adresse peut être quelconque, alors que sur un STF elle doit obligatoirement être un multiple de 256. L'adresse initiale de l’écran est multiple de 256. Il faut créer une zone de 32000 octets pour l'écran virtuel. L’instruction MALLOC permet d'allouer une zone mémoire de n octets. Cette zone mémoire commence obligatoirement à une adresse paire. Pour obtenir une adresse multiple de 256, il faut déclarer avec MALLOC une zone de 32255 octets et masquer les deux derniers bits de l'adresse Le résultat est une adresse multiple de 256 qui ports sur une zone mémoire de 32000 octets contenus dans la zone mémoire de 32255 octets déclarée par le programme. C'est un peu compliqué mais cela marche bien.

adr_tampon%=MALLDC(32255)
adr2%=(adr_tampon%+255) AND &HFFFFFF00

Les variables adrl% et adr2% contiennent l'adresse des deux écrans. La variable adr1% contient l'adresse initiale de la mémoire écran et adr2% contient l'adresse de l’écran virtuel de 32000 octets. L'affichage se fait en bascule. Lorsque l’adresse de la mémoire écran est positionnée sur adr1%, l'image de la nouvelle carte est dessinée dans adr2% Lorsque l’adresse de la mémoire écran est positionnée sur adr1%, l'image de la nouvelle carte est dessinée dans adr1%.

Lorsque le programme a terminé de dessiner une image en mémoire, il change l'adresse de la mémoire écran grace à l’instruction XBIOS(5). Attention: la fonction XBIOS(5) peut être appelée à tous moment par le programme, mais le gestionnaire d’écran ne change l'adresse de la mémoire écran que lorsque l'image courante à été entiérement dessinée, St vous utilisez trop rapidement l'instruction XBIOS(5), seul le dernier changement de mémoire d'écran sera pris en compte. Pour éviter ce probléme, aprés avoir utilisé XBIOS(5), il faut attendre que le gestionnaire d'écran ait affiché entièrement l'image écran. Ce test est réalisé avec l'instruction VSYNC Celle-ci bloque l'exécution du programme tant que le gestionnaire d'écran affiche l’image courante (il y à 50 images affichés par seconde).

VOID XBIOS(5)
VSYNC

Les cartes générées par EDITCART ont une taille de 30 lignes de 60 colonnes. Pour changer fa taille, 1l faut modifier les variables nb_colonnes et nb_lignes sans dépasser les limites du tableau carte(700,75).

Les cartes d'EDITCART ont le format suivant: 19 octets contenant la chaîne “CARTE JdR ATARI MAG” un octet contenant le nombre de colonnes, un octet contenant le nombre de lignes et le codage de la carte (la taille de ce codage est égal à nb_colonnes x nb_lignes octets). La chaîne est un en-tête d'identification. 5i vous tentez de lire un fichier n‘avant pas d'en-tête, le programme affiche un message d'erreur. Le nom d'une carte doit impérativement avoir une extension .CAR, ne l'oubliez pas au moment de taper de la carte à sauver (c'est l'unique moment où l'éditeur utilise le clavier).

' ******************************
' *       EDITEUR DE CARTE     *
' *       POUR JEU DE RÔLE     *
' *        STYLE ULTIMA        *
' ******************************
' * (C) 1991 ATARI MAGAZINE    *
' * (C) 1991 PATRICK LECLEREQ  *
' ******************************
'
RESERVE 100000
'
OPTION BASE 1
DIM element$(200)
'
adr_tampon%=MALLOC(32255)
adr2%=(adr_tampon%+255) AND &HFFFFFFOO
adr1%=XBIOS{2)
nb colonnes%=60
nb_lignes%=30
DIM carte<PIPE>(200,75)
'
@main
VOID XBIOS(5,L:adrl%,L:adrl%,-1)
CLS
VOID MFREE(adr tampon%)
END
'
' -----------------------------------
PROCEDURE set_ecr_log(adr ecran%)
  VOID XBIOS(5,L:adr_ecran%,L:-1,-1)
RETURN
'
PROCEDURE set_ecr_phys([adr ecran%)
  VOID XBIOS(5,L:-1,L:adr_ecran%,-1)
RETURN
'
' -----------------------------------
' ***********************************
' *    ATTENTE ARRET CLIC SQURIS    *
' ***********************************
PROCEDURE attOclic
  DO
    EXIT IF MOUSEK=0
  LOOP
RETURN
'
PROCEDURE souris_fleche
  DEFMOUSE 0
RETURN
'
PROCEDURE souris_abeille
  DEFMOUSE 2
RETURN
'
' ************************************
' *    TEST CLIC SUR ZONE ÉCRAN      *
' ************************************
FUNCTION tstzone(x%,y%,px%, py%, tx%, ty%)
  LOCAL result%
  '
  result%=l
  '
  IF x%<px%
    result%=0
  ENDIF
  IF x%>px%+tx%-1
    result%=0
  ENDIF
  IF y%<py%
    result%=0
  ENDIF
  IF y%=py%+ty%-l
    result%=0
  ENDIF
  RETURN result%
ERDFUNC
'
' ************************************
' * EFFACEMENT ECRAN                 *
' ************************************
PROCEDURE cls_ecran(c%)
  DEFFILL c%
  FBOX 0,0,319,199
RETURN
'
' ************************************
' *    AFFICHAGE CADRE GRAPHIQUE     *
' ************************************
PROCEDURE cadre(px%,py%,tx%,ty%,f%,b%)
  LOCAL px2%, py2%
  '
  px2%=px%+tx%-1
  py2%=py%+ty%-1
  DEFFILL f%
  PBOX px%,py%,px2%,py2%
  COLOR b%
  BOX px%,py%,px2%,pyd%
RETURN
'
' ************************************
' *         AFFICHAGE MESSAGE        *
' *        DANS BOITE DE CLIC        *
' ************************************
PROCEDURE aff_boite(px%,py%,tx%,ty%,f%,b%, m$)
  LOCAL px2%, py1%
  LOCAL xaff%,yaff%
  '
  px2%=px%+tx%-1
  py2%=py%+ty%-1
  '
  xaff%=px%+(tx%-LEN(m$}*8)/2
  yaff%=py%+6+(ty%-7)/2
  '
  DEFFILL f%
  PBOX px%,py%, px2%, py2%
  COLOR b%
  BOX px% py%, px2% , py2%
  TEXT xaff%,yaff%,m$
RETURN
'
' *************************************
' *   CHARGEMENT DU FICHIER BINAIRE   *
' * CONTENANT LES ELEMENTS GRAPHIQUES *
' *************************************
PROCEDURE charge_elements({fichier$)
  LOCAL n%
  LOCAL palette$
  '
  palette$=SPACE$(32)
  OPEN "1" ,#1,fichier$
  BGET #1,VARPTR(palette$),32
  VOID XBIOS (6;L:VARPTR(palette$))
  nb_elements%=INP{#1)
  FOR n%=1 TO nb_elements%
    element$(n%)=SPACE$(134)
    BGET #1,VARPTR(element$(n%)),134
  NEXT n%
  CLOSE #1
RETURN
'
'
' ************************************
' * INITIALISATION DE LA CARTE       *
' ************************************
PROCEDURE init_carte
  ARRAYFILL carte<PIPE>(),l
RETURN
'
D R e b L e R S R o
' * AFFICHAGE IMAGE EDITEUR *
<PIPE> AAAARARE RR RRN RR RE AN RR RE ÉÉ E
PROCEDURE aff ecran
@cls ecran(1)
écadre(xcarte®-l,vcarte=-1,175,178,1,0)
DEFTEXT O
écadre(776,11,48,36,2,0)
Gaff boîte(229,14,20,14,3,0,CHR$(1))
Caff boite(229,30,20,14,3,0,CHR$(4})
@aff _boite(251,14,20,14,3,0,CHRE(2))
Gaff boite(251,30,20,14,3,0,CHR543)!
Eaff_bnite{195,55.11G.13.E,fl.“IHFflRHHTIflHS']
Eaffflhnite{195,33,11D,13,E,U,"GUITTEH FRG")
@aff boite(195,111,110,13,2,0,"CHARGER CARTE")
@aff boite(195,138,110,135,2,0, SAUVER CARTE")
Bcadre(223,164,54,22,2,0)
Paff boite(225,166,14,18,3,0,CHR3(4))
@cadre(241,166,18,18,2,0}
Gaff boite(261,166,14,18,3,0,CHRE(3))
Gaff element courant
RETURN
| TRLNXE ik
| * \AFFICHAGE-DE LA *
4- CARTE YTSIBLE —#
L R A R e d d e d d r d e e u B
PROCEDURE aff carte
LOCAL 1%,0%
LOCAL Tigne%
LOCAL colonnes
LOCAL nums
LOCAL posxs
LOCAL posys
posy&=ycartes
lignes=-ligne cartes
FOR 1%=1 TO 11
posx%=xcartés
colonne“=colonne cartes
FOR c%=1 TO 11
num*=carte| (colonne#, ligne#)
PUT posx%,posy#,element$ (num*)
INC colonne*
ADD posx%,16
NEXT c%
INC lignes
ADD posy*,16
NEXT 1%
RETURN
L ANE e d E
# AFFICHAGE DE *
' * ELEMENT COURANT *
| AIF o o o ol e ETE E
PROCEDURE aff element courant
LOCAL old ecr¥
oid ecri=XBI0S(3)
êset ecr log(adr1%)
PUT 242,167,element$(element_courant*)
Bset ecr log(adr2%) |
PUT 242,167,element$(element courant*)
set ecr log(old ecr%)
RETURN
ï
ä
| RRRNRERRERÉAEREEREETEEERARERE RIRN
| — CESTION PERMUTATION DES ECRANS *
| AARRRRÉTEÉ RR RA RR RR WV EVVRREEL kRl E
PROCEDURE preparation ecr travail
ATAR| MAGAZIME fl BESTOFGFA BASIC
1F etat%=1 ;
ecr visibles-adrl®
ecr travail%=adr2%
ELSE ;
ecr visible%-"adr?#
ecr travail%=adrl%
ENDIF
etlat<=-etat=
üset_ecfi_ïügLflcrütraïaîîäj
RETURN
<PIPE> d d e R R RR RR E E A d d d d d
<PIPE> = VISUALISATION DE LA CARTE *
b d sl ok é e dc d e d e e o Sk e e d e d d e m e A A e E
PROCEDURE visualisation ecr travail
Bset ccr phys(ecr travail®)
VSYNC
RETURN
lNF o S o e e o s L RESRE
' * DEPLACEMENT VERS LE HAUT *
[ L L R R R WN R e e
PROCEDURE aller haut
LOCAL ecrl%, xl%,yl%
LOCAL ecrX2234 y,l
LOCAL pxs,py4
LOCAL c%,colonne*
LOCAL n
IF ligne cartese=I
DEC lîgne cartes
HIDEM
éprepareacrt tiraovanil
ecrli=ecr visibles
x]“=xcartes
Y1%=ycartes
écre4=ecr travail#
Ké4=excarte
y25=ycartet+lb
RC COPY ecrl¥,x1%,yl%,1760,100 TÜ ecret,xé*,yés
colonne#=colonne cartes
px*=xcarte%
pys=ycartes
FOR c%=1 TO 11
nk=carte<PIPE> (colonne#,ligne carte%)
PUT px%,py“#,elementi{n=})
INC colonnes
ADD px#,16
NEXT cÆ
@visualisecar ttriavoainl
SHOWM
ENDIF
RETURN
<PIPE> E e E d C ETE T R r éc e rr e d e E
“* DEPLACEMENT VERS LE BAS 7
1 e E ÉÉÉF TT E EU R
PROCEDURE aller bas
LOCAL ecr. xll%,¥%1%
LOCAL ecre%,x2y%l,
LOCAL px%,pyé
LOCAL c%, colanne=
LÜCAL n*
IF ligne carte%==nb lignes%=-10
INC Tigne carte*
HIDEM
éprepareacrt tiraovanil
ecrl®=ecr visibles
x1l&excartes
yléycartes+ib
ecr2%=ecr travail#
X24=-xcartes
vi=ycarLes
HE_EÜPÏ écrl®,x1%,4v1#,176,160 TO ecrd® 2%, y2%
colonne*=colonne carte
prE=ncartes;
pyé=ycarte=+160
FOR ¢%=1 TO 11
né=carte<PIPE> (colloignne _n carete#s+1,0)
PUT px%,pys,elementi{nw)
INC colonne*”
ADD px*,16
NEXT c%
Evisualisecar ttriavoainl
SHOWM
ENDIF
RETURN
DRF e ke e e e e R R W R R e ok e e e e e o
" = DEPLACEMENT VERS LA GAUCHE =
ï E E E e b c0 L b de de d A RR d E E S
PROCEDURE aller gauche
LOCAL ecrls,x1%,y1%
LOCAL ecrz%,x2%,y2%
LOCAL px=,pys
LOCAL 1,ligne%
LOCAL n*
IF colonne cartes==1
DEC colonne cartes
HIDEM
Épreparation ecr travail
écrls=-ecr visibles
xl%=xcartée*
vl&=vcarte*
ecr&%=ecr travail#
xés=xcarles+1b
vi*=ycarte%
RC COPY ecrl#,x1%,y15,160,176 TO ecrd%, x2%,yZ%
ligne==ligne cartes
px*=xcartew
py*=vcartes
ATAR| MAGAZIRE BEST OF GFA BASIC
FUR 1==1 [0 11
né-cartel(colonne cartes,ligne%)
BRUT #1,VARPIR(entete})1,9 FILESELECT paths," " ,noms LOCAL côlonne clic®
OUT #1,nb colonnes* SPUT fondd LOCAL ligne*
PUT px* ,py,elements(n°) OUT #1,nb ligness IF noms=="" LOCAL colonnes
INC Tignes FOR c%=1 TD nb colonness @souris abeille ; LOCAL old_element®
ADD py&,l6 FOR 1%=1 TD nb lignes% OPEN "T",#1,nomk i
NEXT 15 QUT #1,carte|(e*,1%) entéte$=SPACES(14) xsxmé-xcartes
Gvisualisation écr travail NEXT 1% BGET #1,VARPTR{enteted),19 Vs ymé=-vcartes
SHOWM HR NEAT cæ IF entetef<="CARTE JdR ATARI MAG" ligne clic*=(y%/16)
ENDIF CLOSE #1 CLOSE #1 colonne clic&=(x%/16)
RETURN @souris fleche Bsouris Fleche ligne%=ligne clic#ligne carte*
' RETURN mi="CE FICHIER ME CONTIENT<PIPE>PAS DE CARTE® colonné#=colonne click+colonne carte*
E kbR e B R M RE RL R i e E E , ALEHF fl'm5.1." ÜË Hjh% i
* * DEPLACEMENT VERS LA DROITE * E PEN ETE A E L ELSE old elément%=carte<PIPE> (colonnes,ligne#)
L v R Rk é é b e d r R F ÈÊÜÏEËAËÜE ÉAHÏE SUH ÜIEÛUE *
PROCEDURE aller droite <PIPE> #* INTERFACE UTILISATEUR A
' ok e e e B AW LOCAL Eürï%:ïlaiïl# | T T T S e E w
LOCAL ecr2%,x2%,y25% PROCEQURE sauver carte
nb colonnes%=INP{#1)
nb lignes&=INP{(#1)
FOR c==1 TO nb colonness
FOR 1%=1 TO nb lignes#
IF old element*=#element courant
carte<PIPE>(colonne%,ligne%)=ecloeumreanntt
posx4=colonne clic&*l1b+xcarte#
posy*=ligne chics"lb+ycartes
LOCAL px*,pyt LOCAL nomb,paths carte/ (c*,1#)=INP{#1)] HIDEM
LOCAL 1%, 1igne% LOCAL b% NEXT 1% * PUT posx*,posy*,element${(element courant*)
LOCAL é LOCAL fFonds NEXT c% SHCWM
' ’ CLOSE #1 ENDIF
1F colonne carte*nb colonnes=-10 HIDEM ligne carte%=1 RETURN
INC colonne cartes SGET fonds colonne carte%=1 |
HIDEM ¥ . SHOWM Gaff carte | Rk Rk RR RESRE
Bpreparation ecr travail path$=DIR#{0)+"\#.CAR" ésouris fleche * € OPTION 'QUITTER LE PRG' *
ecrlis=ecr visibles FILESELECT path$,™ ",nom$ ENDIF T AN A A d d
x1%=xcartex+16 IF nomp=="" EMDT F PROCEOURE quitter programme
yl=ycarte* IF EXIST{noms) RETURN LOCAL m8,t5,b%
ecréé*=ecr travail% n6="NO DE FICHIER EXISTANT. " ; '
«Ptexcartes mé=m£+" <PIPE>CONTINUER SAUVEGARDE ? <PIPE>" J bs hc e bbb e odofnl kot etk sortie==0
vax=ycarte# ALERT O,mb, 1, "OUT <PIPE> MON" , b “ * INCREMENTATION ELEMENT COURANT * m$="VOULEZ-VOUS VRAIMENT <PIPE>QUITTER CE PRG ?"
RC COPY ecr1%,x1%,y1%,160,176 TO ecr?5,x2%,y24 LF bx=1 C E RR SE A E E RE de A e o e e P E E RE EhuîïË=“ÜUÏ|NÜH°
1îfihe%=]igne_nartn% ËE!EE_SEHVÈT_ÇËFËEÏNÜNEÏ PROCEDURE inc element ALERT U,mb,2,choix5,bé
px%=xcarte#+1650 _ ENDIF 1F element courant¥<=nb elementss [F b%-=1
pyérycarteï | ELSE INC element courant* sortiet=l
FOR 1=1 TO 11 Bexec sauver carte(noms) Baff element courant ENDIF
né=carte|(colonne_carte*+10,1igne%) ENDLF ‘ Gattüelie SHÔWM
PUT px%,py3,elements{n#) ENDIF ENDIF RETURN
INC Tigne% HIDEM RETURN !
ADD pyè,16 SPUT fondé | | RR RE E
NEXT 1% SHOUM | RR RR RIR E RR RR RR RRN RE E ! # OPTION INFORMATIONS #*
Bvisualisation ecr travail RETURN ! = DECREMENTATION ELEMENT COURANT * R el R tJ E
EHÜHM = i ! | kx hhdaaxéhéxbhdddmm é éh d d e e É ON pHÜEEDUHE fiff_iflfflfi
ENDIF ' - PROCEDURE dec element LOCAL m§,b%
RET”HH R B R e b & e b b b b L RE TR RS E RE IF ÈîËmÊflt EÜHT&HË%{?I i
| * * CHARGER CARTE A PARTIR DU DISQUE * DEC element courants m&="EDITEUR DE CARTE EN GFA BASIC "
RRh dc ÉÉÉ É É R ok kAR E R TRN VNA RE REN E RIR Baff É]Ë…Ëfiï courant m$=m5+"<PIPE>{E] 1991 ATARI HflEflEIHE“
<PIPE> * SAUVEGARDE CARTE SUR DISQUE = PROCEDURE charger carte . gattOelie — mà=m3+" |(C) 1991 FATRICK LECLERCE
“ + FONCTION SYSTEME Ë LOCAL nom$,paths ENDIF ALERT 0,m$,1," OK ",b%
D niede e s i ok v b A o o W o R R R A e e TR LOCAL entete} RETURN RETURN
PROCEDURE exec sauver carte(nom$) LOCAL 1%,c% - . :
LOCAL enteteï LOCAL b% | hhh e n v gk e d e e e e e et e e s e R W | AEAARAHRRHRRER RR A WWEK
LOCAL 1%,c% LOCAL ms #* CLIC SUR UN ELEMENT DE LA CARTE #* | # GESTION ÉDITEUR *
! LOCAL fonds 1R e RRN E R E e e e cd e e hhE V E E E E E A EA
@souris abejlle
OPEN "O",#1,nomb SGET, fonds
entete$="CARTE JdR ATARI MAG" path$=DIR${0}+"\#.CAR"
ATARE MAGAZIME m BEST OF GFA BASIC
PROCEDURE clic carte(xmé,ym)
LOCAL =%y,é
LOCAL ligne clich
PROCEDURE gestion editeur
LOCAL xmé, ym%, km%
ATAR<PIPE> MAGAZIME fi BEST OF GFA BASIC
JEU DE ROLE EN GFA BASIC
DO nb el ements==0
00
MOUSE Xm, YMéÉE , sRIF
EXIT IF kmf==0
LOGH
1F @rstzone(xm®, ym*,195,83,110,13)
Bguitier programme
ENDIF
EXIT IF sortie%=]
IF Btstzaone(=m%,yms,195,56,110,13)
Paff infos
ENDIF
1F @tstzone(xms,yms,195,111,110,13)
@chargér carte
ENDIF
IF @tstzone(xmè,ymt,195,138,110,13)
Esauver carte
ENDIF
IF Gtstzoynmè,e 22(8,x14m,20é,1,4)
Baller haut
ENDIF
IF Ctstzone(xmé,ymé,251,14,20,14)
Catler bas
ENDIF
IF @tstzone(xmé, ymé,251,30,20,14)
éaller droite
ENDIF
[F @tstzoynmk,e 22(9,x 30m,20é,1,4)
Baller gauche
ENDIF
1F Ptstzone(xm®,ymé,xcartes,ycarte*,176,176)
Bclic carte(xmé,yms)
ENDIF
IF Btstzone(xm26s1,% 16,6y,1m4,s18,)
@inc element
ENDIF
IF @Btstzone(x22m5,%16,6,y 1m4,s18,)
Bdec_element
ENCIF
LOUP
lîgne carte%=l
colonne cartes=1
element courant=-!
xcartes=6
vcartes=l=
  @charge_elements ("ELEMENTS.BIN®)
  '
  @init_carte
  HIDEM
  GRAPHMODE 2
  @aff_ecran
  @aff_carte
  BMOVE XBIOS(2),adr2%,32000
  '
  @souris_fleche
  SHOWM
  etat%=1
  @gestion_editeur
RETURN

Nous verrons le mois prochain comment utiliser les cartes générées par EDITCART pour gérer les déplacéments d'une équipe de personnages sur un monde virtuel (affichage de l'image de l'equipe sur la carte, gestion des rencontres, interdictions ou autorisation de deplacements sur certaines cases, etc.) Vous trouverez en téléchargement sur le 3615 ATARI les listings de l’article, un exemple de carte et une image Degas contenant quelques éléments de dessin.

Patrick Leclereq