Meuh non roll tongue wink

A propos est ce qu'il y a un equivalant de if, while, ou for...
non ^^, faut faire tes propres routines
C'est vraiment la galère... hehe
Coucou, me revoila, toujours decidé à apprendre l'ASM
Seulement petit problème, ca marche tjs pas et j'ai pourtant bien appliqué ce que disais Glre

.nolist
#include "ion.inc"
#define x_raquette saferam1
#define y_raquette saferam1+1
#define x_balle saferam1+1+1
#define y_balle saferam1+1+1+1

.list

#ifdef TI83P
.org progstart-2
.db $BB,6D
#else
.org progstart
#endif
ret
jr nc,lblStart
.db "Pong",0


lblStart:
ld hl,txtStartup
bcall(_puts)
bcall(_getkey)
ld a,47
ld (x_raquette),a
ld (y_raquette),a
ld a,10
ld (x_balle),a
ld (y_balle),a



directinput:
bcall(_cleargbuf)
ld b,8
ld a,(y_raquette)
ld l,a
ld a,(x_raquette)
ld ix,raquette
call Ionputsprite

ld b,8
ld a,(y_raquette)
ld l,a
ld a,(x_raquette)
add a,8
ld ix,raquetteb
call Ionputsprite

ld b,4
ld a,(y_balle)
ld l,a
ld a,(x_balle)
ld ix,balle
call Ionputsprite
call IonFastCopy


ld a,$FF
out (1),a
ld a,$FE
out (1),a
in a,(1)
cp 253
call z,droite
cp 251
call z,gauche
jp directinput


gauche:
ld a,(x_raquette)
cp 1
jp z,return
push af
ld a,(x_raquette)
inc a
ld (x_raquette),a
pop af
ret


droite:
ld a,(x_raquette)
cp 70
jp z,return
push af
ld a,(x_raquette)
dec a
ld (x_raquette),a
pop af
ret


balle:
.db %0110
.db %1011
.db %1111
.db %0110

return:
ret

raquette:
.db %01111111
.db %10000000
.db %11111111
.db %01111111
.db %00000000
.db %00000000
.db %00000000
.db %00000000


raquetteb:
.db %11111110
.db %00000001
.db %11111111
.db %11111110
.db %00000000
.db %00000000
.db %00000000
.db %00000000


txtStartup:
.db "----------------"
.db "| Pong |"
.db "----------------"
.db "| Version 0.1 |"
.db "----------------",0



.end END
Non bah enfait c'est bon, j'ai fait un truc mais je suis pas sur que se soit la meilleur solution:

        .nolist
        #include "ion.inc"
#define x_raquette saferam1
#define y_raquette saferam1+1
#define x_balle saferam1+1+1
#define y_balle saferam1+1+1+1
      
.list

#ifdef TI83P
        .org    progstart-2
        .db     $BB,6D
#else
        .org    progstart
#endif
        ret
        jr      nc,lblStart
        .db     "Pong",0


lblStart: 
      ld hl,txtStartup
      bcall(_puts)
      bcall(_getkey)
      ld     a,52
      ld     (x_raquette),a
      ld     (y_raquette),a
      ld     a,4
      ld     (x_balle),a
      ld     (y_balle),a



directinput: 
      bcall(_cleargbuf)
      ld      b,8
      ld      a,(y_raquette)
      ld      l,a
      ld      a,(x_raquette)
      ld      ix,raquette
      call      Ionputsprite

      ld      b,8
      ld      a,(y_raquette)
      ld      l,a
      ld      a,(x_raquette)
      add     a,8
      ld      ix,raquetteb
      call      Ionputsprite

      ld      b,4
      ld      a,(y_balle)
      ld      l,a
      ld      a,(x_balle)
      ld      ix,balle
      call      Ionputsprite
      call      IonFastCopy


      ld      a,$FF
      out      (1),a
      ld      a,$FE
      out      (1),a
      in      a,(1)
      cp      251
      call      z,droite
      cp      253
      call      z,gauche
      jp      directinput 


gauche:
      ld     a,(x_raquette)
      cp     1
      jp     z,gaucheStop
      push   af
      ld     a,(x_raquette)
      dec    a
      ld     (x_raquette),a
      pop    af
      ret 

gaucheStop:
      ld     a,2
      ld     (x_raquette),a 
      ret


droite:
      ld     a,(x_raquette)
      cp     80
      jp     z,droiteStop
      push   af                  
      ld     a,(x_raquette) 
      inc    a 
      ld     (x_raquette),a 
      pop    af                
      ret 

droiteStop:
      ld     a,79
      ld     (x_raquette),a 
      ret


balle:
      .db      %0110
      .db      %1011
      .db      %1111
      .db      %0110


raquette:
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %01111111
      .db      %10000000
      .db      %11111111
      .db      %01111111
     


raquetteb: 
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %11111110
      .db      %00000001
      .db      %11111111
      .db      %11111110



txtStartup:
      .db "----------------"
      .db "|     Pong     |"
      .db "----------------"
      .db "| Version  0.1 |"
      .db "----------------",0


.end
END

Sinon j'aimerais bien pouvoir faire bouger la balle, personne n'as une idée de comment faut faire SVP ?
tu peux faire un truc de ce genre , a chaques boucles tu fais :
x_balle + xdelta => x_balle
y_balle + ydelta => y_balle

si x_balle atteint une limite "horizontale", tu fais -xdelta => xdelta
si y_balle atteint une limite "verticale", tu fais -ydelta => ydelta

essai de faire ça pour que la balle rebondisse dans les 4 murs sans t'occuper des curseur pour l'instant
D'accord merci, je essayer de faire ca
Juste une question, lorqu'on met :

      ld     a,(variable) 
      cp     1 
      jp     z,label


Cela revient à dire :

If variable=1
goto gaucheStop


Et est ce qu'il y a l'equivalant de :
If variable>1 and variable<10
goto gaucheStop
Oui c'est cela, c'est l'équivalent.
Pour une double condition, je fais un truc comme ça :
ld a,(variable)
cp 1
jp z,label1

label1:
cp 10
jp z,gauchestop

Bon je fais ça mais y'a peut-etre une technique qui est mieu....
Oui c'est ce que j'ai fait aussi pour remplacer le and. smile

J'ai essayé d'inclure la collision entre le curseur et la balle mais ca ne marche pas tout le temps, si t'as une idée s'il te plait
Voici mon code :

        .nolist
        #include "ion.inc"
#define x_raquette saferam1
#define y_raquette saferam1+1
#define x_balle saferam1+1+1
#define y_balle saferam1+1+1+1
#define vitesse_balleX saferam1+1+1+1+1
#define vitesse_balleY saferam1+1+1+1+1+1

.list

#ifdef TI83P
        .org    progstart-2
        .db     $BB,6D
#else
        .org    progstart
#endif
        ret
        jr      nc,lblStart
        .db     "Pong",0


lblStart: 
      ld hl,txtStartup
      bcall(_puts)
      bcall(_getkey)
      ld     a,52
      ld     (x_raquette),a
      ld     (y_raquette),a
      ld     a,4
      ld     (x_balle),a
      ld     (y_balle),a
      ld     a,1
      ld     (vitesse_balleX),a
      ld     (vitesse_balleY),a

directinput: 
      bcall(_cleargbuf)
      ld      b,8
      ld      a,(y_raquette)
      ld      l,a
      ld      a,(x_raquette)
      ld      ix,raquette
      call      Ionputsprite

      ld      b,8
      ld      a,(y_raquette)
      ld      l,a
      ld      a,(x_raquette)
      add     a,8
      ld      ix,raquetteb
      call      Ionputsprite

      ld      b,4
      ld      a,(y_balle)
      ld      l,a
      ld      a,(x_balle)
      ld      ix,balle
      call      Ionputsprite
      call      IonFastCopy


      ld      a,$FF
      out      (1),a
      ld      a,$FE
      out      (1),a
      in      a,(1)
      cp      251
      call      z,droite
      cp      253
      call      z,gauche

      ld     a,(vitesse_balleX)
      ld     c,a
      ld     a,(x_balle)
      add    a,c
      ld     (x_balle),a
      cp     1
      jp     z,balleDroite
      cp     80
      jp     z,balleGauche
      ld     a,(vitesse_balleY)
      ld     c,a
      ld     a,(y_balle)
      add    a,c
      ld     (y_balle),a
      cp     1
      jp     z,balleBas
      cp     52
      jp     z,collision
      jp     directinput

balleGauche:
      ld     a,(vitesse_balleX)
      neg
      ld     (vitesse_balleX),a
      jp     directinput

balleDroite:
      ld     a,(vitesse_balleX)
      neg
      ld     (vitesse_balleX),a
      jp     directinput

balleHaut:
      ld     a,(vitesse_balleY)
      neg
      ld     (vitesse_balleY),a
      jp     directinput

balleBas:
      ld     a,(vitesse_balleY)
      neg
      ld     (vitesse_balleY),a
      jp     directinput

collision:
      ld     a,(x_balle)
      ld     b,a
      ld     a,(x_raquette)
      add    16
      cp     b
      jp     nc,collision2
      ret

collision2:
      ld     a,(x_raquette)
      cp     b
      jp     c,balleHaut
      ret



gauche:
      ld     a,(x_raquette)
      cp     1
      jp     z,gaucheStop
      ;push   af
      ;ld     a,(x_raquette)
      dec    a
      ld     (x_raquette),a
      ;pop    af
      ret

gaucheStop:
      ld     a,2
      ld     (x_raquette),a 
      ret


droite:
      ld     a,(x_raquette)
      cp     80
      jp     z,droiteStop
      ;push   af
      ;ld     a,(x_raquette)
      inc    a
      ld     (x_raquette),a
      ;pop    af
      ret

droiteStop:
      ld     a,79
      ld     (x_raquette),a
      ret


balle:
      .db      %0110
      .db      %1011
      .db      %1111
      .db      %0110


raquette:
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %01111111
      .db      %10000000
      .db      %11111111
      .db      %01111111
     


raquetteb: 
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %11111110
      .db      %00000001
      .db      %11111111
      .db      %11111110



txtStartup:
      .db "----------------"
      .db "|     Pong     |"
      .db "----------------"
      .db "| Version  0.1 |"
      .db "----------------",0


.end
END
J'ai trouvé : a doit etre compris entre 0 et 256, et il se trouve que mon a étais négatif, c'est pour ca que ca marchait une fois sur deux, smile
Je crois que je commence a comprendre un peu la logique de l'ASM, hehe

Donc voici mon nouveau code:

        .nolist
        #include "ion.inc"
#define x_raquette saferam1
#define y_raquette x_raquette+1
#define x_balle y_raquette+1
#define y_balle x_balle+1
#define direction_balleX y_balle+1
#define direction_balleY direction_balleX+1
#define vitesse direction_balleY+1
#define compteur_vitesse vitesse+1
#define score compteur_vitesse+1

.list

#ifdef TI83P
        .org    progstart-2
        .db     $BB,6D
#else
        .org    progstart
#endif
        ret
        jr      nc,lblStart
        .db     "Pong par Noufnouf",0


lblStart:
      bcall(_homeup)
      bcall(_clrscrnfull)
      ld hl,txtStartup
      bcall(_puts)
      bcall(_getkey)
      ld     a,50
      ld     (x_raquette),a
      ld     a,52
      ld     (y_raquette),a
      ld     a,4
      ld     (x_balle),a
      ld     (y_balle),a
      ld     a,1
      ld     (direction_balleX),a
      ld     (direction_balleY),a
      ld     a,0
      ld     (compteur_vitesse),a
      ld     a,50
      ld     (vitesse),a
      ld     hl,0
      ld     (score),hl

directinput:
      ld     hl,(score)
      inc    hl
      ld     (score),hl

      ld     b,1
      call   delay
      ld     a,(compteur_vitesse)
      cp     10
      call   z,vitesseAugmente
      inc    a
      ld     (compteur_vitesse),a

      bcall(_cleargbuf)
      ld      b,8
      ld      a,(y_raquette)
      ld      l,a
      ld      a,(x_raquette)
      ld      ix,raquette
      call      Ionputsprite

      ld      b,8
      ld      a,(y_raquette)
      ld      l,a
      ld      a,(x_raquette)
      add     a,8
      ld      ix,raquetteb
      call      Ionputsprite

      ld      b,4
      ld      a,(y_balle)
      ld      l,a
      ld      a,(x_balle)
      ld      ix,balle
      call      Ionputsprite
      call      IonFastCopy


      ld      a,$FF
      out      (1),a
      ld      a,$FE
      out      (1),a
      in      a,(1)
      cp      251
      call      z,droite
      cp      253
      call      z,gauche

      ld     a,(direction_balleX)
      ld     b,a
      ld     a,(x_balle)
      add    a,b
      ld     (x_balle),a
      cp     1
      jp     z,balleDroite
      cp     80
      jp     z,balleGauche
      ld     a,(direction_balleY)
      ld     b,a
      ld     a,(y_balle)
      add    a,b
      ld     (y_balle),a
      cp     1
      jp     z,balleBas
      cp     52
      jp     z,collision

      jp     directinput

balleGauche:
      ld     a,(direction_balleX)
      neg
      ld     (direction_balleX),a
      jp     directinput

balleDroite:
      ld     a,(direction_balleX)
      neg
      ld     (direction_balleX),a
      jp     directinput

balleHaut:
      ld     a,(direction_balleY)
      neg
      ld     (direction_balleY),a
      jp     directinput

balleBas:
      ld     a,(direction_balleY)
      neg
      ld     (direction_balleY),a
      jp     directinput

collision:
      ld     a,(x_raquette)
      add    a,24
      ld     b,a
      ld     a,(x_balle)
      add    a,11
      cp     b
      jp     c,collision2
      jp     quitter

collision2:
      ld     a,(x_balle)
      add    a,32
      cp     b
      jp     nc,balleHaut
      jp     quitter



gauche:
      ld     a,(x_raquette)
      cp     1
      jp     z,gaucheStop
      ;push   af
      ;ld     a,(x_raquette)
      dec    a
      ld     (x_raquette),a
      ;pop    af
      ret

gaucheStop:
      ld     a,2
      ld     (x_raquette),a 
      ret


droite:
      ld     a,(x_raquette)
      cp     80
      jp     z,droiteStop
      ;push   af
      ;ld     a,(x_raquette)
      inc    a
      ld     (x_raquette),a
      ;pop    af
      ret

droiteStop:
      ld     a,79
      ld     (x_raquette),a
      ret

delay:
      ld     a,1
      call   delay2
      inc    b
      ld     a,(vitesse)
      ld     c,a
      ld     a,b
      cp     c
      jp     c,delay
      ret

delay2:
      inc    a
      push   af
      ld     a,(vitesse)
      ld     c,a
      pop    af
      cp     c
      jp     c,delay2
      ret

vitesseAugmente:
      ld     a,(vitesse)
      cp     0
      jp     z,return
      dec    a
      ld     (vitesse),a
      ld     a,0
      ld     (compteur_vitesse),a
      ret


quitter:
      bcall(_homeup)
      bcall(_clrscrnfull)
      ld hl,txtStartup
      bcall(_puts)
      ld hl,scoreStr
      bcall(_puts)
      ld     hl,(score)
      bcall(_disphl)
quitter2:
      bcall(_getkey)
      ld      a,$FF
      out      (1),a
      ld      a,$FE
      out      (1),a
      in      a,(1)
      cp      251
      call      z,quitter2
      cp      253
      call      z,quitter2
      ret

wait:
      jp      wait

return:
      ret

;high:          .dw     0

balle:
      .db      %0110
      .db      %1011
      .db      %1111
      .db      %0110

raquette:
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %01111111
      .db      %10000000
      .db      %11111111
      .db      %01111111
     


raquetteb: 
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %00000000
      .db      %11111110
      .db      %00000001
      .db      %11111111
      .db      %11111110



txtStartup:
      .db "+--------------+"
      .db "|     Pong     |"
      .db "+--------------+"
      .db "| Version  0.1 |"
      .db "+--------------+",0

scoreStr:
      .db " Score : ",0

.end
END


J'ai justes 2 questions :
-J'ai remarqué que en mettant 2nde + [on], la calcu s'eteignait quand même et ca entrenait ensuite un bug, et ce qu'on peut "desactiviter" la touche seconde (idem pour alpha)?

-J'aimerais bien pouvoir aussi randomiser la position de la balle au depart, j'avais trouvé dans un code ionRandom mais je sais pas du tout comment l'utiliser...
Il me semble qu'il y a un petit souci dans le code pour faire >1 et <10 dans la réponse de gLre : ce n'est pas le drapeau "z" qu'il faut utiliser mais le "p" (résultat de cp positif) ou le "m" (négatif).
oui j'avais aussi remarqué, moi perso j'utilise c, qui veut dire plus petit et je rajoute n pour faire l'inverse smile .

PS : En fait pour la touche 2nde c'est resolu, par contre si vous savez des trucs sur la fonction ionRandom...

Ps2: En y reflechissant c'est vrai que ta technique semble mieux : parce que si je met c pour plus petit, alors nc ca voudras dire plus grand ou egal...
ah désolé, j'avais mal lu, je pensais si a = 1 ou = 10... désolé...
En fait c'est bon pour ionRandom j'ai trouvé grin :

ld     b,42 ;si on le veut compris entre 0 et 42
call   ionrandom
; a est ici un nombre aléatoire entre 0 et 42


ld a,r ;a est aléatoire compris entre 0 et 255

J'ai trouvé ca la : http://www.google.fr/search?hl=fr&q=ionrandom&btnG=Rechercher&meta=lr%3Dlang_fr^ tongue
Une dernière question : j'ai essayé de tracé des lignes avec darkline mais comme je met (_cleargbuf) faut que je reexecute la commande a chaque fois, et ca ralenti enormenent !
Est ce qu'il y a un moyen donc de tracé des lignes mais beaucoup plus rapidement ?? ou alors de faire bouger des sprite sans devoir effacer le graph buffer à chaque fois confus
Non en fait c'est bon j'ai trouvé grin : pour effacer un sprite il suffit de l'afficher 2 fois comme ca il s'annule smile
c'est plus lent que d'effacer le graph buffertongue
Ah bon eek ... alors l'ideal ce serait d'effacer juste une partie du graph buffer, mais je sais pas si c'est possible...
Très bonne question, jcrois que jvé squatté ton forum !
(t'inkiète pa, jsai me faire discret !)