Logicielsmoto.com

Je tourne en rond ! je comprend pas pourquoi ça fonctionne pas !

sujet : stocker la valeur (16bits) la plus petite des (DG_UP, DG_RIGHT, DG_DOWN, DG_LEFT) à l'adresse $blinky_G_smaller_dist, puis $pinky_G_smaller_dist
(le principe de trouver la plus petite valeur fonctionne, pas de soucis)

problème : sauvegarder la valeur 16bits à l'adresse $blinky_G_smaller_dist puis $pinky_G_smaller_dist

donc je réserve les adresses


je définie l'emplacement de ghost_G_smaller_dist pour y stocker la valeur 16bits dedans plutard !


1 - trouver la plus petite entre ces 4 valeur 16bit (DG_UP, DG_RIGHT, DG_DOWN, DG_LEFT) (on va dire que c'est déjà calculé !)
2 - puis la stocker dans ghost_G_smaller_dist (qui sera donc l'adresse blinky_G_smaller_dist)



- le but est de faire varier l'adresse ghost_G_smaller_dist à chaque boucle (ici 2 boucles) pour stocker 2 valeurs 16bits différentes (pour mettre à jour les valeurs qui sont en blinky_G_smaller_dist puis pinky_G_smaller_dist).


-Pour qu'au final je définissent la direction à prendre en faite.
-Donc [ ghost_G_smaller_dist est blinky_G_smaller_dist ] puis [ ghost_G_smaller_dist est pinky_G_smaller_dist ] (puis on loop)





Désoler si c'est le bordel, pas évident d'expliquer !
merci

_________________

Oui c'est compliqué. J'arrive pas à comprendre. Parfois tu parles de l'adresse ghost_G_smaller_dist, et parfois d'une la valeur en ghost_G_smaller_dist. C'est pas clair. Il me semble qu'il y a une confusion?

Qu'est supposé contenir ghost_G_smaller_dist ? Une adresse ou une valeur ? Si c'est une adresse il faut utiliser une double indirection alors que toi tu y stockes une valeur. Je pense que le code devrait ressembler à
si tu veux y stocker une adresse. Note: ce code est moche et pas optimal, il pourrait être plus court en utilisant X pour y stocker une adresse, mais on s'en fiche pour le moment.

_________________
Good morning, that's a nice Tnetennba

oui je dois certainement cafouiller entre valeur et adresse !
je sais j'aurai du utiliser X pour les adresses, je vais changer ça, j'y verrais plus clair ...

merci.

_________________

Je ne comprends pas très bien ce que tu cherches à expliquer mais tes routines peuvent être grandement simplifiées. Comme par exemple:



Et

Attention, le soucis est qu'ici on ne veut pas trouver la valeur la plus petite, mais son adresse (pour autant que j'ai bien compris.) Cela complique un peu les choses.

Je ne comprends pas non plus pourquoi tu remplaces les BLO par des BEQ. Ca n'est pas équivalent.

_________________
Good morning, that's a nice Tnetennba

J'ai super simplifié ce que je cherche à traduire en ASM qui va résoudre mon soucis.

voila ce que j'essaye de faire en asm :

a = $00 (valeur 8bits)
blinky = $1111 (valeur 16bits)
pinky = $2222 (valeur 16bits)
ghost = $0000 (valeur 16bits)


if a=1 then ghost=blinky
if a=2 then ghost=pinky

compare ghost à $2222
BEQ branchement


Donc un coup "ghost" = valeur de blinky et l'autre coup "ghost" = valeur de pinky.

ps: le code n'a pas d'intérêt en soit, c'est juste pour trouver les bonnes syntaxes en asm que j'ai besoin en faite.

_________________

Ah oui donc c'est bel et bien les BEQ dont jasz parle dont tu as besoin.

_________________
Good morning, that's a nice Tnetennba

je test ce que jasz m'a expliqué ! pour voir ....

_________________

Je suppose que A (valeur 8bits) est issue de D.

En supposant ceci on peut dire
blinky = #0111
pinky = #FF22

Donc si A>0 then ghost=blinky et si A<0 then ghost=pinky

ici "a" represente l'index de mes fantômes. (1 blinky, 2 pinky, 3 inky, 4 clyde)

et en fonction de a=1 ou 2 ou 3 ou 4
ghost = blinky ou pinky ou inky ou clyde

c'est juste que mon algo de calcul que j'appel va utiliser "ghost" mais en tant que blinky pinky inky et clyde.
mais avant d'appeler j'ai besoin d'initialiser ghost en tant que blinky ou pinky ou inky ou clyde.

je fais ça car j'ai besoin de garder quelque part chaque valeur de : blinky pinky inky et clyde pour l'appel suivant...


je pense que ce que j'arrive pas à faire c'est faire pointé "ghost" sur adresse1, puis au tour suivant faire pointé "ghost" sur adresse2, pour qu'a chaque tour je récupére la valeur stocké en adresse1 ou adresse2 !

_________________

Ah ok, je comprends un peu mieux.

Donc partons du principe binaire que
A=1 pour blinky
A=2 pour pinky
A=4 pour inky
A=8 pour clyde

Pour


D'après ce que je comprends c'est ce que tu cherches... ou presque.

Par la même occasion tu peux garder A=1, 2, 3 ou 4 et remplacer LSRA par DECA. C'est la même chose mais avec un ANDA #7

j'ai du mal là, j'ai fais un truc sur papier pour voir où est mon erreur de compréhension.

Est ce qu'il y a un truc faux dans cette enchainement ?



[modif]
ok j'ai capté ce qu'il me manque (je crois) ...

c'est au niveau de STD ghost , dans les 2 cas STD ghost execute STD $9808

alors que je voudrais que le premier STD ghost soit STD $9800
puis le 2eme STD ghost soit STD $9802
tout en gardant la syntaxe STD ghost (changer le pointage de ghost en faite)

je pense que STD ghost c'est pas bon.

je dois faire un truc du genre :
STY ghost (pour mettre $9800 dans Y)
puis mettre D -> $9800 (STY ,D)
.... c'est là que je cafouille.!

je crois que je dois faire un truc comme ça :

LDY ghost
STD ,Y

OK : bon j'ai testé avec le debugger pas à pas ! c'est bon j'ai la bonne valeur où il faut ! oufff
ça fait depuis ce weekend que je galère là dessus.
bon maintenant je vais appliquer ça à mon code....

_________________

Si dans ta séquence
LEAX, #blinki
STX, #ghost
...
LEAX, #pinky
STX, #ghost
...
STD, #ghost

Ici si D renvoie toujours la même adresse c'est que tu as cafouillé quelque part dans le calcul.
Mais pourquoi réserver X (STX)? Si tu en as besoin dans ton calcul le couple PSHS X / PULS D (récupération de X dans D) ne mange pas de pain

Oui LDX/STX est plus rapide et plus court que LDY/STY.

_________________
Good morning, that's a nice Tnetennba

Merci les gars, le problème précédent est résolu

Dernier problème à résoudre pour que l'IA soit fonctionnelle pour tous les fantômes.

- on considère que valeur dans D : OK (vérifié dans le debugger) peut importe la valeur, ex: D = $1234
- valeur à comparer : fausse !



1 - en ghost_DG_UP (ici $97CA) j'ai stocké l'adresse $97D4 (qui correspond à blinky_DG_UP)
2 - en $97D4(blinky_DG_UP) j'ai stocké la valeur $7777(variable selon le calcul IA)

Donc je dois comparer D à #$7777 mais en utilisant ghost_DG_UP seulement, comme ça.
CMPD ghost_DG_UP (CMPD #$7777)

mais je me retrouve actuellement avec :

CMPD ghost_DG_UP (CMPD $97D4)

_________________