Nox-Rhea WiKi

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 ot les autres données graphiques

YA l.'iliiLl. I.]I_I !':ZLI'_PL'l:'i.EI.' |-.5I:]..-Ii_:l“-I: L:II'_' IH. carie Cil ].HIËIËI'I.E]'LIII-J”I::. Ch J_.i'-l:'LIL J.-'-.'I. I'L‘L'IEE:UI.' ner avec des élements de basé. Une foret peut étre dessinée avec A ou 7 {.:'Ii'l:ml_'“['ltil TEFIë |_i“-“ill=“|1l;': CHI] LETI l-.l:l‘r'l'l'l. I.'.ll['.fil] r:“nnt 'l-.l.'l.”'. T l'l]'ll':l l.”ËË'i-ÜE]'l de beaucoup d'élemonts différents. A la ngucur, une foréc peut S dessine avec une seule petite image représentant un arbré, et la montagne avec un seul élément représentant la silhouerre d'une cime. (st le procédé utilisé par bon nombre de logiciels de jeu du com- FICFce, Pl”l'l_l:l“ I::Il:_”; |_..|.i::i|:.;'r'.:'i li_'i;hrli:.[ul;'i L]'L'l.i Li:l_'l'II-II:Tll: El. l’rjrg:hni!-:ati:m I.:Il_':'i mémoires vidéos, les elements ont le plus souvent une taille de lôx16 pixels ou 32×32 piæels, Une carte esr alors mémorisée sous la forme d'une lisre d’éléments Ë'l'“..'l.'l:lhiqüfl_:j I:::!Il'l TËL[E ._“'Îl'.l:'ll'_'l'i.::l- LECLE [i:-:.L-: ijfiflfi 11F Ï.EIZ_J.IOE'LI. rlurrïrl:riqu:_' ä. deux dimensions, dont le type dépend du nombre d'éléments possibles. Avec moins de 256 élements, ce qui est déjà énorme, on peur utiliser un tableau de vvpe BYTE (svmbole |), chaque élément du tabléau n'occupant qu'un bctét én mémoire. Avec des éléments de 16×16, une carte de 1600x8C0 pixels peut être stockée dans un tableau de 100×50 cléments, occupant une place mémoire de 5000 octets. 5a déclaration se fait de la manière suivante: OFTION BASE 1 DIM carte|{100,50) L'instruction OPTION BASE ! foree le basic à numérotér ces tableaux à partir de l’indice 1 et non & Four calculer le gain de mémoire enrre les deux méthodes, il faur prendre en compre la place mémoire prisé-par les éléments praphigues. ; Un élément graphique de 16×16 pixels stocké dans une variable alphanumérique grâce à l'instruction GET occupe une place de 134 nc ters, ce caloul ayant ête fait avec l'instruction LEN qui détermine la raille 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. Clest donc une valeur limite accéptable pour fairé quelques calculs. Vous utiliserez certainement moins de 200 clements pour créer vos propres cartes. Pour la perite histoire, les premiers jeux Ultima ont été dessinés avec seulement quelques dizaines d'éléments. Le srockage de 200 éléments graphiques prend 26800 oététs. DIM element$(200) En additionnant la place prise par le codage de la carte t par 200 éle ments graphique, on arrive à un total de 31800 ocrets (5000+ 26800), Dans notre cas particulier, le gain de place apporté par le-codage de la carte est de 20, maus saméliore considérablement a1 la carte est plus grande que 100×50 cléments ou s1 le nombre d'objets gra phique est plus petic que 200. Cetté téchnique 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 CTÉES.

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. Lorsqu’on se déplace sur la carte, le programme est visualisé par une portion de la carte affichée à l’écran. Les ordres de déplacements, l’image de la carte et l’ensemble de ses éléments ne sont qu’un contenu de carte visible.

Pour réaliser un système de déplacement similaire à celui d’Ultima, en GFA Basic, il faut tout d’abord définir les éléments graphiques nécessaires. Nous avons déjà vu le codage de la carte peut être stocké dans un tableau unidimensionnel. Il est possible de faire une base de données en chaîne alphabétique, mais il est plus utile de le stocker dans un fichier binaire. Ce fichier regroupe les informations issues de l’image de la carte. Comment afficher rapidement tous ces éléments dans un STF (sur un STE)? Comment stocker les différents éléments pour qu’ils soient facilement lisibles par les déplacements ?

On suppose que les éléments graphiques ont tous été dessinés par un graphiste avec un logiciel de dessin type Dega Elite ou équivalent. Nous précisons bien que nous parlons de dessins pour écran moyen en 16 couleurs. Pour éditer facilement ces éléments GFA l’image est chargée. ELEMENTS.PI1 est le fichier des éléments graphiques dans un format standard.

La structure du fichier est simple. Elle se compose de 32 octets contenant la palette, suivie de l’image de 32000 octets représentant les 200 lignes. Le fichier contient donc 32032 octets. Chaque élément graphique est défini par une portion de l’image de 16 x 16 (x,y) et donné dans un tableau. Le fichier binaire est formé de la façon la plus simple : on extrait tous les éléments, ligne par ligne, fin de ligne, fin de données entraîne l’écriture d’un fichier.

' *************************
' * CHARGEMENT IMAGE
' * DEGA ELITE
' *************************
' * La palette est stockée dans la *
' * variable globale palette$
' *************************
 
PROCEDURE load_degas(nom$)
  DIM palette$(32)
  OPEN "I",#1,nom$
  BGET #1,varptr(palette$),32
  BGET #1,varptr(elements$),32000
  CLOSE #1
RETURN
 
' *************************
' * GENERATION FICHIER BINAIRE
' * ELEMENTS GRAPHIQUES
' *************************
 
PROCEDURE sauve_elements(fichiers)
LOCAL nb, i
  DIM e$(1),fichier$
  OPEN "O",#1,fichiers
  FOR i=1 TO nb_elements
    PUT #1,e$(1)
  NEXT i
  CLOSE #1
RETURN
 
' *************************
' * CHARGEMENT DES
' * ELEMENTS GRAPHIQUES
' *************************
 
PROCEDURE saisie_elements
  RESTORE def_elements
  READ nb_elements
  DIM elements$(nb_elements)
 
  FOR i=1 TO nb_elements
    READ px1,py1,px2,py2
    elements$(i)=GETS$(px1,py1,px2,py2)
  NEXT i
RETURN
 
' *************************
' * POSITION DES
' * ELEMENTS GRAPHIQUES
' *************************
 
def_elements:
DATA 1
DATA 1,1,1,1
DATA 5,1,5,1
DATA 8,1,8,1
DATA 10,1,10,1
DATA 13,1,13,1
DATA 15,1,15,1
DATA 18,1,18,1
DATA 20,1,20,1
DATA 25,18,25,18
DATA 35,18,35,18
DATA 69,18,69,18
DATA -1

Le programme EDITCART est un éditeur de carte virtuelle écrit entièrement en GFA Basic. Il sauve les cartes dans des fichiers binaires. Ces fichiers peuvent être ensuite réutilisés par d'autres programmes pour effectuer une lecture directe à partir du disque, sauvegarde en mémoire, construction de carte de déplacement sur la carte, sélection d’un élément quelconque de la carte, sélection d’un élément de fonction, l’éditeur a tout de même des limitations si on opère un zoom ou une rotation. L’éditeur ne prend pas en compte les options d’édition. Attention : l’éditeur a besoin d’un fichier d’éléments graphiques pour fonctionner. Exécuter le programme GENELEM avant d’utiliser EDITCART. Il vous suffira de charger les éléments dans ELEMENTS.BIN, et de les modifier, mais vous pourrez le modifier dans le code source d’EDITCART ou ajouter des fonctions permettant de charger n’importe quel fichier d’éléments graphiques.

Initialement, cet éditeur a été conçu pour être simple à utiliser et à programmer, en GFA Basic. Les cartes sont organisées sous forme de chaînes simples. Il est possible d’utiliser une base de données en mémoire pour chaque carte, ou alors de relier une base de données au format binaire, ou EDITCART est utilisé en complément de la gestion des images graphiques complexes pour des techniques de programmation avancées.

La première méthode qui vient à l’esprit est de réafficher cette portion visible ligne par ligne. Dans l’exemple suivant, les variables ligne_carte et colonne_carte contiennent les coordonnées du coin haut gauche de la carte visible. Le tableau ELEMENTS() contient les éléments graphiques correspondant aux données de la carte.

La position du coin de la carte visible par rapport à la carte virtuelle est contenue 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 affiché sur l’écran. Pour déplacer la carte d’une position vers la droite, il faut incrémenter la variable colonne_ligne de 1 et appeler de nouveau eff_carte. Pour déplacer la carte d’une position vers le bas, il faut incrémenter ligne_carte et exécuter eff_carte. Remarque : la position (1,1) correspond au premier indice du tableau contenant la carte, grâce à l’instruction OPTION BASE 1. Sans cette option, le tableau débute à la position (0,0). Le morceau de carte visible est affiché à l’écran à la position définie par les variables xcarte$ et ycarte$. Étant donné la 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 des coordonnées d’affichage en x multiple de 16, afin d’accélérer la vitesse d’exécution.

OPTION BASE 1
'
xcarte%=16
ycarte%=50
ligne_carte%=1
colonne_carte%=67
'
@aff_carte
END
 
PROCEDURE aff_carte
  LOCAL i,ligne%
  LOCAL j,col%
  LOCAL posx%
  LOCAL posy%
  LOCAL pos%
  '
  FOR i=1 TO 11
    ligne%=ligne_carte%
    posx%=xcarte%
    FOR j=1 TO 11
      col%=colonne_carte%
      pos=carte1(colonne_ligne)
      PUT posx%,posy%,elements(pos)
      INC col%
      ADD posx%,16
    NEXT j
    INC ligne%
    ADD posy%,16
  NEXT i
RETURN

SNIP-SNIP

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

La portion de carte affichée par les jeux Ultima à une dimension de 176×176 pixels, et est constitué de 11×11 clements de 16×16 pixels. La position de l'équipe de personnages est visualisée par une silhouerte en noir affichee au milieu de l'écran. Lors des déplacements, l'image de la carte est redessinée de manière à cé 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 GEA Basic, il faut résoudre un certain nombte de problémes techniques. Nous avons déjà vu que le codage de la carte peur être stocké dans un tableam numérique et les éléments graphiques de base dans un tabléau alphanumérique, mais il reste bien des questions à etudier. 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éréntes 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 consacrde à la créition d'une carte et la seconde traite de son utilsation pour gérer les déplacements de l'équipe, Définition des éléments graphiques On suppese que les éléments graphiques de base ont êté dessinés par un graphiste avec un logiciel de dessin type Degas Elite où equivalent. Nos précieux cléments sont donc stockes sur disque dans une image au format Degas, Le programme GENELEM,GFA lie l'image Degas ELEMENTS.P11 et stocke les éléments graphiques dans un fichier binaire ELEMENTS . BIN réucilisable par un autre programme. La structure du fichier binaire est la suivante: 32 ocrets contenant la palette de couleur des éléments graphiques, un oot unique conténant le nombre d'élements du Hehier et le codage des éléments, chacun oecupant 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

HM ELEMENTS GRAPHIQUES # LRNF RE RR E RE e e RÉSERVE 100000 DIM element${200) nb elements“%=0 palette$=SPACE4(32) Bload dégas(“ELEMENTS.PI1*) @saisie_elements @sauve elements({“ELEMENTS.BIN”) END e e 44 E RE W W E R W R R * CHARGEMENT-IMAGE * = DEGAS ELITE 8 E T T R P e e T o E E S FRAR N A r L AR ARk AR * * La palette est stockée dans la ” * variable globale palettes ,j UR RIRF REN RN R Rk RE É RE PROCEDURE !oad degas(nom$) palettef=SPACE4(32) OPEN “T”,#1,nom$ SEEK #1,2 . BGET #1 VARPTR(palette$}),37 VOID XE10S(6,L-VARPTR(palette*)) BGET #1,XB105{2},3#000 CLOSE #l RETURR B o e E T e b É el RE * GENERATION FICHIER BINAIRE * “ ELEMENTS GRAPHIQUES & d e e N AI E R RE N A PROCEDURE sauve elements{fichier$) LOCAL 1% OPEN “o”,#1,Tichier} BPUT #1,VARPTR(palettet),32 OUT #1,nb elements® FOR i%=1 TO nb elements“ BPUT #1 ,VARPTR(element5(15)},154 MEXT i% CLOSE #1 RETURN 1 N T e RR E R P PR L TR R E o e R T i CHARGEMENT DES % * ELEMENTS GRAPHIQUES * C e RE e dc d PE E E e E A R E R RS PROCEDURE saisi E__El ements LOCAL ns LOCAL px%, pyi LOCAL px2%,py2% nE=0 RESTORE def elements g READ px% EXIT IF pai==1 READ pys . INC n pxé4a=px=+ls pyess=pystis GET px%,py¥,px2%,pye%,elemants(n%) LOOP nb_élémentss=n ATARI MAGAZIME m BEST OF GRA BASIC RETURN

i POSITION DES n ! * ÉLEMENTS GRAPHIQUES *

def elements: DATA 1,1 DATA 18,1 DATA 35,1 DATA 52,1 DATA 69,1 DATA 66,1l DATA 1,18 DATA 18,18 DATA 35,18 DATA 52,18 DATA 69,18 DATA -1 Programme EDITCART Le programime EDITCART est un éditeur de carte virtuelle écrit entiérement en (FEA Basié: Tl sauve les cartes éditées dans des hchiers binaires, pouvant être relus et exploités par d'autrés programmes. Ses fontions 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 sraphique, affichage d'une boîte d'informations et aption pour quitter lc programme. Le tout est entiérément géré à la souris, Attention: l'éditeur à besoïn d'un fichier d’éléments graphiques pour foncrionner. Exéeutéz le programme GENELEM avant d'utiliser EDITCART. Le nom du fichier d'élements graphiques est ELEMENTS.BIN par défaur, mais vous pourrez le modifier dans le code source d'EDITCART, ou ajouter une fonction permettant de charger n'imparte quel fichier d'éléments graphiques. La simplicité n'est pas de ce monde Initialement, cet éditeur a Été conçu pour être simple à utiliser et à -:-:-mprr:nfln:. Hélas, il s'est averé 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 routinés d'affichage de EDITCART utilisent donc des techniques de programmation un peu complexes à comprendre pour un programmeur debutant. Un système d’affichage simple La première méthode qui vient à l'esprit est de réafficher entiérement l'écran après chaque déplacement. Dans l’evemple qui suit, le codage de la carte est stucké dans le tableau CART E|() et les éléments graphiques de base dans le tableau ELEMENTS(). La procedure Gaff carte dessine la carté sur l'écran. La pésition du morceau de carte visible par rapport à la carte virtuelle cst contenu dans les variables lîgne carte ec colonne_carte. En mettant Tigne carte ot colonne carte à 1, lé côté haut gauche de la carte est affiche sur Pecran. Pour déplacer là carte d’une position vers la droite, il faut incrémenter la variable colonne liane de 1 et appeler de nouveau @aff carte. Fnur_q:'LËFÏ:m':,r la carte d'une position vers le bas, il faur incrementer ligne carte er exécuter Baff carte. Remarque: la position (1, 1) correspond au premier indice du tableau conténant la carte, grice à 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 donnd là sccucture interne de la mémoire vidéo et la manière dont fonctionnent les Instruetions graphiques du GE4 Basic, il est préférable d'utiliser une position d'affichage en x multiple de 16, alin d'accélérer la vitesse d'exécution. OFTION BASE 1 scartes=16 vcarté%=5 ligne cartes=30 cn]unng_cart&%=ñ? éaff carte END PROCEDURE aff carte i LOCAL 1%,c0% LOCAL 1ignes LOCAL colonne% LOCAL nums LOCAL posx LOCAL posy® posyesycartes ligne¥=ligne cartes FOR 1=1 TO 11 posx#=xcartes colonne*=colonne carte* FOR c%=1 TO 11 numé“carte| (colonne®, ligne#) PUT posx%,posy&,elements{(numé) INC colonnes ADD posx%,16 NEXT c& INE ligne= ADD posyé,16 NEXT 1% 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 controler que le -l:ié[;];mt‘.m:m né sé fasse pas en dehors des limites de la carte. ATARI MAGAZINE H BEST OF GFA BASIC PROCEDURE aller haut IF ligne cartes==1 DEC 1igne cartes Baff carte ENDIF RETURN PROCEDURE aller bas IF ligne cartese=ligne max® INC ligne carte% Baff carte ENDLF RETURN PROCEDURE aller gauche 1F colonne cartesss-1 DEC calonne cartes Baff carte ENDIF RETURN PROCEDURE aller droite IF colonne carte*=- INC colonne cartes Gaff carte ENDT F RETURN Ce système est parfait sur le papier, mais une fois mis en ceuvre, il se révéle trop lent pour une utilisation pratique, cas de figure fréquent en informartique, La solution passe par une amélioration du principe de base. Un redessin partiel de la carte 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 pasition vers la gauche, le programme ne dessine vraiment que la nouvelle éolônne 11, De la même manière, lors d'un déplacemient vers la dronté, seule la colonne 1 est nouvelle, Puisqu'une partie de la carte est justé décalée, au licu de le redessiner, on peut la déplacer en une seulc opération graphique. L'une des solutions possible est de lire la portion de carte avec l'instruction GET er de l’afficher à sa nouvelle position avec PUT, Cette technique fonctionne, mais présente uñ 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 particuliér, c'ést 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'effectne 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 Pécran en une setle opétration. Afin d'obrenir un résultat graphiqué encore meilleur, le programme EBITCART utilise une variante de cetté technique: il dessine la carte däns un écran virtuel, puis change l’adresse de la mémoire écran par l'adresse de cet écran virtuel. Ainst, on évité de recopier l'imagé sur l'écran. La fonction XBI0S(5) permet de changer l'adresse de la mémoire écran. Sur un STEE cette adresse peut être quelconque, alors que sur un STE 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 Dclets pour l'écran virtuel. L'inscruction MALLOC permet d'allouer une zonc mémoure de à octéts Cette zone métnoire commence oblipatoirement à une adresse paire- Pour obtenir une adresse multiple de 256, 1] faut déclarer avec MALLOC une zone de 32255 octets ct masquer les deux derniers bits de l'adresse Le résultar est une adresse multiple de 256 qui ports sur une zoné mémoire de 32000 octers contenus dans la zone mémoite de 32255 octets déclarée par le programme, C'est un peu compliqué mais cela marche bien, adr tampon#=MALLDC(32255) adré#=(adr tampon%+255) AND KHFFFFFFO0 Les vartables adrl% et adr2% contiennent l'adrésse des deux écrans. La varable adr1% contient l'adresse inimiale de la mémoire écran et adr?% contienr l'adresse de l’écran virtuel de 32000 octers. L'atfichagé se [ait en bascule. Lorsque l’adresse de la mémoire ééran est post tionnée sur adrl®, l'image de la nouvelle carte est dessinée dans adr?% Lorsque l’adresse de la mémoire écran est positionnée sur adrls, l'image de la nouvellé carte est dessinée dans adriér Lorsque le programme a terminé de dessiner nne image en mémoire, l change Padresse de la mémoire écran grace à l'mnstrucrion XB10S(5}. Artention: la fonction XBI0S(5) peur être appélée à rous moment par le programme, mais le gestionnaire d'éctan ne change Padresse de la mémoire‘écran que lorsque l'image courante à ét éentiérement dessinée, St vous urilisez trop rapidement l'instruction XBIOS(5}, seul le dernier changement de mémoire d'écran sera pris én compré. Pour éviter ce probléme, aprés avoir wrilisé XBI0S(5), il faut attendre que le gestionnaire d'écran aic affiché entierement l'image écran. Ce test est réalisé avec l'mstruction VEYNC Celle-er bloque l'exécution du programme tant que le gestionnaire d'écran atfiche l’image courante (il y à 50 images affichés par seconde). vOID XBIOS(5) VSYNC Format de sauvegarde des cartes Les cartes génerées par EDITCART ont une taille de 30 lignes de 60 colonnes. Four changer fa taille, 1l faut modifier les variables nb_colonnes et nb Tignes sans dépasser les limites du tableau carte( 700,75). Les cartes d'EDITCART ont le formar suivant: 19 octers conténant la chaîne “CARTE JdR ATARI MAG” un octer contenant le nombre de calonnes, un octet contenant le nombre de lignes et le codage de la carte (là taille de cé codage est égal à nb colonnesxnb |îgnes ot tets). 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'érreur. Le nom d'une carte doit impérativement avoir uné excenson .CAR, ne l'oubliez pas au moment de taper de la carte à sauver (c'est l'unique moment où Péditeur utilise le clavier). ATAR| MAGAZINE m BEST OFGFA BASIC

8 EDITEUR DE CARTE ñ r POUR JEU DE RÔLE = st STYLE ULTIMA * L é d e e e 46 ok e e e e d d d e SE SE e ol e e e R “ % - (C) 1991 -ATARI MAGAZINE * * (C) 1991 PATRICK LECLEREG # RR B b R E RR RR E R RR RR RE EF E RESERVE 100000 OPTION BASE 1 DIM element$ (200) adr tampon&=MALLOC(32255) ad?2%=[adr_tamflun%+255} AND SHFFFFFFOO adr1*=XB105{#) nb colonness=60 nb_lignes*=30 DIM carte|(200,75) Gmair VOID XBIOS(5,L:adrl%,L:adrl%,-1) CLS VOID MFREE(adr tampon%) END PROCEDURE set ecr Tog(adr ecrans) VOID X810$(5,L:adr ecrans,L:-1,-1) RETURN PROCEDURE set ecr phys([adr ecran“) VOID XBIOS(5,L:-1,L:adr ecran*,-1) RETURN — — ===” c=s cs — e ] e e e e e C A 045446 GRR A UE UE É ÉÉ R AN RE E E S ' # ATTENTE ARRET CLIC SQURIS * 1 el e e e o e e e e e e e d Sl et e e r ol PROCEDURE attbclac i) EXIT IF MOUSEK=0 LOUP RETURN PROCEDURE Euurîa_fleche DEFMOUSE 0 RETURN PROCEDURE souris abeïlle GEFMOQUSE Z RETURN

‘% TEST CLIC SUR ZONE ÉCRAN * A A A A r P e S S o d e m LT FUNCTION tstzone(x*,y%,px5, pyé, txs, tyf) LOCAL results result%=l IF xe<pxs — resu]t*=0 ENDIF IF x4=px&ttx+-1 result#0 ENDIF LF yésepys result#=0 ENDIF IF yve=pysitys-l result=eD ENDIF RETURN resuLl% ERDFUNE I B o A S ARl e B e o be ' * EFFACEMENT ECRAN

PROCEDURE cls _ ecran(e®) DEFFILL c% FBOX 0,0,319,199 RETURN # Ah b o i i E É É e i e e e S A RR AT * # AFFICHAGE CADRE GRAPHIQUE w

PROCEDURE cadre[px%, pys,tx%, tyd, f=,bé) LOCAL pxé%, pyes pxés“pxe+txe=l pyés=pyésttys-1 DEFFILL f # FEOX pxS,0V5, pad%s, pyas COLOR bé BOX px%,py%,px2%,pyd% RETURN

“ * AFFICHAGE MESSAGE * * DANS ROITE DE CLIC 1 ETENESÉ É R PROCEDURE aff boite(ptxad,% ty,f, pFésy, Déssa m,é) LOCAL pxes, pyes LOCAL xaff=,yaff4 pXx24=ox=+Lx==-1 pyeés=pyt+tys-1 xaffs=pxt+(tx5-LEN(m$}#8)/2 yaffa-pyetôt(tyt-7)/2 ATARI MAGAZIME H BEST-OF GRA BASIC w ¥ DEFFILL 3% PEOX px%,pye, prés, pyés COLOR b* EOX px* pyt, pX24 , pyd=x TEXT xa, fvafffä,*mf RETURN

! * CHARGEMENT DU FICHIER BINAIRE % ! + CONTENANT LES ELEMENTS GRAPHIQUES * I ORRÉÉÉÉTARARRE NN RR E E RRARERARA RE PROCEDURE charge elements({fichierf) LOCAL n% LOCAL palettet ; palettet=SPACE$(32} OPEN “1” ,#1,fichierf BGET #1,VARPTK(palette$),32 VOID XBIOS (6;L:VARPTR(palette$)) nb elementsi=INP{#1) FOR n%=1 TD nb_elements* element$(n%)=5PACE$ (134) BGET #1,VARPTR(element#(n#}},134 MEXT n% CLOSE #1 RETURN L EACAAUARERE S R RR E RE RV e e d d d e * * INITIALISATION DE LA CARTE *

PROCEDURE init carte ARRAYFILL carte[(),l RETURN D R e b L e R S R o ' * AFFICHAGE IMAGE EDITEUR *

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

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 *

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 ï ä

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

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| (colonne#,ligne carte%) PUT px%,py“#,elementi{n=}) INC colonnes ADD px#,16 NEXT cÆ @visualisecar ttriavoainl SHOWM ENDIF RETURN

“* 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| (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|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| (colonnes,ligne#) L v R Rk é é b e d r R F ÈÊÜÏEËAËÜE ÉAHÏE SUH ÜIEÛUE * PROCEDURE aller droite | #* 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|(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£+“ |CONTINUER SAUVEGARDE ? |” J bs hc e bbb e odofnl kot etk sortie==0 vax=ycarte# ALERT O,mb, 1, “OUT | MON” , b “ * INCREMENTATION ELEMENT COURANT * m$=“VOULEZ-VOUS VRAIMENT |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

RRh dc ÉÉÉ É É R ok kAR E R TRN VNA RE REN E RIR Baff É]Ë…Ëfiï courant m$=m5+“|{E] 1991 ATARI HflEflEIHE“

“ + 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| 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= Gcharge elements (“ELEMENTS.BIN®) @init carte HIDEM GRAPHMODE 2 @aff ecran @aff carie BMOVE XBIOS(Z2),adr2%,32000 @souris fleche SHOWM etats=1 @gestion eciteur RETURN Pour finir Nous verrons le mois prochain comment uriliser les cartes générées par EDITCART pour gérer les déplacéments d'une équipe de personnagés sur un monde virruel (affichage de l'image de l'equipe sur la carte, gestion des rencontres, interdictions où Autorisation de deplacements sur certaines cases, e'n:] Vous trouverez én E:ËlÈ:härg,Emflnl: sur le 3615 ATARI les listings de l’article, un exemplé de carte et une image Degas contenant quelques éléments de dessin. Patrick Leclereq