Re: Mr ToutLeMonde et la programmation NES...

[vingazole]

C'est de l'assembleur 6502 (la NES utilise un 6502 modifié).

[drfloyd]

C est un peu HS mais j ai beau m y connaitre en prog c et PHP je comprend rie' a ce que vous dite..

C'est la que tu vas te rendre compte que n'y connais en fait pas grand chose...   face aux fous furieux de la programmation en assembleur

[vingazole]

Fou furieux toi-même :p

@patapouf31: en gros le premier exemple c'est un if et le deuxième un switch :)

@vincent2105: je crois que tu n'es pas obligé de recharger le registre A à chaque fois (LDA NumeroAleatoireTrajectoire), puisque A n'est modifié ni par les CMP ni par les branchements

[Invité]

Encore une fois, ce post est une aubaine, un pain béni ...
J'arrive a suivre avec ma petite base d'assembleur Z80 qui commence a dater ...
Je suggère qu'un tel sujet sois proposé en post it !
Merci encore de vos partages !

[Invité]

je m'apprétais à te donner la soluce, mais vinga a dégainé plus vite   ..
bah je croyais que tu faisais que du Z80 vingazole !!  

@vincent2105: je crois que tu n'es pas obligé de recharger le registre A à chaque fois (LDA NumeroAleatoireTrajectoire), puisque A n'est modifié ni par les CMP ni par les branchements 

Tout à fait .

Sinon y'a une methode bcp plus rapide que:

Code:

LDA NumeroAleatoireTrajectoire
  CMP #$01
  BEQ Tir1
  LDA NumeroAleatoireTrajectoire
  CMP #$02
  BEQ Tir2
  LDA NumeroAleatoireTrajectoire
  CMP #$03
  BNE suite
  JMP Tir3
suite: 

Alors je sais pas comment tu déclares un tableau de constantes dans ton assembleur ,mais tu peux faire:

Code:

_tab_addr_label:    .dw suite , Tir1 , Tir2 , Tir3

lda  NumeroAleatoireTrajectoire
and  #$3
asl  A
tax
jmp  [ _tab_addr_label , X ]  ; ou jmp ( _tab_addr_label , X ) sur ton assembleur

suite:

Bien sur si tu n'as que les valeurs de NumeroAleatoireTrajectoire comprisent entre 0 et 3 , sinon faut adapter .
Mais plus tu auras de choix, plus ce code est rapide .

[vincent2105]

Merci à tous d'animer ce topic, et notamment à mes mentors TOUKO et vingazole qui  se décarcassent dans la joie et la bonne humeur  (au passage, j'ai bien noté votre remarque concernant mes "LDA" superflus) 

J'ai donc fini mes 9 trajectoires qui sont basées sur un même moule (donc côté optimisation y'a du boulot). J'imagine aussi que pour le "switch" de mes 9 trajectoires y'a moyen de faire une boucle. Mais je préfère garder le code comme ça pour l'instant, je m'y retrouve assez facilement et je ne sais pas trop ce que me réserve la suite. 

Les différentes cadences ne sont pas encore "créées". D'ailleurs, je ne sais pas si les tirs de "niveau 3" seront accélérés ou non. En vitesse de base, ils prennent à contre-pied "comme il faut". Je réfléchirai à la mise en place des paliers plus tard ...

Maintenant, je vais revenir sur les nombres aléatoires et essayer de comprendre ce que fait la routine gentiment prêtée par TOUKO.

C'est un nombre aléatoire sur 16 bit, mais rien ne t'empêche d'utiliser 1 ou l'autre partie 8 bit .

Bref, faut que je sois en pleine possession de mes moyens pour adapter ça à mon besoin   . Je pense que je vais travailler avec des opcodes que je n'ai pas encore utilisés : pour l'instant sur les 52 opcodes, j'en utilise une quinzaine, et là y'a rien qui me vient à l'idée.

Au boulot !

EDIT : Je viens juste de voir ton post TOUKO

[Invité]

de toutes façon c'est pas évident de brûler les étapes .
Le code que je t'ai donné, normalement tu vois pas ça au début, mais si ça peut t'aider   
Surtout que comme tu peux le voir il est simple à comprendre (je veux dire l'astuce avec le jmp) .

[vincent2105]

Salut,

Ta routine pour remplacer mon "switch trajectoires" m'intrigue, en fait, quelquechose m'échappe.

Code:

_tab_addr_label:    .dw suite , Tir1 , Tir2 , Tir3

lda  NumeroAleatoireTrajectoire
and  #$3
asl  A
tax
jmp  [ _tab_addr_label , X ]  ; ou jmp ( _tab_addr_label , X ) sur ton assembleur

suite:

La suite d'opcode LDA AND ASL est à mes yeux une multiplication par 2. J'ai essayé de faire les opérations, peux tu me dire ce qui cloche ?

Code:

    0000 ; si numero_aleatoire = 0
AND 0011 ; nombre_de_numeros_aleatoires (3)
    0000 ; Valeur dans l'Accumulateur après AND
ASL 0000 ; On va décaler tous les Bits vers la gauche (inchangé dans ce cas)
    0000 ; Numero obtenu : 0
 
    0001 ; si numero_aleatoire = 1
AND 0011 ; nombre_de_numeros_aleatoires(3)
    0001 ; Valeur dans l'Accumulateur après AND
ASL 0001 ; On va décaler tous les Bits vers la gauche
    0010 ; Numero obtenu : 2
 
    0010 ; si numero_aleatoire = 2
AND 0011 ; nombre_de_numeros_aleatoires(3)
    0010 ; Valeur dans l'Accumulateur après AND
ASL 0010 ; On va décaler tous les Bits vers la gauche
    0100 ; Numero obtenu : 4
 
    0011 ; si numero_aleatoire = 3
AND 0011 ; nombre_de_numeros_aleatoires(3)
    0011 ; Valeur dans l'Accumulateur après AND
ASL 0011 ; On va décaler tous les Bits vers la gauche
    0110 ; Numero obtenu : 6

Une solution que j'imagine mais je n'ai pas réussi à déclarer un tableau de constantes c'est

Code:

 LDX NumeroAleatoireTrajectoire
 JMP [TABLEAUTIR, X]

C'est bizarre, ça me parait tellement simple que ça doit pas être juste.

Enfin, y'a un truc qui m'échappe, si tu peux le pointer du doigt, ça me ferait avancer. 

[patapouf31]

Omdmfmsldozlqldleo oummmfff!!!
Vraiment dur !
Bon je m y mets
Je reviens dans 4 ans

[vincent2105]

Mon emulateur m'a fait une petite blague...  

J'avais pas testé ma ROM depuis l'ajout de l'ecran titre...
La j'allume ma NES... "ecran titre"... j'appuye sur "start".... je tombe sur l'écran de jeu et...


LE - BALLON - NE - BOUGE - PLUS !!!             

Allez courage  

[vingazole]

Salut,

Ta routine pour remplacer mon "switch trajectoires" m'intrigue, en fait, quelquechose m'échappe.

Code:

_tab_addr_label:    .dw suite , Tir1 , Tir2 , Tir3

lda  NumeroAleatoireTrajectoire
and  #$3
asl  A
tax
jmp  [ _tab_addr_label , X ]  ; ou jmp ( _tab_addr_label , X ) sur ton assembleur

suite:

La suite d'opcode LDA AND ASL est à mes yeux une multiplication par 2. J'ai essayé de faire les opérations, peux tu me dire ce qui cloche ?

Code:

    0000 ; si numero_aleatoire = 0
AND 0011 ; nombre_de_numeros_aleatoires (3)
    0000 ; Valeur dans l'Accumulateur après AND
ASL 0000 ; On va décaler tous les Bits vers la gauche (inchangé dans ce cas)
    0000 ; Numero obtenu : 0
 
    0001 ; si numero_aleatoire = 1
AND 0011 ; nombre_de_numeros_aleatoires(3)
    0001 ; Valeur dans l'Accumulateur après AND
ASL 0001 ; On va décaler tous les Bits vers la gauche
    0010 ; Numero obtenu : 2
 
    0010 ; si numero_aleatoire = 2
AND 0011 ; nombre_de_numeros_aleatoires(3)
    0010 ; Valeur dans l'Accumulateur après AND
ASL 0010 ; On va décaler tous les Bits vers la gauche
    0100 ; Numero obtenu : 4
 
    0011 ; si numero_aleatoire = 3
AND 0011 ; nombre_de_numeros_aleatoires(3)
    0011 ; Valeur dans l'Accumulateur après AND
ASL 0011 ; On va décaler tous les Bits vers la gauche
    0110 ; Numero obtenu : 6

Une solution que j'imagine mais je n'ai pas réussi à déclarer un tableau de constantes c'est

Code:

 LDX NumeroAleatoireTrajectoire
 JMP [TABLEAUTIR, X]

C'est bizarre, ça me parait tellement simple que ça doit pas être juste.

Enfin, y'a un truc qui m'échappe, si tu peux le pointer du doigt, ça me ferait avancer. 

La méthode que Touko t'a proposée s'appelle une jump table (littéralement "table de sauts") : le principe est d'avoir un tableau contenant les adresses des routines correspondant à chaque branchement que tu veux effectuer selon la valeur du registre A, la valeur de A correspondant à l'indice du tableau (l'indice A=0 correspondant au premier élément du tableau, l'indice A=1 au deuxième, etc...).


Ces adresses sont codées sur 2 octets (les valeurs du tableau sont déclarées avec dw (data word :  un word est un "mot" de deux octets), c'est pourquoi l'adresse de chaque élément du tableau s'obtient en calculant _tab_addr_label + 2*A

Code:

lda  NumeroAleatoireTrajectoire             ; A = NumeroAleatoireTrajectoire
and  #$3                                    ; A = A mod 4
asl  A                                      ; A = A*2
tax                                         ; X = A
jmp  [ _tab_addr_label , X ]                ; JMP _tab_addr_label + X

Comme tu l'as compris, la multiplication par 2 est effectuée en décalant les bits de A d'un rang vers la gauche avec l'opcode ASL (de manière générale on multiplie par 2^n ("deux puissance n") en décalant de n bits vers la gauche; de même décaler de n bits vers la droite revient à diviser par 2^n).



Touko utilise une "ruse" avec son AND : faire AND 3 revient à obtenir le reste de la division entière de A par 4 (c'est ce qu'on appelle le modulo, généralement noté mod), ici A = A AND 3 = A mod 4, cela permet de "contenir" l'indice A entre 0 et 3.

On peut généraliser cette propriété :    A  mod  (2^n)   =   A  AND  (2^n - 1)

Attention avec cette astuce : elle ne fonctionne que pour des puissances de deux, si tu ajoutes une valeur à ton tableau tu te retrouves avec 5 valeurs; 5 n'étant pas une puissance de deux tu ne peux pas faire AND 4 pour calculer le "modulo 5" (dans ce cas tu obtiendrais A AND 4 = 0 pour toute valeur de A comprise entre 0 et 3 et A AND 4 = 4 pour A=4, ce qui n'est franchement pas le résultat escompté  ) !

[Invité]

Wahou,vingazole est un vieux routard du code   
J'ai rien à rajouter,il a expliqué ça comme un chef,rien à dire ..

Et effectivement,comme on parle d'adresses,il faut 2 octets et non 1 comme ta solution.
En c le switch/case est un truc lent, avec une jump table c'est bcp plus rapide et efficace, car ça évite le code a rallonge qd les cas deviennent nombreux .

Le ASL, décale effectivement les bit vers la gauche, et c'est ça qui fait la multiplication par 2 .

Tu as un petit émulateur web d'assembleur 6502 , tu peux tracer le code pas à pas, et voir l'état des registres à chaque instructions pour voir ce qui se passe .
http://skilldrick.github.io/easy6502/

LE - BALLON - NE - BOUGE - PLUS !!!             

Allez courage  

Au hasard, vérifies l'initialisation de tes variables .

[vingazole]

En c le switch/case est un truc lent, avec une jump table c est bcp plus rapide et efficace, car ca evite le code a rallonge qd les cas deviennent nombreux .

En effet la jump table est ce qu'il y a de plus rapide (à partir d'un certain nombre de branchements, variable selon les microprocesseurs), mais certains compilateurs C (je pense à SDCC en l'occurrence  ) génèrent bien une jump table pour les switch (quand les valeurs de case s'y prêtent, bien sûr) 


   

        

C'est le métier qui rentre ! 

[Invité]

mais certains compilateurs C (je pense à SDCC en l'occurrence  ) génèrent bien unejump table pour les switch (quand les valeurs de case s'y prêtent, bien sûr) 

Ah, ok je savais pas, merci pour l'info   

        

C'est le métier qui rentre ! 

 

EDIT: Oublies le jmp ( _tab , X ), le 6502 ne prend pas le JMP indexé   
il faudrait gruger en passant par un pointeur en ZP, ça rajoute 16 cycles, soit 31 cycles en tout (au lieu de 15 initialement) .   

Code:

lda  NumeroAleatoireTrajectoire             ; A = NumeroAleatoireTrajectoire
and  #$3                                    ; A = A mod 4
asl  A                                      ; A = A*2
tax                                         ; X = A
lda  _tab_addr_label , X
sta  zp_ptr
lda  _tab_addr_label + 1 , X
sta  zp_ptr + 1
jmp  ( zp_ptr )                             ; JMP _tab_addr_label + X

[vingazole]

Mon emulateur m'a fait une petite blague...  

J'avais pas testé ma ROM depuis l'ajout de l'ecran titre...
La j'allume ma NES... "ecran titre"... j'appuye sur "start".... je tombe sur l'écran de jeu et...


LE - BALLON - NE - BOUGE - PLUS !!!             

Assure-toi que tes variables sont situées en RAM et pas en ROM

[vincent2105]

Première nouvelle, pour le ballon en plomb, c'était bien un problème d'initialisation de variables. Problème résolu, merci pour votre perspicacité !   

Tu as un petit émulateur web d'assembleur 6502 , tu peux tracer le code pas à pas, et voir l'état des registres à chaque instructions pour voir ce qui se passe .
http://skilldrick.github.io/easy6502/

Oui, je connaissais cet émulateur, d'ailleurs je le recommande à ceux qui veulent s'initier à l'asm.
Un petit tuto l'accompagne, on apprend beaucoup de choses. A essayer donc !
Je n'ai pas le réflexe de tester le code sur cet émulateur, faudrait que je le consulte plus souvent... 

TOUKO, tu parles de cycles, je me demande comment on les compte.
En consultant la liste d'opcodes, je vois des valeurs pour chaque opcode sous LEN et TIM. J'imagine qu'il y a un rapport http://www.6502.org/tutorials/6502opcodes.html

dw (data word :  un word est un "mot" de deux octets)

D'où la multiplication par 2 qui me semblait suspecte     .

Touko utilise une "ruse" avec son AND : faire AND 3 revient à obtenir le reste de la division entière de A par 4 (c'est ce qu'on appelle le modulo, généralement noté mod), ici A = A AND 3 = A mod 4, cela permet de "contenir" l'indice A entre 0 et 3.

On peut généraliser cette propriété :    A  mod  (2^n)   =   A  AND  (n-1)

Attention avec cette astuce : elle ne fonctionne que pour des puissances de deux, si tu ajoutes une valeur à ton tableau tu te retrouves avec 5 valeurs; 5 n'étant pas une puissance de deux tu ne peux pas faire AND 4 pour calculer le "modulo 5" (dans ce cas tu obtiendrais A AND 4 = 0 pour toute valeur de A comprise entre 0 et 3 et A AND 4 = 4 pour A=4, ce qui n'est franchement pas le résultat escompté  ) !

Merci pour tes explications approfondies. Pour l'instant, j'ai pas pigé, mais ne te dérange pas plus, je vais faire un petit effort.
EDIT 22h52 je bloque : pour moi, dans notre exemple, "AND #$03" ne change jamais la valeur de A. J'en déduis que cette ligne est inutile. La nuit porte conseil, on verra demain... 


EDIT :

Oublies le jmp ( _tab , X ), le 6502 ne prend pas le JMP indexé  

En recherchant "jump table" là => http://6502.org/tutorials/65c02opcodes.html, on trouve ce type de routines. Enfin, pour moi elles sont identiques.

Merci à vous deux

[Invité]

Le and #$03 n est pas la pour changer A, mais comme l a dit vingazole, pour eviter que A depasse 3, puisque les valeurs du tableau vont de 0 a 3 (0 a 6 dans notre tableau d adresses) .
Pour les cycle c est bien la colonne TIM qu il faut prendre .
LEN correspond au nombre d octets que prend l instruction complete .

EDIT:dans ton exemple de jump table le jmp (abs,X) concerne le 65c02,et non le 6502 .
La version 6502 ,c est celle avec les pha,pha, puis le rts a la fin .

[vincent2105]

EDIT:dans ton exemple de jump table le jmp (abs,X) concerne le 65c02,et non le 6502 .
La version 6502 ,c est celle avec les pha,pha, puis le rts a la fin .

Mais sur la NES c'est un 65c02 donc ça colle non? (Merci pour le calcul du nombre de cycles )

Le and #$03 n est pas la pour changer A, mais comme l a dit vingazole, pour eviter que A depasse 3, puisque les valeurs du tableau vont de 0 a 3 (0 a 6 dans notre tableau d adresses) .

      Je passe complètement à côté de quelquechose 

Les valeurs du tableau vont de 0 à 3 et de 0 à 6 dans le tableau d'adresse ça d'accord.

Voilà les 2 lignes qui me posent problème,

Code:

lda  NumeroAleatoireTrajectoire
and  #$3

Première ligne, je charge dans l'Accumulateur la valeur de la variable NumeroAleatoireTrajectoire (le mot Aleatoire est d'ailleurs de trop pour l'instant).
Cette variable me sers pour mes tests d'affichage de trajectoires, elle prend la valeur 1 si j'appuye sur un bouton et la valeur 2 si j'appuye sur au autre bouton. J'avais démarré comme ça puisque je n'avais que 2 trajectoires.
Vu que j'en ai ajouté, j'incrémente cette variable à chaque appel de Tir, je peux donc boucler l'affichage des 9 trajectoires.

Quand j'arrive dans le "switch", l'opcode LDA charge la valeur que je lui donne, or ma routine qui actualise la variable "NumeroAleatoireTrajectoire" l'a déjà limité  à une valeur comprise entre 0 et 3. (Ca vous ne le saviez  peut-être pas   )
C'est pourquoi je ne comprends pas l'utilité de AND  

Ne me tapez pas dessus svp 

[Invité]

Mais sur la NES c'est un 65c02 donc ça colle non? (Merci pour le calcul du nombre de cycles  )

Non ,c'et bien un 6502 .
Et de rien pour les cycles   

e passe complètement à côté de quelquechose  

Les valeurs du tableau vont de 0 à 3 et de 0 à 6 dans le tableau d'adresse ça d'accord.

Voilà les 2 lignes qui me posent problème,

C'est peut être moi qui me suis mal expliqué .
LDA  NumeroAleatoiretrajectoire

tu peux avoir n'importe quelle valeur de 0 à 255 ok ???
Nous on veut (pour cet exemple) un nombre de 0 à 3 maxi (ce qui nous donnera un nombre de 0 à 6 une fois l'ASL A) .
en binaire 3 = 11
Donc si on veut pas que A dépasse 11, on fait un AND #$3

Exemple:
A = 1001 soit 9 dec .
si an fair un AND #$3
A = 0001 soit 1 en dec .


Donc oui on modifie A en fait .


Donc comme dans ton cas la valeur est limitée avant le LDA (mais ça effectivement on savait pas lol), le AND est inutile    

[vincent2105]

Pour le cpu de la NES, j'avais lu que c'était un 6502 modifié, j'ai pas cherché plus loin que ça et  j'en avais déduis que c'était un 65c02. Donc j'ai encore appris quelquechose. 

Donc comme dans ton cas la valeur est limitée avant le LDA (mais ça effectivement on savait pas lol), le AND est inutile   

Je savais que j'en avais fait une belle là.

Du coup je pense avoir pigé : "LDA NumeroAleatoiretrajectoire", charge la valeur comprise à l'adresse de "NumeroAleatoiretrajectoire". Elle prend n'importe quelle valeur comprise entre 0 e FF (à condition qu'elle n'est pas été initialisé   ).
Si c'est bien ça alors j'ai vraiment merdé en vous exposant mon problème, désolé !
On en revient donc à la formule que j'avais trouvé sur nesdev pour générer des nombres pseudo aléatoires. Si c'est çà, j'ai tout pigé.

Dans tous les cas merci Touko

[Invité]

Pour le cpu de la NES, j'avais lu que c'était un 6502 modifié, j'ai pas cherché plus loin que ça et  j'en avais déduis que c'était un 65c02. Donc j'ai encore appris quelquechose. 

Modifié il me semble que oui, mais il est bien sur la base du 6502 ..
Le seul que je connaisse sur la base du 65C02, c'est celui de la pc-engine .

Je savais que j'en avais fait une belle là.

Nan c'est moi, j'ai voulu ne rien laisser au hasard, donc du coup, je t'ai embrouillé   

Du coup je pense avoir pigé : "LDA NumeroAleatoiretrajectoire", charge la valeur comprise à l'adresse de "NumeroAleatoiretrajectoire". Elle prend n'importe quelle valeur comprise entre 0 e FF (à condition qu'elle n'est pas été initialisé   ).
Si c'est bien ça alors j'ai vraiment merdé en vous exposant mon problème, désolé !

C'est ça tu as compris .
Mais t'excuses pas, t'as pas merdé, juste qu'on a pas eu tout les éléments, mais rien de bien méchant, au moins on aura poussé le truc un peu plus loin .

On en revient donc à la formule que j'avais trouvé sur nesdev pour générer des nombres pseudo aléatoires. Si c'est çà, j'ai tout pigé.

CAD ???

Dans tous les cas merci Touko 

De rien, le fun du homebrew,c'est aussi l'entraide   
La preuve, vingazole qui est plus Z80 et SMS, et venu aussi t'aider .

EDIT:y'a aussi ce site http://codebase64.org/doku.php?id=base:demo_programming
Bon c'est dédié au C64, mais y'a bcp d'astuces de code pour 6502 ..

Ou celui là qui donne pas mal d'astuces aussi
http://www.6502.org/tutorials/compare_beyond.html

[vingazole]

Pour le cpu de la NES, j'avais lu que c'était un 6502 modifié, j'ai pas cherché plus loin que ça et  j'en avais déduis que c'était un 65c02. Donc j'ai encore appris quelque chose. 

Modifié il me semble que oui, mais il est bien sur la base du 6502 ..

Dans la NES, les 6502 utilisés avaient été modifiés. Cette série, qui fut produite seulement pour Nintendo, pris le nom de « 2A03/2A07 ». Les 2A03/2A07 n'avaient pas le mode BCD des 6502 mais 23 registres supplémentaires memory-mapped pour la génération du son, l'affichage des sprites et la gestion des manettes.

(source : 6502 sur Wikipedia)

Pas de mode BCD mon pauvre TOUKO 

[Invité]

Pas de mode BCD mon pauvre TOUKO 

LOL, merde, le calcul du score et hiscore va être aussi lent que sur le Z80 et le 68000    

Sinon sur nesdev j'ai trouvé ça : http://nesdev.com/NESDoc.pdf

[vingazole]

 

Pour l'absence de BCD, c'est discuté ici : http://forums.nesdev.com/viewtopic.php?f=9&t=10612&hilit=bcd

[Invité]

Ouai mais nintendo a enlevé "the instruction" merde ...  

[vincent2105]

Les nombres aléatoire sur ces machines c'est assez la galère .
tu peux utiliser cette fonction
Code:

Code:

srand:
   lda      _rndseed + 1
   rol      A
   rol      A
   rol      A
   eor      _rndseed
   ror         A
   php
   lda      _rndseed + 1
   eor      _rndseed
   sta      _rndseed + 1
   lda      _rndseed + 2
   eor      _rndseed
   sta      _rndseed
   plp
   rol      _rndseed
   rol      _rndseed + 1
   lda      _rndseed + 1
   eor      _rndseed
   
   rts

Par contre l'idéal serait de l'appeler dans ta routine nmi, donc il faut que tu es le contrôle dessus .
C'est un nombre aléatoire sur 16 bit, mais rien ne t'empêche d'utiliser 1 ou l'autre partie 8 bit .

J'essaye de  comprendre la situation. Voici quelques affirmations, dites moi si je suis dans l'erreur.

Avant d'appeler cette routine,
- On déclare _rndseed, mais on ne l'initialise pas.
- On a donc une adresse mémoire qui s'appelle _rndseed et qui contient un  nombre aléatoire sur  16 bits.
- Ce nombre est compris entre 0 et FFFF car le CPU de la NES utilise un bus d'adresse 16 bits.

Maintenant, une question :
Après ta routine, "_rndseed" vaut disons #$1234
Comment récupérer l'octet de poids fort (#$12), idem pour l'octet de poids faible(#$34) ?

Dans ma tête, AND #$FF permet de récupérer l'octet de poids faible. Pour l'octet de poids fort je n'ai aucune idée (mais je peux m'en passer dans ce cas précis).

Tip top vos liens . Par contre a ce rythme là, j'en ai jusqu'à la fin de mes jours.    
J'ai pas trop fouiné pour savoir ce qu'était le mode BCD puisque de toute façon, "y'en a pô... "

Heureusement que je vous ai !

[vingazole]

Le microprocesseur de la NES est dit little endian ("petit boutiste" en français) : quand on range une valeur 16 bits à l'adresse adr,  l'octet de poids faible est stocké en adr et l'octet de poids fort en (adr + 1).

Dans ton exemple où [ _rndseed ] vaut $1234, $34 est stocké à l'adresse _rndseed et $12 est stocké en (_rndseed + 1).

Pour récupérer l'octet de poids faible dans le registre A tu dois faire :

Code:

LDA    _rndseed

et pour l'octet de poids fort :

Code:

LDA    _rndseed + 1

AND #$FF va effectuer un AND entre le registre A (8 bits) et la valeur $FF (%11111111 en binaire), donc laisser A inchangé ! 

- Ce nombre est compris entre 0 et FFFF car le CPU de la NES utilise un bus d'adresse 16 bits.

Non, la largeur du bus d'adresse te permet bien d'accéder aux adresses 16 bits $0000 à $FFFF, mais ça n'a pas de rapport avec la taille du nombre aléatoire généré par la routine de TOUKO (d'ailleurs on pourrait très bien calculer un nombre aléatoire sur n octets, soit n*8 bits).


Quant au BCD effectivement ne te prends pas la tête avec ça, c'est juste un running gag entre TOUKO et moi 

[suisseretrogaming]

A l'époque les jeux étaient tous fait en ASM où bien y'avait des compilateurs C ?

[Invité]

Je soupçonne vingazole d'entretenir,en toutes discrétions, un amour passionnel avec le 6502  

Quant au BCD effectivement ne te prends pas la tête avec ça, c'est juste un running gag entre TOUKO et moi 

 

Ce nombre est compris entre 0 et FFFF car le CPU de la NES utilise un bus d'adresse 16 bits.

Non le 6502 ne gère que des nombres sur 8 bit donc de $00 à $FF
Un nombre 16 bit sera découpé en 2 nombres 8 bit 
on appelle ça le LSB (soit les 8 bit de poid faible), et le MSB (soit les 8 bit de poid fort )
donc la valeur #$1234 sera stockée comme suit en 2 parties .
le LSB #$34 sera dans _rndseed
le MSB #$12 sera dans _rndseed + 1

Et comme dit vingazole, on peut gérer des nombres sur 128 bit si tu veux, mais ils seront décomposés en parties codées sur 8 bit .

A l'époque les jeux étaient tous fait en ASM où bien y'avait des compilateurs C ?

Oui mais plus sur la gen 16 bit, et notamment sur MD .
Le C est un langage qui demande pas mal de RAM et un CPU adapté pour ce type de langage, ce que n'est pas le 6502, mais des compilateurs C existent pour la nes .

[vincent2105]

Non le 6502 ne gère que des nombres sur 8 bit donc de $00 à $FF

J'en déduis qu'on parle de largeur du bus de données. C'est ça ?

Tiens je viens de trouver un lien intéressant : http://traf.romhack.org/WikiTraf/index.php/Adressage_m%C3%A9moire_sur_NES_et_utilisation_des_mappers

Question, dans ta routine : 

Code:

srand:
   lda      _rndseed + 1
   rol      A
   rol      A
   rol      A
   eor      _rndseed
   ror         A
   php
   lda      _rndseed + 1
   eor      _rndseed
   sta      _rndseed + 1
   lda      _rndseed + 2
   eor      _rndseed
   sta      _rndseed
   plp
   rol      _rndseed
   rol      _rndseed + 1
   lda      _rndseed + 1
   eor      _rndseed
   
   rts

Je vois que tu charges "_rndseed + 2" dans l'Accumulateur, j'ai l'impression que c'est pour "triturer"  _rndseed qui servira à son tour de base pour triturer _rndseed+1 ? Grossièrement est-ce que c'est le principe ?

Le microprocesseur de la NES est dit little endian ("petit boutiste" en français) : quand on range une valeur 16 bits à l'adresse adr,  l'octet de poids faible est stocké en adr et l'octet de poids fort en (adr + 1).

Merci pour l'info du coup je me met un lien sous le coude http://fr.wikipedia.org/wiki/Endianness

Bon, je pense avoir toutes les infos, ce soir je rend mon buteur imprévisible

[Invité]

J'en déduis qu'on parle de largeur du bus de données. C'est ça ?

Oui c'est ça  .

Tiens je viens de trouver un lien intéressant :http://traf.romhack.org/WikiTraf/index.php/Adressage_m%C3%A9moire_sur_NES_et_utilisation_des_mappers

intéressant merci .

Je vois que tu charges "_rndseed + 2" dans l'Accumulateur, j'ai l'impression que c'est pour "triturer"  _rndseed qui servira à son tour de base pour triturer _rndseed+1 ? Grossièrement est-ce que c'est le principe ?

Oui, le but est d'avoir un nombre le plus aléatoire possible avec le moins de cycles possible .