home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 243.lha / WipeDemo_v2.0 / mywipe.h < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-10  |  20.6 KB  |  1,118 lines
  1. /* by Paul Falstad */
  2. /* vulgarities edited out */
  3.  
  4. #define WIPECOUNT 35
  5. struct RastPort *MaskRast;
  6.  
  7. LoadPict(name,WipeScreen,wipesel,fadeflag)
  8. struct Screen *WipeScreen;
  9. char *name;
  10. int wipesel,fadeflag;
  11. {
  12. int t0,whichwipe;
  13. struct BitMap *WipeMap,*SetupMask(),*OldMap,*SetupOld();
  14. struct ILBM_info *info;
  15. static UWORD oldcmap[32];
  16. static BOOL RandMap[WIPECOUNT];
  17. static int randcount = 1;
  18.  
  19. info = read_iff(name,NULL);
  20. if (info == NULL)
  21.    return(NULL);
  22.  
  23. if (wipesel == -1)
  24.    {
  25.    if (--randcount == 0)
  26.       {
  27.       for (t0 = 0; t0 != WIPECOUNT; t0++)
  28.          RandMap[t0] = FALSE;
  29.       randcount = WIPECOUNT;
  30.       }
  31.  
  32.    while(RandMap[whichwipe = rand() % WIPECOUNT])
  33.       ;
  34.  
  35.    RandMap[whichwipe] = TRUE;
  36.    }
  37. else
  38.    whichwipe = wipesel;
  39.  
  40. WipeMap = SetupMask();
  41. OldMap = SetupOld();
  42.  
  43. GetCols(&WipeScreen->ViewPort,&oldcmap[0]);
  44. if (!(rand() % 3) && fadeflag)
  45.    {
  46.    FadeOut(&WipeScreen->ViewPort,&oldcmap[0]);
  47.    SetRast(&WipeScreen->RastPort,0L);
  48.    }
  49. BltBitMap(WipeScreen->RastPort.BitMap,0L,0L,OldMap,0L,0L,320L,200L,0xC0L,
  50.     0x1fL,0L);
  51.  
  52. for (t0 = 0; t0 != 64; t0++)
  53.    {
  54.    Wipe(WipeScreen->RastPort.BitMap,&info->bitmap,WipeMap,OldMap,t0,whichwipe);
  55.    FadeColors(&WipeScreen->ViewPort,oldcmap,&info->cmap[0],t0);
  56.    }
  57.  
  58. free_planes(&info->bitmap);
  59. FreeOld(OldMap);
  60. }
  61.  
  62. struct BitMap *SetupMask()
  63. {
  64. static struct BitMap MyBitMap;
  65. static BOOL Inited = FALSE;
  66.  
  67. if (!Inited)
  68.    {
  69.    InitBitMap(&MyBitMap,1L,320L,200L);
  70.    Inited = TRUE;
  71.    if ((MyBitMap.Planes[0] = (PLANEPTR) AllocRaster(320L,200L)) == NULL)
  72.       exit(0L);
  73.    }
  74.  
  75. return(&MyBitMap);
  76. }
  77.  
  78. struct BitMap *SetupOld()
  79. {
  80. static struct BitMap MyBitMap;
  81. static BOOL Inited = FALSE;
  82. int t0;
  83.  
  84.    if (!Inited)
  85.       {
  86.       InitBitMap(&MyBitMap,5L,320L,200L);
  87.       Inited = TRUE;
  88.       }
  89.    for (t0 = 0; t0 != 5; t0++)
  90.       if ((MyBitMap.Planes[t0] = (PLANEPTR) AllocRaster(320L,200L)) == NULL)
  91.          exit(0L);
  92.  
  93. return(&MyBitMap);
  94. }
  95.  
  96. FreeOld(map)
  97. struct BitMap *map;
  98. {
  99. int t0;
  100.  
  101.    for (t0 = 0; t0 != 5; t0++)
  102.       FreeRaster(map->Planes[t0],320L,200L);
  103. }
  104.  
  105. GetCols(vport,cmap)
  106. UWORD *cmap;
  107. struct ViewPort *vport;
  108. {
  109. long t0;
  110.  
  111.    for (t0 = 0; t0 != 32; t0++)
  112.       cmap[t0] = GetRGB4(vport->ColorMap,t0);
  113. }
  114.  
  115. FadeOut(vport,cmap)
  116. UWORD *cmap;
  117. struct ViewPort *vport;
  118. {
  119. long r,g,b,col;
  120. int or,og,ob;
  121. int nfix;
  122. int step;
  123.  
  124.    for (step = 0; step != 32; step++)
  125.       {
  126.       Delay(1L);
  127.       nfix = 31-step;
  128.       for (col = 0; col != 32; col++)
  129.          {
  130.          r = (nfix * ((cmap[col] >> 8) & 0x0f));
  131.          g = (nfix * ((cmap[col] >> 4) & 0x0f));
  132.          b = (nfix * ((cmap[col]) & 0x0f));
  133.          SetRGB4(vport,col,r >> 5,g >> 5,b >> 5);
  134.          }
  135.       }
  136.  
  137.    for (col = 0; col != 32; col++)
  138.       cmap[col] = 0;
  139. }
  140.  
  141.  
  142. FadeColors(vport,ocmap,ncmap,step)
  143. int step;
  144. BYTE *ncmap;
  145. UWORD *ocmap;
  146. struct ViewPort *vport;
  147. {
  148. long r,g,b,col;
  149. int or,og,ob;
  150. int ofix,nfix;
  151.  
  152.    ofix = 63-step;
  153.    nfix = step+1;
  154.    for (col = 0; col != 32; col++)
  155.       {
  156.       or = (ocmap[col] >> 8) & 0x0f;
  157.       og = (ocmap[col] >> 4) & 0x0f;
  158.       ob = (ocmap[col]) & 0x0f;
  159.       r = (nfix * ((ncmap[col*3] >> 4) & 0x0f)) + or*ofix;
  160.       g = (nfix * ((ncmap[col*3+1] >> 4) & 0x0f)) + og*ofix;
  161.       b = (nfix * ((ncmap[col*3+2] >> 4) & 0x0f)) + ob*ofix;
  162.       SetRGB4(vport,col,r >> 6,g >> 6,b >> 6);
  163.       }
  164. }
  165.  
  166. void DoTheBlitSh_t();
  167.  
  168. Wipe(dispbits,newbits,mask,oldbits,step,wipeid)
  169. struct BitMap *oldbits,*newbits,*dispbits,*mask;
  170. int step,wipeid; /* step 0 to 63 */
  171. {
  172. int plane;
  173. static BOOL rastinited = FALSE;
  174. static struct RastPort MyRast;
  175.  
  176. if (!rastinited)
  177.    {
  178.    InitRastPort(&MyRast);
  179.    MyRast.BitMap = mask;
  180.    SetAPen(&MyRast,1L);
  181.    DoTmpStuff(&MyRast);
  182.    MaskRast = &MyRast;
  183.    rastinited = TRUE;
  184.    }
  185.  
  186. if (step == 0)
  187.    SetRast(&MyRast,0L);
  188.  
  189. switch(wipeid) {
  190.  case 0:
  191.    UpAndDownPanel(&MyRast,step);
  192.    break;
  193.  case 1:
  194.    Random(&MyRast,step);
  195.    break;
  196.  case 2:
  197.    LeftLinePanel(&MyRast,step);
  198.    break;
  199.  case 3:
  200.    Dice(&MyRast,step);
  201.    break;
  202.  case 4:
  203.    GrowBoxes(&MyRast,step);
  204.    break;
  205.  case 5:
  206.    SideToSide(&MyRast,step);
  207.    break;
  208.  case 6:
  209.    TwoClock(&MyRast,step);
  210.    break;
  211.  case 7:
  212.    OneClock(&MyRast,step);
  213.    break;
  214.  case 8:
  215.    RandomOut(&MyRast,step);
  216.    break;
  217.  case 9:
  218.    Spiral(&MyRast,step);
  219.    break;
  220.  case 10:
  221.    ExpandBox(&MyRast,step);
  222.    break;
  223.  case 11:
  224.    Doors(&MyRast,step);
  225.    break;
  226.  case 12:
  227.    WipeUp(&MyRast,step);
  228.    break;
  229.  case 13:
  230.    WipeDown(&MyRast,step);
  231.    break;
  232.  case 14:
  233.    WipeLeft(&MyRast,step);
  234.    break;
  235.  case 15:
  236.    WipeRight(&MyRast,step);
  237.    break;
  238.  case 16:
  239.    WipeDiag(&MyRast,step);
  240.    break;
  241.  case 17:
  242.    TwoBox(&MyRast,step);
  243.    break;
  244.  case 18:
  245.    Shades(&MyRast,step);
  246.    break;
  247.  case 19:
  248.    RandomShade(&MyRast,step);
  249.    break;
  250.  case 20:
  251.    SymArr(&MyRast,step);
  252.    break;
  253.  case 21:
  254.    FourSweep(&MyRast,step);
  255.    break;
  256.  case 22:
  257.    FourLines(&MyRast,step);
  258.    break;
  259.  case 23:
  260.    HexSweep(&MyRast,step);
  261.    break;
  262.  case 24:
  263.    DiagSplit(&MyRast,step);
  264.    break;
  265.  case 25:
  266.    Xes(&MyRast,step);
  267.    break;
  268.  case 26:
  269.    SlideBoxes(&MyRast,step);
  270.    break;
  271.  case 27:
  272.    Cannon(&MyRast,step);
  273.    break;
  274.  case 28:
  275.    Drip(&MyRast,step);
  276.    break;
  277.  case 29:
  278.    MovingWindow(&MyRast,step);
  279.    break;
  280.  case 30:
  281.    Sun(&MyRast,step);
  282.    break;
  283.  case 31:
  284.    Monolith(&MyRast,step);
  285.    break;
  286.  case 32:
  287.    Rain(&MyRast,step);
  288.    break;
  289.  case 33:
  290.    MergeWindows(&MyRast,step);
  291.    break;
  292.  case 34:
  293.    Slides(&MyRast,step);
  294.    break;
  295.    };
  296.  
  297. if (step == 63)
  298.    SetRast(&MyRast,1L);
  299.  
  300. OwnBlitter();
  301. WaitBlit();
  302.  
  303. for (plane = 4; plane >= 0; plane--)
  304.    DoTheBlitSh_t(dispbits->Planes[plane],newbits->Planes[plane],
  305.       mask->Planes[0],oldbits->Planes[plane]);
  306.  
  307. DisownBlitter();
  308. }
  309.  
  310. Dice(rp,step)
  311. struct RastPort *rp;
  312. int step;
  313. {
  314.    RectFill(rp,0L,0L,step*3L,step*2L);
  315.    RectFill(rp,0L,199L-step*2L,step*3L,199L);
  316.    RectFill(rp,319L-step*3L,0L,319L,step*2L);
  317.    RectFill(rp,319L-step*3L,199L-step*2L,319L,199L);
  318.    RectFill(rp,159L-step,99L-step,159L+step,99L+step);
  319. }
  320.  
  321. #asm
  322.       cseg
  323.  
  324. _DoTheBlitSh_t:
  325.       move.l 12(sp),$dff050 ; A get mask argument */
  326.       move.l #0,$dff060  ; modulos */
  327.       move.l #0,$dff064
  328.       move.l #%00001111110010100000000000000000,$dff040  ; bltcon01 */
  329.       move.l #$ffffffff,$dff044 ; first & last word masks */
  330.       move.l 16(sp),$dff048   ; C */
  331.       move.l 8(sp),$dff04c   ; B */
  332.       move.l 4(sp),$dff054   ; D */
  333.       move.w #%0011001000010100,$dff058  ;go! */
  334.       jsr _WaitBlit
  335.       rts
  336.  
  337. #endasm
  338.  
  339. UpAndDownPanel(rp,step)
  340. struct RastPort *rp;
  341. int step;
  342. {
  343. long t0;
  344.  
  345.    for (t0 = 0; t0 != 320; t0+=40)
  346.       {
  347.       RectFill(rp,t0,0L,t0+19L,step*3L+10L);
  348.       RectFill(rp,t0+20L,189L-step*3L,t0+39L,199L);
  349.       }
  350. }
  351.  
  352. Random(rp,step)
  353. struct RastPort *rp;
  354. int step;
  355. {
  356. static unsigned char matx[64];
  357. int t0,bx;
  358. long x,y;
  359.  
  360.    if (step == 0)
  361.       for (t0 = 0; t0 != 64; t0++)
  362.          matx[t0] = t0;
  363.  
  364.    t0 = (rand() % (64-step))+step;
  365.    bx = matx[t0];
  366.    matx[t0] = matx[step];
  367.    matx[step] = bx;
  368.    x = (bx & 7)*40;
  369.    y = (bx >> 3)*25;
  370.    RectFill(rp,x,y,x+39,y+24);
  371. }
  372.  
  373. LeftLinePanel(rp,step)
  374. struct RastPort *rp;
  375. int step;
  376. {
  377. long x,y;
  378.  
  379.    x = step*5+4;
  380.    for (y = 0; y != 200L; y += 2)
  381.       {
  382.       Move(rp,0L,y);
  383.       Draw(rp,x,y);
  384.       Move(rp,319L-x,y+1L);
  385.       Draw(rp,319L,y+1L);
  386.       }
  387. }
  388.  
  389. GrowBoxes(rp,step)
  390. struct RastPort *rp;
  391. int step;
  392. {
  393. long x,y;
  394. int stepx,stepy;
  395.  
  396.    if ((step & 3) != 0)
  397.       return;
  398.    stepx = 15-(step >> 2);
  399.    stepy = 3-(step >> 4);
  400.    for (x = 0L; x != 320L; x += 32L)
  401.       for (y = 0L; y != 200L; y += 8L)
  402.          RectFill(rp,stepx+x,stepy+y,(31-stepx)+x,(7-stepy)+y);
  403. }
  404.  
  405.  
  406. SideToSide(rp,step)
  407. struct RastPort *rp;
  408. int step;
  409. {
  410. long xstep;
  411.  
  412.    if ((step & 1) != 0)
  413.       return;
  414.    xstep = 155-(step >> 1)*5;
  415.    RectFill(rp,0L,0L,159L-xstep,199L);
  416.    RectFill(rp,159L+xstep,0L,319L,199L);
  417. }
  418.  
  419. DoTmpStuff(rp)
  420. struct RastPort *rp;
  421. {
  422. static UWORD areabuffer[2000];
  423. PLANEPTR TmpRasPlane;
  424. static struct TmpRas MyTmpRas;
  425. static struct AreaInfo MyAreaInfo;
  426.  
  427. InitArea(&MyAreaInfo,&areabuffer[0],800L);
  428. rp->AreaInfo = &MyAreaInfo;
  429. if (!(TmpRasPlane = AllocRaster(330L,210L)))
  430.    exit(0L);
  431. InitTmpRas(&MyTmpRas,TmpRasPlane,RASSIZE(330L,210L));
  432. rp->TmpRas = &MyTmpRas;
  433. }
  434.  
  435. DetachAll()
  436. {
  437. FreeRaster(MaskRast->TmpRas->RasPtr,330L,210L);
  438. FreeRaster(MaskRast->BitMap->Planes[0],320L,200L);
  439. }
  440.  
  441. int XYClock[130] = {
  442.  0,99,-16,99,-31,97,-46,95,-61,91,-75,87,-88,82,
  443. -101,77,-112,70,-123,63,-132,55,-140,47,-147,38,-152,29,
  444. -156,19,-158,10,-159,0,-158, -10,-156, -19,-152, -29,-147, -38,
  445. -140, -47,-132, -55,-123, -63,-112, -70,-101, -77,-88, -82,-75, -87,
  446. -61, -91,-46, -95,-31, -97,-16, -99, 0, -99, 16, -99, 31, -97,
  447.  46, -95, 61, -91, 75, -87, 88, -82, 101, -77, 112, -70, 123, -63,
  448.  132, -55, 140, -47, 147, -38, 152, -29, 156, -19, 158, -10, 159,0,
  449.  158,10, 156,19, 152,29, 147,38, 140,47, 132,55, 123,63,
  450.  112,70, 101,77, 88,82, 75,87, 61,91, 46,95, 31,97,
  451.  16,99, 0,99
  452.    };
  453.  
  454. OneClock(rp,step)
  455. struct RastPort *rp;
  456. int step;
  457. {
  458. long step48;
  459.  
  460.    AreaMove(rp,(long) 160+XYClock[step*2],(long) 100+XYClock[step*2+1]);
  461.    AreaDraw(rp,160L,100L);
  462.    AreaDraw(rp,(long) 160+XYClock[step*2+2],(long) 100+XYClock[step*2+3]);
  463.    AreaEnd(rp);
  464.    if (step > 47)
  465.       {
  466.       step48 = step-48;
  467.       RectFill(rp,0L,0L,step48*10L,step48*5L);
  468.       RectFill(rp,0L,199L-step48*5L,step48*10L,199L);
  469.       RectFill(rp,319L-step48*10L,0L,319L,step48*5L);
  470.       RectFill(rp,319L-step48*10L,199L-step48*5L,319L,199L);
  471.       }
  472. }
  473.  
  474. RandomOut(rp,step)
  475. struct RastPort *rp;
  476. int step;
  477. {
  478. long x,y;
  479. int i,numdots;
  480.  
  481.    if ((numdots = step*20) > 2000)
  482.       numdots = 2000;
  483.    for (i = 0; i != numdots; i++)
  484.       {
  485.       x = 160-(step*5)/2+(rand() % (step*5+1));
  486.       y = 100-(step*25)/16+(rand() % (step*3+4));
  487.       WritePixel(rp,x,y);
  488.       }
  489.    if (step > 47)
  490.       {
  491.       RectFill(rp,300L-10L*(step & 15),0L,319L-10L*(step & 15),199L);
  492.       RectFill(rp,10L*(step & 15),0L,9L+10L*(step & 15),199L);
  493.       }
  494. }
  495.  
  496. TwoClock(rp,step)
  497. struct RastPort *rp;
  498. int step;
  499. {
  500. long line,nx,ny;
  501. static long ox,oy;
  502.  
  503.    if (!step)
  504.       ox = oy = 0;
  505.  
  506.    line = 8*step+4;
  507.    if (line < 320)
  508.       {
  509.       nx = line;
  510.       ny = 0;
  511.       }
  512.    else
  513.       {
  514.       nx = 319;
  515.       ny = line-320;
  516.       }
  517.  
  518.    AreaMove(rp,ox,oy);
  519.    AreaDraw(rp,nx,ny);
  520.    AreaDraw(rp,160L,100L);
  521.    AreaMove(rp,319-ox,199-oy);
  522.    AreaDraw(rp,319-nx,199-ny);
  523.    AreaDraw(rp,159L,99L);
  524.    AreaEnd(rp);
  525.    ox = nx;
  526.    oy = ny;
  527. }
  528.  
  529. ExpandBox(rp,step)
  530. struct RastPort *rp;
  531. int step;
  532. {
  533. int x,y;
  534.  
  535.    x = (5*step)/2;
  536.    y = (25*step)/16;
  537.    RectFill(rp,(long) (160-x),(long) (100-y),(long) (160+x),(long) (100+y));
  538. }
  539.  
  540. Doors(rp,step)
  541. struct RastPort *rp;
  542. int step;
  543. {
  544. long doorx,doory;
  545.  
  546.    doorx = 159-(5*(63-step))/2;
  547.    doory = (63-step)/2;
  548.    AreaMove(rp,0L,0L);
  549.    AreaDraw(rp,doorx,doory);
  550.    AreaDraw(rp,doorx,199-doory);
  551.    AreaDraw(rp,0L,199L);
  552.    AreaEnd(rp);
  553.    AreaMove(rp,319L,0L);
  554.    AreaDraw(rp,319-doorx,doory);
  555.    AreaDraw(rp,319-doorx,199-doory);
  556.    AreaDraw(rp,319L,199L);
  557.    AreaEnd(rp);
  558. }
  559.  
  560. Spiral(rp,step)
  561. struct RastPort *rp;
  562. int step;
  563. {
  564. int bx;
  565. long x,y;
  566. static int spiral[64] = {
  567.    0,1,2,3,4,5,6,7,15,23,31,39,47,55,63,
  568.    62,61,60,59,58,57,56,48,40,32,24,16,8,
  569.    9,10,11,12,13,14,22,30,38,46,54,53,52,
  570.    51,50,49,41,33,25,17,18,19,20,21,29,37,
  571.    45,44,43,42,34,26,27,28,36,35
  572.    };
  573.  
  574.    bx = spiral[step];
  575.    x = (bx & 7)*40;
  576.    y = (bx >> 3)*25;
  577.    RectFill(rp,x,y,x+39,y+24);
  578. }
  579.  
  580. WipeUp(rp,step)
  581. struct RastPort *rp;
  582. int step;
  583. {
  584. long y;
  585.  
  586.    y = (step * 200) / 65;
  587.    RectFill(rp,0L,196L-y,319L,199L-y);
  588. }
  589.  
  590. WipeDown(rp,step)
  591. struct RastPort *rp;
  592. int step;
  593. {
  594. long y;
  595.  
  596.    y = (step * 200) / 64;
  597.    RectFill(rp,0L,y,319L,y+3L);
  598. }
  599.  
  600. WipeRight(rp,step)
  601. struct RastPort *rp;
  602. int step;
  603. {
  604.    RectFill(rp,step*5L,0L,step*5L+4L,199L);
  605. }
  606.  
  607. WipeLeft(rp,step)
  608. struct RastPort *rp;
  609. int step;
  610. {
  611.    RectFill(rp,315L-step*5L,0L,319L-step*5L,199L);
  612. }
  613.  
  614. WipeDiag(rp,step)
  615. struct RastPort *rp;
  616. int step;
  617. {
  618. long x,y;
  619.  
  620.    x = 10*(step+1);
  621.    y = 9*(step+1);
  622.    AreaMove(rp,0L,0L);
  623.    if (x < 320)
  624.       AreaClip(rp,x,0L);
  625.    else
  626.       {
  627.       AreaClip(rp,319L,0L);
  628.       AreaClip(rp,319L,y-287L);
  629.       }
  630.    if (y < 200)
  631.       AreaClip(rp,0L,y);
  632.    else
  633.       {
  634.       AreaClip(rp,x-221L,199L);
  635.       AreaClip(rp,0L,199L);
  636.       }
  637.    AreaEnd(rp);
  638. }
  639.  
  640. TwoBox(rp,step)
  641. struct RastPort *rp;
  642. int step;
  643. {
  644. long x,y;
  645.  
  646.    x = (step * 79) / 63;
  647.    y = (step * 99) / 63;
  648.    RectFill(rp,79L-x,99L-y,80L+x,100L+y);
  649.    RectFill(rp,239L-x,99L-y,240L+x,100L+y);
  650. }
  651.  
  652. Shades(rp,step)
  653. struct RastPort *rp;
  654. int step;
  655. {
  656. long x,y;
  657.  
  658.    for (x = 0; x != 320; x += 64)
  659.       for (y = 0; y != 200; y += 50)
  660.          {
  661.          Move(rp,x+step,y);
  662.          Draw(rp,x+step,y+24L);
  663.          Move(rp,x+63-step,y+25L);
  664.          Draw(rp,x+63-step,y+49L);
  665.          }
  666. }
  667.  
  668. RandomShade(rp,step)
  669. struct RastPort *rp;
  670. int step;
  671. {
  672. static unsigned char matx[16];
  673. int t0,bx,num;
  674. static long x,y;
  675.  
  676.    if (step == 0)
  677.       for (t0 = 0; t0 != 16; t0++)
  678.          matx[t0] = t0;
  679.    if ((step & 3) == 0)
  680.       {
  681.       num = step/4;
  682.       t0 = (rand() % (16-num))+num;
  683.       bx = matx[t0];
  684.       matx[t0] = matx[num];
  685.       matx[num] = bx;
  686.       x = (bx & 3)*80;
  687.       y = (bx >> 2)*50;
  688.       }
  689.    step &= 3;
  690.    RectFill(rp,x+step*20L,y,x+19L+step*20L,y+49L);
  691. }
  692.  
  693. SymArr(rp,step)
  694. struct RastPort *rp;
  695. int step;
  696. {
  697. long x,y;
  698.  
  699.    x = 5*step;
  700.    if (x < 160)
  701.       {
  702.       y = (100*x)/160;
  703.       AreaMove(rp,0L,99L-y);
  704.       AreaDraw(rp,x,99L);
  705.       AreaDraw(rp,0L,100L+y);
  706.       AreaMove(rp,319L,99L-y);
  707.       AreaDraw(rp,319L-x,99L);
  708.       AreaDraw(rp,319L,100L+y);
  709.       AreaEnd(rp);
  710.       }
  711.    else
  712.       {
  713.       RectFill(rp,0L,0L,x-160L,199L);
  714.       RectFill(rp,479L-x,0L,319L,199L);
  715.       AreaMove(rp,x-160L,0L);
  716.       AreaDraw(rp,x,99L);
  717.       AreaDraw(rp,x-160L,199L);
  718.       AreaEnd(rp);
  719.       AreaMove(rp,479L-x,0L);
  720.       AreaDraw(rp,319L-x,99L);
  721.       AreaDraw(rp,479L-x,199L);
  722.       AreaEnd(rp);
  723.       }
  724. }
  725.  
  726. AreaClip(rp,x,y)
  727. long x,y;
  728. struct RastPort *rp;
  729. {
  730.    if (x > 319)
  731.       x = 319;
  732.    if (y > 199)
  733.       y = 199;
  734.    if (x < 0)
  735.       x = 0;
  736.    if (y < 0)
  737.       y = 0;
  738.    AreaDraw(rp,x,y);
  739. }
  740.  
  741. FourSweep(rp,step)
  742. struct RastPort *rp;
  743. int step;
  744. {
  745. static long x1,y1;
  746. long x2,y2;
  747.  
  748.    if (step == 0)
  749.       x1 = y1 = 0;
  750.    x2 = (step+1)*5-1;
  751.    y2 = ((step+1)*200)/64-1;
  752.    AreaMove(rp,x1,0L);
  753.    AreaDraw(rp,x2,0L);
  754.    AreaDraw(rp,319L-x2,199L);
  755.    AreaDraw(rp,319L-x1,199L);
  756.    AreaMove(rp,0L,199L-y1);
  757.    AreaDraw(rp,0L,199L-y2);
  758.    AreaDraw(rp,319L,y2);
  759.    AreaDraw(rp,319L,y1);
  760.    AreaEnd(rp);
  761.    x1 = x2;
  762.    y1 = y2;
  763. }
  764.  
  765. HexSweep(rp,step)
  766. struct RastPort *rp;
  767. int step;
  768. {
  769. long x,y,xa,ya;
  770.  
  771.    xa = (step * 79) / 64;
  772.    ya = (step * 49) / 64;
  773.    for (x = 0; x != 320; x += 80)
  774.       for (y = 0; y != 200; y += 50)
  775.          {
  776.          RectFill(rp,x,y,x+79L-xa,y+ya);
  777.          RectFill(rp,x+xa,y+49L-ya,x+79L,y+49L);
  778.          }
  779. }
  780.  
  781. FourLines(rp,step)
  782. struct RastPort *rp;
  783. int step;
  784. {
  785. long z1,z2;
  786. int step8;
  787.  
  788.    if (step & 1)
  789.       return;
  790.    step8 = (step & 0x0f)/2;
  791.    switch (step >> 4)
  792.       {
  793.       case 0:
  794.       case 1:
  795.          step8 = (step & 0x1f)/2;
  796.          z1 = 20*step8;
  797.          for (z2 = 0; z2 != 20; z2 += 2)
  798.             {
  799.             Move(rp,z1+z2,0L);
  800.             Draw(rp,z1+z2,199L);
  801.             }
  802.          break;
  803.       case 2:
  804.          z1 = 25*step8;
  805.          for (z2 = (step8 & 1); z2 <= 25; z2 += 2)
  806.             {
  807.             Move(rp,0L,z1+z2);
  808.             Draw(rp,319L,z1+z2);
  809.             }
  810.          break;
  811.       case 3:
  812.          z1 = 40*step8;
  813.          for (z2 = 0; z2 != 40; z2 += 2)
  814.             {
  815.             Move(rp,319L-(z1+z2),0L);
  816.             Draw(rp,319L-(z1+z2),199L);
  817.             }
  818.          break;
  819.       }
  820. }
  821.  
  822. DiagSplit(rp,step)
  823. struct RastPort *rp;
  824. int step;
  825. {
  826. int bx;
  827. long x,y;
  828. static int split[64] = {
  829.    56,49,42,35,28,21,14,7,
  830.    6,13,20,27,34,41,48,
  831.    40,33,26,19,12,5,
  832.    4,11,18,25,32,
  833.    24,17,10,3,
  834.    2,9,16,
  835.    8,1,
  836.    0,
  837.    63,
  838.    62,55,
  839.    47,54,61,
  840.    60,53,46,39,
  841.    31,38,45,52,59,
  842.    58,51,44,37,30,23,
  843.    15,22,29,36,43,50,57
  844.    };
  845.  
  846.    bx = split[step];
  847.    x = (bx & 7)*40;
  848.    y = (bx >> 3)*25;
  849.    RectFill(rp,x,y,x+39,y+24);
  850. }
  851.  
  852. Xes(rp,step)
  853. struct RastPort *rp;
  854. int step;
  855. {
  856. static unsigned char matx[64];
  857. int t0,bx;
  858. long x,y;
  859.  
  860.    if (step == 0)
  861.       for (t0 = 0; t0 != 64; t0++)
  862.          matx[t0] = t0;
  863.    t0 = (rand() % (64-step))+step;
  864.    bx = matx[t0];
  865.    matx[t0] = matx[step];
  866.    matx[step] = bx;
  867.    x = (bx & 7)*40;
  868.    y = (bx >> 3)*25;
  869.    AreaMove(rp,x,y);
  870.    AreaClip(rp,x+4L,y);
  871.    AreaClip(rp,x+19L,y+10L);
  872.    AreaClip(rp,x+34L,y);
  873.    AreaClip(rp,x+39L,y);
  874.    AreaClip(rp,x+39L,y+3L);
  875.    AreaClip(rp,x+25L,y+12L);
  876.    AreaClip(rp,x+39L,y+21L);
  877.    AreaClip(rp,x+39L,y+24L);
  878.    AreaClip(rp,x+34L,y+24L);
  879.    AreaClip(rp,x+19L,y+14L);
  880.    AreaClip(rp,x+4L,y+24L);
  881.    AreaClip(rp,x,y+24L);
  882.    AreaClip(rp,x,y+21L);
  883.    AreaClip(rp,x+15L,y+12L);
  884.    AreaClip(rp,x,y+3L);
  885.    AreaEnd(rp);
  886.    if (step >= 32)
  887.       RectFill(rp,(step-32)*10L,0L,(step-32)*10L+9L,199L);
  888. }
  889.  
  890. SlideBoxes(rp,step)
  891. struct RastPort *rp;
  892. int step;
  893. {
  894. long x,y,xa,ya;
  895.  
  896.    xa = (step * 79)/63;
  897.    ya = (step * 49)/63;
  898.    for (x = 0; x != 320; x += 80)
  899.       for (y = 0; y != 200; y += 50)
  900.          RectFill(rp,x,y,x+xa,y+ya);
  901. }
  902.  
  903. Cannon(rp,step)
  904. struct RastPort *rp;
  905. int step;
  906. {
  907. int sstep,tstep;
  908.  
  909.    sstep = step & 0x0f;
  910.    switch (step >> 4)
  911.       {
  912.       case 0:
  913.          RectFill(rp,206L,96L,216L,103L);
  914.          RectFill(rp,sstep*4L,90L,sstep*4L+3L,109L);
  915.          break;
  916.       case 1:
  917.          RectFill(rp,64L+sstep*4L,95L,sstep*4L+67L,104L);
  918.          break;
  919.       case 2:
  920.          SetAPen(rp,0L);
  921.          RectFill(rp,128L,99L,205L,100L);
  922.          RectFill(rp,124L-sstep*4L,95L,127L-sstep*4L,104L);
  923.          SetAPen(rp,1L);
  924.          RectFill(rp,126L+sstep*5L,99L,130L+sstep*5L,100L);
  925.          break;
  926.       case 3:
  927.          for (tstep = 0; tstep != 40; tstep++)
  928.             {
  929.             Move(rp,206L,99L);
  930.             Draw(rp,rand() % 320L,rand() % 200L);
  931.             }
  932.          if (sstep > 7)
  933.             {
  934.             tstep = sstep-8;
  935.             RectFill(rp,206L-(tstep*206L)/7L,99L-(tstep*99L)/7L,
  936.                206L+(tstep*114L)/7L,100L+(tstep*99L)/7L);
  937.             }
  938.          break;
  939.       }
  940. }
  941.  
  942. Drip(rp,step)
  943. struct BitMap *rp;
  944. int step;
  945. {
  946. static long y1[8] = {450,300,700,500,199,400,340,210};
  947. long y;
  948. int t0;
  949.  
  950.    for (t0 = 0; t0 != 8; t0++)
  951.       {
  952.       y = (y1[t0]*step)/63;
  953.       if (y > 199)
  954.          y = 199;
  955.       RectFill(rp,t0*40L,0L,t0*40L+39L,y);
  956.       }
  957. }
  958.  
  959. MovingWindow(rp,step)
  960. struct BitMap *rp;
  961. int step;
  962. {
  963. long x,y;
  964.  
  965.    if (step < 48)
  966.       {
  967.       SetRast(rp,0L);
  968.       x = (140L*step)/47;
  969.       y = (80L*step)/47;
  970.       RectFill(rp,x,y,x+39L,y+39L);
  971.       }
  972.    else
  973.       {
  974.       x = ((step-48)*140L)/7L+20L;
  975.       y = ((step-48)*80L)/7L+20L;
  976.       RectFill(rp,160L-x,100L-y,159L+x,99L+y);
  977.       }
  978. }
  979.  
  980. int RoughSin(ang)
  981. int ang;
  982. {
  983. static int sintab[8] = {
  984.    1,7,8,5,-1,-7,-8,-5
  985.    };
  986.  
  987.    return(sintab[ang & 0x07]);
  988. }
  989.  
  990. Monolith(rp,step)
  991. struct RastPort *rp;
  992. int step;
  993. {
  994. long maxy,x1,x2,y;
  995.  
  996.    SetRast(rp,0L);
  997.    maxy = (105L*step)/63L;
  998.    x1 = (150L*step)/63L;
  999.    x2 = (165L*step)/63L;
  1000.    y = (maxy*RoughSin(step+4))/8;
  1001.    AreaMove(rp,159L,99L);
  1002.    AreaClip(rp,159L-x1,99L-y);
  1003.    AreaClip(rp,159L+x1,99L-y);
  1004.    AreaClip(rp,159L+x2,100L+y);
  1005.    AreaClip(rp,159L-x2,100L+y);
  1006.    AreaClip(rp,159L-x1,99L-y);
  1007.    AreaEnd(rp);
  1008. }
  1009.  
  1010. Sun(rp,step)
  1011. struct RastPort *rp;
  1012. int step;
  1013. {
  1014. int t0;
  1015. long x,y;
  1016.  
  1017.    x = (159L*step)/63;
  1018.    y = (99L*step)/63;
  1019.    SetRast(rp,0L);
  1020.    for (t0 = 0; t0 != 50; t0++)
  1021.       {
  1022.       Move(rp,159L,99L);
  1023.       Draw(rp,rand() % 320L,rand() % 200L);
  1024.       }
  1025.    RectFill(rp,159L-x,99L-y,160L+x,100L+y);
  1026. }
  1027.  
  1028. MergeWindows(rp,step)
  1029. struct RastPort *rp;
  1030. int step;
  1031. {
  1032. long x,ss;
  1033.  
  1034.    SetRast(rp,0L);
  1035.    SetDrMd(rp,COMPLEMENT);
  1036.    x = (130L*step)/47L;
  1037.    if (step < 48)
  1038.       {
  1039.       RectFill(rp,x,65L,x+59L,114L);
  1040.       RectFill(rp,260L-x,85L,319L-x,134L);
  1041.       }
  1042.    if (step > 47 && step < 58)
  1043.       {
  1044.       ss = step-48;
  1045.       RectFill(rp,130L,65L+ss,189L,114L+ss);
  1046.       RectFill(rp,130L,85L-ss,189L,134L-ss);
  1047.       }
  1048.    if (step > 47)
  1049.       {
  1050.       ss = (99L*(step-48))/15L;
  1051.       RectFill(rp,0L,0L,319L,ss);
  1052.       RectFill(rp,0L,199L-ss,319L,199L);
  1053.       }
  1054.    SetDrMd(rp,JAM1);
  1055. }
  1056.  
  1057. Slides(rp,step)
  1058. struct RastPort *rp;
  1059. int step;
  1060. {
  1061. static int right,brick;
  1062.  
  1063.    if (step == 0)
  1064.       {
  1065.       right = 11;
  1066.       brick = 0;
  1067.       }
  1068.    else
  1069.       {
  1070.       brick++;
  1071.       if (brick != right)
  1072.          {
  1073.          SetAPen(rp,0L);
  1074.          RectFill(rp,29L*brick-29L,0L,29L*brick-1L,199L);
  1075.          }
  1076.       else
  1077.          {
  1078.          right--; 
  1079.          brick = 0;
  1080.          }
  1081.       }
  1082.    SetAPen(rp,1L);
  1083.    RectFill(rp,29L*brick,0L,29L*brick+28L,199L);
  1084. }
  1085.  
  1086. Rain(rp,step)
  1087. struct RastPort *rp;
  1088. int step;
  1089. {
  1090. static unsigned char matx[64];
  1091. int t0,t1,bx;
  1092. long x,y;
  1093.  
  1094.    if (step == 0)
  1095.       for (t0 = 0; t0 != 64; t0++)
  1096.          matx[t0] = 0;
  1097.  
  1098.    for (t0 = 0; t0 != 8; t0++)
  1099.       for (t1 = 6; t1 >= 0; t1--)
  1100.          {
  1101.          bx = t0+t1*8;
  1102.          if (matx[bx] == 1 && matx[bx+8] == 0)
  1103.             {
  1104.             x = t0*40;
  1105.             y = t1*25;
  1106.             SetAPen(rp,0L);
  1107.             RectFill(rp,x,y,x+39L,y+24L);
  1108.             matx[bx] = 0;
  1109.             matx[bx+8] = 1;
  1110.             SetAPen(rp,1L);
  1111.             RectFill(rp,x,y+25L,x+39L,y+49L);
  1112.             }
  1113.          }
  1114.    while (matx[t0 = (rand() % 8)]);
  1115.    matx[t0] = 1;
  1116.    RectFill(rp,t0*40L,0L,t0*40L+39L,24L);
  1117. }
  1118.