PONG CODE A MOURIRE DE RIRE

v%=1          !  vitesse de la ball
scrd%=0
scr%=0
bb!=FALSE      !ball bas
bd!=FALSE      !ball droite
yb%=90         ! coordoner ball en y
x%=160          ! coordoner en x ball
yrd%=60        ! coordoner en y raquette de droite
yrg%=60         ! coordoner en y raquette de gauche
'
'
'
' ************ sprite raquette dans ecran logique depuit ecran physique*****************
'
RESERVE (100000)
ecran%=MALLOC(32000)
xb%=XBIOS(2)
xb2%=XBIOS(3)
PCIRCLE 5,5,3
PBOX 0,60,7,120
RC_COPY xb%,0,0,319,199 TO ecran%,0,0
' VOID INP(2)
CLS
'
' *******************************************************************************
'
'
' ************************** depart jeux **************************
REPEAT
 '
 CLS
 INPUT "voulez vous jouer o pour oui n pour non";r$
 IF r$="o" OR r$="O"
   perdu!=FALSE
   CLS
   scr%=0
   @jeux
 ENDIF
UNTIL r$="n"
'
' ************** EFFACE LE MEMOIRE ET REMET LA SOURIE AVANT DE SORTIR************
~MFREE(ecran%)
RESERVE (100000)
OUT 4,8
END
'
'
' ******************************* MOTEUR JEUX ********************************
'
PROCEDURE jeux
 OUT 4,18                                    !RETIRE LA SOURIE
 DO
   yrg|=PADX(0)
   yrd|=PADY(0)
   '
   '       ****************  joueur de gauche ***************
   '
   IF yb%yrg|+60 AND x%<8         !condition perdu
     '
     perdu!=TRUE
     '
   ENDIF
   IF yb%>yrg| AND yb%yrd|+60 AND x%>305        !condition perdue
     '
     perdu!=TRUE
     '
     '
   ENDIF
   IF yb%>yrd| AND yb%305      !condition gagnier
     '      PRINT AT(2,1),"score g  ";scrd%
     scrd%=scrd%+1
   ENDIF
   ' *************************** rebond gauche droite ********************
   '
   '
   IF x%<310 AND bd!=FALSE                  !condition pour avancer la ball
     x%=x%+v%
   ENDIF
   '
   IF x%>307               !condition pour reculer la ball
     condh!=FALSE          !la ball ne vient plus du haut du bas de gauche
     condb!=FALSE
     bg!=FALSE             ! bg=balle gauche
     bd!=TRUE              !ok elle va partir du mur  de droite
   ENDIF
   '
   IF bd!=TRUE             ! si condition vrai recule la ball
     x%=x%-v%
   ENDIF
   IF x%<8                 !autre condition pour avancer la ball
     bd!=FALSE
   ENDIF
   '
   '   *******************    rebond bas haut  ***************
   '
   '
   '
   '
   IF x%>306 AND bb!=FALSE
     condd!=TRUE              ! la ball a toucher le mur de droite
   ENDIF
   '
   '
   IF condd!=TRUE !pour que la ball dessant quand elle touche le mur de droite
     yb%=yb%+1
   ENDIF
   '
   IF yb%>186     ! la ball a toucher le mur du bas
     condd!=FALSE
     condh!=FALSE
     bb!=TRUE
   ENDIF
   '
   IF bb!=TRUE                        !
     yb%=yb%-1
   ENDIF
   '
   IF yb%=0                         !
     bb!=FALSE
   ENDIF
   '    '
   IF yb%=0 AND bb!=FALSE
     condh!=TRUE
   ENDIF
   IF condh!=TRUE
     yb%=yb%+1
   ENDIF
   '
   '
   '
   '    '    ******************  raquette gauche **************
   IF yrg|>139
     yrg|=139
   ENDIF
   '  IF STICK(0)=2     !DEPLACEMENT VERS LE bas
   '  yrg%=yrg%+3
   ' ENDIF
   IF yrg%<0
     yrg%=0
   ENDIF
   ' IF STICK(0)=1    !DEPLACEMENT VERS LE haut
   ' yrg%=yrg%-3
   ' ENDIF
   '
   '        *****************raquette de droite****************
   IF yrd|>139
     yrd|=139
   ENDIF
   '  IF STICK(1)=2     !DEPLACEMENT VERS LE bas
   ' yrd%=yrd%+3
   ' ENDIF
   IF yrd%<0
     yrd%=0
   ENDIF
   ' IF STICK(1)=1    !DEPLACEMENT VERS LE haut
   ' yrd%=yrd%-3
   ' ENDIF
   '
   '
   RC_COPY ecran%,0,40,7,160 TO xb%,1,(yrg|-20)     !raquette gauche
   RC_COPY ecran%,0,0,12,12 TO xb%,x%,yb%     ! ball
   RC_COPY ecran%,0,40,7,160 TO xb%,312,(yrd|-20)     !raquette droite
   BOX 0,0,319,199
   PRINT AT(2,5);" ";yrg|
   PRINT AT(2,10);" ";yrd|
 LOOP UNTIL perdu!=TRUE OR INKEY$=" "
 OUT 4,8
RETURN

En fait tu pars sur un écran en moyenne résolution à la base non ?
( je viens de m'en rendre compte ... mon code est foiré alors )

j'etait en 320x200

mince si tu as bosser comme un dingue et que tout et foirer
je suis degouter pour toi

Ok, chuis pas trop loin d'un résultat, bon j'utilise la souris vu que j'ai pas de potar mais ça sera un ligne de code à changer.
Par contre plus je suis dessus, plus je pense à la suite, genre au lieu d'avoir des raquettes et balles toutes simples, avoir des vrais sprites, avoir un fond comme un terrain au lieu d'un écran vide, et aussi pkoi pas des trous qui font passer la balle d'un côté à un autre du terrain...
La vie quoi :p
Du coup il faut que je rajoute une routine de sauvegarde du fond dans le programme.

Ah bas si tu veux te joindre a nous fait le moi savoir
De toute manière un ami codeur veux bien nous rejoindre
Gt turbo nous rajouter quelque bug ne sera pas de refus .
Ton idée bien bonne passage d un terrain a un autre par un trou noir (idée de thierry)
Ont ce recontacte bientôt
Vivement l ADN je passe ce soir voir pour la salle ADN

Si GT s'occupe de programmer le truc, je ne sers à rien ;)
Bon, je partage quand même le bout de code que j'ai fait :
Evidemment sous l'éditeur ça tourne sous tranxen, mais une fois compilé 50 fps et plein de temps machine dispo pour autre chose :)
Pas de physique de collision et tout et tout hein ?! c'est juste pour bouger des sprites :)
Bref !

Code:


' Pong for JB 2021 05
'
RESERVE 10000                       ! on laisse un peu de place au GFA
'
'
'
' on va stocker les sprites dans cet INLINE
' la raquette fait 60 pix de haut
' on prend un buffer qui a la meme largeur que l'ecran 320 pix=160 octets
' en dessous on va faire les masques donc 160*60*2=19200 octets
'
INLINE sprites%,19200
masques%=sprites%+9600
'
' on va faire les anims en double buffering, il nous faut donc
' un bloc de mémoire qui contient deux ecrans (64000)
' 256 octets pour aligner les ecrans ( pas necessaire pour STE mais bon)
' 32 octets pour sauvegarder la palette initiale
' qu'on remettra en place en quittant le jeu
'
buffer%=MALLOC(64000+256+256+32)       ! ecrans en double buffering
'                                  ! +palette
'
' on met des pointeurs sur chaque ecran : physique et logique
'
phy%=AND(buffer%+255,&HFFFFFF00)   ! ecran physique aligne sur 256
log%=phy%+32000                    ! ecran logique a la suite de l'ecran phy
sav.initial.pal%=log%+32000        ! sauvegarde de la palette de depart
'
' passage en mode superviseur
@super
'
' registres du blitter
@blitter_reg
'
' on efface les buffers
'
@blt.clr(sprites%,60*160)
@blt.clr(phy%,32000)
@blt.clr(log%,32000)
'
sauve_refresh|=BYTE{&HFFFF820A}       ! refreshrate
BYTE{&HFFFF820A}=sauve_refresh| OR 2  ! force 50hz
'                                          /!\ on peut même mettre 60Hz
'
sauve_res|=BYTE{&HFFFF8260}       ! sauvegarde resolution de depart
BYTE{&HFFFF8260}=0               ! met en basse resolution
'
BMOVE &HFFFF8240,sav.initial.pal%,32    ! sauve la palette d'avant le prog
oldphy%=XBIOS(2)                  !
oldlog%=XBIOS(3)                  !
'
sauve_keymode|=BYTE{&H484}         ! ancien mode du bip clavier
BYTE{&H484}=0                     ! plus de bip clavier
'
' BYTE{&HFFFFFC02}=&H12             ! plus de souris //////////////////
HIDEM
'
'
'
'
' on va dessiner les sprites des raquettes et de la balle
' il faudra changer cette partie si on utilise des vrais sprites
' comme la balle amiga
' ici on fait la base en un plan
'
raquette%=&X1111111000000000        ! une ligne de la raquette droite
raquette2%=&X1111111       ! une ligne de la raquette gauche
balle0%=&X10000000000000          ! ligne 1 de la balle
balle1%=&X111000000000000          ! ligne 2 de la balle
balle2%=&X1111100000000000          ! ligne 3 de la balle
balle3%=&X111000000000000          ! ligne 4 de la balle
balle4%=&X10000000000000          ! ligne 5 de la balle
'
' on dessine la raquette dans le buffer sprites%
' elle sera aux coords 0,0 dans le buffer
'
FOR ligne.raquette&=0 TO 59
  CARD{sprites%+ligne.raquette&*160}=raquette%
NEXT ligne.raquette&
'
' on dessine la balle
' elle sera aux coords 16,0 dans le buffer
'
CARD{sprites%+8}=balle0%
CARD{sprites%+8+160}=balle1%
CARD{sprites%+8+160*2}=balle2%
CARD{sprites%+8+160*3}=balle3%
CARD{sprites%+8+160*4}=balle4%
'
'
' creation des masques
'
'
@masking(sprites%,masques%,60)
'        source   dest     hauteur
' création de tableaux pour convertir les coords en adresse
' et les masques utiles au blitter pour afficher les sprites
'
DIM x.to.address&(319)               ! pr convertir x en adresse
DIM x.to.offset&(319)                ! pr connaitre le decalage de x
DIM y.to.address%(199)               ! pr convertir y en adresse
DIM endm%(15)                        ! pr creer les masques du blitter
DIM endmnot%(15)                     ! idem
'
FOR i&=0 TO 319                                     ! calcule adresse
  x.to.address&(i&)=SHL(SHR(i&,4),3)                ! pour chaque x
  x.to.offset&(i&)=i& AND 15                        ! et son decalage
NEXT i&
FOR i&=0 TO 199                                     ! calcule adresse
  y.to.address%(i&)=MUL(i&,160)                     ! pour chaque y
NEXT i&
'
' creation des masques
'
endm%(0)=&HFFFF
endmnot%(0)=0
FOR i&=1 TO 15
  endm%(i&)=SHR(&HFFFF,i&)
  endmnot%(i&)=NOT SHR(&HFFFF,i&)
NEXT i&
'
'
'
' deux raquettes et une balle = 3 sprites
'
@sprite.pre.config(3)
'
' on configure la raquette 1 ( elle se trouve en 0,0 ds le buffer sprites%)
' la routine de sprites manipule des objets de 16 pix de large
' alors on va lui dire que le sprite de la raquette fais 16 de large
' et 60 de haut
' et on veut bouger 4 plans
'
@sprite.init(1,sprites%,masques%,0,0,16,60,&X1111)
'     sprite 1, buffer ,mask buf,x,y,l ,h ,plans a afficher
'
sprite.x1&(1)=8                      ! x de la raquette 1
sprite.y1&(1)=70                     ! y de la raquette 1
'
' idem pour la raquette 2
'
@sprite.init(2,sprites%,masques%,0,0,16,60,&X1111)
'     sprite 2, buffer ,mask buf,x,y,l ,h ,plans a afficher
'
sprite.x1&(2)=320-16                   ! x de la raquette 2
sprite.y1&(2)=70                      ! y de la raquette 2
sens.raquette2&=1
'
' la balle fait 5*5 pixels mais comme la raquette on dit a la routine
' que le sprite fait 16 pix de large
' elle se trouve ds le buffer sprites% en x=16 y=0 et sa hauteur est 5 pix
'
@sprite.init(3,sprites%,masques%,16,0,16,5,&X1111)
'     sprite 3, buffer ,mask buf,x ,y,l ,h,plans a afficher
'
sprite.x1&(3)=160                     ! x de la balle
sprite.y1&(3)=90                       ! y de la balle
'
vitesse.balle.x&=1                    ! vitesse de la balle en x
vitesse.balle.y&=1
'
' ************************************************************************
@sprite.pos(1,3)                      ! initialise la position des sprites
SWAP sprite.old.x&(),sprite.cur.x&()  ! arrays
SWAP sprite.old.y%(),sprite.cur.y%()
'
@sprite.pos(1,3)                      ! *2 a cause du bouble buffering
SWAP sprite.old.x&(),sprite.cur.x&()  ! arrays
SWAP sprite.old.y%(),sprite.cur.y%()
'
'
REPEAT
  adr%=phy%                  ! affiche l'ecran de jeu
  adrlw|=BYTE(adr%)
  adrmw|=BYTE(SHR(adr%,8))
  adrhw|=BYTE(SHR(adr%,16))
  BYTE{&HFFFF8203}=adrmw|    ! vbase mid word (odd byte)
  BYTE{&HFFFF8201}=adrhw|    ! vbase high word(odd byte)
  BYTE{&HFFFF820D}=adrlw|    ! vbase low word (odd byte)
  VSYNC
  INT{&HFFFF8240}=0                 ! restore color 0
  '
  ' routine d'effacage
  ' 1er sprite a effacer,dernier sprite a effacer,buffer ds lequel on le fait
  ' on affiche phy% pendant qu'on travaille dans log%
  '
  @sprite.efface(1,3,log%)
  '
  '
  ' calcul des nouvelles positions des sprites
  '
  @sprite.pos(1,3)
  '
  '
  ' routine d'affichage , fonctionne comme celle d'effacage
  '
  @sprite.show(1,3,log%)
  '
  '
  ' comme j'ai pas de potar, je vais essayer de faire a la souris
  ' nouvelle position de la raquette 1
  '
  MOUSE mx%,my%,mk%
  IF my%<199-60
    sprite.y1&(1)=my%
  ENDIF
  '
  ' mouvement tout naze de la deuxieme raquette
  '
  IF (sprite.y1&(2)<1) OR (sprite.y1&(2)>138)
    sens.raquette2&=-sens.raquette2&
  ENDIF
  ADD sprite.y1&(2),sens.raquette2&
  ' nouvelle position de la balle
  balle.x&=sprite.x1&(3)
  balle.y&=sprite.y1&(3)
  ADD balle.x&,vitesse.balle.x&             ! on met a jour
  ADD balle.y&,vitesse.balle.y&             ! les coords de la balle
  '
  ' on teste si elle touche les bords de l'ecran
  ' en haut et en bas
  IF (balle.y&<0) OR (balle.y&>193)
    vitesse.balle.y&=-vitesse.balle.y&
  ENDIF
  ' droite et gauche
  IF (balle.x&<0) OR (balle.x&>314)
    vitesse.balle.x&=-vitesse.balle.x&
  ENDIF
  '
  ' touche raquette 1
  '
  IF (balle.x&<16) AND (balle.x&>8) AND (balle.y&>sprite.y1&(1)) AND (balle.y&<sprite.y1&(1)+60)
    vitesse.balle.x&=-vitesse.balle.x&
  ENDIF
  '
  ' touche raquette 2
  '
  IF (balle.x&<306) AND (balle.x&>299) AND (balle.y&>sprite.y1&(2)) AND (balle.y&<sprite.y1&(2)+60)
    vitesse.balle.x&=-vitesse.balle.x&
  ENDIF
  ADD sprite.x1&(3),vitesse.balle.x&
  ADD sprite.y1&(3),vitesse.balle.y&
  SWAP sprite.old.x&(),sprite.cur.x&()
  SWAP sprite.old.y%(),sprite.cur.y%()
  '
  SWAP phy%,log%
  '
  tuch&=BYTE{&HFFFFFC02}                              ! Key polling
  IF tuch&=&H3B                                       ! F1=show cpu time
    show.cpu&=1
  ENDIF
  IF tuch&=&H3C                                       ! F2=stop showing cpu
    show.cpu&=0
  ENDIF
  IF show.cpu&                                        ! Alt pressed
    CARD{&HFFFF8240}=&HF                              ! show CPU left
  ENDIF
UNTIL (tuch&=&H39) OR (game.over&)                 ! Space pressed
'
' *****************************************************************************************
BYTE{&HFFFF820A}=sauve_refresh|       ! refreshrate
'
BYTE{&HFFFF8260}=sauve_res|       ! sauvegarde resolution de depart
VSYNC
'
BMOVE sav.initial.pal%,&HFFFF8240,32    ! sauve la palette d'avant le prog
~XBIOS(5,L:oldphy%,L:oldphy%,-1)
VSYNC
'
BYTE{&H484}=sauve_keymode|         ! ancien mode du bip clavier
'
' BYTE{&HFFFFFC02}=&H8             ! plus de souris //////////////////
SHOWM
@user
~MFREE(buffer%)
EDIT
> PROCEDURE sprite.pre.config(howmany&)
  '
  DIM sprite.buffer%(howmany&)
  DIM sprite.buffer.mask%(howmany&)
  DIM sprite.xcount&(howmany&)
  DIM sprite.ycount&(howmany&)
  DIM sprite.syinc&(howmany&)
  DIM sprite.dyinc&(howmany&)
  DIM sprite.octet&(howmany&)
  DIM sprite.plan1&(howmany&)
  DIM sprite.plan2&(howmany&)
  DIM sprite.plan3&(howmany&)
  DIM sprite.plan4&(howmany&)
  DIM sprite.old.x&(howmany&)
  DIM sprite.cur.x&(howmany&)
  DIM sprite.old.y%(howmany&)
  DIM sprite.cur.y%(howmany&)
  DIM sprite.x1&(howmany&)
  DIM sprite.y1&(howmany&)
RETURN
'
> PROCEDURE sprite.init(which&,buffer%,mask%,x&,y&,l&,h&,plan&)
  '
  sprite.octet&(which&)=SHL&(SHR&(l&,4),3)
  sprite.ycount&(which&)=h&
  sprite.xcount&(which&)=SHR&(l&,4)+1
  sprite.buffer%(which&)=buffer%+SHL&(SHR&(x&,4),3)+y&*160
  sprite.buffer.mask%(which&)=mask%+SHL&(SHR&(x&,4),3)+y&*160
  '
  sprite.syinc&(which&)=160-sprite.octet&(which&)
  sprite.dyinc&(which&)=160-sprite.octet&(which&)
  '
  IF (plan& AND 1)=1
    sprite.plan1&(which&)=1
  ELSE
    sprite.plan1&(which&)=0
  ENDIF
  IF (plan& AND 2)=2
    sprite.plan2&(which&)=1
  ELSE
    sprite.plan2&(which&)=0
  ENDIF
  IF (plan& AND 4)=4
    sprite.plan3&(which&)=1
  ELSE
    sprite.plan3&(which&)=0
  ENDIF
  IF (plan& AND 8)=8
    sprite.plan4&(which&)=1
  ELSE
    sprite.plan4&(which&)=0
  ENDIF
  '
RETURN
'
'
> PROCEDURE sprite.efface(first&,last&,log.v%)
  '
  '
  CARD{sxinc%}=8
  CARD{dxinc%}=8
  CARD{end1%}=&HFFFF    !
  CARD{end2%}=&HFFFF
  CARD{end3%}=&HFFFF    !
  BYTE{skew%}=0         !
  BYTE{hop%}=2
  BYTE{op%}=0                            ! blitter en mode effacage
  '
  FOR which&=first& TO last&
    CARD{syinc%}=sprite.syinc&(which&)
    CARD{xcount%}=sprite.xcount&(which&)
    CARD{dyinc%}=sprite.dyinc&(which&)
    destination%=sprite.cur.y%(which&)
    ycount&=sprite.ycount&(which&)
    '
    IF sprite.plan1&(which&)=1
      LONG{dhighw%}=destination%           !log.v%+sprite.old.y%(which&)
      CARD{ycount%}=ycount&                !sprite.ycount&(which&)
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan2&(which&)=1
      LONG{dhighw%}=destination%+2         !
      CARD{ycount%}=ycount&                !
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan3&(which&)=1
      LONG{dhighw%}=destination%+4         !
      CARD{ycount%}=ycount&                !
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan4&(which&)=1
      LONG{dhighw%}=destination%+6         !
      CARD{ycount%}=ycount&                !
      BYTE{blit%}=192
    ENDIF
  NEXT which&
RETURN
'
> PROCEDURE sprite.pos(first&,last&)
  '
  FOR which&=first& TO last&
    sprite.cur.x&(which&)=sprite.x1&(which&) AND 15
    '
    sprite.cur.y%(which&)=log%+x.to.address&(sprite.x1&(which&))+y.to.address%(sprite.y1&(which&))
    '
  NEXT which&
RETURN
'
> PROCEDURE sprite.show(first&,last&,log.v%)
  '
  '
  INT{sxinc%}=8
  INT{dxinc%}=8
  INT{end2%}=&HFFFF
  BYTE{hop%}=2
  '
  FOR which&=first& TO last&
    INT{xcount%}=sprite.xcount&(which&)
    INT{syinc%}=sprite.syinc&(which&)+8
    INT{dyinc%}=sprite.dyinc&(which&)
    skew&=sprite.cur.x&(which&)
    CARD{end1%}=endm%(skew&)
    CARD{end3%}=endmnot%(skew&)
    BYTE{skew%}=skew&+64
    destination%=sprite.cur.y%(which&)
    ycount&=sprite.ycount&(which&)
    '
    '
    source%=sprite.buffer.mask%(which&)
    BYTE{op%}=1                           ! blitter en mode AND pour le masque
    '
    IF sprite.plan1&(which&)=1
      LONG{shighw%}=source%
      LONG{dhighw%}=destination%                !log.v%+sprite.cur.y%(which&)
      INT{ycount%}=ycount&                     !sprite.ycount&(which&)
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan2&(which&)=1
      LONG{shighw%}=source%+2
      LONG{dhighw%}=destination%+2
      INT{ycount%}=ycount&
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan3&(which&)=1
      LONG{shighw%}=source%+4
      LONG{dhighw%}=destination%+4
      INT{ycount%}=ycount&
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan4&(which&)=1
      LONG{shighw%}=source%+6
      LONG{dhighw%}=destination%+6              !
      INT{ycount%}=ycount&                     !
      BYTE{blit%}=192
    ENDIF
    '
    '
    '
    '
    '
    '
    '
    source%=sprite.buffer%(which&)
    BYTE{op%}=7                           ! blitter en mode OR pour le sprite
    '
    IF sprite.plan1&(which&)=1
      LONG{shighw%}=source%
      LONG{dhighw%}=destination%                !log.v%+sprite.cur.y%(which&)
      INT{ycount%}=ycount&                     !sprite.ycount&(which&)
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan2&(which&)=1
      LONG{shighw%}=source%+2
      LONG{dhighw%}=destination%+2
      INT{ycount%}=ycount&
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan3&(which&)=1
      LONG{shighw%}=source%+4
      LONG{dhighw%}=destination%+4
      INT{ycount%}=ycount&
      BYTE{blit%}=192
    ENDIF
    IF sprite.plan4&(which&)=1
      LONG{shighw%}=source%+6
      LONG{dhighw%}=destination%+6              !
      INT{ycount%}=ycount&                     !
      BYTE{blit%}=192
    ENDIF
  NEXT which&
  '
RETURN
'
> PROCEDURE masking(source.buf%,dest.buf%,hauteur&)
  ' ///////////////////////////////////////////////
  ' Create mask
  '
  CARD{xcount%}=20                    ! HOW MANY WORDS IN A LINE OF THE RECTANGULAR BLOCK
  CARD{sxinc%}=8
  CARD{syinc%}=8
  CARD{dxinc%}=8
  CARD{dyinc%}=8
  '
  CARD{end1%}=&HFFFF !endmasks
  CARD{end2%}=&HFFFF
  CARD{end3%}=&HFFFF
  BYTE{skew%}=0        !no shift
  BYTE{hop%}=2         !hog mode
  BYTE{op%}=7        ! or empilé sur le &er mot
  FOR i&=0 TO 6 STEP 2
    LONG{shighw%}=source.buf%+i&      !ecran%+i%+34
    LONG{dhighw%}=dest.buf%           !%ecran%+32+i%+34
    CARD{ycount%}=hauteur&
    BYTE{blit%}=192
  NEXT i&
  BYTE{op%}=12        ! NOT pour avoir le masque
  ' FOR i&=6 TO 0 STEP 2
  LONG{shighw%}=dest.buf%  !+i&      !ecran%+i%+34
  LONG{dhighw%}=dest.buf%  !+i&   !%ecran%+32+i%+34
  CARD{ycount%}=hauteur&
  BYTE{blit%}=192
  ' NEXT i&
  BYTE{op%}=3
  FOR i&=2 TO 6 STEP 2  ! on duplique sur les 3 autres plans
    LONG{shighw%}=dest.buf%  !+i&      !ecran%+i%+34
    LONG{dhighw%}=dest.buf%+i&   !%ecran%+32+i%+34
    CARD{ycount%}=hauteur&
    BYTE{blit%}=192
  NEXT i&
  '
  '
RETURN
'
' procedure d'effacage pour des zones<128k
> PROCEDURE blt.clr(oussa%,combien%)
  combient%=SHR&(combien%,1)                     ! /2 = how many words
  CARD{end1%}=&HFFFF                            ! endmasks
  CARD{end2%}=&HFFFF                            ! we blit all
  CARD{end3%}=&HFFFF                            ! bits
  CARD{sxinc%}=2                                ! moving word by word
  CARD{dxinc%}=2                                ! same applies to dest
  CARD{syinc%}=2                                ! next 'line' is at next
  CARD{dyinc%}=2                                ! word
  BYTE{op%}=0                                   ! We want to clear: op=0
  BYTE{hop%}=2
  BYTE{skew%}=0                                 ! No shift
  INT{xcount%}=combient%
  LONG{dhighw%}=oussa%
  CARD{ycount%}=1
  BYTE{blit%}=192                             ! blit !
RETURN
'
'
> PROCEDURE super
  super%=GEMDOS(&H20,L:0)
RETURN
'
'
> PROCEDURE user
  ~GEMDOS(&H20,L:super%)
RETURN
'
'
> PROCEDURE blitter_reg
  '
  ' BLITTER ADDRESSES
  '
  sxinc%=&HFF8A20    ! SOURCE X INCREMENT
  syinc%=&HFF8A22    ! SOURCE Y INCREMENT
  slow%=&HFF8A26     ! SOURCE ADDRESS LOW WORD
  shighw%=&HFF8A24   ! SOURCE ADDRESS HIGH WORD   (??????)
  end1%=&HFF8A28     ! ENDMASK 1
  end2%=&HFF8A2A     ! ENDMASK 2
  end3%=&HFF8A2C     ! ENDMASK 3
  dxinc%=&HFF8A2E    ! DESTINATION X INCREMENT
  dyinc%=&HFF8A30    ! DESTINATION Y INCREMENT
  dlow%=&HFF8A34     ! DESTINATION ADDRESS LOW WORD
  dhighw%=&HFF8A32   ! DESTINATION ADDRESS HIGH WORD     (?????)
  xcount%=&HFF8A36   ! X COUNTER
  ycount%=&HFF8A38   ! Y COUNTER
  hop%=&HFF8A3A      ! HOP
  op%=&HFF8A3B       ! OPERATION
  skew%=&HFF8A3D     ! CONFIGURATION
  blit%=&HFF8A3C     ! CONFIGURATION
  '
  '
  '
RETURN
'
'


non tk il na rien fait mais si je doit lui demander de nous faire un petit truc en assembleur alors il sera la
aller je teste ton programme
juste 10 min pour le charger

Ton bout de code:
RESERVE (100000)
ecran%=MALLOC(32000)
RC_COPY xb%,0,0,319,199 TO ecran%,0,0

Je le remplacerais par:
ecran$=space$(32000)
ecran%=v:ecran$
bmove xb%,ecran%,32000

Ton RESERVE va te bouffer de la mémoire à chaque redémarrage de ton éditeur GFA et au bout de x démarrage, plantage, mémoire out.

Merci mon ami Shaqow272 pour l'info
mais je fait un MFREE et un autre RESERVE pour liberer la memoire
je penser que c'etait bon
alors
ou ce n'est jusque pour l'editeur gfa?

Le MFREE c'est pour le MALLOC, il faut le faire tout le temps
Par contre le RESERVE, quand tu le fais à la fin, ça fonctionne pas top, mais utiliser SPACE$() te limite la taille de l'espace mémoire que tu veut réserver à un peu plus de 32k , ce qui est nul.

et dans
ecran%=v:ecran$
le v: c'est quoi car ça me perturbe

Quand tu fais
ecran$=SPACE$(xx)

En fait tu crée une chaine de caractères, comme si tu faisais
ecran$="le gfa c'est bien !"

Mais comme on veut détourner ça de son usage de ligne de texte pour en faire un bloc de mémoire où on veut mettre des trucs, il faut qu'on connaisse l'adresse de ecran$ dans la mémoire du ST, c'est ce que fait V: (ou VARPTR [ variable pointer ] )

notre ami shadow me fait des cours sur le gfa très Détailler
et j'avance doucement
mais surement

donc dans
blabla%=v:blabla$
blabla$=SPACE$(19)
blabla$="le gfa c'est bien !"
si je veux afficher          a c'est bien    
je fait un  

PRINT "le pointeur ce trouve décaler ici de 5 octect",blabla$:v+5
un truc comme ca non ?
desoler je suis au bureau pas d'atari pour tester sur l'ordi du bureau mais je veux comprendre car je ne suis pas sur de moi

si non pour les court en ligne on ce callera un moment ?

Il faut commencer par soit blabla$=SPACE$(19)
                                soit blabla$="le gfa c'est bien"
et après faire blabla%=V:blabla$

mais pour un PRINT tu gardes blabla$
Haha !! Pas facile hein ?!

il faut que je test
bon aller c'est froid
A TABLE

Jb a écrit:donc dans
si je veux afficher          a c'est bien    
je fait un  

PRINT "le pointeur ce trouve décaler ici de 5 octect",blabla$:v+5
un truc comme ca  non ?

Tu ne peux pas faire ça

V: c'est une fonction du GFA, comme PRINT ou XBIOS, ça donne juste une adresse.
tout ce que tu peux faire avec V: c'est
bla%=V:bla$ ( bon d'autres trucs aussi mais qui reviennent au même )

Cette ligne de code dit au ST :
1 : bla$ est une chaine de caracteres
2 : bla% est une variable
3 : Fais que la valeur de la variable bla% soit l'adresse ou se situe en mémoire la chaine de caractères bla$

Mais on peut aussi faire bli%=V:bla%
et là la variable bli% a comme valeur l'adresse ou est stockée en mémoire la variable bla%

La c est nikel

Bien compris

La c est nikel

Bien compris