GRAPHIC CITY (c) UBI SOFT

                                 PRSENTATION


GRAPHIC   CITY   est  un  ensemble  de  programmes  destiné  à  exploiter  les
possibilités graphiques de votre ordinateur.

Il s'adresse :

-  au  programmeur  amateur  qui accèdera à des possibilités étendues avec des
utilitaires simples d'emploi.

-  au  professionnel  qui  pourra,  grƒce aux commandes fournies, réaliser les
mêmes programmes en 5 fois moins de temps.

Les  trois  modes  graphiques de l'Amstrad sont utilisés. Le mode 0 permet des
animations  rapides  en  16  couleurs.  Le  mode 1 offre le meilleur compromis
couleur/définition,  et  avec  ses  320 x 200 pixels, correspond à un standard
dans  l'informatique individuelle. L'éditeur SPRITEMATE utilise 10 couleurs en
mode 1.

Cependant,  ce  mode  est  le  plus  difficile à programmer quand il s'agit de
réaliser  des  animations,  mais  les  routines  qui sont fournies prennent en
charge  l'essentiel  et dispensent d'une programmation assembleur du mouvement
des objets.

Les  lutins se déplacent à travers les décors en 3 D, et, comme l'introduction
en  donne  démonstration,  passent  devant le décor ou disparaissent derrière.
L'affichage  ou  le  déplacement  d'un  lutin  se  fait  à  l'aide d'une seule
commande.

La  collection  d'utilitaires  composant  GRAPHIC  CITY  offre  la plus grande
facilité  à  créer  des  lutins  de  toutes  tailles et obtenir des animations
vivantes.  Deux  éditeurs puissants, SPRITE 16 et SPRITEMATE, écrits en partie
en  langage-machine,  sont  capables  de réorganiser les tables. On peut aussi
prendre  les lutins directement sur des logos réalisés avec un éditeur d'écran
quelconque, grƒce au programme CAPTURE.

En  version  disque,  plusieurs  autres  programmes complètent un tool o— sont
dévoilés les secrets de la réalisation des jeux d'arcades et aventures : tracé
de "path" (chemins), générateur de caractères, compresseur d'images...

La  compatibilité entre tous ces programmes fait de GRAPHIC CITY un système de
programmation intégré graphique qui a une diffusion internationale.


                                   SOMMAIRE


1.  Pour démarrer

2.  Liste des programmes

3.  Sprite 16 et Spritemate

4.  Video Sprite

5.  Capture

6.  Fusion

7.  Lutins : commandes

8.  Multiset

9.  Palhmake

10.  Lutins 2

11.  Cruncher et Décruncher

Annexes : utilisation en assembleur. utilisation sur 464 disk



                               1. POUR DMARRER


TAPER : RUN "CG"

pour charger le menu général qui permet d'appeler le programme désiré.

RUN "DEMO" pour la deuxième face de la disquette.


                           2. LISTE DES PROGRAMMES


-  INTRODUCTION  :  Utilise  les  commandes  de  lutins  avec la création d'un
   tableau et animation en mode 1.

-  DEMO 16 (disk) : Démonstration d'animation en mode 0.

-  LUTINS  ET  LUTINSO : 17 commandes graphiques et d'animation pour le mode 0
   ou le mode 1.

-  Lutins 2 : routine de lutins en mode 2.

-  Sprite 16 : éditeur de lutins en mode 0.

-  Spritemate : éditeur de lutins en mode 1 et 2.

-  Vidéo  sprites  (disk)  : pour présenter, reclasser, supprimer, surimposer,
   les lutins d'une table.

-  Capture  (disk)  ;  créer des lutins en les "capturant" sur l'écran. Permet
   aussi de créer des écrans par composition de lutins.

-  Fusion :

-  Multiset (disk) : pour redéfinir les caractères.

-  Pathmake  (disk)  : dessine un chemin que l'on donne à suivre aux lutins en
   jeu d'arcade.

-  Cruncher (disk) : compacteur d'images.

-  Décruncher : affiche les images compressées.


                          3. SPRITE 16 ET SPRITEMATE

                               A - PRSENTATION

Sprite  16  et  SPRITEMATE  sont  des  éditeurs de lutins dotés d'un interface
utilisateur  moderne  comprenant  un  menu  général  à icônes et des commandes
d'éditions puissantes.

Leur  facilité d'utilisation permet à un dessinateur néo-phite de réaliser des
dessins de facture professionnelle.

-

Les  lutins  peuvent  être  réalisés  sur SPRITEMATE en mode 1 en 10 couleurs,
avec  4 couleurs de base et 6 couleurs par tramage. Le mode 2 n'autorise que 2
couleurs.  Ils sont insérés dans une table exploitée par les programmes LUTINS
ou  LUTINSO  dont  un  exemple  d'utilisation  est  fourni  par l'introduction
(programme INTRO) et DEMO mode 0.

Cette  table  peut  contenir 127 lutins pour une taille mémoire limitée à 13 k
octets  dans SPRITEMATE et 16 k octets dans SPRITE 16, ces limitations pouvant
être  dépassées  grƒce  aux autres utilitaires fournis. La taille maximale des
lutins  est  de 45 pixels de haut sur 40 de large en mode 1 et 45 x 20 en mode
0.


                         B - OPTION DU MENU A ICâNES


Pour  sélectionner une option dans le menu à icônes on déplace la main en face
de l'option voulue avec les flèches et on presse ENTER.

Ce menu à icônes propose six options, de gauche à droite :

-  DITER

Pour  créer  un lutin ou modifier un lutin présent dans la mémoire de travail.
L'icône  représentant  un crayon est surmonté d'un nombre qui est le numéro de
mode de dessin :

-  1 : mode graphique 1 en simple agrandis-

sement et cadrage.

-  2 : mode graphique 2.

-  3 : mode graphique 1 en double agrandissement et sans cadrage.

Pour  sélectionner  un  mode,  on  presse  simplement  sur la touche 1,2 ou 3.
L'édition  fait  l'objet  de  chapitres particuliers détaillant ses nombreuses
commandes.

-  CHARGER

Chargement   d'une   table   de  lutins  déjà  édités.  Cette  table  comporte
l'extension LUT par défaut.

On  donne  le  nom  de  la  table  à  charger  sans  taper l'extension qui est
automatiquement  ajoutée, puis ENTER en ayant pris soin au préalable d'insérer
la  disquette  contenant  la table à charger, le programme ne disant pas de le
faire.

Il  est  possible d'obtenir le catalogue d'une disquette à ce niveau en tapant
' ? ' suivi de ENTER à la place du nom.

-  SAUVER

Opère comme l'option précédente avec les mêmes spécifications.

-  CLASSE

Cette  option  donne  accès  à  plusieurs possibilités dont la première est la
présentation des lutins dans la table.

Le  nombre  de  lutins  présents  est  inscrit  sous  l'icône représentant une
armoire.  Les flèches changent le lutin présenté dans la fenêtre. On presse la
barre  d'espacement pour quitter cette option ou l'on utilise les commandes de
réorganisation :

)dition  :  pour  reprendre  un lutin en édition, on aura le choix ensuite de
remplacer  le lutin modifié par la nouvelle version ou d'ajouter celle-ci à la
table.

D)éplacement  :  permet  de  reclasser  la  table. Presser D lorque le lutin à
déplacer  est  représenté,  sélectionner  un  emplacement avec les flèches, et
presser ENTER.

CONTROL - C :   Supprimer   le   lutin

présenté.

Surimpression  :  placer  deux  lutins  l'un  sur  l'autre  pour vérifier leur
alignement ou faire apparaître

les modifications.

- PALETTE

L'option  palette  de SPRITEMATE nous montre comment est réalisé le tramage de
couleurs  composées  à  partir  de  couleurs  de  base et permet de choisir la
couleur  d'encre  attribuée  à un numéro de couleur. Pour ce faire , on presse
les  touches  :  0,  1,  2,  3,  selon que Ton désire changer l'attribution de
l'encre  pour  le  numéro  de couleur 0, 1, 2 ou 3, ce qui sélectionne l'encre
suivante,  et  Ton  continue  de  presser jusqu'à ce que l'on obtienne l'encre
voulue.  La  séquence  des  encres  peut-être  trouvée  soit sur le boîtier de
l'ordinateur, soit sur le manuel fourni avec celui-ci.

Presser la barre d'espacement pour quitter cette option.

Noter  que le choix d'encre ne modifie pas le programme dont les couleurs sont
immuables, mais n'intervient que sur l'écran d'édition.

-  EXIT/ETAT MEMOIRE/OPTIONS

                               SUPPLMENTAIRES

La  dernière  option  permet  de  quitter  le programme, d'indiquer la mémoire
libre, et la taille de la table en mémoire.

Les  commandes  de  chargement/sauvegarde  concernent la mémoire de travail et
permettent de sauver un travail en cours avec les couleurs tramées, lesquelles
sont décomposées en couleur de base quand un lutin revient en édition.

C - COMMANDES DE BASE D'DITION


                                      8
-  Déplacement du curseur :        4     6
On utilise les touches                2

-  Pinceau levé/baissé :

Presser  la  barre  d'espacement pour baisser le pinceau, et la presser encore
pour  le  lever. En bas de l'écran à droite une flèche est dirigée vers le bas
si le pinceau est baissé et vers le haut autrement.

-  Couleurs :

Utiliser les flèches pour sélectionner une couleur.

-  Sur SPRITE 16 :

Les  flèches  verticales  sélectionnent  le  numéro  de  couleur,  les flèches
horizontales attribuent une teinte parmi 27 à ce numéro.

- Sur SPRITEMATE :

Le  numéro  de  couleur courante est indiqué en bas à droite de l'écran devant
la  flèche, et désigné en outre sur la palette toujours en bas à droite par un
trait de couleur.

-  Point :

Pour  placer  dans  la  couleur  courante un pixel, presser "5". On peut ainsi
dessiner point à point avec le pinceau levé.

-  Effacer l'écran :

Taper  CONTROL-C  pour  effacer  l'écran (presser la touche CONTROL d'abord et
sans relƒcher, presser la touche C).

-  Compiler le lutin :

La  compilation  sera  instantanée  et  le lutin apparaîtra en grandeur finale
dans une fenêtre en haut à gauche.

Presser  ENTER  pour  entrer en mode cadrage. Si l'on désire seulement voir le
résultat  final,  presser  ESPACE pour revenir en mode édition, dans ce cas le
lutin n'est pas ajouté à la table.

Lorsqu'il   est  achevé,  on  opère  un  cadrage  semi-automatique  permettant
d'optimiser l'espace utilisé par le lutin.

Deux  paires  de  coordonnées sont nécessaires : la marge inférieure gauche et
la  marge  supérieure droite. La première n'est pas spécifiée, elle est donnée
par  le  bord  de  l'écran,  les  commandes  de  scrolling  (voir  ci-dessous)
permettant de cadrer le lutin dans la fenêtre. La seconde qui limite la taille
de la fenêtre est donnée en dépla‡ant le curseur de cadrage après avoir pressé
ENTER.

En  mode  1  son  déplacement  horizontal  se  fait  par sauts de 4 points car
l'ordinateur  regroupe  4  pixels  dans  un  octet. En mode 0 par saut de 2 (2
pixels par octet) et en mode 2 par saut de 8 (8 pixels par octet).

Presser ENTER pour compiler le lutin, pressez ;

-  ENTER une dernière fois pour ajouter le lutin à la table.

-  Remplace pour substituer le lutin modifié ayant servi de modèle, ou

-  ESPACE pour revenir en cas de mauvais cadrage.

Quitter : Pressez "Q".


                       D - COMMANDES D'DITION VOLUES


Scrolling :

L'écran d'édition peut être déplacé dans les quatre directions avec les touches :

                                       E
                                     S   D
                                       F

Insertion :

"I"  dédouble  la colonne o— se trouve le curseur et l'écran est décalé sur la
droite à partir de cette colonne.

"J"  dédouble  la  ligne  o—  se trouve le curseur et l'écran est décalé d'une
ligne vers le haut à partir de cette ligne.

Surpression :

"K"  supprime la colonne o— se trouve le curseur. Une colonne blanche apparaît
à droite de l'écran.

"L"  supprime  la  ligne o— se trouve le curseur et une ligne blanche apparaît
en haut de l'écran.

Filling :

Taper P)eindrc, le remplissage se fait dans la couleur courante.

Changement de couleur globale :

Cette  commande est un peu plus délicate en apparence mais évidente à l'usage.
Taper  "C"  ce  qui  fait  apparaître  sur la ligne d'indication deux pavés de
couleur  1, représentant à gauche la couleur à changer et à droite la nouvelle
couleur.  On  modifie  le  numéro de la couleur à changer et son pavé avec les
flèches  verticales,  et  celui  de  la  nouvelle  couleur  avec  les  flèches
horizontales.

Presser  "C"  à nouveau pour exécuter le changement de couleur global. Presser
une autre touche pour annuler l'ordre.

4. VIDEO SPRITES

Ce  programme  permet  de  réorganiser les tables de lutins avec un plus grand
confort  que  ne  le permettent les éditeurs. La suppression de lutins dans la
table,  les  déplacements  se  font sur une table de lutins de 16 k maximum en
mode 1 uniquement, les lutins pouvant dépasser la taille de 45 x 40 pixels. On
peut  classer  des  tables créées en tout mode, mais elles seront affichées en
mode 1.

Le programme :

La partie supérieure de l'écran permet de présenter simultanément 12 lutins.

En  bas  à  gauche  se  trouvera  toujours le lutin pointé par le curseur pour
l'opération  en  cours. Les commandes de suppression, déplacement concerneront
le  lutin  dans  cette  fenêtre.  A droite un tableau donne les numéros des 12
lutins  affichés.  Le  numéro  en  inverse  est  celui  du lutin pointé par le
curseur.  Le  libellé  en  tête  de  ce cadre indique l'opération courante, il
indique "champ visualisé" jusqu'à ce qu'une opération autre que le déplacement
soit commandée.

Chargement :

Presser  "C"  puis  donner  le  nom sans l'extension qui comme avec SPRITEMATE
est, "LUT" sauf si l'on spécifie une autre extension.

Sélection :

Le  curseur  peut se déplacer horizontalement et verticalement, Dans le second
cas  il  saute  4 numéros à la fois. Ceci, même s'il sort de la fenêtre ce qui
permet d'effectuer une rotation par 1 ou par 4 des lutins affichés.

Déplacement :

Il s'effectue en deux temps

1)  Sélection d'un lutin à déplacer qui s'inscrira dans la fenêtre à gauche et
y  restera  jusqu'à  la  fin  de  l'opé-ration.  Presser "D" une fois ce lutin
obtenu. Le libellé du cadre inférieur droit devient alors "déplacement".

2)  Sélectionner  alors  son nouvel emplacement. Le curseur affiche en inverse
le  numéro  de  lutin sur lequel il pointe. Lorsqu'il pointe sur l'emplacement
désiré, presser ENTER, le déplacement produit, le programme ramène au menu.

L'insertion  se  fait  derrière  le  numéro  pointé. En d'autres termes, si le
lutin  à  déplacer  se trouve avant le numéro pointé, le déplacement s'opérera
après  ce  numéro.  Si  le  lutin  à  déplacer  se  situe  après ce numéro, il
remplacera le lutin ayant ce numéro qui sera décalé, avec les suivants.

Suppression :

Taper control-C, autrement dit, presser la touche

CONTROL  puis,  sans  relƒcher,  presser "C", pour supprimer le lutin présenté
dans la fenêtre en bas à gauche.

Surimposition :

Permet  de vérifier l'effet obtenu par la combinaison de deux lutins. On opère
exactement comme en mode déplacement.

Cette commande n'effectue aucune modification dans la table.


                              5. CAPTURE (disk)


CAPTURE  constitue  un  interface  idéal  entre  votre  éditeur  d'écran et ce
système d'animation.

Il permet :

-  de capturer des lutins sur un logo pour les animer dans vos programmes.

-  de composer un écran à l'aide de lutins.

- de placer dans une table des images de toute

taille.

- d'utiliser l'écran pour combiner des lutins.

-  etc..

La taille des lutins n'est plus limitée que par la taille de l'écran.

Fonctionnement :

L'espace  de mémoire ne permettant pas de stocker simultanément deux écrans et
la table de lutins, les commandes ne seront pas présentées dans le programme.

CAPTURE  fonctionne en deux modes, mode capture o— Ton se trouve au départ, et
mode composition.

Le  premier  se reconnaît par un bloc d'écran inversé qui est le curseur. Dans
le  second  mode,  c'est un lutin qui sert de curseur. Les commandes propres à
ces deux modes seront détaillées plus loin.

Programmation des opérations :

Mode : 0, 1 ou 2 (1 par défaut).

Taille  maximale  limitée.  Il  faut imposer cette limite de 45 x 40 pixels en
mode  1 si Ton veut rééditer ensuite les lutins avec SPRITEM ATE et se limiter
à  45  x 20 pour les rééditer avec SPRITE 16. Taper O ou N, l'option oui étant
prise par défaut.

cran  à  charger  :  donner  le  nom avec ou sans extension LUT par défaut ou
presser  ENTER  si l'on ne désire ni charger ni créer de table. Dans ce cas le
travail aboutira à la création d'un écran.

Charger la table : taper O ou N, option N par défaut.

cran à sauver : donner le nom ou presser ENTER.

Suivre  ensuite  les  indications que donne le programme. A la fin du travail,
récran  sera  automatiquement  sauvé  s'il  y  a lieu. La table sera également
sauvée mais on demandera confirmation du nom de cette table avant sauvegarde.

Mode capture/composition :

Taper "C" pour se placer en mode capture. Le curseur est un bloc inversé.

Taper  "D" pour déposer les lutins déjà présents dans la table sur l'écran. Le
curseur  sera  le premier lutin de la table. Presser "+" pour obtenir le lutin
suivant, "-" pour le précédent.

La capture d'un lutin : On cadre l'image avec les touches suivantes ;

-  Flèches pour déplacer le curseur inversé.

-  6 élargir le bloc.

-  4 réduire la largeur.

-  8 augmenter la hauteur.

-  2 réduire la hauteur.

-  Presser ENTER : un bip sonore indique que le lutin est ajouté à la table.

-  Le bloc inverse reste présent pour le lutin suivant.

Déposer un lutin sur l'écran :

Se  placer  au préalable en mode dépose, comme indiqué plus haut (taper "D" et
utiliser "+" et "-").

Déplacer  le  curseur  avec  les 4 flêches. Prendre garde à ce que le lutin ne
dépasse  pas  les  limites  d'écran,  aucun contrôle n'est fait à droite et en
haut, et cela créerait des dommages dans le programme et les données.

Presser  ENTER  pour le déposer ce qui fait disparaître le lutin. Utiliser les
flêches : on constate la réapparition de l'image qui complémentait elle-même.

Quitter et sauver : Presser "Q" et laisser la sauvegarde s'opérer.


                                  6. FUSION


Cet  utilitaire  permet  de  fusionner  deux tables de lutins, et de créer une
nouvelle table dont la taille peut aller jusqu'à 30 octets.

7. LUTINS ET LUTINS 0

Ces routines occupent les adresses &9800 à &9FFF, soit 2 K octets.

Elles s'initialisent par CALL &9B00 ou CALL 39680.

Une table de sprites se charge n'importe o— en mémoire :

LOAD "nom.lut", xxxx

précédé de MEMORY xxxx-1

La commande ADR utilisera xxxx comme paramètre.

Les  commandes  sont  identiques dans les deux modes, seul change le paramètre
de  position horizontale x. En mode 1, x est compris entre 0 et 319, en mode 0
il va de 0 à 79.

Une  table  peut  contenir 127 lutins, de 45 x 40 pixels en mode 1, 45 x 20 en
mode 0 ou de taille illimitée si on ne les réédite pas avec les éditeurs.

Commandes de lutins et gestion d'écran :

ADR           |ADR.adresse

Passe l'adresse de la table de lutins, la même que l'adresse de chargement.

Cette  adresse  doit être un multiple de 256, donc un chiffre terminé par deux
zéros en hexadécimal.

SPRITE       |SPRITE, no, x, y

Dessine un lutin devant le décor, à la position horizontale x et verticale y.
no est le numéro du lutin.

x est compris entre 0 et 319 en mode 1.

0 et   79 en mode 0. y est compris entre 0 et 199.

ISPRITE

Commande  au  format  similaire à la précédente. Le lutin est dessiné derrière
le décor.

SCREEN

Format  |SCRENN,  &C000 Permet d'afficher le second écran (SCREEN &4000) et de
revenir au premier (SCREEN, &C000).

COPY

Format |COPY, longueur, départ, arrivée, ou |COPY, départ, arrivée.

Dans  le premier cas, sert à copier un buffer sur un autre. Si la longueur est
omise,  la  valeur &4000 qui est la taille d'un écran est prise par défaut, la
copie d'écran utilise donc le second format.

CL

Format |CL sans paramètre ou |CL, x, y, largeur, hauteur.

La commande CL sans paramètre efface l'écran entier.

Les  paramètres  permettent  de  spécifier  une  fenêtre  dont  on  indique la
position  horizontale  x,  la position verticale y, ainsi que la largeur et la
hauteur.

x varie de 0 à   79 dans les deux modes. y varie de 0 à 199.

Commandes nécessaires à l'animation sur 1 page

Lorsque  l'animation se produit sur un fond noir> une seule page graphique est
nécessaire.

BADR          |BADR, adresse

Passe  l'adresse  d'une  zone  de  mémoire  de  travail  nécessaire  pour  les
animations.  La  taille  de cette zone dépend de la taille des lutins, soit, à
partir de l'écran de SPRITEMATE :

h = nombre de points en hauteur. 1 = nombre de points en largeur.

Taille :lxh/4 + 2xh + 2

Multiplier par 2 pour le mode 0

La  taille maximale est de 902 octets pour les lutins créés avec SPRITEMATE et
452 avec SPRITE 16.

On  peut  donc  simplifier  en utilisant un buffer de 1 k (&400&) en mode 1 et
512 octets (&200) en mode 0.

Ce  buffer  peut  être  placé  n'importe o— en mémoire, en préservant les zone
suivantes :

&9800-&9FFF : lutins ou lutins 0 &A67B-&FFFF : système et écran

Optionnellement :

&A003-&A67A : générateur de caractères s'ils sont redéfinis.

&4000-&7FFF : second  écran éventuel,  qui peut également  être placé ailleurs
              en mémoire si l'on ne raffiche pas avec SCREEN.

1TO1           |1TO1, no, x ,y

Prépare  le  buffer  de travail pour l'insertion d'un lutin. Cela a pour effet
de placer la partie d'écran qu'il occupera dans le buffer. NO est le numéro de
lutin, x et y ses coordonnées.

CLB           |CLB, no, x, y

Efface  le  buffer  courant.  Les  Paramètres  sont  ceux  que  LTRANS  aurait
normalement utilisé.

LTRANS     |LTRANS, no, x, y

Place le lutin no dans le buffer, il sera dessiné devant le décor.

ITRANS

Comme précédemment, mais il sera dessiné derrière

le décor.

SHOW

Affiche le buffer, il n'y a aucun paramètre.

Exemple  de  séquence  pour  dessiner le lutin 1 en position 18,20. On suppose
les commandes ADR et BADR

déjà passées.

|CLB, 1, 18, 20 |LTRANS, 1, 18, 20 |SHOW

SPMOVE     |SPMOVE, no, x, y

Regroupe CLB + LTRANS + SHOW

Commandes complémentaires pour l'animation

dans un décor

SCREEN     |SCREEN : adresse

Permet  de  définir  comme  écran  et  de visualiser une part quelconque de la
mémoire. Les seules adresses pratiquement opérationnelles sont :

C000  l'écran normal &4000 un second écran qui occupe les positions de &4000 à
&7FFF, positions de mémoire allouées à cet effet.

1TO2           |1TO2, no, x, y

Place  dans  le  buffer  le  fond  d'écran  occupé  par  le lutin no en vue de
l'afficher sur l'écran 2, actuellement présenté ou non.

2TO2          |2TO2, no, x, y

Place  dans  le buffer le fond d'écran occupé par le lutin no sur l'écran 2 en
vue de l'afficher sur l'écran 2.

Commandes d'animation avec un second écran

LMOV        |LMOV, no, x, y

Efface le lutin no sur sa position actuelle et l'affiche en coordonnées x et y.

Utilise un second écran sur lequel on a copié le premier avec la commande COPY.

IMOVE

Opère comme précédemment, mais effectue l'animation derrière le décor.

Exemple de réalisation d'animation avec deux pages

d'écran :

1) Initialisation de la séquence

|ADR,  &8000  adresse  des  lutins,  passée  une  fois pour toute, sauf si Ton
              utilise plusieurs tables.

|BADR,  &9000  adresse  du  buffer  de travail. On peut en utiliser plusieurs,
               sinon, passée une fois pour toute.

|COPY,  &C000,  &4000  copie l'écran sur la seconde page. La seconde page peut
                       être mise à jour avec la commande |1TO2.



2) Animation

|SPRITE, 1, 18, 20

|LMOVE, 1, 17, 21 déplace le lutin 1 de la position 18, 20 en 17, 21.


                              8. MULTISET (dise)


C'est  un  utilitaire de redéfinition de caractères. Précisons que la commande
BASIC  permet  de  fournir  un listing de redéfinition en Basic, alors que les
commandes L)oad et S)ave se rapportent aux mêmes données en format binaire.

L'édition   du   caractère   se  fait  à  l'aide  des  flèches,  de  la  barre
d'espacement, et ENTER pour finir.

On utilise les caractères redéfinis avec les commandes :

1) SYMBOL AFTER 33 (et non 32 qui correspond au code espace).

2)  suivi de

-  soit  le  listing  basic  que  l'on  fusionne au programme avec la commande
MERGE.  Ce listing se trouve sur la disquette après que l'on ait tapé "B)asic"
à partir du Multiset.

- soit le chargement du fichier binaire.

Exemple :

10 SYMBOL AFTER 33
20 LOAD "ASCIL.BIN' ' Les caractères redéfinis ayant été sauvés dans le fichier ASCIL.BIN.


                             9. PATH MAKE (disc)


La  combinaison  des  routines  d'animation  de  LUTINS  et  de  ce  programme
permettent  de réaliser un jeu d'arcade en quelques heures. On prédéfinit avec
PATH  MAKE  le  chemin  ou  "path"  que suivront les lutins en déplacement sur
l'écran.  Le  programme  DEMOl  contient  la  routine  basic  qui lit la table
correspondante.  Il  est  également  possible  d'utiliser  le  programme  pour
réaliser  des  dessins translatables sur l'écran, comme le montre le programme
DEMO.

Commandes :

Flèches : Déplacer les coordonnées de départ.

Pavé numérique : Tracé du chemin en 8 directions.

L : Charger un chemin.

S : Sauver un chemin.

E : Effacer et retracer le chemin en mémoire.

C : Effacer la mémoire.

A  : l'adresse  de  départ.  Prendre  garde  au programme  en mémoire. La zone
     mémoire disponible se situe entre :

Début : &4000 16384 Fin      : &A000 40960



                                 10. LUTINS 2


Occupe les adresses &9C00   39936

S'initialise par : CALL &9E00 ou CALL 40448

Commandes :

ADR : passe l'adresse de la table de sprite

Exemple :  |ADR, &8000 Si la table est chargée à l'adresse &8000.

SPRITE  :  dessine  un  lutin
 Format : |SPRITE, no, x, y
           x varie de 0 à 639
           y varie de 0 à 199

Exemple :  |SPRITE, 1, 5, 10

XSPRITE  :  comme  précédemment, mais dessine en inversant la couleur du fond.
En  passant  cette commande 2 fois, on dessine le lutin la première fois et on
restitu le fond original la seconde.


                      11. CRUNCHER et DECRUNCHER (disc)


CRUNCHER permet de compresser une table de spri-tes ou d'écrans.
Pour compresser un écran on exécute les opérations suivantes :

1)  placer  l'écran  en  table  avec CAPTURE. (mode 0/1/2, taille non limitée,
table non chargée).

2)  utiliser CRUNCHER pour compresser la table, dont la taille est ici limitée
à 16 k.

3)  utiliser FUSION pour réunir les écrans compressés en une seule table de 30
k maximum.

4) DECRUNCH.BIN permet d'afficher les écrans par numéros.

DECRUNCHER offre la démo de la routine d'affichage de tables compressées.

DECRUNCH.BIN se charge n'importe o— en mémoire, et occupe 151 octets.

Commandes  : CALL adresse-routine, adresse-table CALL adresse-routine + 3, no,
x, y

adresse-routine   =   adresse   o—   est   chargé DECRUNCH.BIN (ex : &A000)

adresse-table = adresse o— est chargée la table

no = numéro de sprite ou d'écran

x = position horizontale entre 0 et 79 en tous

modes

y = position verticale entre 0 et 199



                                   ANNEXE 1

                     UTILISATION DES LUTINS EN ASSEMBLEUR


I. Utilisation de LUTINS ET LUTINS 0

Le  passage  des  paramètres  se réalise en assembleurs selon la fa‡on dont le
système RSX de l'Amstrad traite les variables :

- Le registre IX pointe sur le début de la table des paramètres.

-  La  table  des  paramètres  contient  d'abord  la  dernière  variable de la
commande, puis l'avant dernière, et ainsi de suite.

-  Chaque  valeur  est  convertie  en  entier de deux octets, le premier octet
contenant la partie basse.

Exemple :  |COPY, &2000, &1000

                        00 20
               IX       00 10

adresses des CALLs :

&9B0F   ADR &
&9B12   CL
&9B15   SCREEN
&9B18   BADR
&9B1B   SPRITE
&9B1E   ISPRITE
&9B21   LTRANS
&9B24   ITRANS
&9B27   SHOW
&9B2A   1TO1
&9B2D   2TOl
&9B30   2TO2
&9B33   COPY
&9B36   LMOVE
&9B39   IMOVE
&9B3C   SPMOVE
&9B3F   CLB

Tous les registres utilisés doivent être sauvegardés avant l'appel, sauf les registres auxiliaires.

II. Utilisation de LUTINS 2

Adresse des CALLs :

&9E0F   ADR &9E12   COPY &9E15   SPRITE &9E18   XSPRITE

Mêmes remarques que pour LUTINS et LUTINS 0



                      ANNEXE 2 UTILISATION SUR 464 disk


Le  464  contient  un  bug relatif au chargement des fichiers, dont le nom est
mai interprété, et qui provoque un "NO FOUND".

Si  cela survient, taper CONT et ENTER, Terreur ne se produisant pas deux fois
de suite.

------------------------------------------------------------------------------
                          Retyped in 2011 by hERMOL
                    Visit my website at http://CPCRULEZ.fr
------------------------------------------------------------------------------