; #A08B RSX ENCRE, Coul1 [, Coul2] [, Coul3] [, Coul4]
; #A090 RSX PAPIER, Coul1 [, Coul2] [, Coul3] [, Coul4]
; #A0B2 RSX CURSEUR, Col, Lig
; #A0D7 RSX GCURSEUR, Col, Lig
; #A0ED RSX AFFICHE, [Zoom,] CHAINE$
; #A16A RSX DEFMAXICHR, Numero, Lig1 [,lig2] [,lig3]... ... [,lig16]
; #A1A1 RSX MAXICHR, [Effet,] Numero
; #A22C FIXE LES RSX
; ########## - ########## - ########## - ########## - ########## - ########## - ########## - ##########
; ### Programmation AVRIL 2019 - Philippe Moulin
; ########## - ########## - ########## - ########## - ########## - ########## - ########## - ##########
; # Liste des Variables utilisees
CouleurCodee EQU #A000 ; #A00F ; 16 Emplacements pour la table des couleurs codees MODE 0
Couleur EQU #A010 ; #A017 ; 8 Emplacements pour nos couleurs (4 Encres et 4 Papiers)
Curseur EQU #A018 ; #A019 ; 2 Emplacements pour les curseur (Colonne et Ligne)
Caractere EQU #A02A ; #A031 ; 8 Emplacements pour le transfert des caracteres
Pile EQU #A032 ; #A039 ; 8 Emplacements pour des variables provisoires
TableMaxiChr EQU #A290 ; #A400 ; (368) Emplacement pour 23 matrices de 8x16
; ########## - ########## - ########## - ########## - ########## - ########## - ########## - ##########
; # Definition des variables par defaut et des couleurs codees de Mr SUGAR
ORG CouleurCodee
; # 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ; Numero du PEN en MODE 0
DB #00,#40,#04,#44,#10,#50,#14,#54,#01,#41,#05,#45,#11,#51,#15,#55 ; Couleur correspondante
ORG Couleur
DB #40, #04, #44, #10 ; 4 Emplacements pour les Encres> Defaut PEN 1, 2, 3, 4
DB #00, #00, #00, #00 ; 4 Emplacements pour les Papiers> Defaut PAPER 0, 0, 0, 0
ORG Curseur
DB 199, 0 ; (LIGNE, COLONE) par defaut en haut a gauche LOCATE 1, 1
ORG Caractere
DS 8, #00 ; 8 emplacements Utilises par les RSX
ORG Pile
DS 8, #00 ; 8 Emplacements Utilises par les RSX
; ########## - ########## - ########## - ########## - ########## - ########## - ########## - ##########
; # SOUS ROUTINES (Utilisees pas les routines, elles ne sont pas directements executables par le BASIC)
; CE> Les variables 'CarCHR'=(8ou16) 'RotCou'=(170ou136) 'Zoom'=(Hauteur du zoom) doivent etre initialisees
; CS> Tous les registres sont detruits
AfficheCarCHR
LD HL, (Curseur) ; 'H'= Col L=Lig
LD D, 0 ; On transforme les coordonnees pour les adapter
LD E, H ; 'DE' = Colonne
LD H, 0 ; 'HL' = Ligne
CALL #BC1D ; Vecteur systeme (Adresse ecran)
LD DE, Caractere ; On recupere l'adresse des octets a traiter
LD IY, Couleur ; 'IY' Pointe sur les couleurs
; Variable 'CarCHR' represente le nombre de ligne (8 pour les caracteres et 16 pour les MaxiCHRs)
; Variable 'RotCou' Indiquera apres une rotation si il faut changer de couleurs
CarCHR LD B, 16 ; 16 lignes pour les MaxiCHRs et 8 pour les caracteres
RotCou LD C, 136 ; Les couleurs tourneront a chaque BIT mis a 1
; 'C' = (10001000) > 'Carry'
; 'Carry' > (01000100)
AFFCARCHR_NbLignes
PUSH BC
; Variable 'Zoom' represente la hauteur (Caractere Amstrad uniquement)
Zoom LD B, 2 ; Permet de zoomer les caracteres Amstrad en vertical
AFFCARCHR_ZOOM
PUSH DE ; DE contient l'adresse de l'octet a traiter
LD A, (DE) ; Et 'A' Contient l'octet
LD C, A ; 'C' aussi
LD E, 4 ; En MODE 0 il faut 4 octets pour les 8 BITs par ligne
AFFCARCHR_QuatreOctetsParLigne
LD A, (IY + 0) ; 'A' contient la couleur de l'encre gauche et droite
LD D, A ; 'D' aussi
SLA C ; Pixel de gauche, Chaque bit est teste
JR C, AFFCARCHR_CouleurGauche
LD D, (IY + 4) ; Le point gauche est off, 'D' contient la couleur du papier
AFFCARCHR_CouleurGauche ; La couleur de gauche est dans 'D'
SLA C ; On regarde si le bit droit est allume (=1)
JR C, AFFCARCHR_CouleurDroite ; 'A' Contient toujours la couleur de l'encre
LD A, (IY + 4) ; Ou celui du papier maintenant
AFFCARCHR_CouleurDroite
SLA D ; On ajuste la couleur (Pour la gauche seulement en MODE 0)
ADD A, D ; 'A' contient l'octet (point Gauche et droit)
AFFCARCHR_Effet
; Reservation d'un emplacement pour ajouter un effet d'affichage
; OR (HL)=#B6 --- AND (HL)=#A6 --- XOR (HL)=#AE --- NOP=#00 ---> (POKE &A06D,xx)
NOP
LD (HL), A ; On affiche 2 pixels de l'octet
INC HL ; Suivant S.V.P.
DEC E
JR NZ,AFFCARCHR_QuatreOctetsParLigne
; Calcul l'emplacement pour descendre d'une ligne ; 'HL' sera incremente d'une ligne - 4 octets
LD DE, #800-4 ; Quand Quasar nous donne la reponse! Merci
ADD HL, DE ; On descent d'une ligne
JR NC, AFFCARCHR_LigneDeDessous
LD DE,#C000+80 ; Mais si il y a debordement hors ecran
ADD HL, DE ; On corrige la cote
AFFCARCHR_LigneDeDessous
POP DE
DJNZ, AFFCARCHR_ZOOM ; Boucle du ZOOM
POP BC
RRC C ; Tourne les couleurs suivant la valeur dans 'C'
JR NC, AFFCARCHR_RotationCouleur ; 'C'= '10001000' pour les MaxiCHRs
; 'C'= '10101010' Pour les caracteres
INC IY ; En incrementant le pointeur des couleurs
AFFCARCHR_RotationCouleur
INC DE
DJNZ, AFFCARCHR_NbLignes ; On passe les 8 ou 16 lignes a afficher
RET
; ########## - ########## - ########## - ########## - ########## - ########## - ########## - ##########
; ROUTINES (Utilisables avec la commande CALL et dans les memes conditions que les RSX
; # RSX ENCRE et RSX PAPIER C'est deux RSX font le meme topo, seul le registre 'HL' du depart change
RSXENCRE
; ENCRE, Coul1 [, Coul2] [, Coul3] [, Coul4]
; PAPIER, Coul1 [, Coul2] [, Coul3] [, Coul4]
; CE > Les parametres [optionnels] gardent leurs anciennes valeurs
LD HL, Couleur - 1 ; 'HL' est positionne sur l' emplacement des encres - 1
JR PourLePapier ; On saute pour la suite du programme
RSXPAPIER
LD HL, Couleur + 3 ; 'HL' pointe sur l'emplacement du papiers - 1
PourLePapier ; A ce stade, 'HL' pointe soit sur les encres soit sur les papiers
CP 5 ; On regarde si on ne depasse pas les 4 parametres
RET NC ; Sinon on sort sans bouder vers le basic
OR A ; Et si il n'y a pas de parametre
RET Z ; On quitte le navire aussi
LD B, 0 ; On va ajouter a 'HL' le nombre de parametres
LD C, A ; 'C' = nombre de parametre
ADD HL, BC ; 'HL' pointe sur la derniere couleur a traiter
LD B, A ; 'B' contient le nombres de parametre
Couleur_Encre
LD A, (IX + 0) ; 'A' = valeur du parametre
CP 16 ; Si >= 16, il n'y a que 16 couleurs en MODE 0
RET NC ; On ne reste pas, Faut pas pousser non plus
; Les couleurs sont codees et il faut chercher la correspondance avec les couleurs du MODE 0
LD DE, CouleurCodee ; 'DE' pointe sur la table des couleurs codees
ADD A, E ; 'A' Contient le numero de la couleur demandee
LD E, A ; 'DE' Pointe sur la correspondance de la couleur demandee
LD A, (DE) ; 'A' est charge avec le code de la couleur codee de MODE 0
LD (HL), A ; On l'incrit simplement dans 'HL'
DEC HL ; Et on passe a la couleur suivant
INC IX
INC IX ; Et aussi au parametre suivant
DJNZ Couleur_Encre ; On recommence tant qu'il y a des parametres
RET
; # RSX CURSEUR
RSXCURSEUR
; Positionne le curseur pour le prochain affichage des maxis caracteres
; CE> CURSEUR, Col, Lig (Comme pour la commande Basic 'LOCATE' du MODE 0)
CP A, 2 ; Si le nombre de parametres envoye est different de 2
RET NZ ; On renvoie au basic
LD A, (IX + 2) ; 'A' = Col
CP A , 21 ; Col (1 a 20) MODE 0
RET NC ; Retour au basic, parametres non valides
CP A, 1
RET C
DEC A ; On reajuste pour les calculs (0 a 19)
ADD A, A ; (x2)
ADD A, A ; (x4)
ADD A, A ; (x8) Par 8 car chaque caractere fait 8 points de largeur
LD H, A ; 'H' Contient la valeur pour les Colonnes
LD A, E ; 'A' = Lig (A l'appel du RSX, 'E' contient le dernier parametre)
CP A, 26 ; Lig (1 a 25) On garde le principe du 'LOCATE'
RET NC ; Retour basic, les parametres ne sont pas valides
CP A, 1
RET C
DEC A ; Mais il faut soustraire 1 car les vrais coordonnes commence a 0
ADD A, A ; (x2) Il faut multiplier sa valeur par 8
ADD A, A ; (x4)
ADD A, A ; (x8) multiplie par 8, 1 caractere=8 lignes
LD L, A ; 'L' contient les lignes en partant du bas
LD A, 199 ; Pour partir du haut a gauche, il faut inverser les lignes
SUB A, L ; Car la position de depart commence en bas a gauche
LD L, A
LD (Curseur), HL ; On inscrit les coordonnees a l'abris des poussiere
RET
; # RSX GCURSEUR
RSXGCURSEUR
; Place le curseur en position graphique (Du bas vers la gauche)
; CE> GCURSEUR, Col, Lig (Col 0-152) et (Lig 7-199)
CP A, 2 ; Si le nombre de parametres envoye est different de 2
RET NZ ; Renvoie au basic
LD A, (IX + 2) ; 'A' = Col
CP A , 153 ; de 152 a 159 On OK pour un autre caractere
RET NC ; Sinon retour au basic, parametres non valides
LD H, A
LD A, E ; 'A' = Lig >>> 'E' = Dernier parametre donc 'A' = Ligne
CP A, 200 ; Lig (7 a 199) 7 pour rester dans l'ecran
RET NC
CP A, 7 ; De 0 a 7 on peut encore afficher un caractere
RET C ; Retour basic, les parametres ne sont pas valides
LD L, A ; Pause cafe
LD (Curseur), HL ; On inscrit les coordonnees dans la variable prevue
RET
; # RSX AFFICHE
RSXAFFICHE
; AFFICHE, A$ Les 256 Caracteres Amstrad sans ZOOM
; AFFICHE, Zoom, A$ les 256 caracteres Amstrad sont affichable et ZOOM en hauteur
; CE> A$ doit contenir au moins un caractere
; CE> Zoom (1 a 25). Valeur par defaut ou si sortie ecran ZOOM = 1
CP A, 3 ; Si le nombre de parametre envoye est >2... Retour Basic
RET NC
OR A ; Ou si il n'y en a pas >Direction BASIC
RET Z
CP A, 1 ; Si 1 seul parametre, alors ZOOM = 1, Pas de ZOOM
JR Z, AFF_PasDeZoom
LD A, (IX + 2) ; Le ZOOM doit etre verifie pour ne pas sortir de l'ecran
CP A, 26
RET NC ; Le ZOOM ne peut pas depasser 25x en hauteur
LD B, A
LD C, A
SLA B ; Il faut multiplier la hauteur par 8 pour calculer la position du curseur
SLA B
SLA B ; En deplacant les BIT vers la gauche (x2 x4 x8)
LD A, (Curseur) ; On charge dans 'A' les coordonnees des lignes du (Curseur)
DEC B ; NB> pour les coordonnees des colonnes -> LD A, (Curseur + 1)
CP A, B
JR NC, AFF_ZoomOK
LD C, 1 ; ca deborde, on remet la valeur par defaut du ZOOM pour eviter la casse
AFF_ZoomOK
LD A, C
AFF_PasDeZoom
LD (Zoom + 1), A ; On inscrit la hauteur du ZOOM VERTICAL avant d'appeler la routine
LD A, 8 ; On inscrit aussi le nombre de ligne (8=caractere et 16=MaxiCHR)
LD (CarCHR + 1), A
LD A, 170
LD (RotCou + 1), A ; Et la rotation des couleurs, 170="10101010"
LD H, (IX + 1) ; On va recuperer l'adresse de la chaine A$
LD L, (IX + 0)
LD A, (HL)
OR A ; Si la chaine est vide... Retour vers le Basic
RET Z
INC HL ; 'HL' contient l'adresse ou est stocke la chaine A$
LD E, (HL) ; Il faut faire pointer 'DE' pour recuperer les caracteres
INC HL
LD D, (HL) ; 'DE' Pointe sur le 1er Caractere de la chaine
LD B, A ; Et 'B' = Longeur de la chaine
AFF_Total
PUSH BC ; On sauvegarde la longeur de la chaine
PUSH DE ; Ainsi que l'endroit ou elle est stockee
LD A,(DE) ; 'A' contient le code ascii du caractere
AFF_AMSTRAD
LD DE, Caractere ; DE pointe vers notre table reservee pour le travail
CALL #BBA5 ; HL contient l'adresse en ROM du caractere
CALL #B906 ; On Active la ROM Inferieur pour recuperer la matrice du caractere
LD BC, 8 ; 'BC' contient le nombre d'octet a recuperer
LDIR ; Le transfert vers notre table est fini
CALL #B90C ; On restore la ROM utilisee
AFF_CHOIXOK
CALL AfficheCarCHR ; On peut affiche le caractere en appelant la sous routine
LD HL, (Curseur) ; Et modifier la position du curseur pour le prochain caractere
LD A, H ; Cette fois, il faut compter le caractere qui vient d'etre affiche
CP A, 146 ; Et voir si le prochain pourra etre affiche
JR C, AFF_ColPlus ; Alors on ajoutera 8 aux coordonnees des colonnes
LD A, L ; Sinon il faudra verifier si on peux descendre d'une ligne
CP A, 15
JR NC, AFF_LigPlus
LD H,0 ; Si ni l'un ni l'autre est possible
LD L, 199 ; On remet les origine par defaut (Haut Gauche)
JP AFF_ColLigOK
AFF_LigPlus
SUB A, 8 ; On descent d'une ligne donc Col=0
LD L, A
LD H, 0
JP AFF_ColLigOK
AFF_ColPlus
ADD A, 8 ; On se deplace d'une colonne et on garde la ligne
LD H, A
AFF_ColLigOK
LD (Curseur), HL ; La variable est remise a jour avec les nouvelles coordonnees
POP DE
POP BC
INC DE ; Puis on passe au caractere suivant
DEC B ; Et on remonte jusqu'a afficher le dernier caractere
JP NZ, AFF_Total
RET
; # RSX DEFMAXICHR
RSXDEFMAXICHR
; DEFMAXICHR, Numero, Lig1 [,lig2] [,lig3]... ... [,lig16]
; Definit un MaxiCHR de 8x16 affichable avec le RSX MAXICHR (8=largeur et 16=hauteur)
; Les parametres optionnels sont remplaces par des ZERO
; CE > Numero, (de 0 a 22), indique le numero du MaxiCHR a redefinir
CP 18 ; Si on a trop de parametre > Retour Basic
RET NC
CP 2 ; Si il y a pas assez de parametres > BASIC
RET C
LD B, 0 ; Il faut trouver le numero du MaxiCHR qui est dans le premier parametre
DEC A ; A l'appelle d'un RSX, 'A' Contient le nombre de parametre transmis
LD C, A ; 'C' = nombre de parametre moins 1
SLA C ; 'C' est multiplie par 2 car les parametres font 2 octets
ADD IX, BC ; IX pointe sur le premier parametre (L'Adresse)
LD C, A ; On remet dans 'C' le nombre de parametre moins 1 (Celui du numero)
LD A, (IX + 0) ; Et dans 'A', on inscrit le numero du MaxiCHR du premier parametre
LD HL, TableMaxiChr ; 'HL' pointe sur le MaxiCHR numero 0
OR A ; Si on veut redefinir le MaxiCHR 0, alors on a pas besoin de chercher l'adresse
JR Z, DEFMAXICHR_NUMERO
CP A, 23 ; Ne pas depasser le numero 22 pour ne pas ecraser les donnees
RET NC
LD DE, 16 ; Il faut recherche l'adresse qui correspond au numero du MaxiCHR
DEFMAXICHR_TABLE
ADD HL, DE ; Un MaxiCHR fait 16 octets, donc on ajoute 16 a 'HL' pour chaque MaxiCHR
DEC A ; Jusqu'a obtenir le MaxiCHR que l'on a indique en premier parametre
JR NZ, DEFMAXICHR_TABLE
DEFMAXICHR_NUMERO
LD A, C ; 'A' contient le nombre de parametre moins 1
LD B, 16 ; On a 16 chiffre a inscrire.
DEF_MAXICHR_Lig
LD D, 0 ; Valeur par defaut si le nombre de parametre est plus petit que 16
OR A ; 'A' sert de compteur, si 'A'=0 alors il n'y en a plus de parametre
JR Z, DEF_MAXICHR_Param
DEC IX ; On fait pointer 'IX' sur le parametre
DEC IX
DEC A ; Et on decremente le compteur de parametre 'A'
LD D, (IX + 0) ; 'D' est charge avec la valeur du parametre
DEF_MAXICHR_Param
LD (HL), D ; On inscrit soit le parametre, soit ZERO
INC HL ; et on passe au suivant
DJNZ, DEF_MAXICHR_Lig ; Jusqu' inscrire 16 valeurs au total
RET
; # RSX MAXICHR
RSXMAXICHR
; MAXICHR, [EFFET], Numero
; Affiche le MaxiCHR de 8x16 prealablement definit avec le RSX DEFMAXICHR
; Numero (0 a 22) designe le MaxiCHR a afficher
; EFFET de (1 a 4) 1=(Pas d'effet) 2=(Retournement horizontal) 3=(Retournement vertical)
; 4=(Pivotement de 90 degree)
CP A, 3 ; Maximum 2 parametres
RET NC
OR A ; Minimum 1 parametre
RET Z
LD C, A ; 'C' Contient le nombre de parametre (1 ou 2)
LD HL, TableMaxiChr ; 'HL' pointe sur le luitn numero 0
LD A, E ; EQUIVALENT LD A, (IX + 0) car 'D' contient le dernier parametre
OR A
JR Z, MAXICHR_NUMERO ; Si c'est le Numero zero, on reajuste pas la table
CP A, 23 ; Sortir car le numero est trop fort (0 - 22)
RET NC
LD DE, 16 ; 'DE' contient le nombre d'octets qui separe deux lurin
MAXICHR_TABLE
ADD HL, DE ; Additionner la table et le nombre de (MaxiCHR * ligne)
DEC A ; Jusqu'a obtenir l'adresse du MaxiCHR
JR NZ, MAXICHR_TABLE
MAXICHR_NUMERO
LD A, C ; Recuperer le Nombre de parametre
LD DE, Caractere ; 'DE' pointe vers la zone de travail
CP A, 1 ; Pas d' OPTION, donc affichage rapide Effet=1
JR Z, EFFET_01
; SE DIRIGER Vers l'Option desiree
LD A, (IX + 2) ; Lire le numero de l'OPTION
CP 1 ; Si OPTION=1 alors affichage normal
JR Z, EFFET_01
CP 2 ; Si OPTION=2 alors Rotation GD
JR Z, EFFET_02
CP 3 ; Si OPTION=3 alors rotation HB
JR Z, EFFET_03
CP 4 ; Si OPTION=4 alors rotation HB GD
JR Z, EFFET_04
; JP EFFET_01 ; Sinon ERREUR donc affichage normal
EFFET_01 ; EFFET NUMERO 1 AFFICHAGE SIMPLE
LD BC, 16 ; Option 1, On va simplement transferer les 16 Octets du MaxiCHR
LDIR ; vers la zone de travail... Voila c'est fait
JP MAXICHR_OK ; Reste plus qu'a afficher le MaxiCHR
EFFET_02 ; ROTATION GAUCHE DROITE GD
EX HL, DE ; On echange les deux registres car 'HL' est plus adapte pour cette tache
LD C, 16 ; 16 Lignes de hauteur = 16 Octets du MaxiCHR
EFFET_GD_LIGNES
LD B, 8 ; Il faut faire tourner les 8 Bits de chaques octets
LD A, (DE) ; 'A' contient l'octet a modifier
EFFET_GD_8BITS
RRA ; 'A' est pousse vers la droite, et le BIT 0 va dans le 'CARRY'
RL (HL) ; '(HL)' est pousse vers la gauche et le BIT 0 recupere le 'CARRY'
DJNZ, EFFET_GD_8BITS
INC DE
INC HL
DEC C
JR NZ, EFFET_GD_LIGNES
JP MAXICHR_OK ; Une fois les 16 octets operes, on peut afficher le MaxiCHR
EFFET_03 ; ROTATION HAUT BAS HB
LD DE, Caractere + 15 ; 'DE' pointe ver la zone de travail + 16 (0 a 15) situee en bas
LD B, 16 ; 16 lignes a transferer
EFFET_HB_LIGNES
LD A,(HL) ; 'A' contient l'octet a transferer
LD (DE), A ; Qui est inscrit en partant du bas vers le haut
INC HL
DEC DE
DJNZ, EFFET_HB_LIGNES
JP MAXICHR_OK ; Les 16 octets sont transferes, on affiche le MaxiCHR
EFFET_04 ; ROTATION 90 DEGRES HBGD
LD DE, Caractere + 15 ; On fait les deux options en meme temps
EX HL, DE ; 'HL' pointe sur la zone de travail + 16
LD C, 16 ; 'DE' est la source. 16 octets a traiter
EFFET_HBGD_LIGNES
LD A, (DE) ; 'A' Contient l'octet source
LD B, 8 ; Et on va tourner les 8 BITS pour les transferer dans 'HL'
EFFET_HBGD_8BITS
RRA
RL (HL)
DJNZ, EFFET_HBGD_8BITS
DEC HL
INC DE
DEC C
JR NZ, EFFET_HBGD_LIGNES ; Les 16 octets sont tournes puis tranferer du bas vers le haut
JP MAXICHR_OK
MAXICHR_OK
LD A, (Curseur) ; Regarder si on peut l'afficher en bas de l'ecran
CP A, 15
RET C ; Si A < 15 alors on n'affiche pas et on sort
LD A, 1
LD (Zoom + 1), A ; On inscrit la hauteur du ZOOM VERTICAL avant d'appeler la routine
LD A, 16 ; On inscrit aussi le nombre de ligne (8=caractere et 16=MaxiCHR)
LD (CarCHR + 1), A
LD A, 136
LD (RotCou + 1), A ; Rotation (10001000) A chaque 1, les couleurs changes
CALL AfficheCarCHR ; Et on affiche le caractere en appelant la sous routine
RET
NOP
; ########## ########## ##########
; MISE EN PLACE DES RSX
FIXERLESRSX
LD A, #C9 ; Un Retour au basic sera effectue pour ne pas rappeler la
LD (FIXERLESRSX), A ; mise en place des RSX en inscrivant 'C9'
LD BC, AdrNomsRSX ; 'BC' pointe sur l'adresse des noms des RSX
LD HL, BuffetRSX ; 'HL' pointe sur un buffet de 4 octets reserve par la routine
JP #BCD1 ; Fabuleuse routine qui fixe les RSX
AdrNomsRSX DW NOMSdesRSX ; 2 octets qui stocks l'adresse des noms
JP RSXENCRE ; Suivis d'autant de sauts vers les routines
JP RSXPAPIER ; Qu'il y a de noms de RSX dans le meme ordre
JP RSXCURSEUR
JP RSXGCURSEUR
JP RSXAFFICHE
JP RSXDEFMAXICHR
JP RSXMAXICHR
BuffetRSX DS 4 ; Zone de 4 Octets reserves par le vecteur RSX #BCD1
NOMSdesRSX ; Adresse des noms des RSX
STR "ENCRE" ; Chaque nom devraient finir par un + #80
STR "PAPIER" ; Mais WinApe le fait pour nous
STR "CURSEUR" ; Exemple pour la commande 'CURSEUR'
STR "GCURSEUR" ; DEFB "CURSEU", "R" + #80
STR "AFFICHE"
STR "DEFMAXICHR"
STR "MAXICHR"
NOP