; ###############################################################################################
; 09/06/2023 RETROPOKE (PHILIPPE MOULIN) 		LONGUEUR=569 MATRICES COMPRISES	        #
; LES MINIS CARACTERES EN FOLIE SONT DE RETOUR.						        #
; PLUS RAPIDES, PLUS NOMBREUX, PLUS SURS, MOINS GOURMANTS, ET TOUJOURS AUSSI FUN !!!	        #
; PLUS RAPIDES	 	TOUTES LES ROUTINES ONT ETE REVITALISEES ET AMELIOREES		        #
; PLUS NOMBREUX 	ILS SONT A PRESENT 65 SOUS VOS ORDRES (54 AVANT)		        #
; PLUS SURS		ILS SONT ARMES DE TESTS ANTI-PLANTAGE				        #
; MOINS GOURMANTS	SOIT UN GAIN DE 57 OCTETS PAR RAPPORT A LA PREMIERE VERSION	        #
; TOUJOURS AUSSI FUN	ILS N'ONT PLUS DE LIMITES EN VOTRE IMAGINATION			        #
; EN PLUS D'ETRE ENTIEREMENT COMPATIBLES SUR TOUTE LA GAMME DES AMSTRAD CPC		        #
; LES 62 MINIS CARACTERES VOUS EN FERONT TOUJOURS AUTANT VOIR DE TOUTES LES COULEURS	        #
; ###############################################################################################
ORG  #A200 					; DEBUT DU PROGRAMME SOURCE			#
FIXE_RSX					; ETIQUETTE DE L'ADRESSE DE DEPART 	        #
	LD A, #C9				; EMPECHER DE RELANCER LE PROCESSUS POUR EVITER #
	LD (FIXE_RSX), A			; QUE LES RSX INTERNES (ùDIR, ùA, ...) PLANTENT #
	LD HL, #BDF7				; ZONE LIBRE DE #BDF7 A #BE3F			#
	LD BC, ADR_NOM_RSX			; 'BC'= ADRESSE DES NOMS DES RSX         	#
	JP #BCD1				; VECTEUR QUI FIXE LES RSX EN MEMOIRE		#
						;					        #
    ADR_NOM_RSX DW NOM_RSX			; 2 OCTETS PRIS PAR LE VECTEUR #BCD1	        #
	JP RSX_CURSEUR				; SUIVIS DES SAUTS VERS LES ROUTINES	        #
	JP RSX_ENCRE				; DANS L'ORDRE DES NOMS DONNES AUX RSX	        #
	JP RSX_PAPIER				;					        #
	JP RSX_DEFCAR				;					        #
	JP RSX_FONTE				;					        #
	JP RSX_ROULE 				;					        #
						;					        #
	NOM_RSX					; LISTE DES NOMS DONNES AUX RSXs	        #
	STR "CURSEUR"				; LA DERNIERE LETTRE DES NOMS DOIT	        #
	STR "ENCRE"				; SE TERMINER AVEC LE BIT 7 DE MIS	        #
	STR "PAPIER"				; HEUREUSEMENT, WINAPE LE FAIT		        #
	STR "DEFCAR"				; AUTOMATIQUEMENT, SINON VOICI DES	        #
	STR "FONTE"				;; EXEMPLE1> DEFB "PAPIE", "R" + #80	        #
	STR "ROULE"				;; EXEMPLE2> DEFB "ROUL",  "E" + #80	        #
	DB #00					; LA LISTE DOIT SE TERMINER PAR UN ZERO	        #
; ###############################################################################################

; ###############################################################################################
; DEFINITION DES VARIABLES PAR DEFAUT UTILISEES PAR LES ROUTINES				#
	ENCRE	 	DB #40, #40, #40	; EMPLACEMENT DES 3 ENCRES (VALEURS CODEES)	#
	PAPIER		DB #00, #00, #00	; EMPLACEMENT DES 3 PAPIERS (VALEURS CODDES)	#
			;#  00  01  02  03  04  05  06  07  08  09  0A  0B  0C  0D  0E  0F	#
	COULEUR_CODEE	DB #00,#40,#04,#44,#10,#50,#14,#54,#01,#41,#05,#45,#11,#51,#15,#55;	#
; ###############################################################################################

; ###############################################################################################
; SOUS ROUTINE QUI PERMET DE TROUVER L'ADRESSE DE LA MATRICE 4x6 D'UN CARACTERE			#
; CE > 		'A' CONTIENT LE CODE ASCII DU CARACTERE						#
; CS > 		'HL' POINTE SUR LA MATRICE 4x6 DU CARACTERE					#
; CS > 		'A' ET 'DE' SONT DETRUITS							#
; NB > 		SI LE NUMERO DU CARACTERE NE FIGURE PAS DANS LA TABLE, 'HL' POINTERA		#
; 		SUR LA MATRICE DU 1er CARACTERE (ESPACE)					#
INIT_CARACTERE					;						#
	SUB A, 32 				;; ELIMINER LES CARACTERES EN DESSOUS DE 32	#
	JR C, CARACTERE_ERREUR			; SI LE CARACTERE < ESPACE (32) ALORS ERREUR	#
	CP A, #41				; REGARDER SI LE CARACTERE EST EN MINUSCULE	#
	JR C, CARACTERE_OK			; NON ALORS ON POURSUIT				#
	SUB A, 32 				; SINON REAJUSTER LES MINUSCULES EN MAJUSCULES	#
						;						#
    CARACTERE_OK				;						#
	CP A, #41				; REGARDER SI LE CARACTERE EST DANS LA LISTE	#
	JR C, CARACTERE_AJUSTE			; OUI ALORS ON POURSUIT 			#
						; SINON						#
    CARACTERE_ERREUR				; ON AJUSTE LE CARACTERE AU DELA DE LA TABLE	#
	XOR A					; PAR LE CARACTERE ESPACE			#
						;						#
    CARACTERE_AJUSTE				; FAIRE POINTER 'HL' SUR LE CARACTERE TROUVE	#
	LD HL, TABLE_CARACTERES			; 'HL' POINTE SUR LE DEBUT DE LA TABLE		#
	LD D, 0					; IL FAUT LUI AJOUTER 3* LA VALEUR DU CARACTERE	#
	LD E, A					; 'DE' CONTIENT LE NUMERO DE CARACTERE		#
	ADD A, A				; MULTIPLIER PAR 3 OCTETS PAR CARACTERE		#
	ADD A, E				; 'A' = 'A' * 3					#
	LD E, A					; 'DE' CONTIENT L'INDEX DU CARACTERE		#
	ADD HL, DE				; 'HL' POINTE SUR LA POSITION DU CARACTERE	#
	RET					;						#
; ###############################################################################################

; ###############################################################################################
; RSX |CURSEUR, Colonne, Ligne			; Colonne de(0 A 39) ET Ligne de(0 A 32)	#
RSX_CURSEUR					;						#
	DEC A					;						#
	DEC A					; REGARDER S'IL Y A BIEN 2 PARAMETRES		#
	RET NZ					; SI LE NOMBRE DE PARAMETRE NE CORRESPOND PAS	#
	LD H, A					; 'H'= 0					#
	LD A, E					; 'A'= Ligne >>> DERNIER PARAMETRE DANS 'DE'	#
	CP A, 33				;						#
	RET NC					; SI Ligne > 32 ALORS ON SORT			#
	ADD A, A				; x2 IL FAUT MULTIPLIER LES LIGNES PAR 6 POUR	#
 	ADD A, E			 	; x3 L'AJUSTER AU VECTEUR ECRAN #BC1D		#
	ADD A, A				; x6 PUIS SOUSTRAIRE 199 AFIN DE FIXER L'INDEX	#
	ADD A, 56				; EN HAUT DE L'ECRAN.				#
	CPL					; EQUIVALENT A (255-56)-'A'			#
	LD L, A					; 'HL'= AXE_Y					#
	LD A, (IX + 2) 				; 'A' = Colonne					#
	CP A , 40				; AJUSTER LES COLONNES POUR LE MODE 0		#
	RET NC					; SI Colonne > 39, ON REPARD VERS LE BASIC	#
	LD (FIN_DE_COLONNE + 1), A		; VARIABLE QUI INDIQURA UNE FIN DE COLONNE	#
	ADD A, A				; x2 MULTIPIER SA VALEUR PAR 4			#
	ADD A, A				; x4 POUR OBTENIR L' AXE_X DE L'ECRAN		#
	LD E, A					; 'DE'= AXE_X					#
	CALL #BC1D				; VECTEUR #BD1D (ADRESSE ECRAN)			#
	LD (CURSEUR + 1), HL			; INSCRIRE LE RESULTAT POUR RSX |FONTE		#
	RET					;						#
; ###############################################################################################

; ###############################################################################################
; RSX |ENCRE, Pen1 [, Pen2] [, Pen3]								#
; RSX |PAPIER, Papier1 [, Papier2] [, Papier3]							#
RSX_ENCRE					;						#
	LD HL, ENCRE - 1			; 'HL'= ADRESSE DES ENCRES -1			#
	JR ENCRE_OK				; ALLER VERS LA SUITE DE LA ROUTINE		#
						; -1 EVITERA UN PLANTAGE PAR UNE BOUCLE A 0	#
RSX_PAPIER					; ET FERA GAGNER DES OCTETS			#
	LD HL, PAPIER - 1			; 'HL'= ADRESSE DES PAPIERS -1			#
						; 'SUIVANT L'APPEL, 'HL' POINTE SUR L'ADRESSE 	#
    ENCRE_OK					; DES ENCRES OU DES PAPIERS -1 OCTET		#
	CP 4					; SI LE NOMBRE DE PARAMETRE EST >3 ALORS SORTIR	#
	RET NC					; 						#
	OR A					; ET SORTIR AUSSI S'IL N'Y A PAS DE PARAMETRE	#
	RET Z					;						#
	LD B, 0					; FAIRE POINTER 'HL' SUR LA DERNIERE COULEUR	#
	LD C, A					; 'BC'= NOMBRE DE PARAMETRE DE 1 A 3		#
	ADD HL, BC				; 'HL' POINTE SUR LA DERNIERE COULEUR A TRAITER	#
	EX HL, DE				; 'DE' =DERNIERE COULEUR (ADR. DESTINATION)	#
						;						#
   ENCRE_PAPIER					;						#
	LD HL, COULEUR_CODEE			; 'HL' POINTE SUR L'ADRESSE DES COULEURS CODEES	#
	LD C, (IX + 0)				; 'C'= VALEUR PARAMETRES EN PARTANT DU DERNIER	#
	ADD HL, BC				; 'HL' POINTE SUR LA COULEUR CODEE A TRANSFERER	#
	LDD					; TRANSFERT LA VALEUR DE 'HL' DANS 'DE'		#
	INC BC					; IL FAUT REMETTRE 'B' A ZERO SUITE A 'LDD'	#
	INC IX					; REMONTER D'UN PARAMETRE EN INCREMENTANT 'IX'	#
	INC IX					; EN DEUX FOIS (CHAQUE PARAMETRE =2 OCTETS)	#
	DEC A					; PUIS DECREMENTER LE COMPTEUR DE PARAMETRE	#
	JR NZ, ENCRE_PAPIER			; ET BOUCLER JUSQU'AU DERNIER			#
	RET					;						#
; ###############################################################################################

; ###############################################################################################
; RSX |DEFCAR, Caractere, v1, v2, v3, v4, v5, v6; (v1 A v6)= VALEURS (0 A 15) SUR 4 BITS	#
; RSX |DEFCAR, Caractere, va11, val2, val3	; (val1 A val3)= VALEURS (0 A 255)SUR 8 BITS	#
;	       Caractere REPRESENTE LE CODE ASCII DU MINI-CARACTERE A REDEFINIR			#
; ASTUCE > |DEFCAR, ASC("1"), ... ...		; SI ON NE CONNAIT PAS LE CODE ASCII		#  
RSX_DEFCAR					; |DEFCAR, Numero caractere, Val1, Val2, Val3	#
						; [DEFCAR, Numero caractere, V1,V2,V3,V4,V5,V6	#
	LD C, A					; 'C' SERA UTILISE POUR TRAITER LES VALEURS	#
	CP A, 4					; FAIRE POINTER 'HL' SUR LE PREMIER PARAMETRE 	#
	JR NZ, SEPT_PARAMETRES			; CORRESPONDANT AU CODE ASCII DU CARACTERE	#
	LD B, (IX + 6)				; 'B' =CODE ASCII DU MINI-CARACTERE A REDEFINIR	#
	JR DEFCAR_HL_OK 			; SAUTER LE TEST POUR LES 7 PARAMETRES		#
						;						#
    SEPT_PARAMETRES				;						#
	CP A, 7					; SI LE NB DE PARAMETRE EST DIFFERENT DE 4 OU 7	#
	RET NZ					; ARRETER LA ROUTINE				#
	LD B, (IX + 12)				; 'B' =CODE ASCII DU MINI-CARACTERE A REDEFINIR	#
						;						#
    DEFCAR_HL_OK				;						#
	LD A, B					; 'A' =CODE ASCII DU MINI-CARACTERE A REDEFINIR #
	CALL INIT_CARACTERE 			; 'HL'=ADRESSE MATRICE DU CARACTERE		#
	INC HL					; FAIRE POINTER 'HL' SUR LE DERNIER OCTET	#
	INC HL					; 'HL' POINTE SUR LA FIN DE LA MATRICE DU CARAC	#
						;						#
	LD B, 3					; 'B' =BOUCLE DE 3 OCTETS DU MINI-CARACATERE	#
    DEFCAR_B					; 						#
	LD A, (IX + 0)				; 'A'= VALEUR PARAMETRES EN PARTANT DU DERNIER	#
	BIT 1, C				; TESTER SI ON A ENVOYER 4 OU 7 PARAMETRES	#
	JR Z, DEFCAR_VALEUR_OK			; SI 4 PARAMETRES, ENVOYER VALEUR DIRECTEMENT	#
	LD E, A					; SINON ON DOIT TRAITER 2 PARAMETRES DE 4 BITS	#
	INC IX					; ALLER CHERCHER LA VALEUR 4 BITS DE GAUCHE	#
	INC IX					; DANS LES PARAMETRES TRANSMIS EN (IX + x)	#
	LD A, (IX + 0)				; POUR EN FAIRE UNE VALEUR DE 8 BITS		#
	ADD A, A				; x2 EN MULTIPLIANT x16 LE PARAMETRE DE GAUCHE	#
	ADD A, A				; x4 ET EN ADDITIONNANT LE PARAMETRE DE DROITE	#
	ADD A, A				; x8						#
	ADD A, A				; x16						#
	ADD A, E				; 'A' =VALEUR SUR 8 BITS DE DEUX PARAMETRES	#
						;						#
    DEFCAR_VALEUR_OK				; 						#
	LD (HL), A				; INSCRIRE LA VALEUR OBTENUE DE 8 BITS		#
	DEC HL					; ET FAIRE POINTER 'HL' SUR UN OCTET EN MOINS	#
	INC IX					; PUIS INCREMENTER IX DEUX FOIS POUR PASSER	#
	INC IX					; AU PARAMETRE SUIVANT				#
	DJNZ, DEFCAR_B				; BOUCLER LES 3 OCTETS				#
	RET					;						#
; ###############################################################################################

; ###############################################################################################
; RSX |FONTE, @a$				; a$ DOIT ETRE DECLARER ET PRECEDE DE [@]	#
RSX_FONTE					;						#
	DEC A					; IL NE FAUT QU'UN SEUL PARAMETRE		#
	RET NZ					; SINON ON ARRETE LA ROUTINE			#
	EX HL, DE				; 'HL' CONTIENT LE DESCRIPTEUR DE LA CHAINE	#
	LD A, (HL)				; 'A'= NB DE CARACTERES DANS LA CHAINE 		#
	OR A					; SI LA CHAINE EST VIDE, ON ARRETE LA ROUTINE	#
	RET Z					; POUR EVITER LE PLATAGE D'UNE BOUCLE A ZERO	#
	INC HL					; RECUPERER L'ADRESSE OU SONT INSCRITS LES	#
	LD E, (HL)				; CARACTERES DE LA CHAINE			#
	INC HL					; 						#
	LD D, (HL)				; 'DE' CONTIENT L'ADRESSE DU PREMIER CARACTERE	#
	LD B, A					; 'B' =LONGUEUR_CHAINE ET SERVIRA DE BOUCLE	#
						;						#
    BOUCLE_CHAINE				;						#
	LD A, (DE)				; 'A'= CARACTERE DE LA CHAINE			#
	INC DE					; SERA UTILISE POUR LE CARACT. SUIVANT		#
    PUSH BC					; SAUVEGARDER LA LONGUEUR DE LA CHAINE		#
    PUSH DE					; SAUVEGARDER L'EMPLACEMENT DES CARACTERES	#
	CALL INIT_CARACTERE			; 'HL' POINTE SUR LES 3 OCTETS A TRAITER	#
	LD IY, ENCRE - 1			; 'IY' EST INITIALISE VERS LES ENCRES -1 OCTET	#
	EX HL, DE				; 'DE'= MATRICE 4x6 DU CARACTERE A TRAITER	#
    CURSEUR	LD HL, #C000			; 'HL'= EMPLACEMEMNT OU AFFICHER LE CARACTERE	#
    PUSH HL					;						#
						;						#
	LD B, 6					; 6 LIGNES A AFFICHER PAR CARACTERE		#
    SIX_LIGNES					;						#
	BIT 0, B				; 1 OCTET CONTIENT 8 BITS ET LA MATRICE EN A 4	#
	JR NZ, COULEUR_OK			; IL FAUT DONC FAIRE 2 LIGNES POUR LIRE 1 OCTET #
	LD A, (DE)				; ET AUSSI POUR CHANGER LES COULEURS.		#
	INC DE					; LE CHIFFRE PAIRE DE 'B' PERMETTRA CE CONTROLE #
	LD C, A					; 'C'= OCTETS DU CARACTERE (1 OCTET=2 LIGNE)	#
	INC IY					; 'IY' POINTE SUR LES ENCRES			#
						;						#
    COULEUR_OK					;						#
    PUSH DE					; 						#
	LD E, (IY + 0)				; 'E' CONTIENT COULEUR DE L'ENCRE		#
	LD D, 2 				; COMPTEUR DE 2 OCTETS (UNE LIGNE DE 4 PIXELS)	#
						;						#
    LIGNE_2OCTETS				;						#
	LD A, (IY + 3)				; 'A'= COULEUR DU PAPIER			#
	SLA C					; ROTATION [carry]<- [76543210]<- [0]		#
	JR NC, PAPIERG_A_GAUCHE			; SI LE DERNIER BIT EST =0, ON GARDE LE PAPIER	#
	LD A, E					; SINON 'A'= COULEUR DE L' ENCRE		#
						;						#
    PAPIERG_A_GAUCHE				; 'A'= COULEUR CODEE DU PIXEL			#
	ADD A, A				; IL FAUT *2 POUR LE PIXEL DE GAUCHE		#
	SLA C					; FAIRE DE MEME POUR LE PIXEL DE DROITE		#
	JR NC, PAPIERG_A_DROITE			; 'A'= PIXEL DE GAUCHE *2			#
	ADD A, E				; SI BIT=1,  'A'= PIXEL DE GAUCHE *2 + ENCRE	#
	JR OCTETG_OK				; ON A LES DEUX COULEURS POUR L'OCTET ECRAN	#
						;						#
    PAPIERG_A_DROITE				; SAUF SI LE BIT ETAIT A ZERO			#
	ADD A, (IY + 3)				; 'A'= PIXEL DE GAUCHE *2 + PAPIER		#
						; 						#
    OCTETG_OK					; ON A LES DEUX COULEURS POUR L'OCTET ECRAN	#
	LD (HL), A				; INSCRIRE L'OCTET SUR L'ECRAN			#
	INC HL					; ET PASSER AU 2EME OCTET DU CARACTERE		#
	DEC D					; 						#
	JR NZ, LIGNE_2OCTETS			;						#
						; UNE LIGNE DE 2 OCTETS EST FINIE, IL FAUT	#
	LD DE, #800 - 2				; DESCENDRE D'UNE LIGNE SUR L'ECRAN - 2 OCTETS	#
	ADD HL, DE				; POUR DESCENDRE D'1 LIGNE, AJOUTER #800 A 'HL' #
	JR NC, CORRIGE_ADR_ECR			; 						#
	LD DE, #C050				; MAIS SI ON TOMBE SUR UNE CASSURE DES 8 LIGNES #
	ADD HL, DE 				; IL FAUT RECTIFIER LA VALEUR EN AJOUTANT #C050	#
						;						#
    CORRIGE_ADR_ECR				; 						#
    POP DE					; RECUPERER L'ADRESSE DE LA CHAINE		#
	DJNZ,  SIX_LIGNES			; FAIRE LES 6 LIGNES QUI COMPOSENT LE CARACTERE	#
    POP HL					; IL FAUT DEPLACER LE CURSEUR D'UNE COLONNE	#
	INC HL					; RIEN DE PLUS SIMPLE, UN CARACTERE OCCUPE 	#
	INC HL					; 2 OCTETS. MAIS... 				#
						; S1 ON ARRIVE A DROITE DE L'ECRAN, IL	FAUT 	#
    FIN_DE_COLONNE 	LD A, #00		; DESCENDRE DE 6 LIGNES ET REVENIR A GAUCHE	#
	INC A					; J'UTILISE UNE VARIABLE FIN_DE_COLONNE  AFIN 	#
	CP A, 40				; D'EFFECTUER CE CONTROLE ET SI 'A' > 39 ALORS 	#
	JR C, COLONNE_OK 			; IL FAUT EXECUTER LA ROUTINE, SINON ON CONTINU #
	LD DE, #2FB0				; POUR DESCENDRE D'UN CARACTERE ET REVENIR A  	#
	ADD HL, DE				; GAUCHE DE L'ECRAN, LA FORMULE EST (6*#800)-80	#
	JR NC, CORRIGE_COLONNE			; (HAUTEUR 6 * #800)-(LARGEUR 2*40)= #2FB0	#
	LD DE, #C050				; MAIS, EN PARTANT DU HAUT DE L'ECRAN, TOUTES	#
	ADD HL, DE 				; LES 8 LIGNES IL Y A UNE CASSURE QU'IL FAUT	#
						; REAJUSTER POUR SE RETROUVER 1 LIGNE PLUS BAS	#
    CORRIGE_COLONNE				;						#
	XOR A					; NE PAS OUBLIER DE REMETTRE LA VARIABLE 	#
						; FIN_DE_COLONNE A ZERO				#
    COLONNE_OK					; 						#
	LD (FIN_DE_COLONNE + 1), A		; INSCRIRE L'INDICATEUR DES COLONNES		#
	LD (CURSEUR + 1), HL			; ET LA POSITION SUR L'ECRAN POUR LE PROCHAIN	#
    POP DE					; CARACTERE. RECUPERER L'ADRESSE DE LA CHAINE	#
    POP BC					; ET SA LONGUEUR AUSSI				#
	DJNZ, BOUCLE_CHAINE			; TERMINER L'AFFICHAGE DE TOUTS LES CARACTERES	#
	RET					;						#
; ###############################################################################################

; ###############################################################################################
; RSX |ROULE, @a$				; a$ DOIT ETRE DECLARER ET PRECEDE DE [@]	#
RSX_ROULE					;						#
	DEC A					; TESTER S'IL Y A BIEN 1 SEUL PARAMETRE		#
	RET NZ					; SINON, ON SORT SANS RIEN MODIFIER		#
	LD B, A					; 'B'= 0					#
	EX HL, DE				; 'HL'= DESCRIPTEUR DE LA CHAINE		#
	LD A, (HL)				; 'A'= NOMBRE DE CARACTERE DE LA CHAINE		#
	OR A					; SI LA LONGUEUR EST NULLE, ON SORT AUSSI	#
	RET Z					;						#
	INC HL					; FAIRE POINTER 'DE' SUR LE 1er CARACTERE	#
	LD E, (HL)				;						#
	INC HL					;						#
	LD D, (HL)				; 'DE' POINTE SUR LE PREMIER CARACTERE		#
	LD C, A					; 'BC'= NOMBRE DE CARACTERE DE LA CHAINE	#
	DEC C					; -1 CARACTERE					#
	LD A, (DE)				; 'A'= CODE ASCII DU 1er CARACTERE DE LA CHAINE	#
	LD H, D					; FAIRE POINTER 'HL' SUR LE 2eme CARACTERE	#
	LD L, E					;						#
	INC HL					; 'HL' POINTE SUR LE DEUXIEME CARACTERE		#
	LDIR					; DEPLACE TOUS LES CARACTERES SAUF LE PREMIER	#
	LD (DE), A				; LE PREMIER CARACTERE VA DANS LE DERNIER	#
	RET					;						#
; ###############################################################################################

; ###############################################################################################
; LES 65 CARACTERES SONT COMPOSES DE 6 LIGNES DE HAUTEUR ET DE 4 PIXELS DE LARGEUR		#
; SOIT UNE MATRICE DE 6*4= 24 PIXELS QUI SERONT DEFINIS DANS 3 OCTETS (3*8= 24)			#
; LE PREMIER OCTET REPRESENTERA LA PREMIERE ET LA DEUXIEME LIGNE, ETC...			#
; VOICI UN EXEMPLE POUR REPRESENTER LE CARACTERE [1] DANS UNE MATRICE DCE 4*6 PIXELS		#
;												#
; MATRICE	VALEUR										#
;  ..#.		= &2										#
;  .##.		= &6	OCTET N1 = [..#.] + [.##.]	SOIT &26				#
;  ..#.		= &2										#
;  ..#.		= &2	OCTET N2 = [..#.] + [..#.]	SOIT &22				#
;  .###		= &7										#
;  ....		= &0	OCTET N3 = [.###] + [....]	SOIT &70				#
;												#
; D'OU LE RESULTAT OBTENU			>>>	DB #26, #22, #70			#
; SUR L'ECRAN EN MODE 0, IL FAUT 2 OCTETS POUR AFFICHER LES 4 PIXELS EN LARGUEUR. IL N'EST PAS	#
; UTILE DE LE SAVOIR, MAIS CA PERMET DE MIEUX COMPRENDRE LE PRINCIPE DE MES ROUTINES SI VOUS	#
; AVEZ L' ATTENTION DE LES MODIFIER POUR VOS PROPRES BESOINS.					#
; ###############################################################################################
TABLE_CARACTERES
DB #00, #00, #00	; " " 	ESPACE
DB #22, #20, #02	; ! 	POINT D'EXCLAMATION
DB #55, #00, #00	; "	DOUBLE GUILLEMET
DB #0A, #FA, #FA	; #	SIGNE DIESE
DB #69, #62, #97	; $	DOLLAR
DB #08, #16, #81	; %	POURCENTAGE
DB #69, #97, #A5	; &	ESPERLUETTE
DB #22, #40, #00	; ' 	APOSTROPHE
DB #12, #22, #21	; (	PARENTHESE OUVRANTE 
DB #42, #22, #24	; )	PARENTHESE FERMANTE
DB #05, #22, #50	; *	MULTIPLIER
DB #00, #27, #20	; +	PLUS
DB #00, #02, #24	; ,	VIRGULE
DB #00, #06, #00	; -	MOINS
DB #00, #04, #40	; .	POINT
DB #11, #22, #44	; /	BARRE OBLIQUE 
DB #75, #55, #70	; 0
DB #26, #22, #70	; 1
DB #71, #74, #70	; 2
DB #71, #31, #70	; 3
DB #55, #71, #10	; 4
DB #74, #71, #70	; 5
DB #74, #75, #70	; 6
DB #71, #12, #20	; 7
DB #75, #75, #70	; 8
DB #75, #71, #10	; 9
DB #00, #20, #20	; : ;	DEUX POINTS
DB #02, #02, #28	; ;	POINT VIRGULE
DB #12, #42, #10	; <	PLUS PETIT QUE
DB #00, #70, #70	; =	EGAL
DB #42, #12, #40 	; >	PLLUS GRAND QUE
DB #61, #12, #02	; ?	POINT D'INTERROGATION
DB #69, #BB, #87	; @	AROBASE
DB #75, #75, #50	; A
DB #65, #75, #70	; B
DB #74, #44, #70	; C
DB #65, #55, #60	; D
DB #74, #64, #70	; E
DB #74, #64, #40	; F
DB #74, #45, #70	; G
DB #55, #75, #50	; H
DB #22, #22, #20	; I
DB #71, #11, #60	; J
DB #44, #56, #50	; K
DB #44, #44, #70	; L
DB #57, #55, #50	; M
DB #75, #55, #50	; N
DB #75, #55, #70	; O
DB #75, #74, #40	; P
DB #75, #55, #71	; Q
DB #75, #65, #50	; R
DB #74, #71, #70	; S
DB #72, #22, #20	; T
DB #55, #55, #70	; U
DB #55, #55, #20	; V
DB #55, #57, #50	; W
DB #55, #25, #50	; X
DB #55, #22, #20	; Y
DB #71, #24, #70	; Z
DB #74, #44, #70	; [	CROCHET GAUCHE
DB #44, #22, #11	; \	BARRE OBLIQUE INVERSEE
DB #71, #11, #70	; ]	CROCHET FROIT
DB #25, #50, #00	; ^	FLECHE HAUT
DB #00, #00, #0F	; _	SOULIGNEMENT
DB #23, #10, #00	; `	APOSTROPHE INVERSEE
FIN