Hum... c'est vrai que la conversion nombre binaire en décimal est couteuse (beaucoup de divisions). On peut être plus malin.
Au lieu de représenter le score comme un entier 16 bits on peut le représenter comme N octets en mémoire, ces N octets ayant des valeurs entre 0 et 9.
Pour convertir un tel nombre en ascii il suffit d'ajouter '0' ($30) aux octets en mémoire. C'est très facile et très rapide.
Très bien, ca facilitera l'affichage, mais comment qu'on fait de l'arithmétique avec ca? En fait on a qu'une seule opération à réaliser: l'addition de deux tels nombres. La routine suivante fait NB0 = NB1 + NB2
Code:
LDA #5 ; 5 octets (chiffres) par nombre
LDY #NB0 ; resultat
LDX #NB1 ; 1er nombre
LDU #NB2 ; 2e nombre
BSR ADD_NB
BSR PRINT_NB_Y
...
*================================================
* calcule nb(Y) = nb(X) + nb(U) avec A=N=nb de chiffres des nombres
ADD_NB
PSHS D
LEAX A,X ; ajuste X pour aller en fin de nombre
LEAU A,U ; idem pour U
LEAY A,Y ; idem pour Y
CLR CARRY ; effacement de la retenue
LOOP1
LDB ,-X ; charge chiffre nb1
ADDB ,-U ; ajoute chiffre nb2
ADDB CARRY ; ajoute retenue
CLR CARRY ; effacement retenue
CMPB #10 ; chiffre du résultat plus grand que 10 ?
BCS PAS_RETENUE ; non => on saute à la suite
SUBB #10 ; OUI => on ramène entre 0 et 9
INC CARRY ; et on met la retenue à 1 pour le chiffre suivant
PAS_RETENUE
STB ,-Y ; on écrit le chiffre du résultat dans nb0
DECA ; décompte
BNE LOOP1 ; pas fini ? => on reboucle pour un nouveau chiffre (octet)
PULS D,PC
*================================================
* affiche nb(Y) par la routine PUTC du moniteur
PRINT_NB_Y
PSHS D,Y
LOOP2
LDB ,Y+ ; charge chiffre 0 à 9
ADDB #$30 ; converti en ascii
JSR $E803 ; PUTC affiche le chiffre ascii '0' à '9'
DECA ; décompte chiffres restants
BNE LOOP2 ; pas fini? => c'est reparti pour un nouveau chiffre à afficher.
PULS D,Y,PC
*================================================
CARRY
FCB 0 ; retenue
NB0
FCB 0,0,0,0,0 ; 0
NB1
FCB 1,2,3,4,5 ; 12345
NB2
FCB 0,0,1,6,5 ; 165
NB3
FCB 9,9,9,9,9 ; -1
Ce code est donnée en exemple et peut être rendu à la fois plus petit et plus rapide. Mais je pense que ca nuirait à la compréhension de son fonctionnement. En fait il réalise l'addition exactement comme on l'a apprise à l'école, chiffre par chiffre, en commençant par la droite (LEA du début). Je te laisse expérimenter avec lui. Tu va voir c'est rigolo cette arithmétique chiffre par chiffre (et en plus c'est super facile à convertir en ASCII du coup, cf la routine PRINT_NB_Y qui affiche nb(Y)).
Heu ajouter c'est bien ... mais comment je fais décroître le score alors? Et bien c'est facile tu ajoutes 10000-N si tu veux soustraire N. Par exemple soustraire 1 revient à ajouter 9,9,9,9,9 (NB3 plus haut). Soustraire 2 revient à ajouter 9,9,9,9,8... c'est facile! C'est ce qu'on appelle de l'arithmétique complément à 9 + 1. Pour trouver l'opposé additif d'un nombre on fait "chiffre <- 9-chiffre" et on ajoute l'entier 1 au nombre dont les chiffres viennent d'être inversés.
A noter: Le complément à 2 du binaire est en fait un complément à 1 + 1 (=2): on remplace tous les bits (chiffres) "b" par leur opposé: "1-b" et on ajoute 1 au résultat. Tout cela marche sur le même principe général.
C'est exactement ce que j'aurais conseillé, sauf pour la partie PUTC qui est inopérante en bm16 couleur (ici on affiche des sprites de nombres).
Peut-être aussi n'affiicher que les chiffres qui ont changé...(routine de tests à voir si c'est plus rapide)