Hmm... il semble que zéro est toujours noir ? Bah je me retire, il est trop tard et je ne peux plus penser wink

Quant à la palette, oui, mais parfois on n'utilise pas tous les couleurs d'une palette dans chaque sprite, mais ce n'est pas un problème pour le moment, avant de continuer je devrais finir de lire tous ces tutoriels smile
Ah oui, si les 16 couleurs ne sont pas toutes utilisées dans le sprite, ses références à la palette ne seront pas les mêmes que pour les sprites dont c'est le cas... Mais tous les autres programmes font pareil (gifs2sprites etc...) :/

Autrement je peux faire en sorte qu'on passe d'abord notre sprite le plus complet (avec les 16 couleurs) dans le convertisseur, celui-ci génère alors la palette puis s'en sert pour toutes les autres sprites confus

Mais il faudra alors que je fasse plein de vérifications pour être sûr que les sprites partagent les mêmes couleurs... sick

Ce serait peut être plus simple (mais pas plus rapide) que je fasse un éditeur directement confus

Sinon je viens d'adapter un thème de coloration syntaxique ARM pour Notepad++ : http://deeph.servhome.org/ftp/Game%20Boy%20Advance/userDefineLang.xml (à copier dans son dossier, puis à sélectionner dans le menu langage), c'est plus lisible comme ça. D'ailleurs je me demandais, c'est quoi vos éditeurs sous linux ?
Moi j'ai écrit mon propre fichier pour gedit, c'est pas très beau mais il marche :
6VwL
Je peux même voir si une instruction existe ou non (si elle est coulourée ou non) smile Voici une liste avec tous les affixes (ne, eq, gt, lt, nes, egs, etc.) si tu le veux :
MOV MOVEQ MOVNE MOVCS MOVHS MOVCC MOVLO MOVMI MOVPL MOVVS MOVVC MOVHI MOVLS MOVGE MOVLT MOVGT MOVLE MOVAL MOVS MOVEQS MOVNES MOVCSS MOVHSS MOVCCS MOVLOS MOVMIS MOVPLS MOVVSS MOVVCS MOVHIS MOVLSS MOVGES MOVLTS MOVGTS MOVLES MOVALS MVN MVNEQ MVNNE MVNCS MVNHS MVNCC MVNLO MVNMI MVNPL MVNVS MVNVC MVNHI MVNLS MVNGE MVNLT MVNGT MVNLE MVNAL MVNS MVNEQS MVNNES MVNCSS MVNHSS MVNCCS MVNLOS MVNMIS MVNPLS MVNVSS MVNVCS MVNHIS MVNLSS MVNGES MVNLTS MVNGTS MVNLES MVNALS MRS MRSEQ MRSNE MRSCS MRSHS MRSCC MRSLO MRSMI MRSPL MRSVS MRSVC MRSHI MRSLS MRSGE MRSLT MRSGT MRSLE MRSAL MSR MSREQ MSRNE MSRCS MSRHS MSRCC MSRLO MSRMI MSRPL MSRVS MSRVC MSRHI MSRLS MSRGE MSRLT MSRGT MSRLE MSRAL MRA MRAEQ MRANE MRACS MRAHS MRACC MRALO MRAMI MRAPL MRAVS MRAVC MRAHI MRALS MRAGE MRALT MRAGT MRALE MRAAL MAR MAREQ MARNE MARCS MARHS MARCC MARLO MARMI MARPL MARVS MARVC MARHI MARLS MARGE MARLT MARGT MARLE MARAL ADD ADDEQ ADDNE ADDCS ADDHS ADDCC ADDLO ADDMI ADDPL ADDVS ADDVC ADDHI ADDLS ADDGE ADDLT ADDGT ADDLE ADDAL ADDS ADDEQS ADDNES ADDCSS ADDHSS ADDCCS ADDLOS ADDMIS ADDPLS ADDVSS ADDVCS ADDHIS ADDLSS ADDGES ADDLTS ADDGTS ADDLES ADDALS ADC ADCEQ ADCNE ADCCS ADCHS ADCCC ADCLO ADCMI ADCPL ADCVS ADCVC ADCHI ADCLS ADCGE ADCLT ADCGT ADCLE ADCAL ADCS ADCEQS ADCNES ADCCSS ADCHSS ADCCCS ADCLOS ADCMIS ADCPLS ADCVSS ADCVCS ADCHIS ADCLSS ADCGES ADCLTS ADCGTS ADCLES ADCALS QADD QADDEQ QADDNE QADDCS QADDHS QADDCC QADDLO QADDMI QADDPL QADDVS QADDVC QADDHI QADDLS QADDGE QADDLT QADDGT QADDLE QADDAL QDADD QDADDEQ QDADDNE QDADDCS QDADDHS QDADDCC QDADDLO QDADDMI QDADDPL QDADDVS QDADDVC QDADDHI QDADDLS QDADDGE QDADDLT QDADDGT QDADDLE QDADDAL SUB SUBEQ SUBNE SUBCS SUBHS SUBCC SUBLO SUBMI SUBPL SUBVS SUBVC SUBHI SUBLS SUBGE SUBLT SUBGT SUBLE SUBAL SUBS SUBEQS SUBNES SUBCSS SUBHSS SUBCCS SUBLOS SUBMIS SUBPLS SUBVSS SUBVCS SUBHIS SUBLSS SUBGES SUBLTS SUBGTS SUBLES SUBALS SBC SBCEQ SBCNE SBCCS SBCHS SBCCC SBCLO SBCMI SBCPL SBCVS SBCVC SBCHI SBCLS SBCGE SBCLT SBCGT SBCLE SBCAL SBCS SBCEQS SBCNES SBCCSS SBCHSS SBCCCS SBCLOS SBCMIS SBCPLS SBCVSS SBCVCS SBCHIS SBCLSS SBCGES SBCLTS SBCGTS SBCLES SBCALS RSB RSBEQ RSBNE RSBCS RSBHS RSBCC RSBLO RSBMI RSBPL RSBVS RSBVC RSBHI RSBLS RSBGE RSBLT RSBGT RSBLE RSBAL RSBS RSBEQS RSBNES RSBCSS RSBHSS RSBCCS RSBLOS RSBMIS RSBPLS RSBVSS RSBVCS RSBHIS RSBLSS RSBGES RSBLTS RSBGTS RSBLES RSBALS RSC RSCEQ RSCNE RSCCS RSCHS RSCCC RSCLO RSCMI RSCPL RSCVS RSCVC RSCHI RSCLS RSCGE RSCLT RSCGT RSCLE RSCAL RSCS RSCEQS RSCNES RSCCSS RSCHSS RSCCCS RSCLOS RSCMIS RSCPLS RSCVSS RSCVCS RSCHIS RSCLSS RSCGES RSCLTS RSCGTS RSCLES RSCALS QSUB QSUBEQ QSUBNE QSUBCS QSUBHS QSUBCC QSUBLO QSUBMI QSUBPL QSUBVS QSUBVC QSUBHI QSUBLS QSUBGE QSUBLT QSUBGT QSUBLE QSUBAL QDSUB QDSUBEQ QDSUBNE QDSUBCS QDSUBHS QDSUBCC QDSUBLO QDSUBMI QDSUBPL QDSUBVS QDSUBVC QDSUBHI QDSUBLS QDSUBGE QDSUBLT QDSUBGT QDSUBLE QDSUBAL MUL MULEQ MULNE MULCS MULHS MULCC MULLO MULMI MULPL MULVS MULVC MULHI MULLS MULGE MULLT MULGT MULLE MULAL MULS MULEQS MULNES MULCSS MULHSS MULCCS MULLOS MULMIS MULPLS MULVSS MULVCS MULHIS MULLSS MULGES MULLTS MULGTS MULLES MULALS MLA MLAEQ MLANE MLACS MLAHS MLACC MLALO MLAMI MLAPL MLAVS MLAVC MLAHI MLALS MLAGE MLALT MLAGT MLALE MLAAL MLAS MLAEQS MLANES MLACSS MLAHSS MLACCS MLALOS MLAMIS MLAPLS MLAVSS MLAVCS MLAHIS MLALSS MLAGES MLALTS MLAGTS MLALES MLAALS UMULL UMULLEQ UMULLNE UMULLCS UMULLHS UMULLCC UMULLLO UMULLMI UMULLPL UMULLVS UMULLVC UMULLHI UMULLLS UMULLGE UMULLLT UMULLGT UMULLLE UMULLAL UMULLS UMULLEQS UMULLNES UMULLCSS UMULLHSS UMULLCCS UMULLLOS UMULLMIS UMULLPLS UMULLVSS UMULLVCS UMULLHIS UMULLLSS UMULLGES UMULLLTS UMULLGTS UMULLLES UMULLALS UMLAL UMLALEQ UMLALNE UMLALCS UMLALHS UMLALCC UMLALLO UMLALMI UMLALPL UMLALVS UMLALVC UMLALHI UMLALLS UMLALGE UMLALLT UMLALGT UMLALLE UMLALAL UMLALS UMLALEQS UMLALNES UMLALCSS UMLALHSS UMLALCCS UMLALLOS UMLALMIS UMLALPLS UMLALVSS UMLALVCS UMLALHIS UMLALLSS UMLALGES UMLALLTS UMLALGTS UMLALLES UMLALALS SMULL SMULLEQ SMULLNE SMULLCS SMULLHS SMULLCC SMULLLO SMULLMI SMULLPL SMULLVS SMULLVC SMULLHI SMULLLS SMULLGE SMULLLT SMULLGT SMULLLE SMULLAL SMULLS SMULLEQS SMULLNES SMULLCSS SMULLHSS SMULLCCS SMULLLOS SMULLMIS SMULLPLS SMULLVSS SMULLVCS SMULLHIS SMULLLSS SMULLGES SMULLLTS SMULLGTS SMULLLES SMULLALS SMLAL SMLALEQ SMLALNE SMLALCS SMLALHS SMLALCC SMLALLO SMLALMI SMLALPL SMLALVS SMLALVC SMLALHI SMLALLS SMLALGE SMLALLT SMLALGT SMLALLE SMLALAL SMLALS SMLALEQS SMLALNES SMLALCSS SMLALHSS SMLALCCS SMLALLOS SMLALMIS SMLALPLS SMLALVSS SMLALVCS SMLALHIS SMLALLSS SMLALGES SMLALLTS SMLALGTS SMLALLES SMLALALS SMULxy SMULxyEQ SMULxyNE SMULxyCS SMULxyHS SMULxyCC SMULxyLO SMULxyMI SMULxyPL SMULxyVS SMULxyVC SMULxyHI SMULxyLS SMULxyGE SMULxyLT SMULxyGT SMULxyLE SMULxyAL SMULWy SMULWyEQ SMULWyNE SMULWyCS SMULWyHS SMULWyCC SMULWyLO SMULWyMI SMULWyPL SMULWyVS SMULWyVC SMULWyHI SMULWyLS SMULWyGE SMULWyLT SMULWyGT SMULWyLE SMULWyAL SMLAxy SMLAxyEQ SMLAxyNE SMLAxyCS SMLAxyHS SMLAxyCC SMLAxyLO SMLAxyMI SMLAxyPL SMLAxyVS SMLAxyVC SMLAxyHI SMLAxyLS SMLAxyGE SMLAxyLT SMLAxyGT SMLAxyLE SMLAxyAL SMLAWy SMLAWyEQ SMLAWyNE SMLAWyCS SMLAWyHS SMLAWyCC SMLAWyLO SMLAWyMI SMLAWyPL SMLAWyVS SMLAWyVC SMLAWyHI SMLAWyLS SMLAWyGE SMLAWyLT SMLAWyGT SMLAWyLE SMLAWyAL SMLALxy SMLALxyEQ SMLALxyNE SMLALxyCS SMLALxyHS SMLALxyCC SMLALxyLO SMLALxyMI SMLALxyPL SMLALxyVS SMLALxyVC SMLALxyHI SMLALxyLS SMLALxyGE SMLALxyLT SMLALxyGT SMLALxyLE SMLALxyAL MIA MIAEQ MIANE MIACS MIAHS MIACC MIALO MIAMI MIAPL MIAVS MIAVC MIAHI MIALS MIAGE MIALT MIAGT MIALE MIAAL MIAPH MIAPHEQ MIAPHNE MIAPHCS MIAPHHS MIAPHCC MIAPHLO MIAPHMI MIAPHPL MIAPHVS MIAPHVC MIAPHHI MIAPHLS MIAPHGE MIAPHLT MIAPHGT MIAPHLE MIAPHAL MIAxy MIAxyEQ MIAxyNE MIAxyCS MIAxyHS MIAxyCC MIAxyLO MIAxyMI MIAxyPL MIAxyVS MIAxyVC MIAxyHI MIAxyLS MIAxyGE MIAxyLT MIAxyGT MIAxyLE MIAxyAL CLZ CLZEQ CLZNE CLZCS CLZHS CLZCC CLZLO CLZMI CLZPL CLZVS CLZVC CLZHI CLZLS CLZGE CLZLT CLZGT CLZLE CLZAL TST TSTEQ TSTNE TSTCS TSTHS TSTCC TSTLO TSTMI TSTPL TSTVS TSTVC TSTHI TSTLS TSTGE TSTLT TSTGT TSTLE TSTAL TEQ TEQEQ TEQNE TEQCS TEQHS TEQCC TEQLO TEQMI TEQPL TEQVS TEQVC TEQHI TEQLS TEQGE TEQLT TEQGT TEQLE TEQAL AND ANDEQ ANDNE ANDCS ANDHS ANDCC ANDLO ANDMI ANDPL ANDVS ANDVC ANDHI ANDLS ANDGE ANDLT ANDGT ANDLE ANDAL ANDS ANDEQS ANDNES ANDCSS ANDHSS ANDCCS ANDLOS ANDMIS ANDPLS ANDVSS ANDVCS ANDHIS ANDLSS ANDGES ANDLTS ANDGTS ANDLES ANDALS EOR EOREQ EORNE EORCS EORHS EORCC EORLO EORMI EORPL EORVS EORVC EORHI EORLS EORGE EORLT EORGT EORLE EORAL EORS EOREQS EORNES EORCSS EORHSS EORCCS EORLOS EORMIS EORPLS EORVSS EORVCS EORHIS EORLSS EORGES EORLTS EORGTS EORLES EORALS ORR ORREQ ORRNE ORRCS ORRHS ORRCC ORRLO ORRMI ORRPL ORRVS ORRVC ORRHI ORRLS ORRGE ORRLT ORRGT ORRLE ORRAL ORRS ORREQS ORRNES ORRCSS ORRHSS ORRCCS ORRLOS ORRMIS ORRPLS ORRVSS ORRVCS ORRHIS ORRLSS ORRGES ORRLTS ORRGTS ORRLES ORRALS BIC BICEQ BICNE BICCS BICHS BICCC BICLO BICMI BICPL BICVS BICVC BICHI BICLS BICGE BICLT BICGT BICLE BICAL BICS BICEQS BICNES BICCSS BICHSS BICCCS BICLOS BICMIS BICPLS BICVSS BICVCS BICHIS BICLSS BICGES BICLTS BICGTS BICLES BICALS CMP CMPEQ CMPNE CMPCS CMPHS CMPCC CMPLO CMPMI CMPPL CMPVS CMPVC CMPHI CMPLS CMPGE CMPLT CMPGT CMPLE CMPAL CMN CMNEQ CMNNE CMNCS CMNHS CMNCC CMNLO CMNMI CMNPL CMNVS CMNVC CMNHI CMNLS CMNGE CMNLT CMNGT CMNLE CMNAL NOP B BEQ BNE BCS BHS BCC BLO BMI BPL BVS BVC BHI BLS BGE BLT BGT BLE BAL BL BLEQ BLNE BLCS BLHS BLCC BLLO BLMI BLPL BLVS BLVC BLHI BLLS BLGE BLLT BLGT BLLE BLAL BX BXEQ BXNE BXCS BXHS BXCC BXLO BXMI BXPL BXVS BXVC BXHI BXLS BXGE BXLT BXGT BXLE BXAL BLX BLXEQ BLXNE BLXCS BLXHS BLXCC BLXLO BLXMI BLXPL BLXVS BLXVC BLXHI BLXLS BLXGE BLXLT BLXGT BLXLE BLXAL LDR LDREQ LDRNE LDRCS LDRHS LDRCC LDRLO LDRMI LDRPL LDRVS LDRVC LDRHI LDRLS LDRGE LDRLT LDRGT LDRLE LDRAL LDRT LDREQT LDRNET LDRCST LDRHST LDRCCT LDRLOT LDRMIT LDRPLT LDRVST LDRVCT LDRHIT LDRLST LDRGET LDRLTT LDRGTT LDRLET LDRALT LDRB LDREQB LDRNEB LDRCSB LDRHSB LDRCCB LDRLOB LDRMIB LDRPLB LDRVSB LDRVCB LDRHIB LDRLSB LDRGEB LDRLTB LDRGTB LDRLEB LDRALB LDRBT LDREQBT LDRNEBT LDRCSBT LDRHSBT LDRCCBT LDRLOBT LDRMIBT LDRPLBT LDRVSBT LDRVCBT LDRHIBT LDRLSBT LDRGEBT LDRLTBT LDRGTBT LDRLEBT LDRALBT LDRSB LDREQSB LDRNESB LDRCSSB LDRHSSB LDRCCSB LDRLOSB LDRMISB LDRPLSB LDRVSSB LDRVCSB LDRHISB LDRLSSB LDRGESB LDRLTSB LDRGTSB LDRLESB LDRALSB LDRH LDREQH LDRNEH LDRCSH LDRHSH LDRCCH LDRLOH LDRMIH LDRPLH LDRVSH LDRVCH LDRHIH LDRLSH LDRGEH LDRLTH LDRGTH LDRLEH LDRALH LDRSH LDREQSH LDRNESH LDRCSSH LDRHSSH LDRCCSH LDRLOSH LDRMISH LDRPLSH LDRVSSH LDRVCSH LDRHISH LDRLSSH LDRGESH LDRLTSH LDRGTSH LDRLESH LDRALSH LDRD LDREQD LDRNED LDRCSD LDRHSD LDRCCD LDRLOD LDRMID LDRPLD LDRVSD LDRVCD LDRHID LDRLSD LDRGED LDRLTD LDRGTD LDRLED LDRALD LDMIA LDMEQIA LDMNEIA LDMCSIA LDMHSIA LDMCCIA LDMLOIA LDMMIIA LDMPLIA LDMVSIA LDMVCIA LDMHIIA LDMLSIA LDMGEIA LDMLTIA LDMGTIA LDMLEIA LDMALIA LDMIB LDMEQIB LDMNEIB LDMCSIB LDMHSIB LDMCCIB LDMLOIB LDMMIIB LDMPLIB LDMVSIB LDMVCIB LDMHIIB LDMLSIB LDMGEIB LDMLTIB LDMGTIB LDMLEIB LDMALIB LDMDA LDMEQDA LDMNEDA LDMCSDA LDMHSDA LDMCCDA LDMLODA LDMMIDA LDMPLDA LDMVSDA LDMVCDA LDMHIDA LDMLSDA LDMGEDA LDMLTDA LDMGTDA LDMLEDA LDMALDA LDMDB LDMEQDB LDMNEDB LDMCSDB LDMHSDB LDMCCDB LDMLODB LDMMIDB LDMPLDB LDMVSDB LDMVCDB LDMHIDB LDMLSDB LDMGEDB LDMLTDB LDMGTDB LDMLEDB LDMALDB LDMFD LDMEQFD LDMNEFD LDMCSFD LDMHSFD LDMCCFD LDMLOFD LDMMIFD LDMPLFD LDMVSFD LDMVCFD LDMHIFD LDMLSFD LDMGEFD LDMLTFD LDMGTFD LDMLEFD LDMALFD LDMED LDMEQED LDMNEED LDMCSED LDMHSED LDMCCED LDMLOED LDMMIED LDMPLED LDMVSED LDMVCED LDMHIED LDMLSED LDMGEED LDMLTED LDMGTED LDMLEED LDMALED LDMFA LDMEQFA LDMNEFA LDMCSFA LDMHSFA LDMCCFA LDMLOFA LDMMIFA LDMPLFA LDMVSFA LDMVCFA LDMHIFA LDMLSFA LDMGEFA LDMLTFA LDMGTFA LDMLEFA LDMALFA LDMEA LDMEQEA LDMNEEA LDMCSEA LDMHSEA LDMCCEA LDMLOEA LDMMIEA LDMPLEA LDMVSEA LDMVCEA LDMHIEA LDMLSEA LDMGEEA LDMLTEA LDMGTEA LDMLEEA LDMALEA PLD STR STREQ STRNE STRCS STRHS STRCC STRLO STRMI STRPL STRVS STRVC STRHI STRLS STRGE STRLT STRGT STRLE STRAL STRT STREQT STRNET STRCST STRHST STRCCT STRLOT STRMIT STRPLT STRVST STRVCT STRHIT STRLST STRGET STRLTT STRGTT STRLET STRALT STRB STREQB STRNEB STRCSB STRHSB STRCCB STRLOB STRMIB STRPLB STRVSB STRVCB STRHIB STRLSB STRGEB STRLTB STRGTB STRLEB STRALB STRBT STREQBT STRNEBT STRCSBT STRHSBT STRCCBT STRLOBT STRMIBT STRPLBT STRVSBT STRVCBT STRHIBT STRLSBT STRGEBT STRLTBT STRGTBT STRLEBT STRALBT STRH STREQH STRNEH STRCSH STRHSH STRCCH STRLOH STRMIH STRPLH STRVSH STRVCH STRHIH STRLSH STRGEH STRLTH STRGTH STRLEH STRALH STRD STREQD STRNED STRCSD STRHSD STRCCD STRLOD STRMID STRPLD STRVSD STRVCD STRHID STRLSD STRGED STRLTD STRGTD STRLED STRALD STMIA STMEQIA STMNEIA STMCSIA STMHSIA STMCCIA STMLOIA STMMIIA STMPLIA STMVSIA STMVCIA STMHIIA STMLSIA STMGEIA STMLTIA STMGTIA STMLEIA STMALIA STMIB STMEQIB STMNEIB STMCSIB STMHSIB STMCCIB STMLOIB STMMIIB STMPLIB STMVSIB STMVCIB STMHIIB STMLSIB STMGEIB STMLTIB STMGTIB STMLEIB STMALIB STMDA STMEQDA STMNEDA STMCSDA STMHSDA STMCCDA STMLODA STMMIDA STMPLDA STMVSDA STMVCDA STMHIDA STMLSDA STMGEDA STMLTDA STMGTDA STMLEDA STMALDA STMDB STMEQDB STMNEDB STMCSDB STMHSDB STMCCDB STMLODB STMMIDB STMPLDB STMVSDB STMVCDB STMHIDB STMLSDB STMGEDB STMLTDB STMGTDB STMLEDB STMALDB STMFD STMEQFD STMNEFD STMCSFD STMHSFD STMCCFD STMLOFD STMMIFD STMPLFD STMVSFD STMVCFD STMHIFD STMLSFD STMGEFD STMLTFD STMGTFD STMLEFD STMALFD STMED STMEQED STMNEED STMCSED STMHSED STMCCED STMLOED STMMIED STMPLED STMVSED STMVCED STMHIED STMLSED STMGEED STMLTED STMGTED STMLEED STMALED STMFA STMEQFA STMNEFA STMCSFA STMHSFA STMCCFA STMLOFA STMMIFA STMPLFA STMVSFA STMVCFA STMHIFA STMLSFA STMGEFA STMLTFA STMGTFA STMLEFA STMALFA STMEA STMEQEA STMNEEA STMCSEA STMHSEA STMCCEA STMLOEA STMMIEA STMPLEA STMVSEA STMVCEA STMHIEA STMLSEA STMGEEA STMLTEA STMGTEA STMLEEA STMALEA SWP SWPEQ SWPNE SWPCS SWPHS SWPCC SWPLO SWPMI SWPPL SWPVS SWPVC SWPHI SWPLS SWPGE SWPLT SWPGT SWPLE SWPAL SWPB SWPEQB SWPNEB SWPCSB SWPHSB SWPCCB SWPLOB SWPMIB SWPPLB SWPVSB SWPVCB SWPHIB SWPLSB SWPGEB SWPLTB SWPGTB SWPLEB SWPALB CDP CDPEQ CDPNE CDPCS CDPHS CDPCC CDPLO CDPMI CDPPL CDPVS CDPVC CDPHI CDPLS CDPGE CDPLT CDPGT CDPLE CDPAL CDP2 CDP2EQ CDP2NE CDP2CS CDP2HS CDP2CC CDP2LO CDP2MI CDP2PL CDP2VS CDP2VC CDP2HI CDP2LS CDP2GE CDP2LT CDP2GT CDP2LE CDP2AL MRC MRCEQ MRCNE MRCCS MRCHS MRCCC MRCLO MRCMI MRCPL MRCVS MRCVC MRCHI MRCLS MRCGE MRCLT MRCGT MRCLE MRCAL MRC2 MRC2EQ MRC2NE MRC2CS MRC2HS MRC2CC MRC2LO MRC2MI MRC2PL MRC2VS MRC2VC MRC2HI MRC2LS MRC2GE MRC2LT MRC2GT MRC2LE MRC2AL MRRC MRRCEQ MRRCNE MRRCCS MRRCHS MRRCCC MRRCLO MRRCMI MRRCPL MRRCVS MRRCVC MRRCHI MRRCLS MRRCGE MRRCLT MRRCGT MRRCLE MRRCAL MCR MCREQ MCRNE MCRCS MCRHS MCRCC MCRLO MCRMI MCRPL MCRVS MCRVC MCRHI MCRLS MCRGE MCRLT MCRGT MCRLE MCRAL MCR2 MCR2EQ MCR2NE MCR2CS MCR2HS MCR2CC MCR2LO MCR2MI MCR2PL MCR2VS MCR2VC MCR2HI MCR2LS MCR2GE MCR2LT MCR2GT MCR2LE MCR2AL MCRR MCRREQ MCRRNE MCRRCS MCRRHS MCRRCC MCRRLO MCRRMI MCRRPL MCRRVS MCRRVC MCRRHI MCRRLS MCRRGE MCRRLT MCRRGT MCRRLE MCRRAL LDC LDCEQ LDCNE LDCCS LDCHS LDCCC LDCLO LDCMI LDCPL LDCVS LDCVC LDCHI LDCLS LDCGE LDCLT LDCGT LDCLE LDCAL LDC2 LDC2EQ LDC2NE LDC2CS LDC2HS LDC2CC LDC2LO LDC2MI LDC2PL LDC2VS LDC2VC LDC2HI LDC2LS LDC2GE LDC2LT LDC2GT LDC2LE LDC2AL STC STCEQ STCNE STCCS STCHS STCCC STCLO STCMI STCPL STCVS STCVC STCHI STCLS STCGE STCLT STCGT STCLE STCAL STC2 STC2EQ STC2NE STC2CS STC2HS STC2CC STC2LO STC2MI STC2PL STC2VS STC2VC STC2HI STC2LS STC2GE STC2LT STC2GT STC2LE STC2AL SWI SWIEQ SWINE SWICS SWIHS SWICC SWILO SWIMI SWIPL SWIVS SWIVC SWIHI SWILS SWIGE SWILT SWIGT SWILE SWIAL BKPT NEG LSL LSR ASR ROR RRX PUSH POP FMULS FMULSEQ FMULSNE FMULSCS FMULSHS FMULSCC FMULSLO FMULSMI FMULSPL FMULSVS FMULSVC FMULSHI FMULSLS FMULSGE FMULSLT FMULSGT FMULSLE FMULSAL FMULD FMULDEQ FMULDNE FMULDCS FMULDHS FMULDCC FMULDLO FMULDMI FMULDPL FMULDVS FMULDVC FMULDHI FMULDLS FMULDGE FMULDLT FMULDGT FMULDLE FMULDAL FNMULS FNMULSEQ FNMULSNE FNMULSCS FNMULSHS FNMULSCC FNMULSLO FNMULSMI FNMULSPL FNMULSVS FNMULSVC FNMULSHI FNMULSLS FNMULSGE FNMULSLT FNMULSGT FNMULSLE FNMULSAL FNMULD FNMULDEQ FNMULDNE FNMULDCS FNMULDHS FNMULDCC FNMULDLO FNMULDMI FNMULDPL FNMULDVS FNMULDVC FNMULDHI FNMULDLS FNMULDGE FNMULDLT FNMULDGT FNMULDLE FNMULDAL FMACS FMACSEQ FMACSNE FMACSCS FMACSHS FMACSCC FMACSLO FMACSMI FMACSPL FMACSVS FMACSVC FMACSHI FMACSLS FMACSGE FMACSLT FMACSGT FMACSLE FMACSAL FMACD FMACDEQ FMACDNE FMACDCS FMACDHS FMACDCC FMACDLO FMACDMI FMACDPL FMACDVS FMACDVC FMACDHI FMACDLS FMACDGE FMACDLT FMACDGT FMACDLE FMACDAL FNMACS FNMACSEQ FNMACSNE FNMACSCS FNMACSHS FNMACSCC FNMACSLO FNMACSMI FNMACSPL FNMACSVS FNMACSVC FNMACSHI FNMACSLS FNMACSGE FNMACSLT FNMACSGT FNMACSLE FNMACSAL FNMACD FNMACDEQ FNMACDNE FNMACDCS FNMACDHS FNMACDCC FNMACDLO FNMACDMI FNMACDPL FNMACDVS FNMACDVC FNMACDHI FNMACDLS FNMACDGE FNMACDLT FNMACDGT FNMACDLE FNMACDAL FMSCS FMSCSEQ FMSCSNE FMSCSCS FMSCSHS FMSCSCC FMSCSLO FMSCSMI FMSCSPL FMSCSVS FMSCSVC FMSCSHI FMSCSLS FMSCSGE FMSCSLT FMSCSGT FMSCSLE FMSCSAL FMSCD FMSCDEQ FMSCDNE FMSCDCS FMSCDHS FMSCDCC FMSCDLO FMSCDMI FMSCDPL FMSCDVS FMSCDVC FMSCDHI FMSCDLS FMSCDGE FMSCDLT FMSCDGT FMSCDLE FMSCDAL FNMSCS FNMSCSEQ FNMSCSNE FNMSCSCS FNMSCSHS FNMSCSCC FNMSCSLO FNMSCSMI FNMSCSPL FNMSCSVS FNMSCSVC FNMSCSHI FNMSCSLS FNMSCSGE FNMSCSLT FNMSCSGT FNMSCSLE FNMSCSAL FNMSCD FNMSCDEQ FNMSCDNE FNMSCDCS FNMSCDHS FNMSCDCC FNMSCDLO FNMSCDMI FNMSCDPL FNMSCDVS FNMSCDVC FNMSCDHI FNMSCDLS FNMSCDGE FNMSCDLT FNMSCDGT FNMSCDLE FNMSCDAL FADDS FADDSEQ FADDSNE FADDSCS FADDSHS FADDSCC FADDSLO FADDSMI FADDSPL FADDSVS FADDSVC FADDSHI FADDSLS FADDSGE FADDSLT FADDSGT FADDSLE FADDSAL FADDD FADDDEQ FADDDNE FADDDCS FADDDHS FADDDCC FADDDLO FADDDMI FADDDPL FADDDVS FADDDVC FADDDHI FADDDLS FADDDGE FADDDLT FADDDGT FADDDLE FADDDAL FSUBS FSUBSEQ FSUBSNE FSUBSCS FSUBSHS FSUBSCC FSUBSLO FSUBSMI FSUBSPL FSUBSVS FSUBSVC FSUBSHI FSUBSLS FSUBSGE FSUBSLT FSUBSGT FSUBSLE FSUBSAL FSUBD FSUBDEQ FSUBDNE FSUBDCS FSUBDHS FSUBDCC FSUBDLO FSUBDMI FSUBDPL FSUBDVS FSUBDVC FSUBDHI FSUBDLS FSUBDGE FSUBDLT FSUBDGT FSUBDLE FSUBDAL FDIVS FDIVSEQ FDIVSNE FDIVSCS FDIVSHS FDIVSCC FDIVSLO FDIVSMI FDIVSPL FDIVSVS FDIVSVC FDIVSHI FDIVSLS FDIVSGE FDIVSLT FDIVSGT FDIVSLE FDIVSAL FDIVD FDIVDEQ FDIVDNE FDIVDCS FDIVDHS FDIVDCC FDIVDLO FDIVDMI FDIVDPL FDIVDVS FDIVDVC FDIVDHI FDIVDLS FDIVDGE FDIVDLT FDIVDGT FDIVDLE FDIVDAL FCPYS FCPYSEQ FCPYSNE FCPYSCS FCPYSHS FCPYSCC FCPYSLO FCPYSMI FCPYSPL FCPYSVS FCPYSVC FCPYSHI FCPYSLS FCPYSGE FCPYSLT FCPYSGT FCPYSLE FCPYSAL FCPYD FCPYDEQ FCPYDNE FCPYDCS FCPYDHS FCPYDCC FCPYDLO FCPYDMI FCPYDPL FCPYDVS FCPYDVC FCPYDHI FCPYDLS FCPYDGE FCPYDLT FCPYDGT FCPYDLE FCPYDAL FABSS FABSSEQ FABSSNE FABSSCS FABSSHS FABSSCC FABSSLO FABSSMI FABSSPL FABSSVS FABSSVC FABSSHI FABSSLS FABSSGE FABSSLT FABSSGT FABSSLE FABSSAL FABSD FABSDEQ FABSDNE FABSDCS FABSDHS FABSDCC FABSDLO FABSDMI FABSDPL FABSDVS FABSDVC FABSDHI FABSDLS FABSDGE FABSDLT FABSDGT FABSDLE FABSDAL FNEGS FNEGSEQ FNEGSNE FNEGSCS FNEGSHS FNEGSCC FNEGSLO FNEGSMI FNEGSPL FNEGSVS FNEGSVC FNEGSHI FNEGSLS FNEGSGE FNEGSLT FNEGSGT FNEGSLE FNEGSAL FNEGD FNEGDEQ FNEGDNE FNEGDCS FNEGDHS FNEGDCC FNEGDLO FNEGDMI FNEGDPL FNEGDVS FNEGDVC FNEGDHI FNEGDLS FNEGDGE FNEGDLT FNEGDGT FNEGDLE FNEGDAL FSQRTS FSQRTSEQ FSQRTSNE FSQRTSCS FSQRTSHS FSQRTSCC FSQRTSLO FSQRTSMI FSQRTSPL FSQRTSVS FSQRTSVC FSQRTSHI FSQRTSLS FSQRTSGE FSQRTSLT FSQRTSGT FSQRTSLE FSQRTSAL FSQRTD FSQRTDEQ FSQRTDNE FSQRTDCS FSQRTDHS FSQRTDCC FSQRTDLO FSQRTDMI FSQRTDPL FSQRTDVS FSQRTDVC FSQRTDHI FSQRTDLS FSQRTDGE FSQRTDLT FSQRTDGT FSQRTDLE FSQRTDAL FCMPS FCMPSEQ FCMPSNE FCMPSCS FCMPSHS FCMPSCC FCMPSLO FCMPSMI FCMPSPL FCMPSVS FCMPSVC FCMPSHI FCMPSLS FCMPSGE FCMPSLT FCMPSGT FCMPSLE FCMPSAL FCMPD FCMPDEQ FCMPDNE FCMPDCS FCMPDHS FCMPDCC FCMPDLO FCMPDMI FCMPDPL FCMPDVS FCMPDVC FCMPDHI FCMPDLS FCMPDGE FCMPDLT FCMPDGT FCMPDLE FCMPDAL FCMPES FCMPESEQ FCMPESNE FCMPESCS FCMPESHS FCMPESCC FCMPESLO FCMPESMI FCMPESPL FCMPESVS FCMPESVC FCMPESHI FCMPESLS FCMPESGE FCMPESLT FCMPESGT FCMPESLE FCMPESAL FCMPED FCMPEDEQ FCMPEDNE FCMPEDCS FCMPEDHS FCMPEDCC FCMPEDLO FCMPEDMI FCMPEDPL FCMPEDVS FCMPEDVC FCMPEDHI FCMPEDLS FCMPEDGE FCMPEDLT FCMPEDGT FCMPEDLE FCMPEDAL FCMPZS FCMPZSEQ FCMPZSNE FCMPZSCS FCMPZSHS FCMPZSCC FCMPZSLO FCMPZSMI FCMPZSPL FCMPZSVS FCMPZSVC FCMPZSHI FCMPZSLS FCMPZSGE FCMPZSLT FCMPZSGT FCMPZSLE FCMPZSAL FCMPZD FCMPZDEQ FCMPZDNE FCMPZDCS FCMPZDHS FCMPZDCC FCMPZDLO FCMPZDMI FCMPZDPL FCMPZDVS FCMPZDVC FCMPZDHI FCMPZDLS FCMPZDGE FCMPZDLT FCMPZDGT FCMPZDLE FCMPZDAL FCMPEZS FCMPEZSEQ FCMPEZSNE FCMPEZSCS FCMPEZSHS FCMPEZSCC FCMPEZSLO FCMPEZSMI FCMPEZSPL FCMPEZSVS FCMPEZSVC FCMPEZSHI FCMPEZSLS FCMPEZSGE FCMPEZSLT FCMPEZSGT FCMPEZSLE FCMPEZSAL FCMPEZD FCMPEZDEQ FCMPEZDNE FCMPEZDCS FCMPEZDHS FCMPEZDCC FCMPEZDLO FCMPEZDMI FCMPEZDPL FCMPEZDVS FCMPEZDVC FCMPEZDHI FCMPEZDLS FCMPEZDGE FCMPEZDLT FCMPEZDGT FCMPEZDLE FCMPEZDAL FCVTDS FCVTDSEQ FCVTDSNE FCVTDSCS FCVTDSHS FCVTDSCC FCVTDSLO FCVTDSMI FCVTDSPL FCVTDSVS FCVTDSVC FCVTDSHI FCVTDSLS FCVTDSGE FCVTDSLT FCVTDSGT FCVTDSLE FCVTDSAL FCVTSD FCVTSDEQ FCVTSDNE FCVTSDCS FCVTSDHS FCVTSDCC FCVTSDLO FCVTSDMI FCVTSDPL FCVTSDVS FCVTSDVC FCVTSDHI FCVTSDLS FCVTSDGE FCVTSDLT FCVTSDGT FCVTSDLE FCVTSDAL FUITOS FUITOSEQ FUITOSNE FUITOSCS FUITOSHS FUITOSCC FUITOSLO FUITOSMI FUITOSPL FUITOSVS FUITOSVC FUITOSHI FUITOSLS FUITOSGE FUITOSLT FUITOSGT FUITOSLE FUITOSAL FUITOD FUITODEQ FUITODNE FUITODCS FUITODHS FUITODCC FUITODLO FUITODMI FUITODPL FUITODVS FUITODVC FUITODHI FUITODLS FUITODGE FUITODLT FUITODGT FUITODLE FUITODAL FSITOS FSITOSEQ FSITOSNE FSITOSCS FSITOSHS FSITOSCC FSITOSLO FSITOSMI FSITOSPL FSITOSVS FSITOSVC FSITOSHI FSITOSLS FSITOSGE FSITOSLT FSITOSGT FSITOSLE FSITOSAL FSITOD FSITODEQ FSITODNE FSITODCS FSITODHS FSITODCC FSITODLO FSITODMI FSITODPL FSITODVS FSITODVC FSITODHI FSITODLS FSITODGE FSITODLT FSITODGT FSITODLE FSITODAL FTOUIS FTOUISEQ FTOUISNE FTOUISCS FTOUISHS FTOUISCC FTOUISLO FTOUISMI FTOUISPL FTOUISVS FTOUISVC FTOUISHI FTOUISLS FTOUISGE FTOUISLT FTOUISGT FTOUISLE FTOUISAL FTOUID FTOUIDEQ FTOUIDNE FTOUIDCS FTOUIDHS FTOUIDCC FTOUIDLO FTOUIDMI FTOUIDPL FTOUIDVS FTOUIDVC FTOUIDHI FTOUIDLS FTOUIDGE FTOUIDLT FTOUIDGT FTOUIDLE FTOUIDAL FTOUIZS FTOUIZSEQ FTOUIZSNE FTOUIZSCS FTOUIZSHS FTOUIZSCC FTOUIZSLO FTOUIZSMI FTOUIZSPL FTOUIZSVS FTOUIZSVC FTOUIZSHI FTOUIZSLS FTOUIZSGE FTOUIZSLT FTOUIZSGT FTOUIZSLE FTOUIZSAL FTOUIZD FTOUIZDEQ FTOUIZDNE FTOUIZDCS FTOUIZDHS FTOUIZDCC FTOUIZDLO FTOUIZDMI FTOUIZDPL FTOUIZDVS FTOUIZDVC FTOUIZDHI FTOUIZDLS FTOUIZDGE FTOUIZDLT FTOUIZDGT FTOUIZDLE FTOUIZDAL FTOSIS FTOSISEQ FTOSISNE FTOSISCS FTOSISHS FTOSISCC FTOSISLO FTOSISMI FTOSISPL FTOSISVS FTOSISVC FTOSISHI FTOSISLS FTOSISGE FTOSISLT FTOSISGT FTOSISLE FTOSISAL FTOSID FTOSIDEQ FTOSIDNE FTOSIDCS FTOSIDHS FTOSIDCC FTOSIDLO FTOSIDMI FTOSIDPL FTOSIDVS FTOSIDVC FTOSIDHI FTOSIDLS FTOSIDGE FTOSIDLT FTOSIDGT FTOSIDLE FTOSIDAL FTOSIZS FTOSIZSEQ FTOSIZSNE FTOSIZSCS FTOSIZSHS FTOSIZSCC FTOSIZSLO FTOSIZSMI FTOSIZSPL FTOSIZSVS FTOSIZSVC FTOSIZSHI FTOSIZSLS FTOSIZSGE FTOSIZSLT FTOSIZSGT FTOSIZSLE FTOSIZSAL FTOSIZD FTOSIZDEQ FTOSIZDNE FTOSIZDCS FTOSIZDHS FTOSIZDCC FTOSIZDLO FTOSIZDMI FTOSIZDPL FTOSIZDVS FTOSIZDVC FTOSIZDHI FTOSIZDLS FTOSIZDGE FTOSIZDLT FTOSIZDGT FTOSIZDLE FTOSIZDAL FSTS FSTSEQ FSTSNE FSTSCS FSTSHS FSTSCC FSTSLO FSTSMI FSTSPL FSTSVS FSTSVC FSTSHI FSTSLS FSTSGE FSTSLT FSTSGT FSTSLE FSTSAL FSTD FSTDEQ FSTDNE FSTDCS FSTDHS FSTDCC FSTDLO FSTDMI FSTDPL FSTDVS FSTDVC FSTDHI FSTDLS FSTDGE FSTDLT FSTDGT FSTDLE FSTDAL FSTMIAS FSTMIASEQ FSTMIASNE FSTMIASCS FSTMIASHS FSTMIASCC FSTMIASLO FSTMIASMI FSTMIASPL FSTMIASVS FSTMIASVC FSTMIASHI FSTMIASLS FSTMIASGE FSTMIASLT FSTMIASGT FSTMIASLE FSTMIASAL FSTMIAD FSTMIADEQ FSTMIADNE FSTMIADCS FSTMIADHS FSTMIADCC FSTMIADLO FSTMIADMI FSTMIADPL FSTMIADVS FSTMIADVC FSTMIADHI FSTMIADLS FSTMIADGE FSTMIADLT FSTMIADGT FSTMIADLE FSTMIADAL FSTMIAX FSTMIAXEQ FSTMIAXNE FSTMIAXCS FSTMIAXHS FSTMIAXCC FSTMIAXLO FSTMIAXMI FSTMIAXPL FSTMIAXVS FSTMIAXVC FSTMIAXHI FSTMIAXLS FSTMIAXGE FSTMIAXLT FSTMIAXGT FSTMIAXLE FSTMIAXAL FSTMDBS FSTMDBSEQ FSTMDBSNE FSTMDBSCS FSTMDBSHS FSTMDBSCC FSTMDBSLO FSTMDBSMI FSTMDBSPL FSTMDBSVS FSTMDBSVC FSTMDBSHI FSTMDBSLS FSTMDBSGE FSTMDBSLT FSTMDBSGT FSTMDBSLE FSTMDBSAL FSTMDBD FSTMDBDEQ FSTMDBDNE FSTMDBDCS FSTMDBDHS FSTMDBDCC FSTMDBDLO FSTMDBDMI FSTMDBDPL FSTMDBDVS FSTMDBDVC FSTMDBDHI FSTMDBDLS FSTMDBDGE FSTMDBDLT FSTMDBDGT FSTMDBDLE FSTMDBDAL FSTMDBX FSTMDBXEQ FSTMDBXNE FSTMDBXCS FSTMDBXHS FSTMDBXCC FSTMDBXLO FSTMDBXMI FSTMDBXPL FSTMDBXVS FSTMDBXVC FSTMDBXHI FSTMDBXLS FSTMDBXGE FSTMDBXLT FSTMDBXGT FSTMDBXLE FSTMDBXAL FLDS FLDSEQ FLDSNE FLDSCS FLDSHS FLDSCC FLDSLO FLDSMI FLDSPL FLDSVS FLDSVC FLDSHI FLDSLS FLDSGE FLDSLT FLDSGT FLDSLE FLDSAL FLDD FLDDEQ FLDDNE FLDDCS FLDDHS FLDDCC FLDDLO FLDDMI FLDDPL FLDDVS FLDDVC FLDDHI FLDDLS FLDDGE FLDDLT FLDDGT FLDDLE FLDDAL FLDMIAS FLDMIASEQ FLDMIASNE FLDMIASCS FLDMIASHS FLDMIASCC FLDMIASLO FLDMIASMI FLDMIASPL FLDMIASVS FLDMIASVC FLDMIASHI FLDMIASLS FLDMIASGE FLDMIASLT FLDMIASGT FLDMIASLE FLDMIASAL FLDMIAD FLDMIADEQ FLDMIADNE FLDMIADCS FLDMIADHS FLDMIADCC FLDMIADLO FLDMIADMI FLDMIADPL FLDMIADVS FLDMIADVC FLDMIADHI FLDMIADLS FLDMIADGE FLDMIADLT FLDMIADGT FLDMIADLE FLDMIADAL FLDMIAX FLDMIAXEQ FLDMIAXNE FLDMIAXCS FLDMIAXHS FLDMIAXCC FLDMIAXLO FLDMIAXMI FLDMIAXPL FLDMIAXVS FLDMIAXVC FLDMIAXHI FLDMIAXLS FLDMIAXGE FLDMIAXLT FLDMIAXGT FLDMIAXLE FLDMIAXAL FLDMDBS FLDMDBSEQ FLDMDBSNE FLDMDBSCS FLDMDBSHS FLDMDBSCC FLDMDBSLO FLDMDBSMI FLDMDBSPL FLDMDBSVS FLDMDBSVC FLDMDBSHI FLDMDBSLS FLDMDBSGE FLDMDBSLT FLDMDBSGT FLDMDBSLE FLDMDBSAL FLDMDBD FLDMDBDEQ FLDMDBDNE FLDMDBDCS FLDMDBDHS FLDMDBDCC FLDMDBDLO FLDMDBDMI FLDMDBDPL FLDMDBDVS FLDMDBDVC FLDMDBDHI FLDMDBDLS FLDMDBDGE FLDMDBDLT FLDMDBDGT FLDMDBDLE FLDMDBDAL FLDMDBX FLDMDBXEQ FLDMDBXNE FLDMDBXCS FLDMDBXHS FLDMDBXCC FLDMDBXLO FLDMDBXMI FLDMDBXPL FLDMDBXVS FLDMDBXVC FLDMDBXHI FLDMDBXLS FLDMDBXGE FLDMDBXLT FLDMDBXGT FLDMDBXLE FLDMDBXAL FMSR FMSREQ FMSRNE FMSRCS FMSRHS FMSRCC FMSRLO FMSRMI FMSRPL FMSRVS FMSRVC FMSRHI FMSRLS FMSRGE FMSRLT FMSRGT FMSRLE FMSRAL FMRS FMRSEQ FMRSNE FMRSCS FMRSHS FMRSCC FMRSLO FMRSMI FMRSPL FMRSVS FMRSVC FMRSHI FMRSLS FMRSGE FMRSLT FMRSGT FMRSLE FMRSAL FMDLR FMDLREQ FMDLRNE FMDLRCS FMDLRHS FMDLRCC FMDLRLO FMDLRMI FMDLRPL FMDLRVS FMDLRVC FMDLRHI FMDLRLS FMDLRGE FMDLRLT FMDLRGT FMDLRLE FMDLRAL FMRDL FMRDLEQ FMRDLNE FMRDLCS FMRDLHS FMRDLCC FMRDLLO FMRDLMI FMRDLPL FMRDLVS FMRDLVC FMRDLHI FMRDLLS FMRDLGE FMRDLLT FMRDLGT FMRDLLE FMRDLAL FMDHR FMDHREQ FMDHRNE FMDHRCS FMDHRHS FMDHRCC FMDHRLO FMDHRMI FMDHRPL FMDHRVS FMDHRVC FMDHRHI FMDHRLS FMDHRGE FMDHRLT FMDHRGT FMDHRLE FMDHRAL FMRDH FMRDHEQ FMRDHNE FMRDHCS FMRDHHS FMRDHCC FMRDHLO FMRDHMI FMRDHPL FMRDHVS FMRDHVC FMRDHHI FMRDHLS FMRDHGE FMRDHLT FMRDHGT FMRDHLE FMRDHAL FMXR FMXREQ FMXRNE FMXRCS FMXRHS FMXRCC FMXRLO FMXRMI FMXRPL FMXRVS FMXRVC FMXRHI FMXRLS FMXRGE FMXRLT FMXRGT FMXRLE FMXRAL FMRX FMRXEQ FMRXNE FMRXCS FMRXHS FMRXCC FMRXLO FMRXMI FMRXPL FMRXVS FMRXVC FMRXHI FMRXLS FMRXGE FMRXLT FMRXGT FMRXLE FMRXAL FMSTAT FMSTATEQ FMSTATNE FMSTATCS FMSTATHS FMSTATCC FMSTATLO FMSTATMI FMSTATPL FMSTATVS FMSTATVC FMSTATHI FMSTATLS FMSTATGE FMSTATLT FMSTATGT FMSTATLE FMSTATAL ADR ADREQ ADRNE ADRCS ADRHS ADRCC ADRLO ADRMI ADRPL ADRVS ADRVC ADRHI ADRLS ADRGE ADRLT ADRGT ADRLE ADRAL ADRL ADREQL ADRNEL ADRCSL ADRHSL ADRCCL ADRLOL ADRMIL ADRPLL ADRVSL ADRVCL ADRHIL ADRLSL ADRGEL ADRLTL ADRGTL ADRLEL ADRALL


Et avec un .bmp, la palette n'est-elle pas sauvée avec le fichier ? (EDIT: "The Bitmap info header is followed by a color palette if the bitcount of the graphic file is less than or equal to 8. Bitmaps with a palette of more than 256 colors do not include a palette but rather the bits of the map for each pixel encode values that are mapped to the system palette.") Sinon ton autre idée serait bonne, c'est ce que je pensais d'abord. Ou l'on peut faire comme Mappy et avoir tous les sprites dans un seul fichier, comme ci :
TEST.BMP

On pourrait ajouter un autre paramètre (s'il est vide donc il faudra créer la palette) ou tout simplement un pourrait ajouter une image qui contient tous les couleurs. (EDIT: donc on écrirait deux .bmps, le fichier du sprite et le fichier de la palette)

EDIT2: BEAUCOUP D'INFORMATION ICI : http://www.pokecommunity.com/showthread.php?t=117917

Il semble que 0 est comme un mask, c'est le bit transparent. Je finalement comprends pourquoi mes programmes ne marchaient pas grin
Transparent Colors
Color 0 of all background and object palettes is treated as transparent. Since palettes can have either 16 or 256 colors, only 15 and 255 colors respectively are actually visible.

Backdrop Color Color 0 of the background palette 0 is used as backdrop color. That means this color is displayed if an area of the screen is not covered by any non-transparent background or object dots.
Merci pour la liste d'instructions smile

Le problème c'est que PureBasic transforme toutes les images qu'il ouvre en 24-bits (ou en 32-bits s'il y a un "channel alpha"), donc je ne peux pas récupérer directement la palette à partir du .bmp. Mais bon, la réduction de couleurs reste facile.

Avoir tous les sprites sur la même image est possible, mais ça rend la source moins lisible, non ?
chickendude (./32) :
On pourrait ajouter un autre paramètre (s'il est vide donc il faudra créer la palette) ou tout simplement un pourrait ajouter une image qui contient tous les couleurs. (EDIT: donc on écrirait deux .bmps, le fichier du sprite et le fichier de la palette)

C'est ce que je vais faire, je pense.

Tiens je ne savais pas pour la transparence, tant mieux !
Oui, j'ai fait quelques modifications très petites, mais je ne crois pas que tout marche. J'ai ajouté un simple 0x0000 au début de la palette pour que tout s'affiche bien et j'ai ajouté un petit morceau de code avant de charger le bitmap pour vérifier s'il y a deux paramètres (le deuxième est le sprite, le premier la palette) et charger le deuxième sprite, mais il semble sauter le premier pixel ???

Voici le code source : http://www.mirari.fr/Q9rw

EDIT: Et si tu charges une palette, il te dira que le fichier est nomDuSprite.asm, mais c'est nomDeLaPalette.asm.

EDIT2: J'ai trouvé une page web sur le système de sons de la GBA : http://www.belogic.com/gba/index.php
Voici mon nouveau gba.inc.

EDIT3: Quelques demos en ASM : http://www.akkit.org/sgstair/gba.html Je ne les comprends pas encore, mais dans le futur ça sera utile peut-être smile

EDIT4: J'ai trouvé un très bon éditeur de tiles : http://consolecopyworld.com/cgi-bin/dl.cgi?id=gba&file=chili1_4!zip smile Il nous donne le sprite/palette dans le formate binary, donc il faut les inclure avec .incbin (et pas avec .include).

EDIT5:
9RYU
smile Il faut ajouter un grand délai, sinon on ne voit rien ! Je vais uploader le source avec les binaires de Chili smile
Et voilà le source avec les autres fichiers nécessaires : http://www.mirari.fr/mVnv
bigeyes

Bravo grin

Là j'ai pas énormément de temps, mais j'ai commencé à modifier le convertisseur pour cette histoire de palette (il faut que je regarde ta version aussi).

Merci pour les liens (je lis tout ça dès que possible) !
Est-ce que tu es prêt à faire un RPG GBA ? grin En ce moment je lis sur le DMA (direct memory acces) et j'ai joué un peu avec les sons, mais je ne saurais pas comment faire de la musique de fond, seulement de petits sons quand tu pousses une touche ou quelque chose comme ça :P
Moi je ne sais pas si je suis prêt, mais pour toi c'est certain (tu as déjà de quoi faire le tilemapper, les sprites etc...) ! grin

Demain j'aurais sans doute un peu plus de temps pour regarder tout ça !

Et pour la musique de fond, elle doit être gérée avec les interruptions, non ?
Je sais que le hardware fait une grande partie du travail, mais je crois qu'il y a plusieurs manières de la gérer. Mais l'émulation de son de VBA ne semble pas être très bon :/ L'émulation de son de no$gba est beaucoup meilleur, mais c'est Windows-only sad

EDIT: J'ai ajouté une section pour le DMA à gba.inc smile Mais à vrai dire je ne sais pas quand il vaut la peine de l'utiliser (DMA), ce n'est pas difficile, mais... je ne sais pas.

EDIT2: J'ai fait un simple tilemap, mais même si mes tuiles sont 32x32 il faut structurer mes cartes comme si j'avais des tuiles 8x8. Voici le premier "rang" de mon tilemap :
map:
.byte 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3, 0x0,0x1,0x2,0x3
.byte 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7, 0x4,0x5,0x6,0x7
.byte 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB, 0x8,0x9,0xA,0xB
.byte 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF, 0xC,0xD,0xE,0xF


On voit que chaque tuile est vraiment un mini-tilemap, composé de 4*4 = 16 sprites. Est-ce comme ça que les tilemaps fonctionne sur la GBA ?
Bon je ne sais pas ce qui se passe avec mon tilemapper mais le scrolling horizontal est parfait, si j'essaie d'ajouter du scrolling vertical tout l'écran saute aléatoirement :/
SNGs
La première partie du screenshot c'est avec le scrolling verticale, puis je l'ai enlevé et le scrolling horizontal se voit bien... confus Je ne sais pas s'il a quelque chose à voir avec le "vsync" mais je crois que non, ça ne se passe que quand j'essaie de changer l'offset X de l'écran :
	ldr r0,[r0]			@ Charger X (r0 = pointeur au label "x")
	ldr r1,[r1]			@ Charger Y (r1 = pointeur au label "y")
	mov r0,r0,LSL #8	@ Premier 8 bits sont une fraction
	mov r1,r1,LSL #8
	ldr r3,=REG_BG2X
	str r0,[r3],#4		@ X
@ Si je commente la suivante instruction le scrolling est bon
	str r1,[r3]			@ Y REG_BG2Y


EDIT: J'ai trouvé le problème, il fallait attendre VBLANK (si tu changer l'écran pendant que le hardware est en train de mettre à jour l'écran l'écran va se déformer quelques instants). Je vais uploader le nouveau code bientôt smile

EDIT2: J'ai trouvé une liste de syscalls ("BIOS Functions") ici :
http://nocash.emubase.de/gbatek.htm#biosfunctions

On peut les ajouter à gba.inc peut à peu smile

Et ici la démo avec scrolling :
scrollingMode1.7z

Et un nouveau screenshot grin
WdSW

Maintenant je recherche les interruptions pour améliorer mon routine de "vSync".
eek

Alors là, chapeau !

De mon côté j'ai modifier un peu mon convertisseur, il est capable de générer les palettes, puis de les importer plus tard pour faire le référencement avec les sprites. Ce sera déjà suffisant pour commencer à coder un peu (plus tard, quand j'essaierai les sprites 8-bits, il faudra sans doute que j'ajoute leur support).

Si j'ai le temps demain je me concentre davantage à l'ASM, parce que là tu as pris beaucoup trop d'avance grin
Oui, il faut jouer un peu après tout ce travail de ton convertisseur smile Je commence à comprendre un peu mieux quelques choses du hardware, mais je n'arrive pas à activer les interruptions :/

Quand je trouverai la manière d'activer les interruptions, je pourrai écrire une version meilleure de waitVSync et puis je veux écrire un vrai 16x16 ou 32x32 tilemapper smile Le tilemapper que tu vois là en réalité n'est qu'un simple tilemap de tuiles 8x8 géré complètement par la GBA !

EDIT: Oh, et j'ai ajouté les syscalls à gba.inc, mais plus tard il faut les documenter un peu.
Oui c'est ce qu'il me semblais (la limite des tiles 8*8), et je trouve ça assez étrange... Peu de jeux sur GBA doivent l'utiliser finalement.
Je crois ce que l'on fait c'est d'avoir deux listes, une liste du data des sprites et une liste de tuiles, par exemple :
map:
.db 1,1,1,1,1,1,1,1,1,1,1
.db 1,0,0,0,0,0,0,0,0,0,1
.db 1,0,0,0,0,0,0,0,0,0,1
.db 1,0,0,0,0,0,0,0,0,0,1
.db 1,0,0,0,0,0,0,0,0,0,1
.db 1,0,0,0,0,0,0,0,0,0,1
.db 1,1,1,1,1,1,1,1,1,1,1

metaTiles:
metaTile0:
.db 0,0
.db 0,0
metaTile1:
.db 1,1
.db 1,1

sprites:
tile0:
.db %00000000
.db %00000000
.db %00000000
.db %00000000
.db %00000000
.db %00000000
.db %00000000
.db %00000000
tile1:
.db %11111111
.db %11111111
.db %11111111
.db %11111111
.db %11111111
.db %11111111
.db %11111111
.db %11111111

Quand on lit la tuile, il faut d'abord le convertir en un groupe de 4 (arrangé 2x2) 8x8 sprites pour les tuiles 16x16 ou 16 (4x4) 8x8 sprites. Et je viens d'apprendre comment activer les interruptions (j'utilisais un ldr en lieu de str mur), demain je vais essayer de finir la routine de vSync. smile

EDIT: Et c'est fini, la routine marche bien avec les interruptions smile Voici le nouveau code source et le dernier gba.inc
Il paraissait qu'il y avait plus d'une interruption (ou que j'ai activé la mauvaise interruption ???) mais j'ai ajouté un petit morceau de code pour vérifier si l'interruption s'exécute dans un VBLANK (mais c'est une interruption VBLANK, donc je pensais qu'elle s'activerait toujours pendant un VBLANK). Et bien, c'est déjà bon, maintenant il faut écrire un vrai tilemapper 16x16, puis ajouter des couches, un petit joueur, etc. grin
C'est sympa que tu aies tant commenté ton fichier source, je vais pouvoir étudier tout ça smile

edit : Je ne comprend pas trop ces lignes :
    ldr r1, =REG_DISPSTAT   @ Display Status, il faut dire au LCD que nous voulons que VBlank
    ldr r2, [r1]            @ déclenche une interruption
    orr r2, r2, #STAT_VBLANK_IRQ
    str r2, [r1]

On charge d'abord l'adresse de REG_DISPSTAT dans r1, puis de nouveau dans r2, ensuite on fait un OR avec STAT_VBLANK_IRQ (= %00001000), puis on remet tout dans r1 ?!

Pourquoi ne pas charger directement =REG_DISPSTAT dans r2 ?

Est-ce expliqué quelque part pourquoi on doit "ORer" ces valeurs ?

Si le but est d'activer une interruption à chaque VBLANK, ça ne devrait pas être :
	ldr r1, =REG_DISPSTAT
	ldr r2, =STAT_VBLANK
	str r2, [r1]


edit2 : Ah j'ai pigé pourquoi tu utilises un OR : c'est une "addition" plus optimisée. Par contre :
    mov r0, #REG_DISPCNT    @ Display Control Register
    mov r1, #BG2_ENABLE
    orr r1, #MODE_1         @ Mode 1 avec BG2
    str r1,[r0]

Ça ne devrait pas être un "strh" ? #BG2_ENABLE est un demi-mot, non ? Il me semble avoir lu qu'il ne fallait pas déborder, mais ça n'a peut être pas d'impact...
Je crois que les deux octets entre REG_DISPCNT (0x4000 0000) et REG_DISPSTAT (0x4000 0004) ne servent à rien, mais de toutes façons je crois que pour être sûr tu as raison. Et en lieu d'un ORR on peux aussi faire une addition. Je me sers beaucoup de ce site-ci :
http://www.cs.rit.edu/~tjh8300/CowBite/CowBiteSpec.htm#REG_DISPCNT

Peut-être je devrais l'imprimer, il serait très utile d'avoir smile
J'ai fait quelques petites optimisations/changements à l'interruption, mais maintenant il ne marche pas sur VBA (mais mieux que jamais avec no$gba). Je ne comprends pas pourquoi avec VBA ça ne marche plus, si c'est un problème avec VBA (no$gba l'exécute sans problème) ou avec mon code :/
interrupt:
	mov r0, #REG_DISPCNT	@ Une petite optimisation, en lieu de "ldr r0,=REG_IE" on calcule l'offset de #REG_DISPCNT (0x0400:0000)
	ldr r1, [r0,#REG_IE-REG_DISPCNT]	@ r1 = REG_IE (2 octets) et REG_IF (2 octets)
	and r0, r1,r1, LSR #16	@ ANDer REG_IE et REG_IF
	tst r0, #INT_VBLANK
	 bxeq lr				@ Si l'interruption n'est pas un VBLANK, quitter
	ldr r0, =x
	ldr r1, =y

	ldr r0,[r0]				@ Charger X
	ldr r1,[r1]				@ Charger Y
	mov r0,r0,LSL #8		@ Premier 8 bits de REG_BG2X = fraction
	mov r1,r1,LSL #8
	ldr r3,=REG_BG2X
	str r0,[r3], #4			@ X
	str r1,[r3]				@ Y REG_BG2Y

@ Annoncer que l'on a fini son travail avec l'interruption
	mov r0, #REG_BASE		@ 0x04000000 (REG_DISPCNT)
	ldr r1, [r0, #REG_IF-REG_BASE]
	mov r2, #INT_VBLANK		@ 
	orr r2, r1				@ Desarmer toutes les interruptions (il faut les mettre à 1 pour les désarmer)
	str r2, [r0, #REG_IF-REG_BASE]	@ 
	ldr r1, [r0, #REG_IE-REG_BASE]	@ r1 = REG_IE (2 octets) et REG_IF (2 octets)
	and r3, r1,r1, LSR #16	@ ANDer REG_IE et REG_IF
	ldrh r2, [r0, #-8]		@ Les drapeaux d'interruptions du BIOS (0x3FFFFF8 est un miroir de 0x3007FF8)
	orr r2, r2, r3			@ (REG_IE & REG_IF) | "BIOS_IF"
	strh r2, [r0, #-8]		@ Les écrire (pour que le hardware les efface, il n'a pas de sens, je sais)
	bx lr
Dwedit m'a aidé avec la dernière partie. Il a dit que le BIOS gère les interruptions aussi et qu'il faut les effacer aussi si l'on veut utiliser certaines routines "swi". Et j'ai appris un petit truc aujourd'hui : pourquoi n'y a-t-il pas un "bx lr" (bx = sauter à l'adresse contenue dans un registre, donc ici comme un ret) à la fin de cette routine (c'est du code pour la NDS) ? wink
waitforVblank:
	stmfd sp!, {r0-r1, lr} 
	ldr r0, =REG_VCOUNT
waitforVblankLoop:									
	ldrh r1,[r0]						@ read REG_VCOUNT into r2
	cmp r1, #193						@ 193 is, of course, the first scanline of vblank
	bne waitforVblankLoop				@ loop if r2 is not equal to (NE condition) 193
	ldmfd sp!, {r0-r1, pc}
Bon je n'ai pas eu beaucoup de temps ces derniers jours, mais j'espère pouvoir écrire un simple tilemapper bientôt. Puis je veux jouer avec de la musique et les couches (avoir plus d'un fond) smile
Ça en fait des nouvelles instructions fou

Je n'ai pas trop compris ce que faisaient "stmfd" et "ldmfd" confus

Et avant de m'attaquer aux interruptions je pense qu'il faut que je m'entraine davantage avec des choses plus basiques (sprites...).

De mon côté, j'ai mis à jour img2asm (qu'il faudra sans doute renommer, car je veux lui faire sortir des .bin aussi !) : maintenant il gère les palettes (enfin il a encore du mal à différencier les couleurs vraiment trop proches). La nouvelle syntaxe est :
img2asm <-sprite16> <sprite> [palette]
Le premier paramètre pour l'instant ne peut être que -sprite16 car je n'ai pas encore attaqué le support des sprites 256 couleurs.

J'ai essayé chili, il a l'air complet mais assez compliqué (en plus j'ai l'impression qu'il importe mal les .bmp... confus).

Autrement je commence à coder un pong (il faut un début à tout tongue), mais il faut que je regarde comment charger des sprites 16*8 et 8*8.
chickendude (./46) :
Dwedit m'a aidé avec la dernière partie.

Ah oui, je me rappel qu'il avait fait un émulateur de TI z80 sur GBA ! Effectivement, il doit vraiment être calé en la matière smile
STMFD est la même chose que STMDB (STore Multiple Decrement Before). FD = Full Descending, "Full" parce que l'adresse dans la pile est occupé (pas vide : Empty). DB pour ne pas déranger les valeurs déjà sur la pile. La seule différence c'est la nomenclature.
STMDA (Decrement After) = STMED (Empty Descending)
STMIA (Increment After) = STMEA (Empty Ascending)
STMDB (Decrement Before) = STMFD (Full Descending) STMIB (Increment Before) = STMFA (Full Ascending)


Donc on charge les registres r0, r1, et LR (LR = r14, quand on fait un appel, LR contient l'adresse où l'on veut rentrer après la routine, on la met pas sur la pile comme en l'assembleur z80) dans la pile. Puis, LDMFA (LoaD Multiple Full Ascending = LDMDA) charge ces valeurs de nouveau dans r0 et r1 mais cette fois, en lieu de mettre la valeur pushé de LR dans LR, on la met dans le PC, qui effectivement fait un ret pour nous smile

A vrai dire, les interruptions ne sont pas trop compliquées, et je crois qu'elles sont la meilleure manière de gérer l'écran (si on dessine quelque chose pendant la mise à jour de l'écran, l'écran va montrer des choses bizarres).

Et je suis ici si tu as des questions (même si je ne sais pas bien la réponse wink)

EDIT : J'ai fais un tilemapper très simple smile Toutes les bogues avec les interruptions ont été reglées aussi. Maintenant je peux utiliser des tuiles de 32x32 en lieu de 8x8. Voici le code du tilemapper (EDIT : dans le fichier .7z je n'ai pas ajouté beaucoup de comments, voici une version qui en avais plus) :
drawMap:
	ldr r0, =map
	ldr r1, =tile32x32
	ldr r2, =SCREEN_BLOCK_16	@ Il faut charger les tilemaps dans un des screen blocks
	mov r9, #16					@ 16 rangs
drawMapOutterLoop:
	mov r8, #16					@ 16 colonnes
drawMapRowLoop:
	ldrb r3, [r0],#1			@ Charger un octet de le map
	add r3, r1, r3, LSL #4		@ ScreenBlock+(tileNo*16)
	ldmia r3,{r4-r7}			@ On charge les valeurs à [r3] (tile32x32 + offset) dans les registres r4-r7
								@ Ce sont des sprites 8x8, chaque registre en contient 4 (8 pixels * 4 sprites = 32 pixels)
								@ Il y a quatre rangs de sprites, donc chaque registre represente un rang
	str r4, [r2],#64			@ Sauter au prochain rang (8x8)
	str r5, [r2],#64			@ Sauter au prochain rang
	str r6, [r2],#64			@ Sauter au prochain rang
	str r7, [r2],#64			@ Sauter au prochain rang
	sub r2, r2, #256-4			@ Le -4 est pour aller à la prochaine colonne
	subs r8, r8, #1				@ Compteur de colonnes
	bne drawMapRowLoop
	add r2,r2,#256-64			@ Sauter au prochain rang (32x32)
	subs r9, r9, #1				@ Compteur de rangs
	bne drawMapOutterLoop
	bx lr
Je crois que les tuiles 16x16 vont être un peu plus compliqués de programmer, parce qu'il faudra utiliser des halfwords.
fUt6

Et le source complet :
tilemapper.7z

Ah, et quant à Chili, je n'ai pas encore essayé d'importer des fichiers .bmps, j'utilise tout simplement l'éditeur inclus.
Bravo !!! eek

Il faut que je prenne le temps de bien analyser la structure des sprites en mémoire et la façons de les utiliser, car il y a encore quelques trucs qui me dérange...

Ton code a l'air étonnement court (il en faudrait 10x plus sur TI ! grin), mais il faut aussi que je prenne le temps de voir comment il fonctionne (ce qui m'étonne c'est qu'on puisse si facilement faire du "smooth scrolling", enfin ça doit être dû au "buffer" de l'écran confus).

À quand un tilemapper multi-couches et animé ? grin

edit : j'ai trouvé un excellent tuto qui explique exactement ce que je cherchais (l'organisation de l'écran selon les modes, celle des sprites etc...) smile
Je n'arrive pas à comprendre ce qui cloche dans mon code... J'essaie d'afficher deux sprites (au moins la partie gauche d'une raquette, vu qu'on ne peut pas afficher des sprites 8*16 en une seule fois, puis la balle) :
.arm
.include "gba.inc"
.text
.global main

main:
	ldr r0,=OAM	@ on reset les sprites (je ne sais pas si ça a vraiment de l'importance)
	ldr r1,=128	@ il y a 128 emplacements de 8 octets chacuns (l'OAM fait 1ko)
	ldr r2,=(300<<16)	@ le 3ème octet suivit du prochain bit définit la coordonnée X (2^9=512 valeurs) du sprite,
	@ on la met donc à 300 pour être hors de l'écran (il fait 240*160)
	@ (pour les attributs de l'OAM, cf http://gfx.developpez.com/prog-gba/touches/#L8 )
reset_sprites_loop:
	str r2,[r0],#8	@ on colle la valeur de r2 à l'adresse de r0, puis incrémente de 8 octets l'adresse de r0
	subs r1,r1,#1	@ la boucle fait 128 tours
	bne reset_sprites_loop

	ldr r1,=REG_DISPCNT
	ldr r2,=(MODE_0|BG2_ENABLE|OBJ_ENABLE|OBJ_MAP_1D)
	str r2,[r1]

	ldr r0,=OAM	@ on va s'occuper de charger nos sprites
	ldr r1,=(SQUARE|COLOR_16|10)|((SIZE_8|10)<<16)	@ cf l'organisation des attributs des sprites (là on règle les deux premiers)
	mov r2,#0	@ premier tile de 8*8 pixels du sprite (index du sprite dans le CHARMEM quoi)
	str r1,[r0],#4	@ on charge les deux premiers attributs, puis on les "saute"
	str r2,[r0],#4	@ on charge le troisième attribut
	ldr r1,=(SQUARE|COLOR_16|30)|((SIZE_8|30)<<16)
	mov r2,#3	@ /!\ est-ce le bon index ?
	str r1,[r0],#4
	str r2,[r0],#4

	ldr r1,=OBJPAL	@ on s'occupe de la palette maintenant
	ldr r2,=5	@ nombre de couleurs de la palette à copier
	ldr r3,=palette

palette_loop:
	ldr r7,[r3],#4	@ on charge la valeur à l'adresse de r3 dans r7, puis on incrémente de 4 octets (16 bits = 1 couleur) l'adresse de r3
	str r7,[r1],#4	@ on colle le tout dans r1 puis incrémente de même r1
	subs r2,r2,#1	@ on fait 5 tours
	bne palette_loop

	ldr r1,=CHARMEM	@ au tour des sprites
	ldr r2,=16*8	@ taille du sprite /!\ ça je ne suis pas sûr
	ldr r3,=pong

sprite_loop:
	ldr r7,[r3],#4	@ la même qu'au dessus
	str r7,[r1],#4
	subs r2,r2,#1
	bne sprite_loop
	ldr r2,=8*8	@ deuxième sprite (la balle)
	ldr r3,=ball

sprite_loop2:
	ldr r7,[r3],#4
	str r7,[r1],#4
	subs r2,r2,#1
	bne sprite_loop2

end:
	b end

.ltorg

palette:
	.hword 0x0000,0x2D6B,0x6F7B,0x6318,0x4210

pong:
	.word 0x00000000
	.word 0x00000000
	.word 0x11111100
	.word 0x22222210
	.word 0x33333331
	.word 0x44444441
	.word 0x44444410
	.word 0x11111100
	.word 0x00000000
	.word 0x00000000
	.word 0x00111111
	.word 0x01222222
	.word 0x12333333
	.word 0x12344444
	.word 0x01344444
	.word 0x00111111

ball:
	.word 0x00111100
	.word 0x01222210
	.word 0x12333331
	.word 0x12344441
	.word 0x12344441
	.word 0x12344441
	.word 0x01344410
	.word 0x00111100

Ça m'affiche des trucs moches et je ne pense pas que ce soit dû à mon convertisseur :/
Il y avait deux problèmes : le premier, ton deuxième sprite n'affiche pas ce que tu veux, tu as mis le mauvais index. L'index commence de 0, donc si tu veux le troisième sprite il faut mettre 2 :
	ldr r1,=(SQUARE|COLOR_16|30)|((SIZE_8|30)<<16) 
	mov r2,#2	@ /!\ est-ce le bon index ? 

Le deuxième : à cause de ta palette, les autres sprites ne sont pas alignés à un word, donc tous les sprites sont décalés. Mets un ".align 4" avant les sprites (ou ajoute un autre couleur) et tout s'affichera bien smile

A propos, tu peux changer le SQUARE du premier sprite à WIDE et tu verras ta raquette entière, pas seulement la moitié wink
Merci, c'est génial ! grin

Tu penses que ça sert vraiment à quelque chose de "dégager" tous les sprites à l'écran (""reset"") ? confus

edit : "bxcc lr" sert à quitter une routine si le carry flag est mis, et "bxcs lr" fait la même chose avec le sign flag (si le résultat est supérieur), non ?! Je n'arrive pas à trouver de la documentation sur ces instructions...

edit2 : j'ai des problèmes avec mon code pour gérer le déplacement de la balle (elle ne bouge pas) :
.arm
.include "gba.inc"
SCREEN_W	=	240
SCREEN_H	=	160
PADDLE_X	=	SCREEN_W/2-(3*8)/2
PADDLE_Y	=	SCREEN_H-8
BALL_X	=	0
BALL_Y	=	0
.text
.global main

main:
	ldr r0,=OAM	@ on reset les sprites (je ne sais pas si ça a vraiment de l'importance)
	ldr r1,=128	@ il y a 128 emplacements de 8 octets chacuns (l'OAM fait 1ko)
	ldr r2,=(300<<16)	@ le 3ème octet suivit du prochain bit définit la coordonnée X (2^9=512 valeurs) du sprite,
	@ on la met donc à 300 pour être hors de l'écran (il fait 240*160)
	@ (pour les attributs de l'OAM, cf http://gfx.developpez.com/prog-gba/touches/#L8 )
reset_sprites_loop:
	str r2,[r0],#8	@ on colle la valeur de r2 à l'adresse de r0, puis incrémente de 8 octets l'adresse de r0
	subs r1,r1,#1	@ la boucle fait 128 tours
	bne reset_sprites_loop

	ldr r1,=REG_DISPCNT
	ldr r2,=(MODE_0|BG2_ENABLE|OBJ_ENABLE|OBJ_MAP_1D)
	str r2,[r1]

	ldr r0,=OAM	@ on va s'occuper de charger nos sprites
	ldr r1,=(SQUARE|COLOR_16|PADDLE_Y)|((SIZE_8|PADDLE_X)<<16)	@ cf l'organisation des attributs des sprites (là on règle les deux premiers)
	mov r2,#0	@ premier tile de 8*8 pixels du sprite (index du sprite dans le CHARMEM quoi)
	str r1,[r0],#4	@ on charge les deux premiers attributs, puis on les "saute"
	str r2,[r0],#4	@ on charge le troisième attribut
	ldr r1,=(SQUARE|COLOR_16|PADDLE_Y)|((SIZE_8|PADDLE_X+8)<<16)
	mov r2,#1
	str r1,[r0],#4
	str r2,[r0],#4
	ldr r1,=(SQUARE|COLOR_16|PADDLE_Y)|((SIZE_8|PADDLE_X+16)<<16)
	mov r2,#2
	str r1,[r0],#4
	str r2,[r0],#4
	ldr r1,=(SQUARE|COLOR_16|BALL_Y)|((SIZE_8|BALL_X)<<16)
	mov r2,#3	@ quatrième tile
	str r1,[r0],#4
	str r2,[r0],#4

	ldr r1,=OBJPAL	@ on s'occupe de la palette maintenant
	ldr r2,=5	@ nombre de couleurs de la palette à copier
	ldr r3,=palette

palette_loop:
	ldr r7,[r3],#4	@ on charge la valeur à l'adresse de r3 dans r7, puis on incrémente de 4 octets (16 bits = 1 couleur) l'adresse de r3
	str r7,[r1],#4	@ on colle le tout dans r1 puis incrémente de même r1
	subs r2,r2,#1	@ on fait 5 tours
	bne palette_loop

	ldr r1,=CHARMEM	@ au tour des sprites
	ldr r2,=8*8*4	@ tailles des sprites et nombre
	ldr r3,=paddle_left

sprite_loop:
	ldr r7,[r3],#4	@ la même qu'au dessus
	str r7,[r1],#4
	subs r2,r2,#1
	bne sprite_loop

main_loop:
	mov r3,#KEYS_HIGH	@ MSB
	orr r3,r3,#KEYS_LOW	@ ajouter LSB de l'adresse (plus rapide que ldr r3,#KEYS)
	mov r2,#0x300
	orr r2,#0xFF	@ r2 = $3FF (10 touches codés sur 10 bits)
	ldr r4,[r3]	@ r4 = touche pressée

	ldr r0,=player_x
	tst r4, #KEY_LEFT
	bleq left
	tst r4, #KEY_RIGHT
	bleq right
	ldrb r0,[r0]	@ on charge un octet de l'adresse r0 dans r0
	ldr r3,=OAM+2	@ deuxième attribut (=OAM+2 octets), X=1er octet+1er bit suivant
	ldrh r4,[r3]
	and r4,r4,#0xFE00	@ on récupère donc les 9 premiers bits
	add r4,r0
	strh r4,[r3]
	add r4,#8	@ on s'occupe de la deuxième partie de la raquette (centre)
	strh r4,[r3, #8]	@ on colle le tout dans l'emplacement suivant (8 octets après)
	add r4,#8	@ idem avec la troisième partie
	strh r4,[r3, #16]

	bl handle_ball	@ on s'occupe de la balle

	mov r0,#0x1F00	@ pour ralentir le programme

delay_loop:
	subs r0,r0,#1
	bne delay_loop
 	b main_loop

left:
	ldrb r2,[r0]
	subs r2,r2,#1
	bxcc lr	@ on quitte si le carry flag est set (donc le résultat du dessus inférieur à 0)
	strb r2,[r0]	@ sauver les nouvelles coordonnées (1 octet)
	bx lr	@ quitter la routine

right:
	ldrb r2,[r0]
	add r2,r2,#1
	cmp r2,#SCREEN_W-(8*3)	@ on test voir si ça sort de l'écran
	bxcs lr	@ on quitte si le sign flag est mis
	strb r2,[r0]
	bx lr

handle_ball:	@ le code suivant doit incrémenter ou décrementer X et Y en fonction de la direction de la balle (gère les rebonds), mais ça bug :/
	ldr r2,=ball_x
	ldrb r0,[r2]
	ldr r3,=ball_velocity
	ldrb r4,[r3]
	add r0,r0,r4
	bcc change_ball_velocity
	cmp r0,#SCREEN_W-8
	bcs change_ball_velocity
	strb r0,[r2]
	ldr r2,=ball_y
	ldrb r1,[r2]
	add r1,r1,r4
	bcc change_ball_velocity
	cmp r1,#SCREEN_H-8
	bcs change_ball_velocity
	strb r1,[r2]
	ldr r3,=OAM+3*8
	ldrh r4,[r3]
	ldrh r5,[r3,#2]
	and r4,r4,#0xFF00
	add r4,r1
	strh r4,[r3],#2
	and r5,r5,#0xFE00
	add r5,r0
	strh r5,[r3]
	bx lr

change_ball_velocity:
	mvn r4,#0
	strb r4,[r3]
	bx lr

.ltorg

palette:
	.hword 0x0000,0x001F,0x56B5,0x7FFF

.align 4	@ peut être inutile maintenant ?

paddle_left:
	.word 0x00000000
	.word 0x22011000
	.word 0x22011130
	.word 0x33033133
	.word 0x22011333
	.word 0x22011133
	.word 0x22011130
	.word 0x22011000

paddle_center:
	.word 0x00000000
	.word 0x22222222
	.word 0x22222222
	.word 0x33333333
	.word 0x22222222
	.word 0x22222222
	.word 0x22222222
	.word 0x22222222

paddle_right:
	.word 0x00000000
	.word 0x00011022
	.word 0x03111022
	.word 0x33133033
	.word 0x33311022
	.word 0x33111022
	.word 0x03111022
	.word 0x00011022

ball:
	.word 0x00003330
	.word 0x00033333
	.word 0x00033333
	.word 0x00033333
	.word 0x00003330
	.word 0x00000000
	.word 0x00000000
	.word 0x00000000

.data	@ ne faudrait-il pas que je le mette avant les sprites ?

player_x:
	.byte PADDLE_X

ball_x:
	.byte BALL_X

ball_y:
	.byte BALL_Y

ball_velocity:
	.byte 1

Au moins les déplacements de la raquette marchent grin

edit3 : Apparemment le problème vient des tests de collision avec les bords de l'écran, mais comme je ne suis pas certain de ce que font "bcc" et "bcs"... :/

Il faudrait simplement sauter à l'adresse =change_ball_velocity lorsque le résultat est négatif ou supérieur à la comparaison.
J'ai aussi eu des problèmes à comprendre le carry, il semble être le contraire (cc = carry set et cs = carry clear) :/ Bon il y a pas mal de sites (en anglais) qui en parle, dont un c'est le site d'ARM même :
http://blogs.arm.com/software-enablement/206-condition-codes-1-condition-flags-and-codes/
Et ici aussi :
http://www.peter-cockerell.net/aalp/html/ch-3.html

Maintenant je veux tester ton code smile

EDIT : Et je crois que .data met tout ce qui le suit dans la RAM où tu pourras le modifier. Il ne faut pas modifier les sprites donc faut pas les mettre dans .data. Si tu laisses les variables dans .text, tu ne pourras pas les modifier parce qu'elles seront dans ROM. Je ne sais pas si c'est comme ça que l'on utilise les variables, on pourrait aussi se servir d'une partie de la pile (avec un pointeur).
Hum ce n'est pas très logique si c'est ça... Il n'y a pas quelque chose comme "jp p," en arm ? Peut être "bxpl" (si ça existe, je n'ai pas vérifié) ?
chickendude (./53) :
Et je crois que .data met tout ce qui le suit dans la RAM où tu pourras le modifier. Il ne faut pas modifier les sprites donc faut pas les mettre dans .data. Si tu laisses les variables dans .text, tu ne pourras pas les modifier parce qu'elles seront dans ROM. Je ne sais pas si c'est comme ça que l'on utilise les variables, on pourrait aussi se servir d'une partie de la pile (avec un pointeur).

Ah ok, merci c'est plus clair comme ça smile

edit : je me demande si ça va pas poser problème d'accéder et de modifier l'OAM sans attendre un VBLANK ? Les interruptions sont peut être obligatoire finalement...
Voilà du code qui marche grin Quant au VBLANK, j'ai fait une petite routine waitVBlank pour faire juste ça, mais je crois qu'il serait mieux de réorganiser le code un peu pour qu'il y ait une partie seulement qui affiche à l'écran. J'aimerais bien pouvoir tester ces programmes sur une vraie GBA, parfois j'ai l'impression que l'émulation n'est pas parfaite... A propos, il fallait deux vélocités (une X et une Y), et j'ai trouvé que les drapeaux avec les soustractions sont un peu confus, le drapeau carry est armé quand le résultat ne prend pas un "borrow" (je suppose que ça veux dire, si le résultat > 0) et désarmé quand il y'en a (le résultat <= 0), mais j'en suis pas sûr.
.arm
.include "gba.inc"
SCREEN_W	=	240
SCREEN_H	=	160
PADDLE_X	=	SCREEN_W/2-(3*8)/2
PADDLE_Y	=	SCREEN_H-8
BALL_X	=	0
BALL_Y	=	0
.text
.global main

main:
	ldr r0,=OAM	@ on reset les sprites (je ne sais pas si ça a vraiment de l'importance)
	ldr r1,=128	@ il y a 128 emplacements de 8 octets chacuns (l'OAM fait 1ko)
	ldr r2,=(300<<16)	@ le 3ème octet suivit du prochain bit définit la coordonnée X (2^9=512 valeurs) du sprite,
	@ on la met donc à 300 pour être hors de l'écran (il fait 240*160)
	@ (pour les attributs de l'OAM, cf  http://gfx.developpez.com/prog-gba/touches/#L8  )
reset_sprites_loop:
	str r2,[r0],#8	@ on colle la valeur de r2 à l'adresse de r0, puis incrémente de 8 octets l'adresse de r0
	subs r1,r1,#1	@ la boucle fait 128 tours
	bne reset_sprites_loop

	ldr r1,=REG_DISPCNT
	ldr r2,=(MODE_0|BG2_ENABLE|OBJ_ENABLE|OBJ_MAP_1D)
	str r2,[r1]

	ldr r0,=OAM	@ on va s'occuper de charger nos sprites
	ldr r1,=(SQUARE|COLOR_16|PADDLE_Y)|((SIZE_8|PADDLE_X)<<16)	@ cf l'organisation des attributs des sprites (là on règle les deux premiers)
	mov r2,#0	@ premier tile de 8*8 pixels du sprite (index du sprite dans le CHARMEM quoi)
	str r1,[r0],#4	@ on charge les deux premiers attributs, puis on les "saute"
	str r2,[r0],#4	@ on charge le troisième attribut
	ldr r1,=(SQUARE|COLOR_16|PADDLE_Y)|((SIZE_8|PADDLE_X+8)<<16)
	mov r2,#1
	str r1,[r0],#4
	str r2,[r0],#4
	ldr r1,=(SQUARE|COLOR_16|PADDLE_Y)|((SIZE_8|PADDLE_X+16)<<16)
	mov r2,#2
	str r1,[r0],#4
	str r2,[r0],#4
	ldr r1,=(SQUARE|COLOR_16|BALL_Y)|((SIZE_8|BALL_X)<<16)
	mov r2,#3	@ quatrième tile
	str r1,[r0],#4
	str r2,[r0],#4

	ldr r1,=OBJPAL	@ on s'occupe de la palette maintenant
	ldr r2,=5	@ nombre de couleurs de la palette à copier
	ldr r3,=palette

palette_loop:
	ldr r7,[r3],#4	@ on charge la valeur à l'adresse de r3 dans r7, puis on incrémente de 4 octets (16 bits = 1 couleur) l'adresse de r3
	str r7,[r1],#4	@ on colle le tout dans r1 puis incrémente de même r1
	subs r2,r2,#1	@ on fait 5 tours
	bne palette_loop

	ldr r1,=CHARMEM	@ au tour des sprites
	ldr r2,=8*8*4	@ tailles des sprites et nombre
	ldr r3,=paddle_left

sprite_loop:
	ldr r7,[r3],#4	@ la même qu'au dessus
	str r7,[r1],#4
	subs r2,r2,#1
	bne sprite_loop

main_loop:
	mov r3,#KEYS_HIGH	@ MSB
	orr r3,r3,#KEYS_LOW	@ ajouter LSB de l'adresse (plus rapide que ldr r3,#KEYS)
	mov r2,#0x300
	orr r2,#0xFF	@ r2 = $3FF (10 touches codés sur 10 bits)
	ldr r4,[r3]	@ r4 = touche pressée

	ldr r0,=player_x
	tst r4, #KEY_LEFT
	bleq left
	tst r4, #KEY_RIGHT
	bleq right

	ldr r6,=REG_VCOUNT
waitVBlank:
	ldrb r7,[r6]
	cmp r7,#161
	bne waitVBlank

	ldrb r0,[r0]	@ on charge un octet de l'adresse r0 dans r0
	ldr r3,=OAM+2	@ deuxième attribut (=OAM+2 octets), X=1er octet+1er bit suivant
	ldrh r4,[r3]
	and r4,r4,#0xFE00	@ on récupère donc les 9 premiers bits
	add r4,r0
	strh r4,[r3]
	add r4,#8	@ on s'occupe de la deuxième partie de la raquette (centre)
	strh r4,[r3, #8]	@ on colle le tout dans l'emplacement suivant (8 octets après)
	add r4,#8	@ idem avec la troisième partie
	strh r4,[r3, #16]

	bl handle_ball	@ on s'occupe de la balle

	mov r0,#0x100	@ pour ralentir le programme
delay_loop:
	subs r0,r0,#1
	bne delay_loop
 	b main_loop

left:
	ldrb r2,[r0]
	subs r2,r2,#1
	bxcc lr	@ on quitte si le carry flag est set (donc le résultat du dessus inférieur à 0)
	strb r2,[r0]	@ sauver les nouvelles coordonnées (1 octet)
	bx lr	@ quitter la routine

right:
	ldrb r2,[r0]
	add r2,r2,#1
	cmp r2,#SCREEN_W-(8*3)	@ on test voir si ça sort de l'écran
	bxcs lr	@ on quitte si le sign flag est mis
	strb r2,[r0]
	bx lr

handle_ball:	@ le code suivant doit incrémenter ou décrementer X et Y en fonction de la direction de la balle (gère les rebonds), mais ça bug :/
@ r0 = nouveau valeur de ball_x
@ r2 = ball_x (ptr)
@ r3 = ball_vel_x (ptr)
@ r4 = ball_vel_x (valeur)
	ldr r2,=ball_x
	ldrb r0,[r2]
	ldr r3,=ball_velocity_x
	ldrb r4,[r3]
	add r0,r0,r4			@ ball_x + ball_vel
	and r0,r0,#0xFF			@ si le résultat est plus de 8 bits
	stmfd sp!,{lr}			@ pour faire des appels imbriqués
@		blcc change_ball_velocity
		cmp r0,#SCREEN_W-8
		blcs change_ball_velocity
	ldmfd sp!,{lr}
	strb r0,[r2]
	ldr r2,=ball_y
	ldrb r1,[r2]
	ldr r3,=ball_velocity_y
	ldr r4,[r3]
	add r1,r1,r4
	and r1,r1,#0xFF
	stmfd sp!,{lr}
@		blcc change_ball_velocity
		cmp r1,#SCREEN_H-8
		blcs change_ball_velocity
	ldmfd sp!,{lr}
	strb r1,[r2]	
	ldr r3,=OAM+3*8
	ldrh r4,[r3]
	ldrh r5,[r3,#2]
	and r4,r4,#0xFF00
	add r4,r1
	strh r4,[r3],#2
	and r5,r5,#0xFE00
	add r5,r0
	strh r5,[r3]
	bx lr

change_ball_velocity:
	eor r4,#0xFF
	add r4,#1
	strb r4,[r3]
	bx lr

.ltorg

palette:
	.hword 0x0000,0x001F,0x56B5,0x7FFF

.align 4	@ peut être inutile maintenant ?

paddle_left:
	.word 0x00000000
	.word 0x22011000
	.word 0x22011130
	.word 0x33033133
	.word 0x22011333
	.word 0x22011133
	.word 0x22011130
	.word 0x22011000

paddle_center:
	.word 0x00000000
	.word 0x22222222
	.word 0x22222222
	.word 0x33333333
	.word 0x22222222
	.word 0x22222222
	.word 0x22222222
	.word 0x22222222

paddle_right:
	.word 0x00000000
	.word 0x00011022
	.word 0x03111022
	.word 0x33133033
	.word 0x33311022
	.word 0x33111022
	.word 0x03111022
	.word 0x00011022

ball:
	.word 0x00003330
	.word 0x00033333
	.word 0x00033333
	.word 0x00033333
	.word 0x00003330
	.word 0x00000000
	.word 0x00000000
	.word 0x00000000

.data	@ ne faudrait-il pas que je le mette avant les sprites ?

player_x:
	.byte PADDLE_X

ball_x:
	.byte BALL_X

ball_y:
	.byte BALL_Y

ball_velocity_x:
	.byte 1
ball_velocity_y:
	.byte 1

EDIT : En effet, le carry agit différemment pour les instructions add et sub/cmp. Pour les add c'est normal, pour les sub/cmp, z80 c = cc (carry clear) et nc = cs (carry set), c'est le contraire de ce que l'on penserait... c'est bizarre.
C'est parfait, merci ! smile

Thhn

Y'a plus qu'à améliorer tout ça tongue
chickendude (./55) :
A propos, il fallait deux vélocités (une X et une Y)

Ah oui, j'étais tellement pressé de tester que je n'ai pas fait gaffe grin
chickendude (./55) :
mais je crois qu'il serait mieux de réorganiser le code un peu pour qu'il y ait une partie seulement qui affiche à l'écran

Oui je pense que je vais faire comme ça. Et merci pour la routine waitVBlank, ça va m'être utile smile
chickendude (./55) :
J'aimerais bien pouvoir tester ces programmes sur une vraie GBA, parfois j'ai l'impression que l'émulation n'est pas parfaite...

Ont-ils répondus pour la Revo ?
Pas encore, et ça fait plus d'une semaine que j'attends une réponse. Je crois qu'ils ne vont pas m'écrire sad J'en achèterais une quand même mais dans quelques mois je ne sais pas ou je serai, et comme je ne suis pas sûr quand elle arriverait...

Maintenant j'essaie d'ajouter une deuxième couche à mon tilemapper, mais il semble que les "fonds de texte" (BG0/1 pour mode 1) ont un formate différent que les fonds "affine" (ici, BG2). Mais je ne sais pas comment est le formate des fonds de texte. Tu ne saurais pas quelle est la différence ? grin
Merci, je l'ai fait, il faut l'embellir/nettoyer un petit peu et j'uploade le source smile Le code n'est pas très beau, mais je crois que mon nouveau tilemapper est meilleur que l'autre, parce que maintenant il ne faut pas l'autre liste de tiles (une liste avec les tiles 32x32, une autre avec les tiles 8x8).
Code source :
http://www.mirari.fr/zzRG

8sPM
Autrement je commence à me demander comment afficher du texte à l'écran. Les BG 0 et 1 sont fait pour ça ? Je me demande si c'est simple et comment il faut faire (autant de sprites que de lettres ?).

Ce serait peut être plus simple de faire sa propre routine de sprite pour ne pas avoir à utiliser l'OAM, en plus ça permettrait d'avoir des tailles plus optimisées pour les lettres (genre 5*3 comme sur TI, j'aime assez sa police d'ailleurs).

Je vais y réfléchir !