; ############################################################################################### ; 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