Re: Mr ToutLeMonde et la programmation NES...

[vincent2105]

Pour que ça marche, après
CODE:

Code:

LDA  ZPPTR_liste_listes_sprite , X                 
  STA  ZPPTR_liste_sprite                     
  LDA  ZPPTR_liste_listes_sprite + 1 , X             
  STA  ZPPTR_liste_sprite + 1    

il faut faire
CODE:

Code:

LDA  [ ZPPTR_liste_listes_sprite ]                 
  STA  ZPPTR_liste_sprite                     
  LDA  [ ZPPTR_liste_listes_sprite + 1 ]            
  STA  ZPPTR_liste_sprite + 1    

Tu voulais pas plutôt dire : "au lieu de" ? 

Sinon, j'ai eut le message "incorrect adressing mode", j'ai donc remplacé les crochets par des parenthèses, mais je n'obtiens toujours pas ce que j'attends... 
Si c'est correct, j'ai lu que la seule instruction à utiliser l'adressage indirect absolu ($aaaa) était JMP.

Désolé de t'avoir embarqué dans ma galère 

[Invité]

Pas sûr que son assembleur accepte les balises ...

 non ça c'est sur .. 

Désolé de t'avoir embarqué dans ma galère  

Nah pas de soucis .

essayes ça .

; On récupére l'adresse de la liste de sprites on le fait qu'une foi
LDA  LISTE_listes_sprites , X                 
STA  ZPPTR_liste_listes_sprite                     
LDA  LISTE_listes_sprites + 1 , X             
STA  ZPPTR_liste_listes_sprite + 1

; On récupére l'adresse du meta sprite,on se sert de [ ZPPTR_liste_listes_sprite ] , Y  pour récup l'adresse souhaitée
LDA  [ ZPPTR_liste_listes_sprite ] , Y                
STA  ZPPTR_liste_sprite                     
LDA  [ ZPPTR_liste_listes_sprite + 1 ] , Y            
STA  ZPPTR_liste_sprite + 1  

PS:Les Y n'ont pas les mêmes valeurs bien sur .

Là tu devrais récupérer tes valeurs avec .
lda  [ ZPPTR_liste_sprite ] , Y  

J'ai copier/coller trop vite tout à l'heure, un pointeur indexé c'est soit:
[ ZPPTR_liste_listes_sprite ] , Y 
  
Soit


[ ZPPTR_liste_listes_sprite , X ] 
Ce sont 2 adressages différents.

[vincent2105]

Je vais devenir fou   (Touko, j'ai essayé ta proposition, mais je n'obtiens pas le résultat attendu :/ )
C'est pas grave, mais j'ai 2 questions...

Avec le code : 

Spoiler:

Tout fonctionne, j'affiche le sprite choisi au sein de "liste_sprite_0"...

Mais, comme je l'ai dit, j'ai créé plusieurs listes de listes de sprites...

QUESTION 1 : Dans le code ci dessus, si je remplace "liste_sprite_0" par une variable sur 2 octets égale à l'adresse de la liste que je veux choisir,  le metasprite choisi dans cette liste devrait bien s'afficher non ?? 

Voici le code qui ne retourne pas ce que j'attends... (en orange les modifications apportées au code précédent)

Spoiler:

QUESTION 2 : j'ai essayé de deviner sans vraiment comprendre les infos retournées par le débugger et  je me demandais  entre autre ce que signifiait la ligne :  $C099:B1 00     LDA ($00),Y @ $E0B6 = #$FF   
En outre, je me demande bien d'où sort le "B6"...

Spoiler:

[Invité]

Bon j'ai testé et il y a une toute petite erreur dans mon code,je mets la version corrigée.

clx
LDA  LISTE_listes_sprites , X                 
STA  ZPPTR_liste_listes_sprite                     
LDA  LISTE_listes_sprites + 1 , X             
STA  ZPPTR_liste_listes_sprite + 1

; On récupére l'adresse du meta sprite,on se sert de [ ZPPTR_liste_listes_sprite ] , Y  pour récup l'adresse souhaitée
cly
LDA  [ ZPPTR_liste_listes_sprite ] , Y                
STA  ZPPTR_liste_sprite
iny                    
LDA  [ ZPPTR_liste_listes_sprite ] , Y    ; Corrigée        
STA  ZPPTR_liste_sprite + 1  

PS:Les Y n'ont pas les mêmes valeurs bien sur .

Là tu devrais récupérer tes valeurs avec .
cly
lda  [ ZPPTR_liste_sprite ] , Y  

le  
lda  [ ZPPTR_liste_listes_sprite + 1 ] , Y 
est faux, c'est  :
iny
lda [ ZPPTR_liste_listes_sprite ] , Y  qu'il faut mettre et là c'est bon ..

[vincent2105]

Ca marche ! Touko je t'aime   
Maintenant, je vais tacher de comprendre 

[Invité]

Alors la première partie récupère les 2 premiers octets(première adresse,car je mets X à 0) de ta LISTE_listes_sprites,soit l'adresse de liste_sprite_0 .
Et le met dans le pointeur ZPPTR_liste_listes_sprite
ldx #00
LDA  LISTE_listes_sprites , X                 
STA  ZPPTR_liste_listes_sprite                     
LDA  LISTE_listes_sprites + 1 , X             
STA  ZPPTR_liste_listes_sprite + 1

Ensuite la seconde partie récupère les 2 premiers octets(première adresse,car je mets Y à 0) de liste_sprite_0(via le pointeur ZPPTR_liste_listes_sprite) ,soit l'adresse de sprite_0 et le stocke dans ZPPTR_liste_sprite . 
LDY #00
LDA  [ ZPPTR_liste_listes_sprite ] , Y                
STA  ZPPTR_liste_sprite
INY                   
LDA  [ ZPPTR_liste_listes_sprite ] , Y    ; Corrigée        
STA  ZPPTR_liste_sprite + 1  

La partie 3 enfin récupère le premier octet du tableau  sprite_0 (car je mets Y à 0),via le pointeur ZPPTR_liste_sprite .
LDY   #00
LDA  [ ZPPTR_liste_sprite ] , Y 

[vincent2105]

Ok, mais c'est surtout l'erreur que tu as corrigée que j'essaye de comprendre...
A savoir remplacer :

Code:

lda  [ ZPPTR_liste_listes_sprite + 1 ] , Y 

par : 

Code:

iny
lda [ ZPPTR_liste_listes_sprite ] , Y  

Je vais me creuser un peu la tête, je te fais signe si je comprends pas

[Invité]

Ah ok, en fait [ ZPPTR_liste_listes_sprite + 1 ], décalait de 1 l'adresse de ZPPTR_liste_listes_sprite .
Donc si par exemple ZPPTR_liste_listes_sprite était à l'adresse $2020 je récupérais l'adresse contenue à $2021,au lieu de [ ZPPTR_liste_listes_sprite ] , Y+1 comme je le pensais , ce qui n'est pas bon .. 

Donc je résume :
ZPPTR_liste_listes_sprite a pour adresse $2020,le contenue de ZPPTR_liste_listes_sprite et $4000, je voulais donc récupérer les valeurs à l'adresses $4000 et $4001 .
hors je récupérais l'octet à $4000 ( [ZPPTR_liste_listes_sprite],Y ) mais celle de l'adresse contenue dans $2021 ( [ZPPTR_liste_listes_sprite+1],Y ) pour l'autre octet, donc erronée . 

[vincent2105]

Salut à tous, 

J'ai toujours aussi peu de temps à consacrer à ce loisir, mais j'ai eu 2h cet aprem, et je suis surexcité du fait d'avoir réussi à utiliser un mapper (le MMC1 en l'occurence). A part piocher un background parmi 14 banks, je ne fais rien de fantastique, mais (en suivant la configuration d'un tuto trouvé sur le net) je passe d'un coup de 16 KB de PRG-ROM à 128 KB ! 
Avant cela, j'avais juste assez de place pour mon code et grosso modo 8 nametables (background), maintenant je double la taille disponible pour la logique du jeu mais j'ai également suffisamment de place pour une bonne centaine de backgrounds sans avoir a me soucier de leur compression...

Bref, je vais pouvoir continuer de bidouiller, je suis trop content ! 

[Invité]

C'est cool que tu progresses, et continues à nous tenir informé, même si je connais rien aux mappers nes, c'est toujours agréable de lire ceux qui codent sur des machines/perifs . 

[Invité]

Tu l'as appris assez tard , quand j'ai touché sur la Nes c'est la première chose que je me suis dit comment changer le mapper a loisir.
Bon courage , j'aime bien la console mais je déteste programmer avec

[Invité]

Tu l'as appris assez tard , quand j'ai touché sur la Nes c'est la première chose que je me suis dit comment changer le mapper a loisir.
Bon courage , j'aime bien la console mais je déteste programmer avec

Pourtant il parait qu'elle est moins chiante à programmer que la snes(moins complexe) ..

[Invité]

Oui elle est beaucoup plus simple a programmer si on enlève le son , il n'y a que une dizaine de registres hard a connaître pour prog avec, c'est plus une histoire de goût je la trouve comment dire trop 'archaïque' et qu'on ne puisse pas écrire sur la VRAM (pour les data des sprites) me dérange énormément.
Pour être honnête je suis assez étonné que c'est une console aussi populaire en homebrew , c'est sûrement sa facilité a faire des jeux dessus (d'un coter la gestion de la VRAM qui est un vrai casse tete) devient sur Nes assez simple vu sa limite imposé.

[Invité]

Pour être honnête je suis assez étonné que c'est une console aussi populaire en homebrew , c'est sûrement sa facilité a faire des jeux dessus (d'un coter la gestion de la VRAM qui est un vrai casse tete) devient sur Nes assez simple vu sa limite imposé.

Gros côté nostalgie + bcp de doc et d'outils, et forcement grosse communauté .

[vincent2105]

Merci pour votre soutien

Tu l'as appris assez tard , quand j'ai touché sur la Nes c'est la première chose que je me suis dit comment changer le mapper a loisir.
Bon courage , j'aime bien la console mais je déteste programmer avec

Tu sais, j'ai pas appris grand chose jusque là, j'ai eu de gros passages à vide  donc l'utilisation de mapper est la suite logique de mon apprentissage... Y'a des aspects qui semblent parfois "effrayants" pour un noob, mais effectivement, lorsqu'on se penche sérieusement dessus, c'est comme tout, on y arrive.
J'ai pas de grosses connaissances, mais comme vous le répétez souvent, il y a énormément de doc sur la NES et pour ma part, c'est avant tout un problème de temps : à part coder entre 2 clients, j'ai rarement l'occasion de m'isoler et d'être concentré à 100% mais je vais continuer d'apprendre et réaliser des petits trucs et c'est ce que je trouve intéressant/excitant. L'envie est là, c'est le principal

Pour être honnête je suis assez étonné que c'est une console aussi populaire en homebrew , c'est sûrement sa facilité a faire des jeux dessus (d'un coter la gestion de la VRAM qui est un vrai casse tete) devient sur Nes assez simple vu sa limite imposé.

Je suis de l'avis de Touko, y'a une bonne part de nostalgie : c'est avec la NES que j'ai découvert le jeu vidéo, j'ai littéralement été charmé par cette console/époque, j'avais 10/12 ans 

Coté "avancées", juste pour voir si j'avais bien pigé,  j'ai créé une map de 8*8 nametables différentes dans laquelle je peux déambuler. Prochaine session de prog, j'attaque le scrolling ! (parait-il moins compliqué que sur d'autres machines ).

Bonne continuation à tous 

[Invité]

Tu sais, j'ai pas appris grand chose jusque là, j'ai eu de gros passages à vide   donc l'utilisation de mapper est la suite logique de mon apprentissage... Y'a des aspects qui semblent parfois "effrayants" pour un noob, mais effectivement, lorsqu'on se penche sérieusement dessus, c'est comme tout, on y arrive.

Je pense que d'abord on essayes de comprendre/maitriser le système de base avant de se compliquer la vie avec les addon,surtout si on en a pas besoin,on apprend pas à faire un scrolling, sans savoir comment gérer un tilemap .
Le temps est vraiment ce qui fait défaut en homebrew, de ce fait les projets tirent en longueur et no souvent raison de la patience et l'envie du codeur .

Après on est pas tous pareil sur ce que l'on a envie de voir dans une machine, et sur nes les addon sont je pense incontournables tôt ou tard .

Coté "avancées", juste pour voir si j'avais bien pigé,  j'ai créé une map de 8*8 nametables différentes dans laquelle je peux déambuler. Prochaine session de prog, j'attaque le scrolling ! (parait-il moins compliqué que sur d'autres machines

Tu avances bien, je pense que tu as fais le plus dur, le scrolling c'est juste 2/3 registres à modifier puisqu'il est hardware, rien de difficile normalement.

[vingazole]

Il faut mettre la tilemap à jour en fonction des déplacements / du scrolling, quand même

[Invité]

Il faut mettre la tilemap à jour en fonction des déplacements / du scrolling, quand même

Oui mais pour faire ça, faut déjà comprendre comment la mettre à jour ,et aussi comment la mettre en jour en plein scrolling (wrap around et cie) ..

En général tu commences d'abord par afficher un fond avant de le faire scroller . 

[vingazole]

Il faut mettre la tilemap à jour en fonction des déplacements / du scrolling, quand même

Oui mais pour faire ça, faut déjà comprendre comment la mettre à jour ,et aussi comment la mettre en jour en plein scrolling (wrap around et cie) ..

Ben t'as qu'à carrément paraphraser ce que j'écris, tant qu'à faire !

[Invité]

LOL dsl alors,mais c'était tellement beau(on appelle ça la technique du chat: comment retomber sur ses pattes  )   
je vous présente toutes mes confuses missiou !! 

[vingazole]

Au moins on est d'accord ! (et accessoirement on pollue bien le topic initial  )

[Invité]

C'est pas faux ..

[vincent2105]

Pas de problème, faites comme chez vous !

Hier soir, je me suis penché sur le sujet, et en effet, scroller sur 2 et seulement 2 nametables se fait assez rapidement... Il me semble à ma portée de scroller une carte à la manière d'un zelda (sans la "status bar"), mais mon souhait est de scroller à la manière d'un "SMB 2", c'est pourquoi je ne me suis pas attardé la dessus .
Par ailleurs, les possibilités en matière de scrolling dépendent aussi du mapper utilisé... faudra que je m'assure de choisir celui qui convient le mieux... Donc encore pas mal de lecture en perspective...

Cet aprem, j'aurai 2h de libre, j'espère bien progresser sérieusement

[Invité]

Par ailleurs, les possibilités en matière de scrolling dépendent aussi du mapper utilisé... faudra que je m'assure de choisir celui qui convient le mieux...

Le MMC3 semble le plus adapté, car suffisamment bon est surtout très commun, donc simple de trouver de la doc/exemples .
Il permet aussi d'avoir des interruptions H-sync,utile pour faire des parallaxes simplement.

[vincent2105]

Suite de mon aventure... Je demande pas forcément de solution, c'est avant tout pour entretenir ma motivation, discuter un peu et partager pour ceux que ça pourrait intéresser  

Je suis toujours sur le même tuto : http://nintendoage.com/forum/messageview.cfm?catid=22&threadid=36958

Je ne trouve pas les explications d'une grande difficulté, en effet, j'ai compris assez rapidement comment cela fonctionnait ( du moins je pense avoir compris)...
Le hic, c'est que le code permet de scroller en récupérant dans un fichier dont chaque ligne de .db représente une colonne de la nametable 
Or l'utilitaire "NES screen tool" que j'utilise depuis le début me permet de créér un background (nametable) et générer un fichier  (.nam) dans lequel 32 bytes consécutifs correspondent à une ligne de background et non à une colonne (ceci 30 fois => 960 octets pour une nametable)
J'ai donc 2 solutions : concevoir un outil me permettant de modifier mes fichiers .nam  ou adapter la routine du tuto...

J'ai penché vers la seconde solution et j'ai l'impression de me retrouver dans une impasse 
Voici le code qui permet de récupérer les 30 bytes d'une colonne de nametable
Pour adapter ce code à mes fichiers .nam, il faut donc indexer de 32 en plus à chaque tour de boucle, or avec un registre Y de 8 bits c'est juste impossible. Le registre X etant utilisé également, que faire ?  

Code:

 LDX #$1E              ; copy 30 bytes
  LDY #$00
DrawColumnLoop:
  
  LDA [sourceLow], y
  STA $2007
  INY
  DEX
  
  BNE DrawColumnLoop

[Invité]

Tu peux faire ça .

LDY #$00
DrawColumnLoop:
  
  LDA [sourceLow], y
  STA $2007
  INY
  cpy  #30  
  BNE DrawColumnLoop

X reste libre 

Après tu peux rajouter 30 octets à ton pointeur sourceLow. pour la suite.

[vincent2105]

Merci Touko  j'avais pas pensé à ça   ... Plus le temps de coder, on verra ce soir, dommage !

[vincent2105]

On libère X de cette facon, mais ce que tu proposes, on peut le faire avec l'accumulateur aussi non ? (ce que j'avais fait avant ta réponse)
Voici ce que j'avais fait...
  

Code:

 LDX #$1E              ; copy 30 bytes
  LDY #$00
DrawColumnLoop:
  
  LDA [sourceLow], y
  STA $2007  

  LDA sourceLow
  CLC
  ADC #$20            ; on ajoute 32 (nbre de tiles par ligne) pour atteindre la tile a afficher juste en dessous
  STA sourceLow

  INY
  DEX  
  BNE DrawColumnLoop
  RTS

Je suis en train de me dire qu' il faudra aussi incrémenter sourceHigh lorsque sourceLow atteindra %11111111 
J'ai pas le temps de tester mais tu en penses quoi ? J'ai tout faux ?

[Invité]

C'est pas bon car tu incrémentes ton sourceLow de 32 à chaque foi,il faut le faire tout les 30/32 octets de copiés .

Combien d'octets tu dois copier au total ??
Tu dois faire que des boucles de 30/32 octets et faire autre choses après, ou copier toute ta nametable dans la boucle ??

code pour une copie totale (960 octets)

Code:

; Boucle de 3 * 256 octets = 768, reste donc 192 octets à copier
LDX #3              ; copy 30 bytes
LDY #$00
DrawColumnLoop:
  
  LDA [sourceLow], y
  STA $2007

  INY
  BNE DrawColumnLoop  ; on boucle tant que Y != 256 (0 en fait)
  
  inc sourceLow + 1  ; on incremente la partie high du pointeur (sourceLow + 256)
  dex
  bne DrawColumnLoop  
  
  ; // Boucle copie 192 octets
DrawColumnLoop2:
  
  LDA [sourceLow], y
  STA $2007

  INY
  cpy #192
  BNE DrawColumnLoop2  ; on boucle tant que Y != 192  
  
  RTS

 
Ou méthode 2 (celle que tu voulais faire), plus jolie, mais probablement plus lente.

Code:

; Boucle totale
LDX #30              ; copy 30 bytes
LDY #$00
DrawColumnLoop:
  
  LDA [sourceLow], y
  STA $2007

  INY
  cpy #32  
  BNE DrawColumnLoop  ; on boucle tant que Y != 256 (0 en fait)
  
  lda  #32
  clc
  adc  sourceLow
  sta  sourceLow
  lda  sourceLow + 1
  adc  #00
  sta  sourceLow + 1
  
  dex
  bne DrawColumnLoop
  
  RTS

[vincent2105]

arf, apparemment, je me suis pas fait comprendre. désolé, je vais peut-être m'enliser ! Désolé pour l'embrouille !

Je ne veux pas copier une NT entièrement mais juste une colonne. Dans le tuto, ils ont organisés les datas de leur NT de facon à ce que chaque ligne de datas affiche une colonne lorsqu'on utilise la boucle suivante : 

Code:

 LDX #$1E              ; copy 30 bytes
  LDY #$00
DrawColumnLoop:
  LDA [sourceLow], y
  STA $2007
  INY
  DEX
  BNE DrawColumnLoop

  

Ci dessous,la facon dont ils ont organisé leurs datas (autrement dit rangé par colonne) :
.db   Y0/X0, Y1/X0, Y2/X0, Y3/X0 (...) Y30/X0
.db   Y0/X1, Y1/X1, Y2/X1, Y3/X1 (...) Y30/X1
etc
On ne copie que 30 bytes.
Dans la routine ci dessus, chaque INY permet de récupérer l'octet suivant qui correspond dans une NT à la tile se trouvant juste au dessus.



Je souhaite réutiliser cette routine (par conséquent on ne copiera également que 30 bytes).
Le problème c'est qu'avec mon utilitaire les datas de mes NT sont organisées de cette facon (rangé par ligne) : 
.db   Y0/X0, Y0/X1, Y0/X2, Y0/X3 (...) Y0/X32
.db   Y1/X0, Y1/X1, Y1/X2, Y1/X3 (...) Y1/X32
etc 

Le fait d'incrémenter Y n'est pas "suffisant" puisque si on considère une NT cela nous amènerais sur la tile située juste a droite de la précédente et non celle du dessus comme je le souhaite.
Et c'est là que c'est important, et que j'espère me faire comprendre il faudrait donc pouvoir indexer Y de 32 en plus à chaque tour de boucle. 
C'est pourquoi je disais qu'avec un registre 8 bits et vu que la boucle est répétée 30 fois (c'est le nombre de tile composant chaque colonne), je me voyais mal barré 

Après j'ai peut-être encore tout faux  

[Invité]

Ah ok donc il faut ajouter 32 octets à ton pointeur à chaque octets copié

Code:

LDX #$1E              ; copy 30 bytes[size=13][/size]
  
DrawColumnLoop:
  LDA [sourceLow]
  STA $2007

; On passe à l'octet suivant de la colonne
  lda  #32
  clc
  adc  sourceLow
  sta  sourceLow
  lda  sourceLow + 1
  adc  #00
  sta  sourceLow + 1
  
  dex
  bne DrawColumnLoop
 
  rts

L'idéal serrait d'avoir les octets de la colonne alignés dans ton fichier (je fais ça sur PCE) .