File: scrolldemo.c - Tab length: 1 2 4 8 - Lines: on off - No wrap: on off

/*
 scrolling 0.1 - LYNX - kit BLL (newcc65) - 16/12/2010 - philippe H.

 LYNX - r�solution: 160*102 - scroll demo -
 
 Gestion des tiles: 6 tiles * 7 tiles = 42 tiles, chaque tile ayant une taille de 34*34 -
 
 Zone de jeu: 30 tiles * 7 tiles soit 210 tiles - 1020 * 238 = 242760 pixels */

 
#include <stdlib.h>
#include <lynx.h>
#include <lynxlib.h>

/* LYNX-specific #defines: */
#define JOY_RIGHT               0x10
#define JOY_LEFT                0x20
#define JOY_DOWN                0x40
#define JOY_UP                  0x80

#define BUTTON_OPTION1  0x08
#define BUTTON_OPTION2  0x04
#define BUTTON_LEFT             0x02
#define BUTTON_RIGHT    0x01

#define BUTTON_PAUSE    0x01

//#define BUFFER1     0xBC40
//#define BUFFER2     0xDC20
//char SCREEN[8160]       at (MEMTOP-16320);
char SCREEN[8160]       at (MEMTOP-16320);
char RENDER[8160]       at (MEMTOP-8160);

uchar pal[]={
        0x00,0x00,0x0F,0x0F,0x0E,0x08,0x07,0x03,0x05,0x0A,0x00,0x0F,0x09,0x09,0x08,0x08,
        0x00,0x0F,0x7C,0x28,0x02,0x00,0x66,0x32,0xE0,0xAA,0x50,0xFF,0x99,0x99,0x88,0x88};

/**
// ------------------------------------
extern char fond1[];
char SCB[];
#asm        
_SCB      dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
#endasm

**/




// ------------------------------------
/*****************************************************************************
**  Ci-dessous, le contenu du fichier batchfile pour l'image cara.bmp      **
set image01=cara.bmp

SPRPCK -t6 -S030021 -r001003 -o000000 -i030063 -a014010 -p0 %image01% ca
cmd
**  Le point d'action de l'image ghost est mis au centre de celle-ci,       **
**  (-a014010).
*****************************************************************************/

extern uchar ca000000[];
extern uchar ca001000[];
extern uchar ca002000[];


uchar *catab[3] = {ca000000, ca001000, ca002000};

uchar SCBca[]; // d�claration d'un nouveau controleur de sprite --> car
#asm        
_SCBca      dc.b $c7,$10,$20
                dc.w 0,0
                dc.w 0,0,$100,$100
                dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
#endasm
// ------------------------------------
// clip du sprite rtile, d'une taille de 34*34 : 0(pelouse), 1 (bordure), 2 (bord de la route), 3 (bord de la route + flaque d'huile), 4 (route), 5 (route + bande).
/*****************************************************************************
**  Ci-dessous, le contenu du fichier batchfile pour l'image rtile.bmp      **
set image01=rtile.bmp

SPRPCK -t6 -S034034 -r014001 -o000000 -i476034 -p0 %image01% rt
cmd

*****************************************************************************/

extern uchar rt000000[];
extern uchar rt000001[];
extern uchar rt000002[];
extern uchar rt000003[];
extern uchar rt000004[];
extern uchar rt000005[];
extern uchar rt000006[];
extern uchar rt000007[];
extern uchar rt000008[];
extern uchar rt000009[];
extern uchar rt000010[];
extern uchar rt000011[];
extern uchar rt000012[];
extern uchar rt000013[];

uchar *rttab[14] =      {rt000000, rt000001, rt000002, rt000003, rt000004, rt000005,
                                         rt000006, rt000007, rt000008, rt000009, rt000010, rt000011,
                                         rt000012, rt000013};
// nombreuses d�clarations des nouveaux controleurs de sprite (42) pour les tiles.
uchar SCBrt01[];
uchar SCBrt02[];
uchar SCBrt03[];
uchar SCBrt04[];
uchar SCBrt05[];
uchar SCBrt06[];
uchar SCBrt07[];
 
uchar SCBrt08[];
uchar SCBrt09[];
uchar SCBrt10[];
uchar SCBrt11[];
uchar SCBrt12[];
uchar SCBrt13[];
uchar SCBrt14[];

uchar SCBrt15[];
uchar SCBrt16[];
uchar SCBrt17[];
uchar SCBrt18[];
uchar SCBrt19[];
uchar SCBrt20[];
uchar SCBrt21[];

uchar SCBrt22[];
uchar SCBrt23[];
uchar SCBrt24[];
uchar SCBrt25[];
uchar SCBrt26[];
uchar SCBrt27[];
uchar SCBrt28[];

uchar SCBrt29[];
uchar SCBrt30[];
uchar SCBrt31[];
uchar SCBrt32[];
uchar SCBrt33[];
uchar SCBrt34[];
uchar SCBrt35[];

uchar SCBrt36[];
uchar SCBrt37[];
uchar SCBrt38[];
uchar SCBrt39[];
uchar SCBrt40[];
uchar SCBrt41[];
uchar SCBrt42[];
/*****************************************************************************
************************************ _SCBrt01     dc.b $c7,$10,$20 *****************************************/

#asm
_SCBrt01     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt02     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt03     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt04     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt05     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt06     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt07     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt08     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt09     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt10     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt11     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt12     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt13     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt14     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt15     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt16     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt17     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt18     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt19     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt20     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt21     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt22     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt23     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt24     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt25     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt26     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt27     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt28     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt29     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt30     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt31     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt32     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt33     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt34     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt35     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt36     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt37     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt38     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt39     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt40     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt41     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBrt42     dc.b $c0,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
#endasm
// ------------------------------------
// clip du sprite chiffres, chacun d'une taille de 8*8: 0123456789.LEV
extern uchar bc000000[];
extern uchar bc000001[];
extern uchar bc000002[];
extern uchar bc000003[];
extern uchar bc000004[];
extern uchar bc000005[];
extern uchar bc000006[];
extern uchar bc000007[];
extern uchar bc000008[];
extern uchar bc000009[];
extern uchar bc000010[];
extern uchar bc000011[];
extern uchar bc000012[];
extern uchar bc000013[];

uchar *chiffrestab[14] = {bc000000, bc000001, bc000002, bc000003, bc000004,
                         bc000005, bc000006, bc000007, bc000008, bc000009,
                         bc000010, bc000011, bc000012, bc000013};
uchar SCBchiffres1[]; // d�claration d'un nouveau controleur de sprite (test)
uchar SCBchiffres2[]; // d�claration d'un nouveau controleur de sprite (test)
uchar SCBchiffres3[]; // d�claration d'un nouveau controleur de sprite (test)
uchar SCBchiffres4[]; // d�claration d'un nouveau controleur de sprite (test)
uchar SCBchiffres5[]; // d�claration d'un nouveau controleur de sprite (test)

uchar SCBscore1[]; // d�claration d'un nouveau controleur de sprite (score unit�)
uchar SCBscore2[]; // d�claration d'un nouveau controleur de sprite (score dizaine)
uchar SCBscore3[]; // d�claration d'un nouveau controleur de sprite (score centaine)
uchar SCBscore4[]; // d�claration d'un nouveau controleur de sprite (score millier)

uchar SCBtexte1[]; // d�claration d'un nouveau controleur de sprite (level)
uchar SCBtexte2[]; // d�claration d'un nouveau controleur de sprite (level)
uchar SCBtexte3[]; // d�claration d'un nouveau controleur de sprite (level)
uchar SCBtexte4[]; // d�claration d'un nouveau controleur de sprite (level)
uchar SCBtexte5[]; // d�claration d'un nouveau controleur de sprite (level)

uchar SCBlife[]; // d�claration d'un nouveau controleur de sprite (score unit�)

#asm
_SCBchiffres1     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBchiffres2     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBchiffres3     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBchiffres4     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBchiffres5     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBscore1     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBscore2     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBscore3     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBscore4     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBtexte1     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBtexte2     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBtexte3     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBtexte4     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBtexte5     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
;
_SCBlife     dc.b $c7,$10,$20
          dc.w 0,0
          dc.w 0,0,$100,$100
          dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
#endasm
// ------------------------------------


//_SCB7b        dc.b $c5,$18,$20
//              dc.w _SCBp1, hills
//              dc.w 0,83,$100,$100
//              dc.b $01, $23, $45, $67, $89,$Ab,$cd,$ef
//

int posx,posy,level,score,xpush,ypush,relach;
int i;

int atest,unite,dizaine,centaine,millier,dmillier,horszone;

char tempa,tempb,tempc,tempd,tempe,etape,filife,gspause,gsblip,mhaut,mbas; // de -128 � 127

int compti, comptx, compty;
int tligne,nbrbriqx, nbrbriqy;








// ------------------------------------
uchar *brdata[42]; //6*7 = 42 tiles
int cible, bbcontact, rebcot, brnbr, brie[42], brix[6] ,briy[7], pointx, tile_x, xboucle, iboucle, jboucle; // 5 car il y a 6 rang�es de tiles sur la m�me ligne (ligne car ecran vertical).


ShowScreen() // Proc�dure de mise � jour des coordonn�es des 42 tiles.
{

  SCBX(SCBrt01) = brix[0];
  SCBX(SCBrt02) = brix[0];
  SCBX(SCBrt03) = brix[0];
  SCBX(SCBrt04) = brix[0];
  SCBX(SCBrt05) = brix[0];
  SCBX(SCBrt06) = brix[0];
  SCBX(SCBrt07) = brix[0];

  SCBX(SCBrt08) = brix[1];
  SCBX(SCBrt09) = brix[1];
  SCBX(SCBrt10) = brix[1];
  SCBX(SCBrt11) = brix[1];
  SCBX(SCBrt12) = brix[1];
  SCBX(SCBrt13) = brix[1];
  SCBX(SCBrt14) = brix[1];

  SCBX(SCBrt15) = brix[2];
  SCBX(SCBrt16) = brix[2];
  SCBX(SCBrt17) = brix[2];
  SCBX(SCBrt18) = brix[2];
  SCBX(SCBrt19) = brix[2];
  SCBX(SCBrt20) = brix[2];
  SCBX(SCBrt21) = brix[2];

  SCBX(SCBrt22) = brix[3];
  SCBX(SCBrt23) = brix[3];
  SCBX(SCBrt24) = brix[3];
  SCBX(SCBrt25) = brix[3];
  SCBX(SCBrt26) = brix[3];
  SCBX(SCBrt27) = brix[3];
  SCBX(SCBrt28) = brix[3];

  SCBX(SCBrt29) = brix[4];
  SCBX(SCBrt30) = brix[4];
  SCBX(SCBrt31) = brix[4];
  SCBX(SCBrt32) = brix[4];
  SCBX(SCBrt33) = brix[4];
  SCBX(SCBrt34) = brix[4];
  SCBX(SCBrt35) = brix[4];

  SCBX(SCBrt36) = brix[5];
  SCBX(SCBrt37) = brix[5];
  SCBX(SCBrt38) = brix[5];
  SCBX(SCBrt39) = brix[5];
  SCBX(SCBrt40) = brix[5];
  SCBX(SCBrt41) = brix[5];
  SCBX(SCBrt42) = brix[5];
 
        SCBY(SCBrt01) = briy[0];SCBY(SCBrt08) = briy[0];SCBY(SCBrt15) = briy[0];SCBY(SCBrt22) = briy[0];SCBY(SCBrt29) = briy[0];SCBY(SCBrt36) = briy[0];
        SCBY(SCBrt02) = briy[1];SCBY(SCBrt09) = briy[1];SCBY(SCBrt16) = briy[1];SCBY(SCBrt23) = briy[1];SCBY(SCBrt30) = briy[1];SCBY(SCBrt37) = briy[1];
        SCBY(SCBrt03) = briy[2];SCBY(SCBrt10) = briy[2];SCBY(SCBrt17) = briy[2];SCBY(SCBrt24) = briy[2];SCBY(SCBrt31) = briy[2];SCBY(SCBrt38) = briy[2];
        SCBY(SCBrt04) = briy[3];SCBY(SCBrt11) = briy[3];SCBY(SCBrt18) = briy[3];SCBY(SCBrt25) = briy[3];SCBY(SCBrt32) = briy[3];SCBY(SCBrt39) = briy[3];
        SCBY(SCBrt05) = briy[4];SCBY(SCBrt12) = briy[4];SCBY(SCBrt19) = briy[4];SCBY(SCBrt26) = briy[4];SCBY(SCBrt33) = briy[4];SCBY(SCBrt40) = briy[4];
        SCBY(SCBrt06) = briy[5];SCBY(SCBrt13) = briy[5];SCBY(SCBrt20) = briy[5];SCBY(SCBrt27) = briy[5];SCBY(SCBrt34) = briy[5];SCBY(SCBrt41) = briy[5];
        SCBY(SCBrt07) = briy[6];SCBY(SCBrt14) = briy[6];SCBY(SCBrt21) = briy[6];SCBY(SCBrt28) = briy[6];SCBY(SCBrt35) = briy[6];SCBY(SCBrt42) = briy[6];

}


// assembler vertical retrace syncronisation routine
void Vsync()
{
#asm
vretrace:
        lda $fd0a
        bne vretrace
#endasm
}
/**************************************************************************

ATTENTION : Ci-dessous un tableau de valeurs : ces valeurs ne pourront pas �tre modifi� par la suite.

La variable brie[42] sera donc utilis� pour modifier l'�tat des 42 tiles.
**************************************************************************/

#include "rdata.h"

/**************************************************************************
**                                                                       **
**                                                                       **
**************************************************************************/

char main()
{
  InitIRQ();
  CLI;

  SetBuffers(SCREEN, RENDER ,0);

  /* set the palette */
  SetRGB(pal); //  Ceci sert � changer la palette de la Lynx.
  //DrawFBox(0,0,160,102,0);

/**
 SCBX(SCB) = 0;
 SCBY(SCB) = 0;
 SCBDATA(SCB) = fond1;
 SCBNEXT(SCB) = SCBromeo; // chainage de sprite
 
 **/



horszone=500;// mettre les tiles hors de l'�cran visible. Sprite tile d'une taille de 34*34.

  SCBX(SCBrt01) = 0;SCBY(SCBrt01) = 0-horszone;
  SCBDATA(SCBrt01) = rttab[0%14]; //
  SCBNEXT(SCBrt01) = SCBrt02; // chainage de la tile 02
  SCBY(SCBrt02) = 34-horszone;
  SCBDATA(SCBrt02) = rttab[0%14]; //
  SCBNEXT(SCBrt02) = SCBrt03; // chainage de la tile 03
  SCBY(SCBrt03) = 68-horszone;
  SCBDATA(SCBrt03) = rttab[0%14]; //
  SCBNEXT(SCBrt03) = SCBrt04; // chainage de la tile 04
  SCBY(SCBrt04) = 102-horszone;
  SCBDATA(SCBrt04) = rttab[0%14]; //
  SCBNEXT(SCBrt04) = SCBrt05; // chainage de la tile 05
  SCBY(SCBrt05) = 136-horszone;
  SCBDATA(SCBrt05) = rttab[0%14]; //
  SCBNEXT(SCBrt05) = SCBrt06; // chainage de la tile 06
  SCBY(SCBrt06) = 170-horszone;
  SCBDATA(SCBrt06) = rttab[0%14]; //
  SCBNEXT(SCBrt06) = SCBrt07; // chainage de la tile 07
  SCBY(SCBrt07) = 204-horszone;
  SCBDATA(SCBrt07) = rttab[0%14]; //

  SCBNEXT(SCBrt07) = SCBrt08; // chainage de la tile 08
  SCBY(SCBrt08) = 0-horszone;
  SCBDATA(SCBrt08) = rttab[0%14]; //
  SCBNEXT(SCBrt08) = SCBrt09; // chainage de la tile 09
  SCBY(SCBrt09) = 34-horszone;
  SCBDATA(SCBrt09) = rttab[0%14]; //
  SCBNEXT(SCBrt09) = SCBrt10; // chainage de la tile 10
  SCBY(SCBrt10) = 68-horszone;
  SCBDATA(SCBrt10) = rttab[0%14]; //
  SCBNEXT(SCBrt10) = SCBrt11; // chainage de la tile 11
  SCBY(SCBrt11) = 102-horszone;
  SCBDATA(SCBrt11) = rttab[0%14]; //
  SCBNEXT(SCBrt11) = SCBrt12; // chainage de la tile 12
  SCBY(SCBrt12) = 136-horszone;
  SCBDATA(SCBrt12) = rttab[0%14]; //
  SCBNEXT(SCBrt12) = SCBrt13; // chainage de la tile 13
  SCBY(SCBrt13) = 170-horszone;
  SCBDATA(SCBrt13) = rttab[0%14]; //
  SCBNEXT(SCBrt13) = SCBrt14; // chainage de la tile 14
  SCBY(SCBrt14) = 204-horszone;
  SCBDATA(SCBrt14) = rttab[0%14]; //

  SCBNEXT(SCBrt14) = SCBrt15; // chainage de la tile 15
  SCBY(SCBrt15) = 0-horszone;
  SCBDATA(SCBrt15) = rttab[0%14]; //
  SCBNEXT(SCBrt15) = SCBrt16; // chainage de la tile 16
  SCBY(SCBrt16) = 34-horszone;
  SCBDATA(SCBrt16) = rttab[0%14]; //
  SCBNEXT(SCBrt16) = SCBrt17; // chainage de la tile 17
  SCBY(SCBrt17) = 68-horszone;
  SCBDATA(SCBrt17) = rttab[0%14]; //
  SCBNEXT(SCBrt17) = SCBrt18; // chainage de la tile 18
  SCBY(SCBrt18) = 102-horszone;
  SCBDATA(SCBrt18) = rttab[0%14]; //
  SCBNEXT(SCBrt18) = SCBrt19; // chainage de la tile 19
  SCBY(SCBrt19) = 136-horszone;
  SCBDATA(SCBrt19) = rttab[0%14]; //
  SCBNEXT(SCBrt19) = SCBrt20; // chainage de la tile 20
  SCBY(SCBrt20) = 170-horszone;
  SCBDATA(SCBrt20) = rttab[0%14]; //
  SCBNEXT(SCBrt20) = SCBrt21; // chainage de la tile 21
  SCBY(SCBrt21) = 204-horszone;
  SCBDATA(SCBrt21) = rttab[0%14]; //

  SCBNEXT(SCBrt21) = SCBrt22; // chainage de la tile 22
  SCBY(SCBrt22) = 0-horszone;
  SCBDATA(SCBrt22) = rttab[0%14]; //
  SCBNEXT(SCBrt22) = SCBrt23; // chainage de la tile 23
  SCBY(SCBrt23) = 34-horszone;
  SCBDATA(SCBrt23) = rttab[0%14]; //
  SCBNEXT(SCBrt23) = SCBrt24; // chainage de la tile 24
  SCBY(SCBrt24) = 68-horszone;
  SCBDATA(SCBrt24) = rttab[0%14]; //
  SCBNEXT(SCBrt24) = SCBrt25; // chainage de la tile 25
  SCBY(SCBrt25) = 102-horszone;
  SCBDATA(SCBrt25) = rttab[0%14]; //
  SCBNEXT(SCBrt25) = SCBrt26; // chainage de la tile 26
  SCBY(SCBrt26) = 136-horszone;
  SCBDATA(SCBrt26) = rttab[0%14]; //
  SCBNEXT(SCBrt26) = SCBrt27; // chainage de la tile 27
  SCBY(SCBrt27) = 170-horszone;
  SCBDATA(SCBrt27) = rttab[0%14]; //
  SCBNEXT(SCBrt27) = SCBrt28; // chainage de la tile 28
  SCBY(SCBrt28) = 204-horszone;
  SCBDATA(SCBrt28) = rttab[0%14]; //

  SCBNEXT(SCBrt28) = SCBrt29; // chainage de la tile 29
  SCBY(SCBrt29) = 0-horszone;
  SCBDATA(SCBrt29) = rttab[0%14]; //
  SCBNEXT(SCBrt29) = SCBrt30; // chainage de la tile 30
  SCBY(SCBrt30) = 34-horszone;
  SCBDATA(SCBrt30) = rttab[0%14]; //
  SCBNEXT(SCBrt30) = SCBrt31; // chainage de la tile 31
  SCBY(SCBrt31) = 68-horszone;
  SCBDATA(SCBrt31) = rttab[0%14]; //
  SCBNEXT(SCBrt31) = SCBrt32; // chainage de la tile 32
  SCBY(SCBrt32) = 102-horszone;
  SCBDATA(SCBrt32) = rttab[0%14]; //
  SCBNEXT(SCBrt32) = SCBrt33; // chainage de la tile 33
  SCBY(SCBrt33) = 136-horszone;
  SCBDATA(SCBrt33) = rttab[0%14]; //
  SCBNEXT(SCBrt33) = SCBrt34; // chainage de la tile 34
  SCBY(SCBrt34) = 170-horszone;
  SCBDATA(SCBrt34) = rttab[0%14]; //
  SCBNEXT(SCBrt34) = SCBrt35; // chainage de la tile 35
  SCBY(SCBrt35) = 204-horszone;
  SCBDATA(SCBrt35) = rttab[0%14]; //

  SCBNEXT(SCBrt35) = SCBrt36; // chainage de la tile 36
  SCBY(SCBrt36) = 0-horszone;
  SCBDATA(SCBrt36) = rttab[0%14]; //
  SCBNEXT(SCBrt36) = SCBrt37; // chainage de la tile 37
  SCBY(SCBrt37) = 34-horszone;
  SCBDATA(SCBrt37) = rttab[0%14]; //
  SCBNEXT(SCBrt37) = SCBrt38; // chainage de la tile 38
  SCBY(SCBrt38) = 68-horszone;
  SCBDATA(SCBrt38) = rttab[0%14]; //
  SCBNEXT(SCBrt38) = SCBrt39; // chainage de la tile 39
  SCBY(SCBrt39) = 102-horszone;
  SCBDATA(SCBrt39) = rttab[0%14]; //
  SCBNEXT(SCBrt39) = SCBrt40; // chainage de la tile 40
  SCBY(SCBrt40) = 136-horszone;
  SCBDATA(SCBrt40) = rttab[0%14]; //
  SCBNEXT(SCBrt40) = SCBrt41; // chainage de la tile 41
  SCBY(SCBrt41) = 170-horszone;
  SCBDATA(SCBrt41) = rttab[0%14]; //
  SCBNEXT(SCBrt41) = SCBrt42; // chainage de la tile 42
  SCBY(SCBrt42) = 204-horszone;
  SCBDATA(SCBrt42) = rttab[0%14]; //


  SCBNEXT(SCBrt42) = SCBca; // chainage de la voiture
  SCBX(SCBca) = 32;SCBY(SCBca) = 51;
  SCBDATA(SCBca) = catab[0%3]; //




 
//  SCBNEXT(SCBrt09) = SCBrt10; // chainage de la tile 10
//  SCBX(SCBrt10) = 95-horszone;
//  SCBY(SCBrt10) = 16+56;
//  SCBDATA(SCBrt10) = brtab[0%4]; //
//[0]

// 2�me sprite chain� (test)
  SCBX(SCBchiffres1) = 0;SCBY(SCBchiffres1) = 0;
  //SCBDATA(SCBchiffres1) = chiffres;    
  SCBNEXT(SCBchiffres1) = SCBchiffres2; // chainage de sprite
  SCBX(SCBchiffres2) = 0;SCBY(SCBchiffres2) = 0;
  //SCBDATA(SCBchiffres2) = chiffres;  
  SCBNEXT(SCBchiffres2) = SCBchiffres3; // chainage de sprite
  SCBX(SCBchiffres3) = 0;SCBY(SCBchiffres3) = 0;
  //SCBDATA(SCBchiffres3) = chiffres;  
  SCBNEXT(SCBchiffres3) = SCBchiffres4; // chainage de sprite
  SCBX(SCBchiffres4) = 0;SCBY(SCBchiffres4) = 0;
  SCBNEXT(SCBchiffres4) = SCBchiffres5; // chainage de sprite
  SCBX(SCBchiffres5) = 0;SCBY(SCBchiffres5) = 0;
 
 
 
// truc bien pratique : associer les tiles du tableau � une variable num�rot�.
brdata[0] = SCBrt01;brdata[1] = SCBrt02;brdata[2] = SCBrt03;brdata[3] = SCBrt04;brdata[4] = SCBrt05;brdata[5] = SCBrt06;brdata[6] = SCBrt07;
brdata[7] = SCBrt08;brdata[8] = SCBrt09;brdata[9] = SCBrt10;brdata[10] = SCBrt11;brdata[11] = SCBrt12;brdata[12] = SCBrt13;brdata[13] = SCBrt14;
brdata[14] = SCBrt15;brdata[15] = SCBrt16;brdata[16] = SCBrt17;brdata[17] = SCBrt18;brdata[18] = SCBrt19;brdata[19] = SCBrt20;brdata[20] = SCBrt21;
brdata[21] = SCBrt22;brdata[22] = SCBrt23;brdata[23] = SCBrt24;brdata[24] = SCBrt25;brdata[25] = SCBrt26;brdata[26] = SCBrt27;brdata[27] = SCBrt28;
brdata[28] = SCBrt29;brdata[29] = SCBrt30;brdata[30] = SCBrt31;brdata[31] = SCBrt32;brdata[32] = SCBrt33;brdata[33] = SCBrt34;brdata[34] = SCBrt35;
brdata[35] = SCBrt36;brdata[36] = SCBrt37;brdata[37] = SCBrt38;brdata[38] = SCBrt39;brdata[39] = SCBrt40;brdata[40] = SCBrt41;brdata[41] = SCBrt42;


/**************************************************************************

level=1;
//              for(comptx=0 ; comptx<5; comptx++) // de 0 � 4, ce qui fait 5.
//                      {
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[0][compty]%14];
                                       
                                        }
                                }
//                      }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+9)]) = rttab[tbr01[1][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+18)]) = rttab[tbr01[2][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+27)]) = rttab[tbr01[3][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+36)]) = rttab[tbr01[4][compty]%14];
                                       
                                        }
                                }
**************************************************************************/


/**************************************************************************

 //�a marche !
                comptx=0;
                SCBDATA(brdata[comptx]) = rttab[tbr01[0][0]%14];
                comptx=1;
                SCBDATA(brdata[comptx]) = rttab[tbr01[0][1]%14];
                comptx=2;
                SCBDATA(brdata[comptx]) = rttab[tbr01[0][2]%14];
                comptx=3;
                SCBDATA(brdata[comptx]) = rttab[tbr01[0][3]%14];
                comptx=4;
                SCBDATA(brdata[comptx]) = rttab[tbr01[0][4]%14];
**************************************************************************/







 
/**************************************************************************
**                       BOUCLE PRINCIPALE                               **
**************************************************************************/
   
  while(1)
{
//  for( ; ; )

  Vsync();
  SwapBuffers();
//update_music(); // petite subtilit� de la gestion sonore





        ++gsblip; // economie ressource machine --> certaines des conditions n'ont pas besoin d'�tre lu par la LYNX � chaque boucle.
        if (gsblip==5)
        {
        gsblip=1;

        if (switches & BUTTON_PAUSE)
                {
                if (gspause==0) {gspause=1;} //silence();abcmusic(0,abcaptvir);}
                }
        if (!(switches & BUTTON_PAUSE))
                {
                if (gspause==1) gspause=2;
                }

        if (switches & BUTTON_PAUSE)
                {
                if (gspause==2) gspause=3;
                }

        if (!(switches & BUTTON_PAUSE))
                {
                if (gspause==3) gspause=0;
                }
        }



/**************************************************************************
**************************************************************************/

 if (etape>=0 & etape<=4)  // �cran titre
        {
        ++tempa;
        if (tempa>16)   {tempa=0;etape=9;}
        }
// Affichage des sprites chain�:  
/**************************************************************************
**************************************************************************/

 if (etape==9)  // coordonn�es affichage texte "LEVEL", et surtout application des choix de la nature des tiles (voir tables de donn�es plus haut).
        {
        ++etape;
       
        //horszone=0;
       
        }
/**************************************************************************
**************************************************************************/

 if (etape==10)  // ecran level
        {
        brix[0] = 0;
        brix[1] = 34;
        brix[2] = 68;
        brix[3] = 102;
        brix[4] = 136;
        brix[5] = 170;
       
        briy[0]=0;briy[1]=34;briy[2]=68;briy[3]=102;briy[4]=136;briy[5]=170;briy[6]=204;//briy[7]=238;briy[8]=272;
       
        ShowScreen(); // Coordonn�es de toutes les tiles (voir la proc�dure situ� au d�but de ce joyeux code).
       
        level=1;
//              for(comptx=0 ; comptx<5; comptx++) // de 0 � 4, ce qui fait 5.
//                      {
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[0][compty]%14];
                                       
                                        }
                                }
//                      }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[1][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[2][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[3][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[4][compty]%14];
                                       
                                        }
                                }
                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                {
                                if (level==1)
                                        {
                                        //SCBDATA(brdata[comptx+(compty*5)]) = rttab[tbr01[compty][comptx]%14];
                                        SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[5][compty]%14];
                                       
                                        }
                                }
        etape=20;pointx=0;
       
       
//      if (level==1)
//              {
//              
//              }
       
        }
       
 if (etape==20)  // ecran level
        {
        /**************************************************************************
        #define JOY_DOWN                0x40
        #define JOY_UP                  0x80

        #define JOY_RIGHT               0x10
        #define JOY_LEFT                0x20

        brix[0] = 0;
        brix[1] = 34;
        brix[2] = 68;
        brix[3] = 102;
        brix[4] = 136;
       
                if (joystick & JOY_UP)          {
                                                                        //yplayer=yplayer-2;
                                                                        //if (yplayer<15)       {yplayer=15;}
                                                                        ++brix[0];++brix[1];++brix[2];++brix[3];++brix[4];
                                                                        }
       
                if (joystick & JOY_DOWN)        {
                                                                        //yplayer=yplayer+2;
                                                                        //if (yplayer>87)       {yplayer=87;} // (102-24 = 78-3 = 75) ; 24 = largeur de la raquette
                                                                        --brix[0];--brix[1];--brix[2];--brix[3];--brix[4];
                                                                        }
        **************************************************************************/



                /** Coordonn�es des 42 Tiles, r�parties en 19 colonnes (de 0 � 18). Il est bien s�r possible d'afficher plus de colonne encore. **/
                if (joystick & JOY_LEFT)        {
                                                                        //yplayer=yplayer-2;
                                                                        //if (yplayer<15)       {yplayer=15;}
                                                                       
                                                                        //if (pointx>0)
                                                                        if (tile_x>0 | (tile_x==0 & pointx>0))
                                                                        //if (tile_x>0 | (tile_x==0 & pointx>0))
                                                                                {
                                                                                --pointx;
                                                                                ++brix[0];++brix[1];++brix[2];++brix[3];++brix[4];++brix[5];
                                                                                }
                                                                        if (pointx<0) // tile d'une taille de 34*34 --> 0 � 33
                                                                                {
                                                                                pointx=33;
                                                                                if (tile_x>0) --tile_x;
                                                                                //
/**
                                                                                if (tile_x==0)
                                                                                        {
                                                                                        brix[0]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[0][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==1)
                                                                                        {
                                                                                        brix[1]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[1][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==2)
                                                                                        {
                                                                                        brix[2]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                        SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[2][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==3)
                                                                                        {
                                                                                        brix[3]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[3][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==4)
                                                                                        {
                                                                                        brix[4]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[4][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==5)
                                                                                        {
                                                                                        brix[5]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[5][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
**/


                                                                                       
                                                                                       
                                                                                       
/**
                                                                                if (tile_x==6)
                                                                                        {
                                                                                        brix[0]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[6][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==7)
                                                                                        {
                                                                                        brix[1]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[7][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==8)
                                                                                        {
                                                                                        brix[2]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[8][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==9)
                                                                                        {
                                                                                        brix[3]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[9][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==10)
                                                                                        {
                                                                                        brix[4]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[10][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==11)
                                                                                        {
                                                                                        brix[5]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[11][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
**/


                                                                                       
                                                                                       
                                                                                       
                                                                                       
/**
                                                                                if (tile_x==12)
                                                                                        {
                                                                                        brix[0]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[12][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==13)
                                                                                        {
                                                                                        brix[1]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[13][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==14)
                                                                                        {
                                                                                        brix[2]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[14][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==15)
                                                                                        {
                                                                                        brix[3]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[15][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==16)
                                                                                        {
                                                                                        brix[4]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[16][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==17)
                                                                                        {
                                                                                        brix[5]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[17][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
**/

                                                                                if (tile_x<6) // 0 1 2 3 4 5
                                                                                        {
                                                                                        jboucle=tile_x;
                                                                                       
                                                                                        brix[jboucle]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;//iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x>5 & tile_x<12) // 6 7 8 9 10 11
                                                                                        {
                                                                                        jboucle=tile_x;jboucle=jboucle-6;
                                                                                        brix[jboucle]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;//iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x>11 & tile_x<18) // 12 13 14 15 16 17
                                                                                        {
                                                                                        jboucle=tile_x;jboucle=jboucle-12;
                                                                                        brix[jboucle]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;//iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x>17 & tile_x<24) // 18 19 20 21 22 23
                                                                                        {
                                                                                        jboucle=tile_x;jboucle=jboucle-18;
                                                                                        brix[jboucle]=-33;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;//iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                }
                                                                               
                                                                        }


                if (joystick & JOY_RIGHT)       {
                                                                        //yplayer=yplayer+2;
                                                                        //if (yplayer>87)       {yplayer=87;} // (102-24 = 78-3 = 75) ; 24 = largeur de la raquette
                                                                       
                                                                        if (tile_x<25 | (tile_x==25 & pointx<10))
                                                                                {
                                                                                ++pointx;
                                                                                --brix[0];--brix[1];--brix[2];--brix[3];--brix[4];--brix[5];
                                                                                }
                                                                                if (pointx>33)
                                                                                {
                                                                                pointx=0;
                                                                                ++tile_x;
                                                                               
/**************************************************************************
                                                                                if (tile_x==1)
                                                                                        {
                                                                                        brix[0]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[6][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==2)
                                                                                        {
                                                                                        brix[1]=170; // 2eme colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[7][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==3)
                                                                                        {
                                                                                        brix[2]=170; // 3eme colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[8][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==4)
                                                                                        {
                                                                                        brix[3]=170; // 4eme colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[9][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==5)
                                                                                        {
                                                                                        brix[4]=170; // 5eme colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[10][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==6)
                                                                                        {
                                                                                        brix[5]=170; // 6eme colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[11][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }

                                                                                if (tile_x==7)
                                                                                        {
                                                                                        brix[0]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[12][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==8)
                                                                                        {
                                                                                        brix[1]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[13][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==9)
                                                                                        {
                                                                                        brix[2]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[14][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==10)
                                                                                        {
                                                                                        brix[3]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[15][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==11)
                                                                                        {
                                                                                        brix[4]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[16][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==12)
                                                                                        {
                                                                                        brix[5]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[17][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }

                                                                                if (tile_x==13)
                                                                                        {
                                                                                        brix[0]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty)]) = rttab[tbr01[18][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==14)
                                                                                        {
                                                                                        brix[1]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+7)]) = rttab[tbr01[19][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==15)
                                                                                        {
                                                                                        brix[2]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+14)]) = rttab[tbr01[20][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==16)
                                                                                        {
                                                                                        brix[3]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+21)]) = rttab[tbr01[21][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==17)
                                                                                        {
                                                                                        brix[4]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+28)]) = rttab[tbr01[22][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x==18)
                                                                                        {
                                                                                        brix[5]=170; // 1ere colonne de sprites plac�e � droite.
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                SCBDATA(brdata[0 + (compty+35)]) = rttab[tbr01[23][compty]%14];  // lecture donn�e
                                                                                                }
                                                                                        }
**************************************************************************/

                                                                                if (tile_x<7) // 1 2 3 4 5 6
                                                                                        {
                                                                                        jboucle=tile_x-1;
                                                                                       
                                                                                        brix[jboucle]=170;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x>6 & tile_x<13) // 7 8 9 10 11 12
                                                                                        {
                                                                                        jboucle=tile_x-7;
                                                                                       
                                                                                        brix[jboucle]=170;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x>12 & tile_x<19) // 13 14 15 16 17 18
                                                                                        {
                                                                                        jboucle=tile_x-13;
                                                                                       
                                                                                        brix[jboucle]=170;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                if (tile_x>18 & tile_x<25) // 19 20 21 22 23 24
                                                                                        {
                                                                                        jboucle=tile_x-19;
                                                                                       
                                                                                        brix[jboucle]=170;
                                                                                        for(compty=0 ; compty<7; compty++) // de 0 � 6, ce qui fait 7 tiles par colonne.
                                                                                                {
                                                                                                xboucle=jboucle;xboucle=xboucle*7;
                                                                                                iboucle=tile_x;iboucle=iboucle+5;
                                                                                                SCBDATA(brdata[0 + (compty+xboucle)]) = rttab[tbr01[iboucle][compty]%14]; // lecture donn�e
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }

       
                if (joystick & JOY_UP)          {
                                                                        //yplayer=yplayer-2;
                                                                        //if (yplayer<15)       {yplayer=15;}
                                                                        //briy[0]
                                                                        if (briy[0]<0)
                                                                                {
                                                                        ++briy[0];++briy[1];++briy[2];++briy[3];++briy[4];++briy[5];++briy[6];//++briy[7];++briy[8];
                                                                                }
                                                                        }
       
                if (joystick & JOY_DOWN)        {
                                                                        //yplayer=yplayer+2;
                                                                        //if (yplayer>87)       {yplayer=87;} // (102-24 = 78-3 = 75) ; 24 = largeur de la raquette
                                                                        if (briy[0]>-136)//34*4 = 136
                                                                                {
                                                                                --briy[0];--briy[1];--briy[2];--briy[3];--briy[4];--briy[5];--briy[6];//--briy[7];--briy[8];
                                                                                }
                                                                        }

       
       
       
       
       
        ShowScreen(); // Coordonn�es de toutes les tiles (voir la proc�dure situ� au d�but de ce joyeux code).
        }
       
       
       
        DrawSprite(SCBrt01); // Affichage de toutes les images chain�es (tiles, voiture...).


 
/**************************************************************************
**************************************************************************/

/** test


        atest=tile_x;//pointx;//xboucle;//tile_x;//xboucle+compty;//tile_x;//pointx;//etape;//brsco[0];//ttest;//9;//balldirX;//yplayer;//speedX;//dirf;//etape;

        //atest=horszone;//relach;//etape;//SCBCTL0(SCBbr);
        unite = atest % 10;
        dizaine = atest / 10 % 10;
        centaine = atest / 100 % 10;
//      millier = atest / 1000 % 10;
//      dmillier = atest / 10000 % 10;
  // unit�:  
  SCBDATA(SCBchiffres1) = chiffrestab[unite%14];
  SCBX(SCBchiffres1) = 100;
  SCBY(SCBchiffres1) = 53;  

  // dizaine:  
  SCBDATA(SCBchiffres2) = chiffrestab[dizaine%14];
  SCBX(SCBchiffres2) = 100;
  SCBY(SCBchiffres2) = 53-8;

  // centaine:  
  SCBDATA(SCBchiffres3) = chiffrestab[centaine%14]; // 0
  SCBX(SCBchiffres3) = 100;
  SCBY(SCBchiffres3) = 53-16;
 
  // millier:  
//  SCBDATA(SCBchiffres4) = chiffrestab[millier%14]; // 0
//  SCBX(SCBchiffres4) = 100;
//  SCBY(SCBchiffres4) = 53-24;

  // dizaine de millier:  
//  SCBDATA(SCBchiffres5) = chiffrestab[dmillier%14]; // 0
//  SCBX(SCBchiffres5) = 100;
//  SCBY(SCBchiffres5) = 53-32;
 
  DrawSprite(SCBchiffres1); // Affichage valeur test�            

     **/

 
 
}
 
/**************************************************************************
**                     FIN de la BOUCLE PRINCIPALE                       **
**************************************************************************/

 
 }