fission_06.c

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

0001: /*
0002:  Fission (casse brique) 0.6 - LYNX - kit BLL (newcc65)
0003:  10/02/2011
0004:  console tenu ï¿½ la verticale
0005:  Handy/Option/Rotate Screen(Right)
0006:  D-pad et bouton pause
0007:  LYNX - video game */
0008:
0009: #include <stdlib.h>
0010: #include <lynx.h>
0011: #include <lynxlib.h>
0012: //{
0013: extern void silence();
0014: extern void abcmusic();
0015: extern void update_music();
0016:
0017: char abcmusic0[];
0018: char abcmusic1[];
0019: char abcmenu1[];
0020: char abcmenu2[];
0021: char abcball1[];
0022: char abcball2[];
0023: char abcball3[];
0024: char abcball4[];
0025: char abcaptvir[];
0026: char abcbric[];
0027: char uplif[];
0028: #asm
0029:  xref _abcmenu1
0030:  xref _abcmenu2
0031:  xref _abcball1
0032:  xref _abcball2
0033:  xref _abcball3
0034:  xref _abcball4
0035:  xref _abcbric
0036:  xref _abcaptvir
0037:  xref _abcboum
0038:  xref _abcpanne
0039:  xref _abces
0040:  xref _abcmusic0
0041:  xref _abcmusic1
0042:  xref _uplif
0043: _uplif
0044:  dc.b "O3X4I1V127T8R40H2K2"
0045:  dc.b "|:E2D2C2D2E2D2"
0046:  dc.b 0
0047: _abcmenu1
0048:  dc.b "O2X7I1V32T20R54H7K8"
0049:  dc.b "|:C4"
0050:  dc.b 0
0051: _abcmenu2
0052:  dc.b "O3X7I1V16T20R54H7K12"
0053:  dc.b "|:c2"
0054:  dc.b 0
0055: ; ball :
0056: _abcball1
0057:  dc.b "O4X3I1V70T20R32H2K1"
0058:  dc.b "|:C4"
0059: _abcball2
0060:  dc.b "O4X3I1V70T20R32H2K1"
0061:  dc.b "|:D4"
0062: _abcball3
0063:  dc.b "O4X3I1V70T20R32H2K1"
0064:  dc.b "|:F4"
0065: _abcball4
0066:  dc.b "O4X2I1V70T20R32H2K3"
0067:  dc.b "|:B4"
0068: _abcaptvir
0069:  dc.b "O2X15I1V32T1R14H6K30"
0070:  dc.b "|:C4D4C4E4D4C4D4"
0071:  dc.b 0
0072: _abcbric
0073:  dc.b "O4X7I1V16T20R54H7K12"
0074:  dc.b "|:C1"
0075:  dc.b 0
0076: _abcmusic0
0077:  dc.b "O2X3I1V70T20R54H2K1"
0078:  dc.b "|:C4O3T2C4"
0079:  dc.b 0
0080: _abcmusic1
0081:  dc.b "O2X7I0V45T20R80H8K1"
0082:  dc.b "|:C4D4E4F4"
0083:  dc.b "C4D4E4F4"
0084:  dc.b "c4B4A4E4"
0085:  dc.b "c4B4A4E4"
0086:  dc.b "E4F4G4A4"
0087:  dc.b "E4F4G4A4"
0088:  dc.b "C4D4E4F4"
0089:  dc.b "C4D4E4F4:"
0090:  dc.b 0
0091: #endasm
0092: //}
0093:
0094: /* LYNX-specific #defines: */
0095: #define JOY_RIGHT 0x10
0096: #define JOY_LEFT 0x20
0097: #define JOY_DOWN 0x40
0098: #define JOY_UP 0x80
0099:
0100: #define BUTTON_OPTION1 0x08
0101: #define BUTTON_OPTION2 0x04
0102: #define BUTTON_LEFT 0x02
0103: #define BUTTON_RIGHT 0x01
0104:
0105: #define BUTTON_PAUSE 0x01
0106:
0107: #define SC BSTRETC H(a) (*(uint *)((a)+15)) // dï¿½formation, macro
0108: #define SC BTILT(a) (*(uint *)((a)+17)) // dï¿½formation, macro
0109:
0110: uchar SCREEN[8160] at (MEMTOP-16320);
0111: uchar RENDER[8160] at (MEMTOP-8160);
0112:
0113: uchar pali[]={
0114:  0x00,0x0F,0x02,0x03,0x0A,0x04,0x05,0x06,0x07,0x0B,0x08,0x09,0x04,0x0B,0x0C,0x01,
0115:  0x00,0xFF,0x22,0x33,0xAA,0x44,0x55,0x66,0x77,0x00,0x88,0x99,0x53,0xBB,0xCC,0x11};
0116: uchar palg[]={
0117:  0x00,0x0F,0x0A,0x00,0x03,0x05,0x08,0x0A,0x0C,0x0E,0x0D,0x00,0x04,0x03,0x02,0x00,
0118:  0x00,0xFF,0xF0,0x0F,0x3F,0x5F,0x8F,0xAF,0xCF,0xEF,0x28,0xF8,0x53,0x63,0x52,0x21};
0119:
0120:
0121: uchar palr[]={
0122:  0x00,0x0F,0x0A,0x00,0x03,0x05,0x08,0x0A,0x0C,0x0E,0x0D,0x00,0x04,0x00,0x02,0x00,
0123:  0x00,0xFF,0xF0,0x0F,0x3F,0x5F,0x8F,0xAF,0xCF,0xEF,0x28,0xF8,0x53,0x0F,0x52,0x21};
0124: /*****************************************************************************
0125: ** Ci-dessous, le contenu du fichier batchfile pour l'image imole.bmp **
0126:   **
0127: set image01=imole.bmp
0128: SPRPCK -t6 -S072072 -r001001 -a036036 -p0 %image01%
0129: cmd
0130:   **
0131: ** Le point d'action de l'image imole est mis au centre de celle-ci, **
0132: ** 72/2 = 36 (-a036036). Le but de la manoeuvre est de rï¿½aliser un zoom **
0133: ** correctement. **
0134: *****************************************************************************/
0135:
0136: extern uchar ititre[]; // image titre, d'une taille de 15*49;
0137: extern uchar iname[]; // image nom/prï¿½nom de auteur, d'une taille de 93*9;
0138: extern uchar imole[]; // image molecule, d'une taille de 72*72;
0139: uchar SCB[];
0140: #asm
0141: _SCB dc.b $c7,$10,$20
0142:   dc.w 0,0
0143:   dc.w 0,0,$100,$100
0144:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0145: #endasm
0146: // ------------------------------------
0147: extern uchar fondg[]; // image fond game, d'une taille de 160*102;
0148: uchar SCBg[];
0149:
0150: #asm
0151: _SCBg dc.b $c0,$10,$20
0152:   dc.w 0,0
0153:   dc.w 0,0,$100,$100
0154:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0155: ;
0156: #endasm
0157: // ------------------------------------
0158: extern uchar pushup[]; // image appuyez sur haut, d'une taille de 48*35;
0159: uchar SCBp[];
0160: #asm
0161: _SCBp dc.b $c7,$10,$20
0162:   dc.w 0,0
0163:   dc.w 0,0,$100,$100
0164:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0165: #endasm
0166: // ------------------------------------
0167: /*****************************************************************************
0168: ** Ci-dessous, le contenu du fichier batchfile pour l'image raquet.bmp **
0169: set image01=raquet.bmp
0170: SPRPCK -t6 -S008025 -a000012 -p0 %image01%
0171: cmd
0172: *****************************************************************************/
0173: extern uchar raquet[]; // image raquette, d'une taille de 8*24;
0174: uchar SCBr[];
0175: #asm
0176: _SCBr dc.b $c7,$10,$20
0177:   dc.w 0,0
0178:   dc.w 0,0,$100,$100
0179:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0180: #endasm
0181: // ------------------------------------
0182: // clip du sprite chiffres, chacun d'une taille de 8*8: 0123456789.LEV
0183: extern uchar bc000000[];
0184: extern uchar bc000001[];
0185: extern uchar bc000002[];
0186: extern uchar bc000003[];
0187: extern uchar bc000004[];
0188: extern uchar bc000005[];
0189: extern uchar bc000006[];
0190: extern uchar bc000007[];
0191: extern uchar bc000008[];
0192: extern uchar bc000009[];
0193: extern uchar bc000010[];
0194: extern uchar bc000011[];
0195: extern uchar bc000012[];
0196: extern uchar bc000013[];
0197:
0198: uchar *chiffrestab[14] = {bc000000, bc000001, bc000002, bc000003, bc000004,
0199:   bc000005, bc000006, bc000007, bc000008, bc000009,
0200:   bc000010, bc000011, bc000012, bc000013};
0201: uchar SCBchiffres1[]; // dï¿½claration d'un nouveau controleur de sprite (test)
0202: uchar SCBchiffres2[]; // dï¿½claration d'un nouveau controleur de sprite (test)
0203: uchar SCBchiffres3[]; // dï¿½claration d'un nouveau controleur de sprite (test)
0204: uchar SCBchiffres4[]; // dï¿½claration d'un nouveau controleur de sprite (test)
0205: uchar SCBchiffres5[]; // dï¿½claration d'un nouveau controleur de sprite (test)
0206:
0207: uchar SCBscore1[]; // dï¿½claration d'un nouveau controleur de sprite (score unitï¿½)
0208: uchar SCBscore2[]; // dï¿½claration d'un nouveau controleur de sprite (score dizaine)
0209: uchar SCBscore3[]; // dï¿½claration d'un nouveau controleur de sprite (score centaine)
0210: uchar SCBscore4[]; // dï¿½claration d'un nouveau controleur de sprite (score millier)
0211:
0212: uchar SCBtexte1[]; // dï¿½claration d'un nouveau controleur de sprite (level)
0213: uchar SCBtexte2[]; // dï¿½claration d'un nouveau controleur de sprite (level)
0214: uchar SCBtexte3[]; // dï¿½claration d'un nouveau controleur de sprite (level)
0215: uchar SCBtexte4[]; // dï¿½claration d'un nouveau controleur de sprite (level)
0216: uchar SCBtexte5[]; // dï¿½claration d'un nouveau controleur de sprite (level)
0217:
0218: uchar SCBlife[]; // dï¿½claration d'un nouveau controleur de sprite (score unitï¿½)
0219:
0220: uchar SCBl1[]; // dï¿½claration d'un nouveau controleur de sprite ( pause level 1)
0221: uchar SCBl2[]; // dï¿½claration d'un nouveau controleur de sprite (pause level 2)
0222: #asm
0223: _SCBchiffres1 dc.b $c7,$10,$20
0224:   dc.w 0,0
0225:   dc.w 0,0,$100,$100
0226:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0227: ;
0228: _SCBchiffres2 dc.b $c7,$10,$20
0229:   dc.w 0,0
0230:   dc.w 0,0,$100,$100
0231:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0232: ;
0233: _SCBchiffres3 dc.b $c7,$10,$20
0234:   dc.w 0,0
0235:   dc.w 0,0,$100,$100
0236:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0237: ;
0238: _SCBchiffres4 dc.b $c7,$10,$20
0239:   dc.w 0,0
0240:   dc.w 0,0,$100,$100
0241:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0242: ;
0243: _SCBchiffres5 dc.b $c7,$10,$20
0244:   dc.w 0,0
0245:   dc.w 0,0,$100,$100
0246:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0247: ;
0248: _SCBscore1 dc.b $c7,$10,$20
0249:   dc.w 0,0
0250:   dc.w 0,0,$100,$100
0251:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0252: ;
0253: _SCBscore2 dc.b $c7,$10,$20
0254:   dc.w 0,0
0255:   dc.w 0,0,$100,$100
0256:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0257: ;
0258: _SCBscore3 dc.b $c7,$10,$20
0259:   dc.w 0,0
0260:   dc.w 0,0,$100,$100
0261:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0262: ;
0263: _SCBscore4 dc.b $c7,$10,$20
0264:   dc.w 0,0
0265:   dc.w 0,0,$100,$100
0266:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0267: ;
0268: _SCBtexte1 dc.b $c7,$10,$20
0269:   dc.w 0,0
0270:   dc.w 0,0,$100,$100
0271:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0272: ;
0273: _SCBtexte2 dc.b $c7,$10,$20
0274:   dc.w 0,0
0275:   dc.w 0,0,$100,$100
0276:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0277: ;
0278: _SCBtexte3 dc.b $c7,$10,$20
0279:   dc.w 0,0
0280:   dc.w 0,0,$100,$100
0281:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0282: ;
0283: _SCBtexte4 dc.b $c7,$10,$20
0284:   dc.w 0,0
0285:   dc.w 0,0,$100,$100
0286:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0287: ;
0288: _SCBtexte5 dc.b $c7,$10,$20
0289:   dc.w 0,0
0290:   dc.w 0,0,$100,$100
0291:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0292: ;
0293: _SCBlife dc.b $c7,$10,$20
0294:   dc.w 0,0
0295:   dc.w 0,0,$100,$100
0296:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0297: ;
0298: _SCBl1 dc.b $c7,$10,$20
0299:   dc.w 0,0
0300:   dc.w 0,0,$100,$100
0301:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0302: ;
0303: _SCBl2 dc.b $c7,$10,$20
0304:   dc.w 0,0
0305:   dc.w 0,0,$100,$100
0306:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0307: #endasm
0308: // ------------------------------------
0309: // set image01=fdir.bmp
0310: // SPRPCK -t6 -S018015 -r007001 -o000000 -i126015 -p0 %image01% fd
0311: // cmd
0312: // clip du sprite fleches (7 images d'une taille de 18*15).
0313: extern uchar fd000000[];
0314: extern uchar fd000001[];
0315: extern uchar fd000002[];
0316: extern uchar fd000003[];
0317: extern uchar fd000004[];
0318: extern uchar fd000005[];
0319: extern uchar fd000006[];
0320:
0321: uchar *fdtab[7] = {fd000000, fd000001, fd000002, fd000003, fd000004,
0322:   fd000005, fd000006};
0323: uchar SCBfd[]; // dï¿½claration d'un nouveau controleur de sprite
0324: #asm
0325: _SCBfd dc.b $c7,$10,$20
0326:   dc.w 0,0
0327:   dc.w 0,0,$100,$100
0328:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0329: #endasm
0330: // ------------------------------------
0331: /*****************************************************************************
0332: ** Ci-dessous, le contenu du fichier batchfile pour l'image fball.bmp **
0333:   **
0334: set image01=fball.bmp
0335: SPRPCK -t6 -S005005 -r001001 -a002002 -p0 %image01%
0336: cmd
0337:   **
0338: ** Le point d'action de l'image fball est mis au centre de celle-ci, **
0339: ** 0 1 2 3 4 --> la valeur 2 correspond exactement au centre (-a002002) **
0340: *****************************************************************************/
0341:
0342: extern uchar fball[]; // image balle, d'une taille de 5*5;
0343: uchar SCBball[];
0344: #asm
0345: _SCBball dc.b $c7,$10,$20
0346:   dc.w 0,0
0347:   dc.w 0,0,$100,$100
0348:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0349: #endasm
0350: // ------------------------------------
0351: // ------------------------------------
0352:
0353: // clip du sprite brique, d'une taille de 10*14 : 0(dï¿½truite), 1(normale), 2(dure) et 3(incassable).
0354: extern uchar br000000[];
0355: extern uchar br000001[];
0356: extern uchar br000002[];
0357: extern uchar br000003[];
0358: extern uchar br000004[];
0359:
0360: uchar *brtab[5] = {br000000, br000001, br000002, br000003, br000004};
0361:
0362: // nombreuses dï¿½clarations des nouveaux controleurs de sprite pour les briques.
0363: uchar SCBbr01[];
0364: uchar SCBbr02[];
0365: uchar SCBbr03[];
0366: uchar SCBbr04[];
0367: uchar SCBbr05[];
0368: uchar SCBbr06[];
0369: uchar SCBbr07[];
0370: uchar SCBbr08[];
0371: uchar SCBbr09[];
0372: uchar SCBbr10[];
0373: uchar SCBbr11[];
0374: uchar SCBbr12[];
0375: uchar SCBbr13[];
0376: uchar SCBbr14[];
0377: uchar SCBbr15[];
0378: uchar SCBbr16[];
0379: uchar SCBbr17[];
0380: uchar SCBbr18[];
0381: uchar SCBbr19[];
0382: uchar SCBbr20[];
0383: uchar SCBbr21[];
0384: uchar SCBbr22[];
0385: uchar SCBbr23[];
0386: uchar SCBbr24[];
0387: uchar SCBbr25[];
0388: uchar SCBbrind[];
0389: #asm
0390: _SCBbr01 dc.b $c7,$10,$20
0391:   dc.w 0,0
0392:   dc.w 0,0,$100,$100
0393:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0394: ;
0395: _SCBbr02 dc.b $c7,$10,$20
0396:   dc.w 0,0
0397:   dc.w 0,0,$100,$100
0398:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0399: ;
0400: _SCBbr03 dc.b $c7,$10,$20
0401:   dc.w 0,0
0402:   dc.w 0,0,$100,$100
0403:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0404: ;
0405: _SCBbr04 dc.b $c7,$10,$20
0406:   dc.w 0,0
0407:   dc.w 0,0,$100,$100
0408:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0409: ;
0410: _SCBbr05 dc.b $c7,$10,$20
0411:   dc.w 0,0
0412:   dc.w 0,0,$100,$100
0413:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0414: ;
0415: _SCBbr06 dc.b $c7,$10,$20
0416:   dc.w 0,0
0417:   dc.w 0,0,$100,$100
0418:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0419: ;
0420: _SCBbr07 dc.b $c7,$10,$20
0421:   dc.w 0,0
0422:   dc.w 0,0,$100,$100
0423:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0424: ;
0425: _SCBbr08 dc.b $c7,$10,$20
0426:   dc.w 0,0
0427:   dc.w 0,0,$100,$100
0428:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0429: ;
0430: _SCBbr09 dc.b $c7,$10,$20
0431:   dc.w 0,0
0432:   dc.w 0,0,$100,$100
0433:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0434: ;
0435: _SCBbr10 dc.b $c7,$10,$20
0436:   dc.w 0,0
0437:   dc.w 0,0,$100,$100
0438:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0439: ;
0440: _SCBbr11 dc.b $c7,$10,$20
0441:   dc.w 0,0
0442:   dc.w 0,0,$100,$100
0443:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0444: ;
0445: _SCBbr12 dc.b $c7,$10,$20
0446:   dc.w 0,0
0447:   dc.w 0,0,$100,$100
0448:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0449: ;
0450: _SCBbr13 dc.b $c7,$10,$20
0451:   dc.w 0,0
0452:   dc.w 0,0,$100,$100
0453:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0454: ;
0455: _SCBbr14 dc.b $c7,$10,$20
0456:   dc.w 0,0
0457:   dc.w 0,0,$100,$100
0458:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0459: ;
0460: _SCBbr15 dc.b $c7,$10,$20
0461:   dc.w 0,0
0462:   dc.w 0,0,$100,$100
0463:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0464: ;
0465: _SCBbr16 dc.b $c7,$10,$20
0466:   dc.w 0,0
0467:   dc.w 0,0,$100,$100
0468:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0469: ;
0470: _SCBbr17 dc.b $c7,$10,$20
0471:   dc.w 0,0
0472:   dc.w 0,0,$100,$100
0473:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0474: ;
0475: _SCBbr18 dc.b $c7,$10,$20
0476:   dc.w 0,0
0477:   dc.w 0,0,$100,$100
0478:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0479: ;
0480: _SCBbr19 dc.b $c7,$10,$20
0481:   dc.w 0,0
0482:   dc.w 0,0,$100,$100
0483:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0484: ;
0485: _SCBbr20 dc.b $c7,$10,$20
0486:   dc.w 0,0
0487:   dc.w 0,0,$100,$100
0488:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0489: ;
0490: _SCBbr21 dc.b $c7,$10,$20
0491:   dc.w 0,0
0492:   dc.w 0,0,$100,$100
0493:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0494: ;
0495: _SCBbr22 dc.b $c7,$10,$20
0496:   dc.w 0,0
0497:   dc.w 0,0,$100,$100
0498:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0499: ;
0500: _SCBbr23 dc.b $c7,$10,$20
0501:   dc.w 0,0
0502:   dc.w 0,0,$100,$100
0503:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0504: ;
0505: _SCBbr24 dc.b $c7,$10,$20
0506:   dc.w 0,0
0507:   dc.w 0,0,$100,$100
0508:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0509: ;
0510: _SCBbr25 dc.b $c7,$10,$20
0511:   dc.w 0,0
0512:   dc.w 0,0,$100,$100
0513:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0514: ;
0515: _SCBbrind dc.b $c7,$10,$20
0516:   dc.w 0,0
0517:   dc.w 0,0,$100,$100
0518:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0519: #endasm
0520: // ------------------------------------ ouf !
0521:
0522: // ------------------------------------
0523: extern char ipause[]; // image pause, d'une taille de 13*43;
0524: char SCBip[];
0525: #asm
0526: _SCBip dc.b $c7,$10,$20
0527:   dc.w 0,0
0528:   dc.w 0,0,$100,$100
0529:   dc.b $01,$23,$45,$67,$89,$ab,$cd,$ef
0530: #endasm
0531: // ------------------------------------
0532:
0533:
0534:
0535:
0536: int posx,posy,level,score,dcore,dlife,compteur,xpush,ypush,relach,xind,yind,arfind;
0537: int i;
0538: char tempa,tempb,tempc,tempd,tempe,etape,filife,gspause,gsblip,mhaut,mbas; // de -128 ï¿½ 127
0539: int molescx,molescy;
0540: int atest,unite,dizaine,centaine,millier,dmillier,horszone;
0541:
0542: // ydirf --> dï¿½placer lï¿½gï¿½rement la flï¿½che.
0543: // dirf --> direction fleche de 0 ï¿½ 6, mais aussi direction Y de la balle (-3 -2 -1 0 +1 +2 +3) (ici gauche/droite car LYNX verticale).
0544: // bdirx --> direction X de la balle (ici haut/bas car le jeu se joue la LYNX tenu ï¿½ la verticale).
0545: char ydirf,dirf,bdirx,speedX,oboucl,basar,odirx,Xtemp,Ytemp,fsaut,upbri;
0546: int balldirX,balldirY,yplayer;
0547:
0548: int compti, comptx, compty;
0549: int tligne,nbrbriqx, nbrbriqy;
0550:
0551: // assembler vertical retrace syncronisation routine
0552: void Vsync()
0553: {
0554: #asm
0555: vretrace:
0556:  lda $fd0a
0557:  bne vretrace
0558: #endasm
0559: }
0560:
0561: // Hors de l'assembleur, point de salut...
0562: // L'utilisation de la procedure suivante, lors de l'ï¿½cran d'action,
0563: // fait ramer le jeu.
0564:
0565: void Fchiffres(clx,cly,classe)
0566: int clx,cly,classe;
0567:  {
0568:  SCBDATA(SCBchiffres1) = chiffrestab[classe%14];
0569:  SCBX(SCBchiffres1) = clx;
0570:  SCBY(SCBchiffres1) = cly;
0571:  DrawSprite(SCBchiffres1);
0572:  }
0573:
0574:
0575: // brique : ï¿½tat + coordonnï¿½es X et Y. brsco[25], bricol[5],
0576: int cible,ciblf,xycol, bbcontact, rebcot, brnbr, brie[25], brif[25], brix[5], briy[5]; // 5 car il y a 5 rangï¿½es de briques sur la mï¿½me ligne (ligne car ecran vertical).
0577:
0578:  uchar *brdata[25];//25 briques test en ligne
0579: // uchar *brdatb[25];//25 briques test en colonne
0580:  uchar *brsco[25];
0581:
0582:
0583: ShowScreen()
0584: {
0585:
0586:
0587:  brix[0] = 85-horszone;
0588:   SCBX(SCBbr01) = brix[0];
0589:
0590:   SCBX(SCBbr02) = brix[0];
0591:
0592:   SCBX(SCBbr03) = brix[0];
0593:
0594:   SCBX(SCBbr04) = brix[0];
0595:
0596:   SCBX(SCBbr05) = brix[0];
0597:
0598:
0599:  brix[1] = 95-horszone;
0600:   SCBX(SCBbr06) = brix[1];
0601:
0602:   SCBX(SCBbr07) = brix[1];
0603:
0604:   SCBX(SCBbr08) = brix[1];
0605:
0606:   SCBX(SCBbr09) = brix[1];
0607:
0608:   SCBX(SCBbr10) = brix[1];
0609:
0610:
0611:  brix[2] = 105-horszone;
0612:   SCBX(SCBbr11) = brix[2];
0613:
0614:   SCBX(SCBbr12) = brix[2];
0615:
0616:   SCBX(SCBbr13) = brix[2];
0617:
0618:   SCBX(SCBbr14) = brix[2];
0619:
0620:   SCBX(SCBbr15) = brix[2];
0621:
0622:
0623:  brix[3] = 115-horszone;
0624:   SCBX(SCBbr16) = brix[3];
0625:
0626:   SCBX(SCBbr17) = brix[3];
0627:
0628:   SCBX(SCBbr18) = brix[3];
0629:
0630:   SCBX(SCBbr19) = brix[3];
0631:
0632:   SCBX(SCBbr20) = brix[3];
0633:
0634:
0635:  brix[4] = 125-horszone;
0636:   SCBX(SCBbr21) = brix[4];
0637:
0638:   SCBX(SCBbr22) = brix[4];
0639:
0640:   SCBX(SCBbr23) = brix[4];
0641:
0642:   SCBX(SCBbr24) = brix[4];
0643:
0644:   SCBX(SCBbr25) = brix[4];
0645:
0646:
0647:  if (horszone>0)
0648:   {
0649:   horszone=horszone-4;
0650:   if (horszone<1) horszone=0;
0651:   }
0652:
0653: }
0654:
0655:
0656:
0657: /**************************************************************************
0658:
0659: ATTENTION : Ci-dessous des tableaux de valeurs : ces valeurs ne pourront pas ï¿½tre modifiï¿½ par la suite.
0660:
0661: La variable brie[25] sera donc utilisï¿½ pour modifier l'ï¿½tat des 25 briques.
0662: **************************************************************************/
0663:
0664: #include "fifi.h"
0665:
0666: /**************************************************************************
0667: ** **
0668: ** **
0669: **************************************************************************/
0670: char main()
0671: {
0672:   InitIRQ();
0673:   CLI;
0674:
0675:   SetBuffers(SCREEN, RENDER ,0);
0676:
0677:
0678:
0679:   posx=76;
0680:   posy=47;
0681:   xpush=-48;
0682:   ypush=34;
0683: // SCBX(SCB) = 60;
0684: // SCBY(SCB) = 42;
0685: // SCBDATA(SCB) = ititre;
0686:
0687: // 1er sprite chainï¿½ (fond + raquette)
0688:   SCBX(SCBg) = 0;
0689:   SCBY(SCBg) = 0;
0690:   SCBDATA(SCBg) = fondg;
0691:
0692:   SCBNEXT(SCBg) = SCBp; // chainage de sprite info commande
0693:   SCBX(SCBp) = xpush;
0694:   SCBY(SCBp) = ypush;
0695:   SCBDATA(SCBp) = pushup;
0696: //SCBCTL0(SCBp)= 0x001;//99; // pas glop
0697:   SCBNEXT(SCBp) = SCBr; // chainage de sprite raquette
0698:   SCBX(SCBr) = -200;
0699:   SCBY(SCBr) = 0;
0700:   SCBDATA(SCBr) = raquet;
0701:
0702:   SCBNEXT(SCBr) = SCBfd; // chainage de sprite fleche directionnelle
0703:   SCBX(SCBfd) = 0;
0704:   SCBY(SCBfd) = 0;
0705:   SCBDATA(SCBfd) = fdtab[dirf%7];//fleche;
0706:
0707: horszone=150;// mettre les briques hors de l'ï¿½cran visible. Sprite brique d'une taille de 6*14, 0=normale 1=dure 2=incassable.
0708:   SCBNEXT(SCBfd) = SCBbr01; // chainage de la brique 01
0709:   SCBX(SCBbr01) = 85-horszone;
0710:   SCBY(SCBbr01) = 16;
0711:   SCBDATA(SCBbr01) = brtab[0%5]; //
0712:   SCBNEXT(SCBbr01) = SCBbr02; // chainage de la brique 02
0713:   SCBX(SCBbr02) = 85-horszone;
0714:   SCBY(SCBbr02) = 16+14;
0715:   SCBDATA(SCBbr02) = brtab[0%5]; //
0716:   SCBNEXT(SCBbr02) = SCBbr03; // chainage de la brique 03
0717:   SCBX(SCBbr03) = 85-horszone;
0718:   SCBY(SCBbr03) = 16+28;
0719:   SCBDATA(SCBbr03) = brtab[0%5]; //
0720:   SCBNEXT(SCBbr03) = SCBbr04; // chainage de la brique 04
0721:   SCBX(SCBbr04) = 85-horszone;
0722:   SCBY(SCBbr04) = 16+42;
0723:   SCBDATA(SCBbr04) = brtab[0%5]; //
0724:   SCBNEXT(SCBbr04) = SCBbr05; // chainage de la brique 05
0725:   SCBX(SCBbr05) = 85-horszone;
0726:   SCBY(SCBbr05) = 16+56;
0727:   SCBDATA(SCBbr05) = brtab[0%5]; //
0728:
0729:   SCBNEXT(SCBbr05) = SCBbr06; // chainage de la brique 06
0730:   SCBX(SCBbr06) = 95-horszone;
0731:   SCBY(SCBbr06) = 16;
0732:   SCBDATA(SCBbr06) = brtab[0%5]; //
0733:   SCBNEXT(SCBbr06) = SCBbr07; // chainage de la brique 07
0734:   SCBX(SCBbr07) = 95-horszone;
0735:   SCBY(SCBbr07) = 16+14;
0736:   SCBDATA(SCBbr07) = brtab[0%5]; //
0737:   SCBNEXT(SCBbr07) = SCBbr08; // chainage de la brique 08
0738:   SCBX(SCBbr08) = 95-horszone;
0739:   SCBY(SCBbr08) = 16+28;
0740:   SCBDATA(SCBbr08) = brtab[0%5]; //
0741:   SCBNEXT(SCBbr08) = SCBbr09; // chainage de la brique 09
0742:   SCBX(SCBbr09) = 95-horszone;
0743:   SCBY(SCBbr09) = 16+42;
0744:   SCBDATA(SCBbr09) = brtab[0%5]; //
0745:   SCBNEXT(SCBbr09) = SCBbr10; // chainage de la brique 10
0746:   SCBX(SCBbr10) = 95-horszone;
0747:   SCBY(SCBbr10) = 16+56;
0748:   SCBDATA(SCBbr10) = brtab[0%5]; //
0749:
0750:   SCBNEXT(SCBbr10) = SCBbr11; // chainage de la brique 11
0751:   SCBX(SCBbr11) = 105-horszone;
0752:   SCBY(SCBbr11) = 16;
0753:   SCBDATA(SCBbr11) = brtab[0%5]; //
0754:   SCBNEXT(SCBbr11) = SCBbr12; // chainage de la brique 12
0755:   SCBX(SCBbr12) = 105-horszone;
0756:   SCBY(SCBbr12) = 16+14;
0757:   SCBDATA(SCBbr12) = brtab[0%5]; //
0758:   SCBNEXT(SCBbr12) = SCBbr13; // chainage de la brique 13
0759:   SCBX(SCBbr13) = 105-horszone;
0760:   SCBY(SCBbr13) = 16+28;
0761:   SCBDATA(SCBbr13) = brtab[0%5]; //
0762:   SCBNEXT(SCBbr13) = SCBbr14; // chainage de la brique 14
0763:   SCBX(SCBbr14) = 105-horszone;
0764:   SCBY(SCBbr14) = 16+42;
0765:   SCBDATA(SCBbr14) = brtab[0%5]; //
0766:   SCBNEXT(SCBbr14) = SCBbr15; // chainage de la brique 15
0767:   SCBX(SCBbr15) = 105-horszone;
0768:   SCBY(SCBbr15) = 16+56;
0769:   SCBDATA(SCBbr15) = brtab[0%5]; //
0770:
0771:   SCBNEXT(SCBbr15) = SCBbr16; // chainage de la brique 16
0772:   SCBX(SCBbr16) = 115-horszone;
0773:   SCBY(SCBbr16) = 16;
0774:   SCBDATA(SCBbr16) = brtab[0%5]; //
0775:   SCBNEXT(SCBbr16) = SCBbr17; // chainage de la brique 17
0776:   SCBX(SCBbr17) = 115-horszone;
0777:   SCBY(SCBbr17) = 16+14;
0778:   SCBDATA(SCBbr17) = brtab[0%5]; //
0779:   SCBNEXT(SCBbr17) = SCBbr18; // chainage de la brique 18
0780:   SCBX(SCBbr18) = 115-horszone;
0781:   SCBY(SCBbr18) = 16+28;
0782:   SCBDATA(SCBbr18) = brtab[0%5]; //
0783:   SCBNEXT(SCBbr18) = SCBbr19; // chainage de la brique 19
0784:   SCBX(SCBbr19) = 115-horszone;
0785:   SCBY(SCBbr19) = 16+42;
0786:   SCBDATA(SCBbr19) = brtab[0%5]; //
0787:   SCBNEXT(SCBbr19) = SCBbr20; // chainage de la brique 15
0788:   SCBX(SCBbr20) = 115-horszone;
0789:   SCBY(SCBbr20) = 16+56;
0790:   SCBDATA(SCBbr20) = brtab[0%5]; //
0791:
0792:   SCBNEXT(SCBbr20) = SCBbr21; // chainage de la brique 21
0793:   SCBX(SCBbr21) = 125-horszone;
0794:   SCBY(SCBbr21) = 16;
0795:   SCBDATA(SCBbr21) = brtab[0%5]; //
0796:   SCBNEXT(SCBbr21) = SCBbr22; // chainage de la brique 22
0797:   SCBX(SCBbr22) = 125-horszone;
0798:   SCBY(SCBbr22) = 16+14;
0799:   SCBDATA(SCBbr22) = brtab[0%5]; //
0800:   SCBNEXT(SCBbr22) = SCBbr23; // chainage de la brique 23
0801:   SCBX(SCBbr23) = 125-horszone;
0802:   SCBY(SCBbr23) = 16+28;
0803:   SCBDATA(SCBbr23) = brtab[0%5]; //
0804:   SCBNEXT(SCBbr23) = SCBbr24; // chainage de la brique 24
0805:   SCBX(SCBbr24) = 125-horszone;
0806:   SCBY(SCBbr24) = 16+42;
0807:   SCBDATA(SCBbr24) = brtab[0%5]; //
0808:   SCBNEXT(SCBbr24) = SCBbr25; // chainage de la brique 25
0809:   SCBX(SCBbr25) = 125-horszone;
0810:   SCBY(SCBbr25) = 16+56;
0811:   SCBDATA(SCBbr25) = brtab[0%5]; //
0812:
0813:   SCBNEXT(SCBbr25) = SCBbrind; // chainage du cache de la brique indestructible
0814:   SCBX(SCBbrind) = 0;
0815:   SCBY(SCBbrind) = -20;
0816:   SCBDATA(SCBbrind) = brtab[4%5]; //
0817:
0818:   SCBNEXT(SCBbrind) = SCBball; // chainage de sprite balle
0819:   SCBX(SCBball) = -200;
0820:   SCBY(SCBball) = 0;
0821:   SCBDATA(SCBball) = fball;
0822:
0823:   SCBNEXT(SCBball) = SCBscore1; // chainage score unitï¿½
0824:   SCBX(SCBscore1) = -10;
0825:   SCBY(SCBscore1) = 99-8;
0826:   SCBDATA(SCBscore1) = chiffrestab[0%14]; //
0827:   SCBNEXT(SCBscore1) = SCBscore2; // chainage score dizaine
0828:   SCBX(SCBscore2) = -10;
0829:   SCBY(SCBscore2) = 99-16;
0830:   SCBDATA(SCBscore2) = chiffrestab[0%14]; //
0831:   SCBNEXT(SCBscore2) = SCBscore3; // chainage score centaine
0832:   SCBX(SCBscore3) = -10;
0833:   SCBY(SCBscore3) = 99-24;
0834:   SCBDATA(SCBscore3) = chiffrestab[0%14]; //
0835:   SCBNEXT(SCBscore3) = SCBscore4; // chainage score millier
0836:   SCBX(SCBscore4) = -10;
0837:   SCBY(SCBscore4) = 99-32;
0838:   SCBDATA(SCBscore4) = chiffrestab[0%14]; //
0839:
0840:   SCBNEXT(SCBscore4) = SCBlife; // chainage nombre de vie
0841:   SCBY(SCBlife) = 9;
0842:
0843:
0844:   //SCBX(SCBscore1) = -10;SCBX(SCBscore2) = -10;SCBX(SCBscore3) = -10;SCBX(SCBscore4) = -10; // score placï¿½s hors de l'ï¿½cran
0845:
0846:   SCBNEXT(SCBlife) = SCBtexte1; // chainage texte 1
0847:   SCBX(SCBtexte1) = 0;SCBY(SCBtexte1) = -200;
0848:   SCBDATA(SCBtexte1) = chiffrestab[0%14]; //
0849:
0850:   SCBNEXT(SCBtexte1) = SCBtexte2; // chainage texte 2
0851:   SCBX(SCBtexte2) = 0;SCBY(SCBtexte2) = -200;
0852:   SCBDATA(SCBtexte2) = chiffrestab[0%14]; //
0853:
0854:   SCBNEXT(SCBtexte2) = SCBtexte3; // chainage texte 3
0855:   SCBX(SCBtexte3) = 0;SCBY(SCBtexte3) = -200;
0856:   SCBDATA(SCBtexte3) = chiffrestab[0%14]; //
0857:
0858:   SCBNEXT(SCBtexte3) = SCBtexte4; // chainage texte 4
0859:   SCBX(SCBtexte4) = 0;SCBY(SCBtexte4) = -200;
0860:   SCBDATA(SCBtexte4) = chiffrestab[0%14]; //
0861:
0862:   SCBNEXT(SCBtexte4) = SCBtexte5; // chainage texte 3
0863:   SCBX(SCBtexte5) = 0;SCBY(SCBtexte5) = -200;
0864:   SCBDATA(SCBtexte5) = chiffrestab[0%14]; //
0865:
0866:
0867:
0868:
0869:   SCBNEXT(SCBtexte5) = SCBip; // chainage pause
0870:   SCBX(SCBip) = 147;SCBY(SCBip) = -200;
0871:   SCBDATA(SCBip) = ipause; //
0872:
0873:
0874:   SCBNEXT(SCBip) = SCBl1; // chainage texte level 1
0875:   SCBX(SCBl1) = 0;SCBY(SCBl1) = -200;
0876:   SCBDATA(SCBl1) = chiffrestab[0%14]; //
0877:
0878:   SCBNEXT(SCBl1) = SCBl2; // chainage texte level 2
0879:   SCBX(SCBl2) = 0;SCBY(SCBl2) = -200;
0880:   SCBDATA(SCBl2) = chiffrestab[0%14]; //
0881:
0882:
0883: // 2ï¿½me sprite chainï¿½ (test)
0884:   SCBX(SCBchiffres1) = 0;SCBY(SCBchiffres1) = 0;
0885:   //SCBDATA(SCBchiffres1) = chiffres;
0886:   SCBNEXT(SCBchiffres1) = SCBchiffres2; // chainage de sprite
0887:   SCBX(SCBchiffres2) = 0;SCBY(SCBchiffres2) = 0;
0888:   //SCBDATA(SCBchiffres2) = chiffres;
0889:   SCBNEXT(SCBchiffres2) = SCBchiffres3; // chainage de sprite
0890:   SCBX(SCBchiffres3) = 0;SCBY(SCBchiffres3) = 0;
0891:   //SCBDATA(SCBchiffres3) = chiffres;
0892:   SCBNEXT(SCBchiffres3) = SCBchiffres4; // chainage de sprite
0893:   SCBX(SCBchiffres4) = 0;SCBY(SCBchiffres4) = 0;
0894:   SCBNEXT(SCBchiffres4) = SCBchiffres5; // chainage de sprite
0895:   SCBX(SCBchiffres5) = 0;SCBY(SCBchiffres5) = 0;
0896:
0897:
0898: // truc bien pratique : associer les briques des tableaux ï¿½ une variable numï¿½rotï¿½.
0899: brdata[0] = SCBbr01;brdata[1] = SCBbr02;brdata[2] = SCBbr03;brdata[3] = SCBbr04;brdata[4] = SCBbr05;
0900: brdata[5] = SCBbr06;brdata[6] = SCBbr07;brdata[7] = SCBbr08;brdata[8] = SCBbr09;brdata[9] = SCBbr10;
0901: brdata[10] = SCBbr11;brdata[11] = SCBbr12;brdata[12] = SCBbr13;brdata[13] = SCBbr14;brdata[14] = SCBbr15;
0902: brdata[15] = SCBbr16;brdata[16] = SCBbr17;brdata[17] = SCBbr18;brdata[18] = SCBbr19;brdata[19] = SCBbr20;
0903: brdata[20] = SCBbr21;brdata[21] = SCBbr22;brdata[22] = SCBbr23;brdata[23] = SCBbr24;brdata[24] = SCBbr25;
0904:
0905:
0906: briy[0] = 16;
0907: briy[1] = 30;
0908: briy[2] = 44;
0909: briy[3] = 58;
0910: briy[4] = 72;
0911: /**************************************************************************
0912:  ï¿½a marche !
0913:   comptx=0;
0914:   SCBDATA(brdata[comptx]) = brtab[tbr01[0][0]%3];
0915:   comptx=1;
0916:   SCBDATA(brdata[comptx]) = brtab[tbr01[0][1]%3];
0917:   comptx=2;
0918:   SCBDATA(brdata[comptx]) = brtab[tbr01[0][2]%3];
0919:   comptx=3;
0920:   SCBDATA(brdata[comptx]) = brtab[tbr01[0][3]%3];
0921:   comptx=4;
0922:   SCBDATA(brdata[comptx]) = brtab[tbr01[0][4]%3];
0923: **************************************************************************/
0924:
0925: /**************************************************************************
0926:  ï¿½a marche !
0927:  for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5. 1ere rangï¿½e de brique
0928:   {
0929:   SCBDATA(brdata[comptx]) = brtab[tbr01[0][comptx]%3];
0930:   }
0931:  for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5. 2eme rangï¿½e de brique
0932:   {
0933:   SCBDATA(brdata[(comptx+5)]) = brtab[tbr01[1][comptx]%3];
0934:   }
0935:  for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5. 3eme rangï¿½e de brique
0936:   {
0937:   SCBDATA(brdata[(comptx+10)]) = brtab[tbr01[2][comptx]%3];
0938:   }
0939:  for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5. 4eme rangï¿½e de brique
0940:   {
0941:   SCBDATA(brdata[(comptx+15)]) = brtab[tbr01[3][comptx]%3];
0942:   }
0943:  for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5. 5eme rangï¿½e de brique
0944:   {
0945:   SCBDATA(brdata[(comptx+20)]) = brtab[tbr01[4][comptx]%3];
0946:   }
0947: **/
0948:
0949: /**************************************************************************
0950:  ï¿½a marche !
0951:  for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5. 1ere rangï¿½e de brique
0952:   {
0953:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
0954:   {
0955:   SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr01[compty][comptx]%3];
0956:   }
0957:   }
0958: **/
0959:
0960: /**************************************************************************
0961: ** BOUCLE PRINCIPALE **
0962: **************************************************************************/
0963:   while(1)
0964: {
0965: // for( ; ; )
0966:
0967:   Vsync();
0968:   SwapBuffers();
0969: update_music(); // petite subtilitï¿½ de la gestion sonore
0970:
0971:
0972:
0973:
0974:
0975:  ++gsblip; // economie ressource machine --> certaines des conditions n'ont pas besoin d'ï¿½tre lu par la LYNX ï¿½ chaque boucle.
0976:  if (gsblip==5)
0977:  {
0978:   gsblip=1;
0979:
0980:   /** affichage du score et nombre de vie:**/
0981:   unite = score % 10;
0982:   dizaine = score / 10 % 10;
0983:   centaine = score / 100 % 10;
0984:   millier = score / 1000 % 10;
0985:   // unitï¿½:
0986:   SCBDATA(SCBscore1) = chiffrestab[unite%14];
0987:   // dizaine:
0988:   SCBDATA(SCBscore2) = chiffrestab[dizaine%14];
0989:   // centaine:
0990:   SCBDATA(SCBscore3) = chiffrestab[centaine%14];
0991:   // millier:
0992:   SCBDATA(SCBscore4) = chiffrestab[millier%14];
0993:
0994:
0995:   unite = filife % 10;
0996:   SCBDATA(SCBlife) = chiffrestab[unite%14];
0997:
0998:
0999:
1000:  if (switches & BUTTON_PAUSE)
1001:   {
1002:   if (gspause==0) {gspause=1;silence();abcmusic(0,abcaptvir);}
1003:   }
1004:  if (!(switches & BUTTON_PAUSE))
1005:   {
1006:   if (gspause==1) gspause=2;
1007:   }
1008:
1009:  if (switches & BUTTON_PAUSE)
1010:   {
1011:   if (gspause==2) gspause=3;
1012:   }
1013:
1014:  if (!(switches & BUTTON_PAUSE))
1015:   {
1016:   if (gspause==3) gspause=0;
1017:   }
1018:
1019:  if (dcore>0) // score
1020:   {
1021:   score=score+dcore; // augmente le score
1022:   dlife=dlife+dcore; // dlife ---> cette variable va dï¿½terminer si le joueur va gagner une raquette supplï¿½mentaire...
1023:   dcore=0;
1024:   if (dlife>499 & filife<9) // ... chaque 200 points.
1025:   {
1026:   dlife=0;
1027:   for(compteur=0 ; compteur<40; compteur++) // de 0 ï¿½ 39
1028:   {
1029:   if (dlife>=(compteur*500))
1030:   {
1031:   //if (filife<9) {abcmusic(3,uplif);++filife;} // gagne une raquette chaque 100 points;
1032:   if (filife<9) {abcmusic(3,abcaptvir);++filife;} // gagne une raquette chaque 200 points;
1033:
1034:   }
1035:   }
1036:   }
1037:
1038:   }
1039:   if (etape==30) // ï¿½cran jeu 2 : sï¿½curitï¿½: si la balle se coince, alors le joueur peut perdre une raquette volontairement.
1040:   {
1041:   if (joystick & BUTTON_LEFT)
1042:   {
1043:   if (joystick & BUTTON_RIGHT)
1044:   {
1045:   etape=50;gsblip=1;--filife; // aie !
1046:   }
1047:   }
1048:   }
1049:
1050:  }
1051:
1052:
1053:
1054: /**************************************************************************
1055: **************************************************************************/
1056:  if (etape>=0 & etape<=4) // ï¿½cran titre
1057:  {
1058:   /* set the palette */
1059:  SetRGB(pali); // Ceci sert ï¿½ changer la palette de la Lynx.
1060:  DrawFBox(0,0,160,102,0); // couleur 0 (noire)
1061:
1062:  SCBX(SCBlife) = -10;SCBDATA(SCBlife) = chiffrestab[3%14]; //
1063:
1064:  SCBX(SCBr) = -200; // raquette mis hors de l'ï¿½cran
1065:  SCBX(SCBball) = -200; // balle mis hors de l'ï¿½cran
1066:  SCBX(SCBfd) = -200; // fleche directionnelle mis hors de l'ï¿½cran
1067:
1068:
1069:  //SCBX(SCB) = 78-(molescx/gmole);SCBY(SCB) = 42-(molescy/gmole)
1070:
1071:  //SCBX(SCB) = SCBX(SCB) - (molescx/6); SCBY(SCB) = SCBY(SCB) - (molescy/6);
1072:  SCBX(SCB) = 78; SCBY(SCB) = 52;
1073:  SCBDATA(SCB) = imole;
1074:
1075: // SCBY(SCBacteur) = yacteur-(actscy/4);
1076: // SCBY(SCBacteur) = SCBY(SCBacteur) + 16;
1077:
1078:   //SCBHS(SCB) = 0x100;
1079:   //SCBVS(SCB) = 0x100;
1080:
1081: if (gspause==0)
1082:  {
1083:
1084: /**
1085:  etape=1;molescx=256;molescy=256;
1086: **/
1087:
1088:
1089: /**
1090:
1091:  if (etape==4) {
1092:   if (molescx>256) molescx=molescx-4;
1093:   if (molescy>128) molescy=molescy-8;
1094:   if (molescx<257 & molescy<129) {molescx=256;molescy=128;etape=2;mhaut=4;}
1095:   }
1096:  if (etape==3) {
1097:   if (molescx>128) molescx=molescx-8;
1098:   if (molescy>256) molescy=molescy-4;
1099:   if (molescx<129 & molescy<257) {molescx=128;molescy=256;etape=2;mbas=4;}
1100:   }
1101:  if (etape==2) {
1102:   if (molescx<384) molescx=molescx+(4+mbas);
1103:   if (molescy<384) molescy=molescy+(4+mhaut);
1104:   if (molescx>383 & molescy>383)
1105:   {
1106:   molescx=384;molescy=384;++tempc;mhaut=0;mbas=0;
1107:   if (tempc==3) tempc=1;
1108:   if (tempc==1) etape=3;
1109:   if (tempc==2) etape=4;
1110:   }
1111:   }
1112:  if (etape==1) {
1113:   ++tempb;
1114:   if (tempb>64) {
1115:   tempb=0;etape=2;
1116:   }
1117:   }
1118:  if (etape==0) {
1119:   if (molescx<256) {
1120:   molescx=molescx+2;molescy=molescy+2;
1121:   if (molescx>255) {molescx=256;molescy=256;etape=1;}
1122:   }
1123:   }
1124: **/
1125:  switch (etape)
1126:   {
1127:   case 0:
1128:   molescx=molescx+2;molescy=molescy+2;
1129:   break;
1130:   }
1131:  if (molescx>255) {molescx=256;molescy=256;etape=1;}
1132:
1133:
1134:
1135:  SCBY(SCBip) = -50;
1136:  }// if (gspause==0)
1137:  else
1138:  {
1139:  SCBY(SCBip) = 30; // coordonnï¿½es image pause
1140:  }
1141:
1142:
1143:
1144:  SCBHS(SCB) = molescx;
1145:  SCBVS(SCB) = molescy;
1146:  DrawSprite(SCB); // affichage molecule
1147:
1148:  if (etape>0) {SCBHS(SCB) = 256;SCBVS(SCB) = 256;} // remise ï¿½ 0 echelle des images SCB
1149:  SCBX(SCB) = 34; SCBY(SCB) = 2; SCBDATA(SCB) = iname; DrawSprite(SCB);
1150:  SCBX(SCB) = 74; SCBY(SCB) = 26; SCBDATA(SCB) = ititre; DrawSprite(SCB);
1151:
1152: //
1153:  SCBX(SCBscore1) = 4;SCBX(SCBscore2) = 4;SCBX(SCBscore3) = 4;SCBX(SCBscore4) = 4;SCBX(SCBscore1) = 4;
1154:  SCBDATA(SCBscore1) = chiffrestab[1%14];
1155:  SCBDATA(SCBscore2) = chiffrestab[1%14];
1156:  SCBDATA(SCBscore3) = chiffrestab[0%14];
1157:  SCBDATA(SCBscore4) = chiffrestab[2%14];
1158:
1159:
1160:  SCBX(SCBp) = xpush;//48;
1161:  SCBY(SCBp) = ypush;
1162:
1163:  SCBY(SCBg) = -200; // fond zone de jeu
1164:  SCBX(SCBr) = -200; // raquette
1165:
1166:  DrawSprite(SCBg); // Affichage fond jeu + info commande + raquette + balle + fleche directionnelle + briques + score + texte + pause
1167:
1168:  if (gspause==0 & etape>0)
1169:   {
1170:   if (xpush<8) xpush=xpush+2; // apparition de la bulle info "Push UP"
1171:   if (xpush>7)//(tempa>24 & etape==0) // petite teporisation avant d'autoriser le joueur de recommencer le jeu.
1172:   {
1173:   xpush=8;
1174:   ++tempa; // bulle info clignote doucement
1175:   if (tempa>63) tempa=1;
1176:   if (tempa>0 & tempa<32) ypush=34;
1177:   if (tempa>31) ypush=-100;
1178:
1179:   if (joystick & JOY_RIGHT)
1180:   {
1181:   level=1;//1;//7;//1;//3;//1;
1182:   tempa=0;tempb=0;etape=9;//xpush=-48;ypush=34;xlvla=160;xlvlb=160;xlvlc=160;xlvld=160;xlvle=160;elvl=0;
1183:   xpush=-48;ypush=34;
1184:   score=0;dcore=0;filife=3;dlife=0;
1185:
1186:
1187:   // bruitage menu :
1188:   silence();
1189:   abcmusic(0,abcmenu1);
1190:   abcmusic(1,abcmenu2);
1191:
1192:
1193:   SetRGB(palg); // Ceci sert ï¿½ changer la palette de la Lynx.
1194:   SCBY(SCBg) = 0; // fond zone de jeu.
1195:   SCBX(SCBp) = xpush;
1196:   relach=1;
1197:
1198:   SCBDATA(SCBscore1) = chiffrestab[0%14];
1199:   SCBDATA(SCBscore2) = chiffrestab[0%14];
1200:   SCBDATA(SCBscore3) = chiffrestab[0%14];
1201:   SCBDATA(SCBscore4) = chiffrestab[0%14];
1202:
1203:
1204:
1205:
1206:
1207:
1208:
1209:   }
1210:   }
1211:   }
1212:  //TextOut(24, 2, 2, 0, "Philippe Haouli present"); // lettre grise 32,32,32
1213:  //TextOut(24, 2, 1, 0, "Philippe Haouli"); // lettre blanche
1214:
1215:  }
1216:
1217: /**************************************************************************
1218: **************************************************************************/
1219:  if (etape==9) // coordonnï¿½es affichage texte "LEVEL", et surtout application des choix de la nature des briques (voir tables de donnï¿½es plus haut).
1220:  {
1221:  ++etape;
1222:   SCBX(SCBtexte1) = 140; SCBY(SCBtexte1) = 18; SCBDATA(SCBtexte1) = chiffrestab[11%14]; // L
1223:   SCBX(SCBtexte2) = 140; SCBY(SCBtexte2) = 26; SCBDATA(SCBtexte2) = chiffrestab[12%14]; // E
1224:   SCBX(SCBtexte3) = 140; SCBY(SCBtexte3) = 34; SCBDATA(SCBtexte3) = chiffrestab[13%14]; // V
1225:   SCBX(SCBtexte4) = 140; SCBY(SCBtexte4) = 42; SCBDATA(SCBtexte4) = chiffrestab[12%14]; // E
1226:   SCBX(SCBtexte5) = 140; SCBY(SCBtexte5) = 50; SCBDATA(SCBtexte5) = chiffrestab[11%14]; // L
1227:
1228:  if (level>0 & level<13)
1229:   {
1230:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1231:   {
1232:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1233:   {
1234:   if (level==1) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr01[compty][comptx]%5];
1235:   if (level==2) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr02[compty][comptx]%5];
1236:   if (level==3) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr03[compty][comptx]%5];
1237:   if (level==4) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr04[compty][comptx]%5];
1238:   if (level==5) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr05[compty][comptx]%5];
1239:
1240:   if (level==6) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr06[compty][comptx]%5];
1241:   if (level==7) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr07[compty][comptx]%5];
1242:   if (level==8) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr08[compty][comptx]%5];
1243:   if (level==9) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr09[compty][comptx]%5];
1244:   if (level==10) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr10[compty][comptx]%5];
1245:
1246:   if (level==11) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr11[compty][comptx]%5];
1247:   if (level==12) SCBDATA(brdata[comptx+(compty*5)]) = brtab[tbr12[compty][comptx]%5];
1248:   }
1249:   }
1250: //brsco=25;// nombre initial de brique ï¿½ casser
1251: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1252:   if (level==1)
1253:   {
1254: /************************************************************************** ok
1255: **************************************************************************/
1256:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1257:   {
1258:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1259:   {
1260:   brie[brnbr]=tbr01[comptx][compty];
1261:   ++brnbr;
1262:   //if (brie[brnbr]==0 | brie[brnbr]==3) --brsco; // nombre de brique ï¿½ casser
1263:   //if (brie[brnbr]==0) --brsco; // nombre de brique ï¿½ casser
1264:   //if (brie[brnbr]==3) --brsco; // nombre de brique ï¿½ casser
1265:   }
1266:   }
1267: /**
1268: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1269:
1270:
1271:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1272:   {
1273:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1274:   {
1275:   brif[brnbr]=tbr01[comptx][compty];
1276:   ++brnbr;
1277:   }
1278:   }
1279: **/
1280: /************************************************************************** ok
1281:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1282:   {
1283:   brif[compty]=tbr01[compty][0];
1284:   }
1285:
1286:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1287:   {
1288:   brie[compty]=tbr01[0][compty];
1289:   }
1290:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1291:   {
1292:   brie[compty+5]=tbr01[1][compty];
1293:   }
1294:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1295:   {
1296:   brie[compty+10]=tbr01[2][compty];
1297:   }
1298:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1299:   {
1300:   brie[compty+15]=tbr01[3][compty];
1301:   }
1302:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1303:   {
1304:   brie[compty+20]=tbr01[4][compty];
1305:   }
1306: **************************************************************************/
1307:
1308: /************************************************************************** ok
1309:   brif[0]=tbr01[0][0];
1310:   brif[1]=tbr01[1][0];
1311:   brif[2]=tbr01[2][0];
1312:   brif[3]=tbr01[3][0];
1313:   brif[4]=tbr01[4][0];
1314:
1315:   brif[5]=tbr01[1][1];
1316:   brif[6]=tbr01[1][1];
1317:   brif[7]=tbr01[1][2];
1318:   brif[8]=tbr01[1][3];
1319:   brif[9]=tbr01[1][4];
1320:
1321:   brie[0]=tbr01[0][0];
1322:   brie[1]=tbr01[0][1];
1323:   brie[2]=tbr01[0][2];
1324:   brie[3]=tbr01[0][3];
1325:   brie[4]=tbr01[0][4];
1326:
1327:   brie[5]=tbr01[1][1];
1328:   brie[6]=tbr01[1][1];
1329:   brie[7]=tbr01[1][2];
1330:   brie[8]=tbr01[1][3];
1331:   brie[9]=tbr01[1][4];
1332:
1333:   brie[10]=tbr01[2][1];
1334:   brie[11]=tbr01[2][1];
1335:   brie[12]=tbr01[2][2];
1336:   brie[13]=tbr01[2][3];
1337:   brie[14]=tbr01[2][4];
1338:
1339:   brie[15]=tbr01[3][1];
1340:   brie[16]=tbr01[3][1];
1341:   brie[17]=tbr01[3][2];
1342:   brie[18]=tbr01[3][3];
1343:   brie[19]=tbr01[3][4];
1344:
1345:   brie[20]=tbr01[4][1];
1346:   brie[21]=tbr01[4][1];
1347:   brie[22]=tbr01[4][2];
1348:   brie[23]=tbr01[4][3];
1349:   brie[24]=tbr01[4][4];
1350: **************************************************************************/
1351:   }
1352: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1353:   if (level==2)
1354:   {
1355:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1356:   {
1357:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1358:   {
1359:   brie[brnbr]=tbr02[comptx][compty];
1360:   ++brnbr;
1361:   }
1362:   }
1363:   }
1364: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1365:   if (level==3)
1366:   {
1367:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1368:   {
1369:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1370:   {
1371:   brie[brnbr]=tbr03[comptx][compty];
1372:   ++brnbr;
1373:   }
1374:   }
1375:   }
1376: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1377:   if (level==4)
1378:   {
1379:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1380:   {
1381:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1382:   {
1383:   brie[brnbr]=tbr04[comptx][compty];
1384:   ++brnbr;
1385:   }
1386:   }
1387:   }
1388: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1389:   if (level==5)
1390:   {
1391:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1392:   {
1393:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1394:   {
1395:   brie[brnbr]=tbr05[comptx][compty];
1396:   ++brnbr;
1397:   }
1398:   }
1399:   }
1400: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1401:   if (level==6)
1402:   {
1403:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1404:   {
1405:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1406:   {
1407:   brie[brnbr]=tbr06[comptx][compty];
1408:   ++brnbr;
1409:   }
1410:   }
1411:   }
1412: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1413:   if (level==7)
1414:   {
1415:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1416:   {
1417:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1418:   {
1419:   brie[brnbr]=tbr07[comptx][compty];
1420:   ++brnbr;
1421:   }
1422:   }
1423:   }
1424: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1425:   if (level==8)
1426:   {
1427:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1428:   {
1429:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1430:   {
1431:   brie[brnbr]=tbr08[comptx][compty];
1432:   ++brnbr;
1433:   }
1434:   }
1435:   }
1436: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1437:   if (level==9)
1438:   {
1439:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1440:   {
1441:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1442:   {
1443:   brie[brnbr]=tbr09[comptx][compty];
1444:   ++brnbr;
1445:   }
1446:   }
1447:   }
1448: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1449:   if (level==10)
1450:   {
1451:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1452:   {
1453:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1454:   {
1455:   brie[brnbr]=tbr10[comptx][compty];
1456:   ++brnbr;
1457:   }
1458:   }
1459:   }
1460: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1461:   if (level==11)
1462:   {
1463:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1464:   {
1465:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1466:   {
1467:   brie[brnbr]=tbr11[comptx][compty];
1468:   ++brnbr;
1469:   }
1470:   }
1471:   }
1472: brnbr=0; // ï¿½tat des briques, de 0 ï¿½ 24.
1473:   if (level==12)
1474:   {
1475:   for(comptx=0 ; comptx<5; comptx++) // de 0 ï¿½ 4, ce qui fait 5.
1476:   {
1477:   for(compty=0 ; compty<5; compty++) // de 0 ï¿½ 4, ce qui fait 5.
1478:   {
1479:   brie[brnbr]=tbr12[comptx][compty];
1480:   ++brnbr;
1481:   }
1482:   }
1483:   }
1484:   brsco[0]=19; // nombre de brique ï¿½ casser
1485:   brsco[1]=19; // nombre de brique ï¿½ casser
1486:   brsco[2]=20; // nombre de brique ï¿½ casser
1487:   brsco[3]=15; // nombre de brique ï¿½ casser
1488:   brsco[4]=17; // nombre de brique ï¿½ casser
1489:   brsco[5]=15; // nombre de brique ï¿½ casser
1490:   brsco[6]=15; // nombre de brique ï¿½ casser
1491:   brsco[7]=16; // nombre de brique ï¿½ casser
1492:   brsco[8]=12; // nombre de brique ï¿½ casser
1493:   brsco[9]=14; // nombre de brique ï¿½ casser
1494:   brsco[10]=15; // nombre de brique ï¿½ casser
1495:   brsco[11]=12; // nombre de brique ï¿½ casser
1496:   }
1497:
1498:
1499:  }
1500:
1501:
1502: /**************************************************************************
1503: **************************************************************************/
1504:  if (etape==10) // ecran level
1505:  {
1506:
1507:  ShowScreen(); // Coordonnï¿½es de toutes les briques (voir au dï¿½but de ce joyeux code).
1508:
1509:  SCBX(SCBp) = xpush;//48;
1510:  SCBY(SCBp) = ypush;
1511:
1512:  SCBX(SCBr) = -200; // Coordonnï¿½e X de la raquette (ici mis hors de l'ï¿½cran).
1513:  DrawSprite(SCBg); // Affichage fond jeu + info commande + raquette + balle + fleche directionnelle + briques + score + texte + pause
1514:
1515:  unite = level % 10;
1516:  dizaine = level / 10 % 10;
1517:  // unitï¿½:
1518:  SCBDATA(SCBl1) = chiffrestab[unite%14];
1519:  SCBX(SCBl1) = 140;
1520:  SCBY(SCBl1) = 50+24;
1521:
1522:  // dizaine:
1523:  SCBDATA(SCBl2) = chiffrestab[dizaine%14];
1524:  SCBX(SCBl2) = 140;
1525:  SCBY(SCBl2) = 50+16;
1526:
1527:  //DrawSprite(SCBchiffres1); // Affichage valeur testï¿½
1528:
1529:
1530:  if (relach==1) {
1531:   if (!(joystick & JOY_RIGHT)) {relach=0;} // utile pour vï¿½rifier si le joueur n'appui plus sur D-pad haut
1532:   }
1533:  if (gspause==0)
1534:   {
1535:   if (xpush<8 & horszone==0) xpush=xpush+2;
1536:   if (xpush>7)//(tempa>24 & etape==0) // petite teporisation avant d'autoriser le joueur de recommencer le jeu.
1537:   {
1538:   xpush=8;
1539:
1540:   ++tempa; // bulle info clignote doucement
1541:   if (tempa>63) tempa=1;
1542:   if (tempa>0 & tempa<32) ypush=34;
1543:   if (tempa>31) ypush=200;
1544:
1545:   if (relach==0 & horszone==0)
1546:   {
1547:   if (joystick & JOY_RIGHT) {
1548:   //level=1;//3;//1;
1549:   tempa=0;tempb=0;etape=20,yplayer=51;//xpush=-48;ypush=34;xlvla=160;xlvlb=160;xlvlc=160;xlvld=160;xlvle=160;elvl=0;
1550:   xpush=-48;ypush=34;
1551:   dirf=3;ydirf=6;
1552:   SCBY(SCBtexte1) = -200;SCBY(SCBtexte2) = -200;SCBY(SCBtexte3) = -200;SCBY(SCBtexte4) = -200;SCBY(SCBtexte5) = -200;
1553:   SCBY(SCBl1) = -200;SCBY(SCBl2) = -200;
1554:   SCBX(SCBlife) = 4;
1555:
1556:   // bruitage menu :
1557:   silence();
1558:   abcmusic(0,abcmenu1);
1559:   abcmusic(1,abcmenu2);
1560:
1561:
1562:   //SetRGB(palg); // Ceci sert ï¿½ changer la palette de la Lynx.
1563:   //SCBX(SCBg) = 0; // fond zone de jeu
1564:   SCBX(SCBp) = xpush;
1565:   //SCBX(SCBr) = 200; // raquette
1566:
1567:
1568:   relach=1; // utile pour vï¿½rifier si le joueur n'appui plus sur D-pad haut
1569:
1570:   //Vsync();
1571:   //SwapBuffers();
1572:   }
1573:   }
1574:   }
1575:   SCBY(SCBip) = -50;
1576:   }// if (gspause==0)
1577:   else
1578:   {
1579:   SCBY(SCBip) = 30; // coordonnï¿½es image pause
1580:   }
1581:
1582:
1583:
1584:
1585:
1586:  }
1587:
1588: /**************************************************************************
1589: **************************************************************************/
1590:  if (etape==20) // ï¿½cran jeu 1 (fleche directionnelle)
1591:  {
1592:  // raquette :
1593:  SCBX(SCBr) = 24;//32;
1594:  SCBY(SCBr) = yplayer;
1595:
1596:  // balle :
1597:  SCBX(SCBball) = 34;//+116;//+110;//42
1598:  SCBY(SCBball) = 51;
1599:
1600:  // fleche directionnelle :
1601:  SCBDATA(SCBfd) = fdtab[dirf%7];
1602:  SCBX(SCBfd) = 39;
1603:  SCBY(SCBfd) = 38+ydirf;
1604:
1605:  if (gspause==0)
1606:   {
1607:   if (tempa>0) {--tempa;}
1608:
1609:   if (joystick & JOY_DOWN)
1610:   {
1611:   if (tempa==0 & dirf<6) {++dirf;tempa=16;++ydirf;++ydirf;}
1612:   }
1613:   if (joystick & JOY_UP)
1614:   {
1615:   if (tempa==0 & dirf>0) {--dirf;tempa=16;--ydirf;--ydirf;}
1616:   }
1617:
1618:   if (relach==1)
1619:   {
1620:   if (!(joystick & JOY_RIGHT)) {relach=0;} // utile pour vï¿½rifier si le joueur n'appui plus sur D-pad haut
1621:   }
1622:   if (joystick & JOY_RIGHT)
1623:   {
1624:   if (relach==0) {
1625:   SCBX(SCBfd) = -200; // fleche directionnelle mis hors de l'ï¿½cran
1626:   dirf=dirf-3;bdirx=1;
1627:   tempa=0;etape=30;
1628:   balldirX=SCBX(SCBball);
1629:   balldirY=SCBY(SCBball);
1630:   }
1631:   }
1632:
1633:
1634:   SCBY(SCBip) = -50;
1635:   }// if (gspause==0)
1636:   else
1637:   {
1638:   SCBY(SCBip) = 30; // coordonnï¿½es image pause
1639:   }
1640:   //}
1641:  DrawSprite(SCBg); // Affichage fond jeu + info commande + raquette + balle + fleche directionnelle + briques + score + texte + pause
1642:  }
1643:
1644: /**************************************************************************
1645: **************************************************************************/
1646:  if (etape==30) // ï¿½cran jeu 2
1647:  {
1648:  if (gspause==0)
1649:   {
1650:   if (dirf<0) // Si la balle se dirige vers la gauche, alors...
1651:   {
1652:   if (balldirY<3)
1653:   {
1654:   balldirY=3;dirf=-dirf; // cadre gauche
1655:   // bruitage balle cadre:
1656:   silence();
1657:   abcmusic(1,abcball2);
1658:   }
1659:   if (dirf==-3) {
1660:   ++Ytemp;
1661:   if (Ytemp>1) {Ytemp=0;balldirY=balldirY-3;odirx=3;} // vitesse Y rï¿½elle --> -1,5
1662:   }
1663:   if (dirf==-2) {balldirY=balldirY-1;odirx=2;} // vitesse Y --> -1
1664:   if (dirf==-1) {
1665:   ++Ytemp;odirx=1;
1666:   if (Ytemp>1) {Ytemp=0;balldirY=balldirY-1;} // vitesse Y rï¿½elle --> -0,5
1667:   }
1668:   }
1669:
1670:   if (dirf==0) {odirx=0;} // vitesse X --> +2 balle se dirige droit devant.
1671:
1672:   if (dirf>0) // Si la balle se dirige vers la droite, alors...
1673:   {
1674:   if (dirf==1) {
1675:   ++Ytemp;odirx=1;
1676:   if (Ytemp>1) {Ytemp=0;balldirY=balldirY+1;} // vitesse Y rï¿½elle --> +0,5
1677:   }
1678:   if (dirf==2) {balldirY=balldirY+1;odirx=2;} // vitesse Y --> +1
1679:   if (dirf==3) {
1680:   ++Ytemp;
1681:   if (Ytemp>1) {Ytemp=0;balldirY=balldirY+3;odirx=3;} // vitesse Y rï¿½elle --> +1,5
1682:   }
1683:
1684:   if (balldirY>93)
1685:   {
1686:   balldirY=93;dirf=-dirf;// cadre droite (102-6 = 96-3 = 93)
1687:   // bruitage balle cadre:
1688:   silence();
1689:   abcmusic(1,abcball2);
1690:   }
1691: // balldirY=balldirY+2;
1692:   //balldirY=balldirY+dirf;
1693:
1694:   //if (dirf==1) {balldirY=balldirY+1;speedX=1;}
1695:   //if (dirf==2) {balldirY=balldirY+2;speedX=3;}
1696:   //if (dirf==3) {balldirY=balldirY+2;speedX=5;}
1697:
1698:   }
1699:
1700:
1701:
1702:   //If bille()\balldirY=0:bille()\bally-(3+bille()\speed):EndIf
1703:   //If bille()\balldirY=1:bille()\bally+(3+bille()\speed):EndIf
1704:   if (odirx==0)
1705:   {
1706:   //if (bdirx==1) balldirX=balldirX+2; // vitesse X --> +2
1707:   //if (bdirx==-1) balldirX=balldirX-2; // vitesse X --> -2
1708:
1709:   ++Xtemp;
1710:   if (Xtemp>1)
1711:   {
1712:   Xtemp=0;
1713:   if (bdirx==1) balldirX=balldirX+3; // vitesse X rï¿½elle --> +1,5
1714:   if (bdirx==-1) balldirX=balldirX-3; // vitesse X rï¿½elle --> -1,5
1715:   }
1716:   }
1717:   if (odirx==1)
1718:   {
1719:   ++Xtemp;
1720:   if (Xtemp>1)
1721:   {
1722:   Xtemp=0;
1723:   if (bdirx==1) balldirX=balldirX+3; // vitesse X rï¿½elle --> +1,5
1724:   if (bdirx==-1) balldirX=balldirX-3; // vitesse X rï¿½elle --> -1,5
1725:   }
1726:   }
1727:   if (odirx==2)
1728:   {
1729:   if (bdirx==1) balldirX=balldirX+1; // vitesse X --> +1
1730:   if (bdirx==-1) balldirX=balldirX-1; // vitesse X --> -1
1731:   }
1732:   if (odirx==3)
1733:   {
1734:   ++Xtemp;
1735:   if (Xtemp>1)
1736:   {
1737:   Xtemp=0;
1738:   if (bdirx==1) balldirX=balldirX+1; // vitesse X rï¿½elle --> +0,5
1739:   if (bdirx==-1) balldirX=balldirX-1; // vitesse X rï¿½elle --> -0,5
1740:   }
1741:   }
1742:   if (bdirx==1) { // Si la balle monte
1743:   if (balldirX>154)
1744:   {// collision haut du cadre: changement de direction
1745:   balldirX=154;bdirx=-bdirx; // inverse la direction de la balle
1746:   if (dirf==0) {
1747:   basar=random()%3; // de 0 ï¿½ 2
1748:   --basar;dirf=basar; // -1 ou 0 ou 1
1749:   }
1750:   // bruitage balle cadre:
1751:   silence();
1752:   abcmusic(1,abcball2);
1753:   }
1754:   }
1755:   if (bdirx==-1) { // Si la balle descend
1756:
1757:   if (balldirX<18) // provisoire
1758:   {// collision bas du cadre: changement de direction
1759:   //balldirX=18;bdirx=-bdirx; // inverse la direction de la balle
1760:   etape=50;gsblip=1;--filife; // aie !
1761:   }
1762:
1763:   //if (balldirX>34 & balldirX<42)// collision ball/raquette: changement de direction
1764:   if (balldirX>26 & balldirX<34)// collision ball/raquette: changement de direction
1765:   {
1766:   if (balldirY>yplayer-13 & balldirY<yplayer+13)
1767:   {
1768:   balldirX=34;bdirx=-bdirx;
1769:   // bruitage balle raquette:
1770:   silence();
1771:   abcmusic(0,abcball1);
1772:
1773:   //centre de la raquette :
1774:   if (balldirY>yplayer-3 & balldirY<yplayer+3)
1775:   {
1776:   if (dirf==1) {dirf=0;oboucl=1;}
1777:   if (dirf==2) {dirf=1;oboucl=1;}
1778:   if (dirf==3) {dirf=2;oboucl=1;}
1779:
1780:   if (dirf==-1) {dirf=0;oboucl=1;}
1781:   if (dirf==-2) {dirf=-1;oboucl=1;}
1782:   if (dirf==-3) {dirf=-2;oboucl=1;}
1783:   }
1784:   if (oboucl==1) {oboucl=0;goto test_finish;}
1785:
1786:   //gauche de la raquette :
1787:   if (balldirY>yplayer-8 & balldirY<yplayer-2)
1788:   {
1789:   //if (dirf==-1) {dirf=-2;oboucl=1;}
1790:   if (dirf==-1) {dirf=-1;oboucl=1;}
1791:   if (dirf==-3) {dirf=-2;oboucl=1;}
1792:
1793:   if (dirf==1) {dirf=-1;oboucl=1;}
1794:   if (dirf==2) {dirf=-2;oboucl=1;}
1795:   if (dirf==3) {dirf=-2;oboucl=1;}
1796:
1797:   if (dirf==0) {dirf=-1;oboucl=1;}
1798:   }
1799:   if (oboucl==1) {oboucl=0;goto test_finish;}
1800:
1801:   //droite de la raquette :
1802:   if (balldirY>yplayer+2 & balldirY<yplayer+8)
1803:   {
1804:   //if (dirf==1) {dirf=2;oboucl=1;}
1805:   if (dirf==1) {dirf=1;oboucl=1;}
1806:   if (dirf==3) {dirf=2;oboucl=1;}
1807:
1808:   if (dirf==-1) {dirf=1;oboucl=1;}
1809:   if (dirf==-2) {dirf=2;oboucl=1;}
1810:   if (dirf==-3) {dirf=2;oboucl=1;}
1811:
1812:   if (dirf==0) {dirf=1;oboucl=1;}
1813:   }
1814:   if (oboucl==1) {oboucl=0;goto test_finish;}
1815:
1816:   //exgauche de la raquette :
1817:   if (balldirY>yplayer-13 & balldirY<yplayer-7)
1818:   {
1819:   if (dirf==-1) {dirf=-2;oboucl=1;}//break;
1820:   if (dirf==-2) {dirf=-3;oboucl=1;}
1821:
1822:   if (dirf==1) {dirf=-2;oboucl=1;}
1823:   if (dirf==2) {dirf=-3;oboucl=1;}
1824:   if (dirf==3) {dirf=-3;oboucl=1;}
1825:
1826:   if (dirf==0) {dirf=-2;oboucl=1;}
1827:   }
1828:   if (oboucl==1) {oboucl=0;goto test_finish;}
1829:
1830:   //exdroite de la raquette :
1831:   if (balldirY>yplayer+7 & balldirY<yplayer+13)
1832:   {
1833:   if (dirf==1) {dirf=2;oboucl=1;}
1834:   if (dirf==2) {dirf=3;oboucl=1;}
1835:
1836:   if (dirf==-1) {dirf=2;oboucl=1;}
1837:   if (dirf==-2) {dirf=3;oboucl=1;}
1838:   if (dirf==-3) {dirf=3;oboucl=1;}
1839:
1840:   if (dirf==0) {dirf=2;oboucl=1;}
1841:   }
1842:   if (oboucl==1) {oboucl=0;goto test_finish;}
1843:   }
1844:   }
1845:   }
1846:
1847: test_finish:
1848:
1849:   if (joystick & JOY_DOWN) {
1850:   yplayer=yplayer+2;
1851:   if (yplayer>87) {yplayer=87;} // (102-24 = 78-3 = 75) ; 24 = largeur de la raquette
1852:   }
1853:   if (joystick & JOY_UP) {
1854:   yplayer=yplayer-2;
1855:   if (yplayer<15) {yplayer=15;}
1856:   }
1857:
1858:
1859:  SCBX(SCBball)=balldirX;SCBY(SCBball)=balldirY; // appliquer les variables balldirX et balldirY aux coordonnï¿½es de la balle.
1860:  SCBY(SCBr) = yplayer;
1861:
1862:
1863:
1864:
1865: //ShowScreen(); // Coordonnï¿½es de toutes les briques (voir au dï¿½but de ce joyeux code). Ici dï¿½sactivï¿½ car inutile et couteux en ressource machine...
1866:
1867: // test Balle/briques
1868:
1869:  if (tempa>0)//;xind=0;yind=0;
1870:   {
1871:   --tempa;
1872:   if (tempa==0) {xind=0;yind=-20;}
1873:   SCBX(SCBbrind) = xind;SCBY(SCBbrind) = yind;
1874:   }
1875:  cible=0;bbcontact=0;
1876: // *************************************************************************************
1877:  if (bdirx==1)// Si balle monte
1878:   {
1879:   if (balldirY>16-1 & balldirY<29+1) cible=1;
1880:   if (balldirY>30-1 & balldirY<43+1) cible=2;
1881:   if (balldirY>44-1 & balldirY<57+1) cible=3;
1882:   if (balldirY>58-1 & balldirY<71+1) cible=4;
1883:   if (balldirY>72-1 & balldirY<85+1) cible=5;
1884:   arfind=cible;
1885:   if (cible>0)
1886:   {
1887:   if (balldirX+3>brix[0]-1 & balldirX+3<brix[0]+4) {xycol=1;}
1888:   if (balldirX+3>brix[1]-1 & balldirX+3<brix[1]+4) {xycol=2;cible=cible+5;}
1889:   if (balldirX+3>brix[2]-1 & balldirX+3<brix[2]+4) {xycol=3;cible=cible+10;}
1890:   if (balldirX+3>brix[3]-1 & balldirX+3<brix[3]+4) {xycol=4;cible=cible+15;}
1891:   if (balldirX+3>brix[4]-1 & balldirX+3<brix[4]+4) {xycol=5;cible=cible+20;}
1892:   --cible;
1893:
1894:   if (xycol>0)
1895:   {
1896:   // La variable brie[25] sera donc utilisï¿½ pour modifier l'ï¿½tat des 25 briques.
1897:   if (brie[cible] == 1)
1898:   {
1899:   brie[cible]=0;dcore=10;SCBDATA(brdata[0 + cible]) = brtab[0%5];bbcontact=1;
1900:   --level;--brsco[level];
1901:   if (brsco[level]==0) etape=40; // toutes les briques destrutibles sont dï¿½truites : passage au niveau suivant...
1902:   ++level;
1903:   silence();abcmusic(2,abcball3);
1904:   }
1905:   if (brie[cible] == 2) {brie[cible]=1;dcore=20;SCBDATA(brdata[0 + cible]) = brtab[1%5];bbcontact=1;silence();abcmusic(2,abcball3);}
1906:   if (brie[cible] == 3) {
1907:   bbcontact=1;dcore=5;
1908:   tempa=12;
1909:   --xycol;
1910:   xind=brix[xycol];
1911:
1912:   --arfind;
1913:   yind=briy[arfind];
1914:   silence();
1915:   abcmusic(1,abcball4);
1916:   }
1917:   xycol=0;
1918:   }
1919:
1920:
1921:   if (bbcontact==1)
1922:   {
1923:   bdirx=-bdirx;//balldirX=balldirX-4;
1924:   if (dirf==0) { // hasard changement de direction...
1925:   basar=random()%3; // de 0 ï¿½ 2
1926:   --basar;dirf=basar; // -1 ou 0 ou 1
1927:   }
1928:   goto stop_test;
1929:   }
1930:   }
1931:   }
1932: cible=0;
1933: // *************************************************************************************
1934:  if (bdirx==-1)// Si balle descend
1935:   {
1936:   if (balldirY>16-1 & balldirY<29+1) cible=1;
1937:   if (balldirY>30-1 & balldirY<43+1) cible=2;
1938:   if (balldirY>44-1 & balldirY<57+1) cible=3;
1939:   if (balldirY>58-1 & balldirY<71+1) cible=4;
1940:   if (balldirY>72-1 & balldirY<85+1) cible=5;
1941:   arfind=cible;
1942:   if (cible>0)
1943:   {
1944:   if (balldirX-3>brix[0]+5 & balldirX-3<brix[0]+10) {xycol=1;}
1945:   if (balldirX-3>brix[1]+5 & balldirX-3<brix[1]+10) {xycol=2;cible=cible+5;}
1946:   if (balldirX-3>brix[2]+5 & balldirX-3<brix[2]+10) {xycol=3;cible=cible+10;}
1947:   if (balldirX-3>brix[3]+5 & balldirX-3<brix[3]+10) {xycol=4;cible=cible+15;}
1948:   if (balldirX-3>brix[4]+5 & balldirX-3<brix[4]+10) {xycol=5;cible=cible+20;}
1949:   --cible;
1950:
1951:   if (xycol>0)
1952:   {
1953:   // La variable brie[25] sera donc utilisï¿½ pour modifier l'ï¿½tat des 25 briques.
1954:   if (brie[cible] == 1)
1955:   {
1956:   brie[cible]=0;dcore=10;SCBDATA(brdata[0 + cible]) = brtab[0%5];bbcontact=1;
1957:   --level;--brsco[level];
1958:   if (brsco[level]==0) etape=40; // toutes les briques destrutibles sont dï¿½truites : passage au niveau suivant...
1959:   ++level;
1960:   silence();abcmusic(2,abcball3);
1961:   }
1962:   if (brie[cible] == 2) {brie[cible]=1;dcore=20;SCBDATA(brdata[0 + cible]) = brtab[1%5];bbcontact=1;silence();abcmusic(2,abcball3);}
1963:   if (brie[cible] == 3) {
1964:   bbcontact=1;dcore=5;
1965:   tempa=12;
1966:   --xycol;
1967:   xind=brix[xycol];
1968:
1969:   --arfind;
1970:   yind=briy[arfind];
1971:   silence();
1972:   abcmusic(1,abcball4);
1973:   }
1974:   xycol=0;
1975:   }
1976:
1977:
1978:   if (bbcontact==1)
1979:   {
1980:   bdirx=-bdirx;//balldirX=balldirX+4;
1981:   goto stop_test;
1982:   }
1983:   }
1984:   }
1985: cible=0;
1986: // *************************************************************************************
1987:  if (dirf>0)// Si balle va ï¿½ droite
1988:   {
1989:   if (balldirX>brix[0]-1 & balldirX<brix[0]+10) {cible=1;arfind=0;}
1990:   if (balldirX>brix[1]-1 & balldirX<brix[1]+10) {cible=6;arfind=1;}
1991:   if (balldirX>brix[2]-1 & balldirX<brix[2]+10) {cible=11;arfind=2;}
1992:   if (balldirX>brix[3]-1 & balldirX<brix[3]+10) {cible=16;arfind=3;}
1993:   if (balldirX>brix[4]-1 & balldirX<brix[4]+10) {cible=21;arfind=4;}
1994:
1995:   if (cible>0)
1996:   {
1997:   if (balldirY+3>briy[0]-1 & balldirY+3<briy[0]+3) {xycol=1;}
1998:   if (balldirY+3>briy[1]-1 & balldirY+3<briy[1]+3) {xycol=2;cible=cible+1;}
1999:   if (balldirY+3>briy[2]-1 & balldirY+3<briy[2]+3) {xycol=3;cible=cible+2;}
2000:   if (balldirY+3>briy[3]-1 & balldirY+3<briy[3]+3) {xycol=4;cible=cible+3;}
2001:   if (balldirY+3>briy[4]-1 & balldirY+3<briy[4]+3) {xycol=5;cible=cible+4;}
2002:   --cible;
2003:
2004:   if (xycol>0)
2005:   {
2006:   // La variable brie[25] sera donc utilisï¿½ pour modifier l'ï¿½tat des 25 briques.
2007:   if (brie[cible] == 1)
2008:   {
2009:   brie[cible]=0;dcore=10;SCBDATA(brdata[0 + cible]) = brtab[0%5];bbcontact=1;
2010:   --level;--brsco[level];
2011:   if (brsco[level]==0) etape=40; // toutes les briques destrutibles sont dï¿½truites : passage au niveau suivant...
2012:   ++level;
2013:   silence();abcmusic(2,abcball3);
2014:   }
2015:   if (brie[cible] == 2) {brie[cible]=1;dcore=20;SCBDATA(brdata[0 + cible]) = brtab[1%5];bbcontact=1;silence();abcmusic(2,abcball3);}
2016:   if (brie[cible] == 3) {
2017:   bbcontact=1;dcore=5;
2018:   tempa=12;
2019:   xind=brix[arfind];
2020:
2021:   --xycol;
2022:   yind=briy[xycol];
2023:   silence();
2024:   abcmusic(1,abcball4);
2025:   }
2026:   xycol=0;
2027:   }
2028:
2029:
2030:   if (bbcontact==1)
2031:   {
2032:   dirf=-dirf;//balldirY=balldirY-3;
2033:   goto stop_test;
2034:   }
2035:   }
2036:   }
2037: cible=0;
2038: // *************************************************************************************
2039:  if (dirf<0)// Si balle va ï¿½ gauche
2040:   {
2041:   if (balldirX>brix[0]-1 & balldirX<brix[0]+10) {cible=1;arfind=0;}
2042:   if (balldirX>brix[1]-1 & balldirX<brix[1]+10) {cible=6;arfind=1;}
2043:   if (balldirX>brix[2]-1 & balldirX<brix[2]+10) {cible=11;arfind=2;}
2044:   if (balldirX>brix[3]-1 & balldirX<brix[3]+10) {cible=16;arfind=3;}
2045:   if (balldirX>brix[4]-1 & balldirX<brix[4]+10) {cible=21;arfind=4;}
2046:
2047:   if (cible>0)
2048:   {
2049:   if (balldirY-3>briy[0]+10 & balldirY-3<briy[0]+14) {xycol=1;}
2050:   if (balldirY-3>briy[1]+10 & balldirY-3<briy[1]+14) {xycol=2;cible=cible+1;}
2051:   if (balldirY-3>briy[2]+10 & balldirY-3<briy[2]+14) {xycol=3;cible=cible+2;}
2052:   if (balldirY-3>briy[3]+10 & balldirY-3<briy[3]+14) {xycol=4;cible=cible+3;}
2053:   if (balldirY-3>briy[4]+10 & balldirY-3<briy[4]+14) {xycol=5;cible=cible+4;}
2054:   --cible;
2055:
2056:   if (xycol>0)
2057:   {
2058:   // La variable brie[25] sera donc utilisï¿½ pour modifier l'ï¿½tat des 25 briques.
2059:   if (brie[cible] == 1)
2060:   {
2061:   brie[cible]=0;dcore=10;SCBDATA(brdata[0 + cible]) = brtab[0%5];bbcontact=1;
2062:   --level;--brsco[level];
2063:   if (brsco[level]==0) etape=40; // toutes les briques destrutibles sont dï¿½truites : passage au niveau suivant...
2064:   ++level;
2065:   silence();abcmusic(2,abcball3);
2066:   }
2067:   if (brie[cible] == 2) {brie[cible]=1;dcore=20;SCBDATA(brdata[0 + cible]) = brtab[1%5];bbcontact=1;silence();abcmusic(2,abcball3);}
2068:   if (brie[cible] == 3) {
2069:   bbcontact=1;dcore=5;
2070:   tempa=12;
2071:   xind=brix[arfind];
2072:
2073:   --xycol;
2074:   yind=briy[xycol];
2075:   silence();
2076:   abcmusic(1,abcball4);
2077:   }
2078:   xycol=0;
2079:   }
2080:
2081:
2082:   if (bbcontact==1)
2083:   {
2084:   dirf=-dirf;//balldirY=balldirY+3;
2085:   goto stop_test;
2086:   }
2087:   }
2088:   }
2089: cible=0;
2090: // *************************************************************************************
2091:
2092:
2093:
2094:
2095:
2096:
2097:
2098:
2099:
2100:
2101:
2102: stop_test:
2103:
2104:
2105:
2106:
2107:   SCBY(SCBip) = -50;SCBY(SCBl1) = -200;SCBY(SCBl2) = -200;
2108:   }// if (gspause==0)
2109:
2110:
2111:
2112:
2113: else
2114: {
2115:  SCBY(SCBip) = 30;SCBY(SCBl1) = 74;SCBY(SCBl2) = 66; // coordonnï¿½es image pause et level
2116: }
2117:
2118:  DrawSprite(SCBg); // Affichage fond jeu + info commande + raquette + balle + fleche directionnelle + briques + score + texte + pause
2119:
2120: }
2121: /**************************************************************************
2122: **************************************************************************/
2123:  if (etape==40) // passage au niveau suivant.
2124:  {
2125:   tempa=0;tempb=0;etape=9;//xpush=-48;ypush=34;xlvla=160;xlvlb=160;xlvlc=160;xlvld=160;xlvle=160;elvl=0;
2126:   xpush=-48;ypush=34;
2127:   ++level;
2128:   if (level>12) level=1;
2129:  // balle :
2130:  SCBY(SCBball) = -20;
2131:  horszone=150;// mettre les briques hors de l'ï¿½cran visible.
2132:  xind=0;yind=-20;SCBX(SCBbrind) = xind;SCBY(SCBbrind) = yind;
2133:  }
2134: /**************************************************************************
2135: **************************************************************************/
2136:
2137:  if (etape==50) // perd une raquette !
2138:  {
2139:  SetRGB(palr); // Ceci sert ï¿½ changer la palette de la Lynx.
2140:  DrawSprite(SCBg); // Affichage fond jeu + info commande + raquette + balle + fleche directionnelle + briques + score + texte + pause
2141:
2142:  ++tempb;
2143:  /**
2144:  if (tempb>64)
2145:   {
2146:   tempb=0;
2147:   SetRGB(palg); // Ceci sert ï¿½ changer la palette de la Lynx.
2148:
2149:   yplayer=51;//xpush=-48;ypush=34;xlvla=160;xlvlb=160;xlvlc=160;xlvld=160;xlvle=160;elvl=0;
2150:   dirf=3;ydirf=6;
2151:
2152:   etape=20;
2153:   // raquette :
2154:   SCBX(SCBr) = 24;//32;
2155:   SCBY(SCBr) = yplayer;
2156:
2157:   // balle :
2158:   SCBX(SCBball) = 34;//42
2159:   SCBY(SCBball) = 51;
2160:
2161:   // fleche directionnelle :
2162:   SCBDATA(SCBfd) = fdtab[dirf%7];
2163:   SCBX(SCBfd) = 39;
2164:   SCBY(SCBfd) = 38+ydirf;
2165:
2166:
2167:
2168:   }
2169:  **/
2170:
2171:  switch (tempb)
2172:   {
2173:   case 70:
2174:   tempb=0;
2175:   SetRGB(palg); // Ceci sert ï¿½ changer la palette de la Lynx.
2176:
2177:   yplayer=51;//xpush=-48;ypush=34;xlvla=160;xlvlb=160;xlvlc=160;xlvld=160;xlvle=160;elvl=0;
2178:   dirf=3;ydirf=6;
2179:
2180:   etape=20;
2181:   // raquette :
2182:   SCBX(SCBr) = 24;//32;
2183:   SCBY(SCBr) = yplayer;
2184:
2185:   // balle :
2186:   SCBX(SCBball) = 34;//42
2187:   SCBY(SCBball) = 51;
2188:
2189:   // fleche directionnelle :
2190:   SCBDATA(SCBfd) = fdtab[dirf%7];
2191:   SCBX(SCBfd) = 39;
2192:   SCBY(SCBfd) = 38+ydirf;
2193:   if (filife==0) {etape=0;horszone=150;ShowScreen();}
2194:   break;
2195:   }
2196:
2197:  //if (filife==0) etape=0;
2198:
2199: // switch (filife)
2200: // {
2201: // case 0:
2202: // etape=0;
2203: /// break;
2204: // }
2205:  }
2206: /**************************************************************************
2207: **************************************************************************/
2208: /** test
2209:
2210:
2211:  atest=dirf;//cible;//upbri;//etape;//brsco[0];//ttest;//9;//balldirX;//yplayer;//speedX;//dirf;//etape;
2212:
2213:  //atest=horszone;//relach;//etape;//SCBCTL0(SCBbr);
2214:  unite = atest % 10;
2215:  dizaine = atest / 10 % 10;
2216:  centaine = atest / 100 % 10;
2217: // millier = atest / 1000 % 10;
2218: // dmillier = atest / 10000 % 10;
2219:   // unitï¿½:
2220:   SCBDATA(SCBchiffres1) = chiffrestab[unite%14];
2221:   SCBX(SCBchiffres1) = 100;
2222:   SCBY(SCBchiffres1) = 53;
2223:
2224:   // dizaine:
2225:   SCBDATA(SCBchiffres2) = chiffrestab[dizaine%14];
2226:   SCBX(SCBchiffres2) = 100;
2227:   SCBY(SCBchiffres2) = 53-8;
2228:
2229:   // centaine:
2230:   SCBDATA(SCBchiffres3) = chiffrestab[centaine%14]; // 0
2231:   SCBX(SCBchiffres3) = 100;
2232:   SCBY(SCBchiffres3) = 53-16;
2233:
2234:   // millier:
2235: // SCBDATA(SCBchiffres4) = chiffrestab[millier%14]; // 0
2236: // SCBX(SCBchiffres4) = 100;
2237: // SCBY(SCBchiffres4) = 53-24;
2238:
2239:   // dizaine de millier:
2240: // SCBDATA(SCBchiffres5) = chiffrestab[dmillier%14]; // 0
2241: // SCBX(SCBchiffres5) = 100;
2242: // SCBY(SCBchiffres5) = 53-32;
2243:
2244:   DrawSprite(SCBchiffres1); // Affichage valeur testï¿½
2245:
2246: **/
2247:
2248:
2249: // SCBDATA(SCBchiffres1) = chiffrestab[10%14];
2250: // SCBX(SCBchiffres1) = 40;
2251:   //SCBY(SCBchiffres1) = yplayer;
2252: // SCBY(SCBchiffres1) = yplayer;//yplayer+23;
2253:
2254: /*** Tests important des coordonnï¿½es des images
2255:
2256:  SCBDATA(SCBchiffres1) = chiffrestab[10%14];
2257:  SCBX(SCBchiffres1) = SCBX(SCBball);
2258:  SCBY(SCBchiffres1) = balldirY+2;//SCBY(SCBball);
2259:
2260:
2261:   DrawSprite(SCBchiffres1); // Affichage valeur testï¿½
2262:
2263:  fin de ces tests de coordonnï¿½e ***/
2264:
2265:   //Vsync();
2266:   //SwapBuffers();
2267:
2268: }
2269:
2270: /**************************************************************************
2271: ** FIN de la BOUCLE PRINCIPALE **
2272:
2273: **************************************************************************/
2274:
2275:  }
2276:
2277:
2278:
2279: /*
2280:
2281: #asm
2282: vretrace:
2283:  lda $fd0a
2284:  bne vretrace
2285: #endasm
2286:
2287:
2288:
2289:
2290:   LDA bally
2291:   CMP #TOPWALL
2292:   BCS MoveBallUpDone ;;if ball y > top wall, still on screen, skip next section
2293:   LDA #$01
2294:   STA balldown
2295:   LDA #$00
2296:   STA ballup ;;bounce, ball now moving down
2297: MoveBallUpDone:
2298:
2299:
2300: MoveBallDown:
2301:   LDA balldown
2302:   BEQ MoveBallDownDone ;;if ballup=0, skip this section
2303:
2304:   LDA bally
2305:   CLC
2306:   ADC ballspeedy ;;bally position = bally + ballspeedy
2307:   STA bally
2308:
2309:   LDA bally
2310:   CMP #BOTTOMWALL
2311:   BCC MoveBallDownDone ;;if ball y < bottom wall, still on screen, skip next section
2312:
2313:
2314:
2315:
2316:
2317:
2318:
2319:   LDA ballx
2320:   SEC
2321:   SBC ballspeedx ;;ballx position = ballx - ballspeedx
2322:   STA ballx
2323:
2324:
2325:
2326: LDA ballright
2327: BEQ MoveBallRightDone // if ballright=0, skip this section
2328: */
2329: //#asm
2330: //lda oboucl
2331: //bne test_finish ;;// if oboucl=0, skip this section
2332: //#endasm
2333:
2334:
2335:
2336:
2337: //#asm
2338: //vretrace:
2339: // lda $fd0a
2340: // bne vretrace
2341: //#endasm