test.c

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

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