home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 311.lha / Wipedemo_v4.0 / mywipe.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-12-10  |  29.2 KB  |  1,468 lines
  1. /* mywipe2.h by Paul Falstad */
  2.  
  3. extern long numplanes;
  4. long mx,my,cx,cy,bx,by,topcol,yadd,bpr,D4Store;
  5. #include "wipecount.h"
  6. #include "jiff.h"
  7. #define CX(X) ((X) << cx)
  8. #define CY(Y) ((Y) << cy)
  9. struct RastPort *MaskRast = 0;
  10. struct BitMap *NewMap;
  11. WORD BMod;
  12. PLANEPTR AllocClearRaster();
  13.  
  14. struct BitMap *SetupMaps(info,wn)
  15. struct ILBM_info *info;
  16. int wn;
  17. {
  18. static struct BitMap MBitMap,NBitMap;
  19. static struct RastPort MRast;
  20. int t0,neww,newh;
  21.  
  22.    InitBitMap(&NBitMap,numplanes,mx,my);
  23.    for (t0 = 0; t0 != numplanes; t0++)
  24.       if (!(NBitMap.Planes[t0] = AllocClearRaster(mx,my)))
  25.          {
  26.          while (t0)
  27.             FreeRaster(NBitMap.Planes[--t0],mx,my);
  28.          free_planes(&info->bitmap);
  29.          TheEnd();
  30.          }
  31.    NewMap = &NBitMap;
  32.    neww = info->header.w;
  33.    newh = info->header.h;
  34.    if (neww > mx)
  35.       neww = mx;
  36.    if (newh > my)
  37.       newh = my;
  38.    BltBitMap(&info->bitmap,0L,0L,NewMap,((long) mx-neww) >> 1,
  39.          ((long) my-newh) >> 1,(long) neww,(long) newh,0xc0L,
  40.          (1L << info->header.nPlanes)-1L,0L);
  41.    WaitBlit();
  42.    free_planes(&info->bitmap);
  43.    InitBitMap(&MBitMap,1L,mx,my);
  44.    if ((MBitMap.Planes[0] = (PLANEPTR) AllocRaster(mx,my)) == NULL)
  45.       {
  46.       for (t0 = 0; t0 != numplanes; t0++)
  47.          FreeRaster(NBitMap.Planes[t0],mx,my);
  48.       TheEnd();
  49.       }
  50.    InitRastPort(&MRast);
  51.    MRast.BitMap = &MBitMap;
  52.    SetAPen(&MRast,1L);
  53.    MaskRast = &MRast;
  54.    DoTmpStuff(MaskRast);
  55.    printf("wipe #%d\n",wn);
  56. }
  57.  
  58. LoadPict(name,WipeScreen,wipesel,cycsel,fadeflag,exclmap,hires,lace)
  59. struct Screen *WipeScreen;
  60. char *name;
  61. int wipesel,fadeflag,cycsel;
  62. BOOL exclmap[WIPECOUNT],hires,lace;
  63. {
  64. int t0,whichwipe,numleft;
  65. struct ILBM_info *info;
  66. static UWORD oldcmap[32];
  67. static BOOL RandMap[WIPECOUNT];
  68. struct BitMap *ScrnMap;
  69. UWORD startword;
  70. long modes;
  71.  
  72. if (hires) { mx = 768; cx = 1; topcol = 16; }
  73.       else { mx = 384; cx = 0; topcol = 32; }
  74. if (lace)  { my = 480; cy = 1; } else { my = 240; cy = 0; }
  75. startword = ((lace) ? 0x7800 : 0x3c00) | ((hires) ? 0x0030 : 0x0018);
  76. bpr = mx/8;
  77.  
  78. bx = mx-1; by = my-1;
  79. modes = WipeScreen->ViewPort.Modes & ~(HAM | EXTRA_HALFBRITE);
  80. StopCringe();
  81. info = read_iff(name,NULL);
  82. if (info == NULL)
  83.    return(NULL);
  84.  
  85. if (info->camg)
  86.    modes = info->camg;
  87.  
  88. if (wipesel == -1)
  89.    {
  90.    for (t0 = numleft = 0; t0 != WIPECOUNT; t0++)
  91.       if (!RandMap[t0] && !exclmap[t0])
  92.          numleft++;
  93.    if (!numleft)
  94.       for (t0 = 0; t0 != WIPECOUNT; t0++)
  95.          RandMap[t0] = FALSE;
  96.    do
  97.       whichwipe = rand() % WIPECOUNT;
  98.    while (RandMap[whichwipe] || exclmap[whichwipe]);
  99.  
  100.    RandMap[whichwipe] = TRUE;
  101.    }
  102. else
  103.    whichwipe = wipesel;
  104.  
  105. SetupMaps(info,whichwipe);
  106.  
  107. GetCols(&WipeScreen->ViewPort,&oldcmap[0]);
  108. for (t0 = 0; t0 != topcol*3; t0++)
  109.    info->cmap[t0] >>= 4;
  110.  
  111. if (WipeScreen->ViewPort.Modes & HAM)
  112.    WipeOut(&WipeScreen->ViewPort,&WipeScreen->RastPort,&oldcmap[0],info->cmap,
  113.       mx,my,(int) topcol);
  114. else
  115.    FadeOut(&WipeScreen->RastPort,&WipeScreen->ViewPort,&oldcmap[0],info->cmap);
  116. SetRast(&WipeScreen->RastPort,0L);
  117. WipeScreen->ViewPort.Modes = modes;
  118. MakeScreen(WipeScreen);
  119. RethinkDisplay();
  120. yadd = BMod = 0;
  121. ScrnMap = WipeScreen->RastPort.BitMap;
  122. for (t0 = 0; t0 != 64; t0++)
  123.    Wipe(ScrnMap,t0,whichwipe,startword);
  124. FreeAll();
  125. if (cycsel)
  126.    CycleScreen(WipeScreen,info);
  127. }
  128.  
  129. FreeAll()
  130. {
  131. int t0;
  132.  
  133.    for (t0 = 0; t0 != numplanes; t0++)
  134.       FreeRaster(NewMap->Planes[t0],mx,my);
  135.    FreeRaster(MaskRast->TmpRas->RasPtr,mx+10L,my+10L);
  136.    FreeRaster(MaskRast->BitMap->Planes[0],mx,my);
  137. }
  138.  
  139. GetCols(vport,cmap)
  140. UWORD *cmap;
  141. struct ViewPort *vport;
  142. {
  143. long t0;
  144.  
  145.    for (t0 = 0; t0 != topcol; t0++)
  146.       cmap[t0] = GetRGB4(vport->ColorMap,t0);
  147. }
  148.  
  149. FadeOut(rport,vport,cmap,ncmap)
  150. UWORD *cmap;
  151. UBYTE *ncmap;
  152. struct ViewPort *vport;
  153. struct RastPort *rport;
  154. {
  155. long r,g,b,col;
  156. int or,og,ob;
  157. int nfix;
  158. int step;
  159.  
  160.    for (step = 0; step != 32; step++)
  161.       {
  162.       Delay(1L);
  163.       nfix = 31-step;
  164.       for (col = 0; col != topcol; col++)
  165.          {
  166.          r = (nfix * ((cmap[col] >> 8) & 0x0f));
  167.          g = (nfix * ((cmap[col] >> 4) & 0x0f));
  168.          b = (nfix * ((cmap[col]) & 0x0f));
  169.          SetRGB4(vport,col,r >> 5,g >> 5,b >> 5);
  170.          }
  171.       }
  172.    SetRast(rport,0L);
  173.    Delay(10L);
  174.    for (col = 0; col != topcol; col++)
  175.       {
  176.       or = ncmap[col*3]; og = ncmap[col*3+1]; ob = ncmap[col*3+2];
  177.       cmap[col] = (or << 8) | (og << 4) | ob;
  178.       SetRGB4(vport,col,(long) or,(long) og,(long) ob);
  179.       }
  180. }
  181.  
  182. void DoTheBlitSh_t(),Sh_tLoop();
  183.  
  184. Wipe(dispbits,step,wipeid,startword)
  185. struct BitMap *dispbits;
  186. int step,wipeid; /* step 0 to 63 */
  187. UWORD startword;
  188. {
  189. int plane;
  190. static BOOL rastinited = FALSE;
  191. PLANEPTR *p1,*p2,p3,*p4;
  192.  
  193. if (step == 0)
  194.    SetRast(MaskRast,0L);
  195.  
  196. switch(wipeid) {
  197.  case 0:
  198.    UpAndDownPanel(MaskRast,step);
  199.    break;
  200.  case 1:
  201.    Random(MaskRast,step);
  202.    break;
  203.  case 2:
  204.    LeftLinePanel(MaskRast,step);
  205.    break;
  206.  case 3:
  207.    Dice(MaskRast,step);
  208.    break;
  209.  case 4:
  210.    GrowBoxes(MaskRast,step);
  211.    break;
  212.  case 5:
  213.    SideToSide(MaskRast,step);
  214.    break;
  215.  case 6:
  216.    TwoClock(MaskRast,step);
  217.    break;
  218.  case 7:
  219.    OneClock(MaskRast,step);
  220.    break;
  221.  case 8:
  222.    RandomOut(MaskRast,step);
  223.    break;
  224.  case 9:
  225.    Spiral(MaskRast,step);
  226.    break;
  227.  case 10:
  228.    ExpandBox(MaskRast,step);
  229.    break;
  230.  case 11:
  231.    Doors(MaskRast,step);
  232.    break;
  233.  case 12:
  234.    WipeUp(MaskRast,step);
  235.    break;
  236.  case 13:
  237.    WipeDown(MaskRast,step);
  238.    break;
  239.  case 14:
  240.    WipeLeft(MaskRast,step);
  241.    break;
  242.  case 15:
  243.    WipeRight(MaskRast,step);
  244.    break;
  245.  case 16:
  246.    WipeDiag(MaskRast,step);
  247.    break;
  248.  case 17:
  249.    TwoBox(MaskRast,step);
  250.    break;
  251.  case 18:
  252.    Shades(MaskRast,step);
  253.    break;
  254.  case 19:
  255.    RandomShade(MaskRast,step);
  256.    break;
  257.  case 20:
  258.    SymArr(MaskRast,step);
  259.    break;
  260.  case 21:
  261.    FourSweep(MaskRast,step);
  262.    break;
  263.  case 22:
  264.    FourLines(MaskRast,step);
  265.    break;
  266.  case 23:
  267.    HexSweep(MaskRast,step);
  268.    break;
  269.  case 24:
  270.    DiagSplit(MaskRast,step);
  271.    break;
  272.  case 25:
  273.    Xes(MaskRast,step);
  274.    break;
  275.  case 26:
  276.    SlideBoxes(MaskRast,step);
  277.    break;
  278.  case 27:
  279.    Cannon(MaskRast,step);
  280.    break;
  281.  case 28:
  282.    Drip(MaskRast,step);
  283.    break;
  284.  case 29:
  285.    MovingWindow(MaskRast,step);
  286.    break;
  287.  case 30:
  288.    Sun(MaskRast,step);
  289.    break;
  290.  case 31:
  291.    Monolith(MaskRast,step);
  292.    break;
  293.  case 32:
  294.    Rain(MaskRast,step);
  295.    break;
  296.  case 33:
  297.    MergeWindows(MaskRast,step);
  298.    break;
  299.  case 34:
  300.    Slides(MaskRast,step);
  301.    break;
  302.  case 35:
  303.    RandomDown(MaskRast,step);
  304.    break;
  305.  case 36:
  306.    Stretch(MaskRast,step);
  307.    break;
  308.  case 37:
  309.    ExpandSlide(MaskRast,step);
  310.    break;
  311.  case 38:
  312.    SlideSlabs(MaskRast,step);
  313.    break;
  314.  case 39:
  315.    Checkerboard(MaskRast,step);
  316.    break;
  317.  case 40:
  318.    MiniRandom(MaskRast,step);
  319.    break;
  320.  case 41:
  321.    ConcentricRectangles(MaskRast,step);
  322.    break;
  323.  case 42:
  324.    Cloverleaf(MaskRast,step);
  325.    break;
  326.  case 43:
  327.    Cloverleaf2(MaskRast,step);
  328.    break;
  329.  case 44:
  330.    ConcentricRectangles2(MaskRast,step);
  331.    break;
  332.    };
  333.  
  334. if (step == 63)
  335.    {
  336.    SetRast(MaskRast,1L);
  337.    yadd = 0;
  338.    }
  339. p1 = &dispbits->Planes[numplanes];
  340. p2 = &NewMap->Planes[numplanes];
  341. p3 = MaskRast->BitMap->Planes[0];
  342.  
  343.    OwnBlitter();
  344.    WaitBlit();
  345.    Forbid();
  346.    DoTheBlitSh_t(p1,p2,p3,0L,startword,(int) (numplanes-1));
  347.    Permit();
  348.    DisownBlitter();
  349. }
  350.  
  351. #asm
  352.       cseg
  353. _DoTheBlitSh_t:
  354.       move.l d4,_D4Store
  355.       clr.l d4
  356.       move.w 22(sp),d4     ;# planes
  357.       movea.l 4(sp),a2     ;&Dest
  358.       movea.l 8(sp),a3     ;&New
  359. _Sh_tLoop:
  360.       move.l 12(sp),$dff050 ; A get mask argument
  361.       clr.w $dff060  ; modulos
  362.       move.w _BMod,$dff062   ;BMod
  363.       clr.l $dff064
  364.       move.l #$0fc00000,$dff040 ;bltcon01
  365.       move.l -(a3),d0        ; B
  366.       add.l _yadd,d0        ; add yadd
  367.       move.l d0,$dff04c      ; B
  368.       move.l #$ffffffff,$dff044 ; first & last word masks
  369.       move.l -(a2),$dff054   ; D
  370.  
  371.       move.w #$8400,$dff096  ; set Blitter Nasty
  372.       move.w 20(sp),$dff058  ; go! (should be $3c18) AB
  373.       jsr _WaitBlit
  374.       move.w #$0400,$dff096  ; Blitter Nice
  375.       dbf.w d4,_Sh_tLoop
  376.       move.l _D4Store,d4
  377.       rts
  378.  
  379. #endasm
  380.  
  381. DoTmpStuff(rp)
  382. struct RastPort *rp;
  383. {
  384. static UWORD areabuffer[125];
  385. PLANEPTR TmpRasPlane;
  386. static struct TmpRas MyTmpRas;
  387. static struct AreaInfo MyAreaInfo;
  388.  
  389. InitArea(&MyAreaInfo,&areabuffer[0],50L);
  390. rp->AreaInfo = &MyAreaInfo;
  391. if (!(TmpRasPlane = AllocRaster(mx+10L,my+10L)))
  392.    TheEnd();
  393. InitTmpRas(&MyTmpRas,TmpRasPlane,RASSIZE(mx+10L,my+10L));
  394. rp->TmpRas = &MyTmpRas;
  395. }
  396.  
  397. PLANEPTR AllocClearRaster(xm,ym)
  398. long xm,ym;
  399. {
  400. PLANEPTR pl;
  401.  
  402.    pl = AllocMem(xm/8L*ym,MEMF_CHIP|MEMF_CLEAR);
  403.    if (!pl)
  404.       return(0L);
  405.    return(pl);
  406. }
  407.  
  408. UpAndDownPanel(rp,step)
  409. struct RastPort *rp;
  410. int step;
  411. {
  412. long t0,t1,t2,t3;
  413.  
  414.    t3 = (step*by)/63;
  415.    for (t0 = 0, t1 = 24, t2 = 48; t0 != 384; t0 += 48, t1 += 48, t2 += 48)
  416.       {
  417.       RectFill(rp,CX(t0),0L,CX(t1)-1L,t3);
  418.       RectFill(rp,CX(t1),by-t3,CX(t2)-1L,by);
  419.       }
  420. }
  421.  
  422. Dice(rp,step)
  423. struct RastPort *rp;
  424. int step;
  425. {
  426. long s3,s2;
  427.  
  428.    s3 = bx*step/126;
  429.    s2 = by*step/126;
  430.    RectFill(rp,0L,0L,s3,s2);
  431.    RectFill(rp,0L,by-s2,s3,by);
  432.    RectFill(rp,bx-s3,0L,bx,s2);
  433.    RectFill(rp,bx-s3,by-s2,bx,by);
  434.    RectFill(rp,bx/2-CX(step),by/2-CY(step),bx/2+CX(step),by/2+CY(step));
  435. }
  436.  
  437. Random(rp,step)
  438. struct RastPort *rp;
  439. int step;
  440. {
  441. static unsigned char matx[64];
  442. int t0,qx;
  443. long x,y;
  444.  
  445.    if (step == 0)
  446.       for (t0 = 0; t0 != 64; t0++)
  447.          matx[t0] = t0;
  448.  
  449.    t0 = (rand() % (64-step))+step;
  450.    qx = matx[t0];
  451.    matx[t0] = matx[step];
  452.    matx[step] = qx;
  453.    x = CX((qx & 7)*48);
  454.    y = CY((qx >> 3)*30);
  455.    RectFill(rp,x,y,x+CX(48)-1L,y+CY(30)-1L);
  456. }
  457.  
  458. LeftLinePanel(rp,step)
  459. struct RastPort *rp;
  460. int step;
  461. {
  462. long x,y;
  463.  
  464.    x = (step*bx)/63;
  465.    for (y = 0; y != my; y += 2)
  466.       {
  467.       Move(rp,0L,y);
  468.       Draw(rp,x,y);
  469.       Move(rp,bx-x,y+1L);
  470.       Draw(rp,bx,y+1L);
  471.       }
  472. }
  473.  
  474. GrowBoxes(rp,step)
  475. struct RastPort *rp;
  476. int step;
  477. {
  478. long x1,y1,x2,y2;
  479. int stepx,stepy;
  480.  
  481.    if ((step & 3) != 0)
  482.       return;
  483.    stepx = 15-(step >> 2);
  484.    stepy = 3-(step >> 4);
  485.    for (x1 = CX(stepx), x2 = CX(32-stepx)-1; x1 < mx;
  486.          x1 += CX(32L), x2 += CX(32L))
  487.       for (y1 = CY(stepy), y2 = CY(8-stepy)-1; y1 < my;
  488.             y1 += CY(8L), y2 += CY(8L))
  489.          RectFill(rp,x1,y1,x2,y2);
  490. }
  491.  
  492. SideToSide(rp,step)
  493. struct RastPort *rp;
  494. int step;
  495. {
  496. long xstep,bx2;
  497.  
  498.    if ((step & 1) != 0)
  499.       return;
  500.    bx2 = bx/2;
  501.    xstep = CX(188-(step >> 1)*6);
  502.    RectFill(rp,0L,0L,bx2-xstep,by);
  503.    RectFill(rp,bx2+xstep,0L,bx,by);
  504. }
  505.  
  506. int XYClock[130] = {
  507.  0,99,-16,99,-31,97,-46,95,-61,91,-75,87,-88,82,
  508. -101,77,-112,70,-123,63,-132,55,-140,47,-147,38,-152,29,
  509. -156,19,-158,10,-159,0,-158, -10,-156, -19,-152, -29,-147, -38,
  510. -140, -47,-132, -55,-123, -63,-112, -70,-101, -77,-88, -82,-75, -87,
  511. -61, -91,-46, -95,-31, -97,-16, -99, 0, -99, 16, -99, 31, -97,
  512.  46, -95, 61, -91, 75, -87, 88, -82, 101, -77, 112, -70, 123, -63,
  513.  132, -55, 140, -47, 147, -38, 152, -29, 156, -19, 158, -10, 159,0,
  514.  158,10, 156,19, 152,29, 147,38, 140,47, 132,55, 123,63,
  515.  112,70, 101,77, 88,82, 75,87, 61,91, 46,95, 31,97,
  516.  16,99, 0,99
  517.    };
  518.  
  519. OneClock(rp,step)
  520. struct RastPort *rp;
  521. int step;
  522. {
  523. long step48,ccx,ccy;
  524.  
  525.    ccx = cx+1; ccy = cy+1;
  526.    AreaMove(rp,ccx*(192L+XYClock[step*2]*191L/159),
  527.       ccy*(120L+XYClock[step*2+1]*119L/99));
  528.    AreaDraw(rp,mx/2,my/2);
  529.    AreaDraw(rp,ccx*(192L+XYClock[step*2+2]*191L/159),
  530.       ccy*(120L+XYClock[step*2+3]*119L/99));
  531.    AreaEnd(rp);
  532.    if (step > 47)
  533.       {
  534.       step48 = step-48;
  535.       RectFill(rp,0L,0L,CX(step48*12L),CY(step48*8L));
  536.       RectFill(rp,0L,by-CY(step48*8L),CX(step48*12L),by);
  537.       RectFill(rp,bx-CX(step48*12L),0L,bx,CY(step48*8L));
  538.       RectFill(rp,bx-CX(step48*12L),by-CY(step48*8L),bx,by);
  539.       }
  540. }
  541.  
  542. RandomOut(rp,step)
  543. struct RastPort *rp;
  544. int step;
  545. {
  546. long x,y,x1,x2,y1,y2;
  547. int i,num;
  548.  
  549.    x1 = mx/2-CX(step*5)/2;
  550.    x2 = CX(step*5+1);
  551.    y1 = my/2-CY(step*25)/16;
  552.    y2 = CY(step*3+4);
  553.    num = 7*step;
  554.    for (i = 0; i != num; i++)
  555.       {
  556.       x = x1+(rand() % x2);
  557.       y = y1+(rand() % y2);
  558.       WritePixel(rp,x,y);
  559.       }
  560.    if (step > 47)
  561.       {
  562.       RectFill(rp,CX(371L-12L*(step & 15)),0L,bx-CX(12L*(step & 15)),by);
  563.       RectFill(rp,CX(12L*(step & 15)),0L,CX(12L*(1+(step & 15)))-1L,by);
  564.       }
  565. }
  566.  
  567. TwoClock(rp,step)
  568. struct RastPort *rp;
  569. int step;
  570. {
  571. long line,nx,ny;
  572. static long ox,oy;
  573.  
  574.    if (!step)
  575.       ox = oy = 0;
  576.  
  577.    line = (622L*step)/63L;
  578.    if (line < 384)
  579.       {
  580.       nx = line;
  581.       ny = 0;
  582.       }
  583.    else
  584.       {
  585.       nx = 383;
  586.       ny = line-384;
  587.       }
  588.    AreaMove(rp,CX(ox),CY(oy));
  589.    AreaDraw(rp,CX(nx),CY(ny));
  590.    AreaDraw(rp,mx/2,my/2);
  591.    AreaMove(rp,bx-CX(ox),by-CY(oy));
  592.    AreaDraw(rp,bx-CX(nx),by-CY(ny));
  593.    AreaDraw(rp,bx/2,by/2);
  594.    AreaEnd(rp);
  595.    ox = nx;
  596.    oy = ny;
  597. }
  598.  
  599. ExpandBox(rp,step)
  600. struct RastPort *rp;
  601. int step;
  602. {
  603. int x,y;
  604.  
  605.    x = step*mx/126;
  606.    y = step*my/126;
  607.    RectFill(rp,(long) (mx/2-x),(long) (my/2-y),
  608.                (long) (mx/2+x),(long) (my/2+y));
  609. }
  610.  
  611. Doors(rp,step)
  612. struct RastPort *rp;
  613. int step;
  614. {
  615. long doorx,doory;
  616.  
  617.    doorx = CX(step*191/63);
  618.    doory = CY(63-step);
  619.    AreaMove(rp,0L,0L);
  620.    AreaDraw(rp,doorx,doory);
  621.    AreaDraw(rp,doorx,by-doory);
  622.    AreaDraw(rp,0L,by);
  623.    AreaEnd(rp);
  624.    AreaMove(rp,bx,0L);
  625.    AreaDraw(rp,bx-doorx,doory);
  626.    AreaDraw(rp,bx-doorx,by-doory);
  627.    AreaDraw(rp,bx,by);
  628.    AreaEnd(rp);
  629. }
  630.  
  631. Spiral(rp,step)
  632. struct RastPort *rp;
  633. int step;
  634. {
  635. int qx;
  636. long x,y;
  637. static int spiral[64] = {
  638.    0,1,2,3,4,5,6,7,15,23,31,39,47,55,63,
  639.    62,61,60,59,58,57,56,48,40,32,24,16,8,
  640.    9,10,11,12,13,14,22,30,38,46,54,53,52,
  641.    51,50,49,41,33,25,17,18,19,20,21,29,37,
  642.    45,44,43,42,34,26,27,28,36,35
  643.    };
  644.  
  645.    qx = spiral[step];
  646.    x = CX((qx & 7)*48);
  647.    y = CY((qx >> 3)*30);
  648.    RectFill(rp,x,y,x+CX(48)-1L,y+CY(30)-1L);
  649. }
  650.  
  651. WipeUp(rp,step)
  652. struct RastPort *rp;
  653. int step;
  654. {
  655. long y;
  656.  
  657.    y = (step * by) / 63;
  658.    yadd = -(by-y)*bpr;
  659.    RectFill(rp,0L,by-y,bx,by);
  660. }
  661.  
  662. WipeDown(rp,step)
  663. struct RastPort *rp;
  664. int step;
  665. {
  666. long y;
  667.  
  668.    y = (step * my) / 63;
  669.    yadd = (by-y)*bpr;
  670.    RectFill(rp,0L,0L,bx,y);
  671. }
  672.  
  673. WipeRight(rp,step)
  674. struct RastPort *rp;
  675. int step;
  676. {
  677.    RectFill(rp,CX(step*6L),0L,CX((step+1)*6L)-1,by);
  678. }
  679.  
  680. WipeLeft(rp,step)
  681. struct RastPort *rp;
  682. int step;
  683. {
  684.    RectFill(rp,mx-CX((step+1)*6L),0L,bx-CX(step*6L),by);
  685. }
  686.  
  687. WipeDiag(rp,step)
  688. struct RastPort *rp;
  689. int step;
  690. {
  691. long x,y;
  692.  
  693.    x = 12*(step+1);
  694.    y = 8*(step+1);
  695.    AreaMove(rp,0L,0L);
  696.    if (x < 384)
  697.       AreaClip(rp,CX(x),0L);
  698.    else
  699.       {
  700.       AreaClip(rp,bx,0L);
  701.       AreaClip(rp,bx,CY(y-255L)); /* y = 8/12 x */
  702.       }
  703.    if (y < 240)
  704.       AreaClip(rp,0L,CY(y));
  705.    else
  706.       {
  707.       AreaClip(rp,CX(x-358L),by); /* x = 12/8 y */
  708.       AreaClip(rp,0L,by);
  709.       }
  710.    AreaEnd(rp);
  711. }
  712.  
  713. TwoBox(rp,step)
  714. struct RastPort *rp;
  715. int step;
  716. {
  717. long x,y;
  718.  
  719.    x = (step * 95) / 63;
  720.    y = (step * 119) / 63;
  721.    RectFill(rp,CX(95L-x),CY(119L-y),CX(96L+x),CY(120L+y));
  722.    RectFill(rp,CX(287L-x),CY(119L-y),CX(288L+x),CY(120L+y));
  723. }
  724.  
  725. Shades(rp,step)
  726. struct RastPort *rp;
  727. int step;
  728. {
  729. long x,y;
  730.  
  731.    for (x = 0; x != 384; x += 64)
  732.       for (y = 0; y != 240; y += 60)
  733.          {
  734.          Move(rp,CX(x+step),CY(y));
  735.          Draw(rp,CX(x+step),CY(y+30L)-1L);
  736.          Move(rp,CX(x+64-step)-1L,CY(y+30L));
  737.          Draw(rp,CX(x+64-step)-1L,CY(y+60L)-1L);
  738.          if (cx == 1)
  739.             {
  740.             Move(rp,CX(x+step)+1L,CY(y));
  741.             Draw(rp,CX(x+step)+1L,CY(y+30L)-1L);
  742.             Move(rp,CX(x+64-step)-2L,CY(y+30L));
  743.             Draw(rp,CX(x+64-step)-2L,CY(y+60L)-1L);
  744.             }
  745.          }
  746. }
  747.  
  748. RandomShade(rp,step)
  749. struct RastPort *rp;
  750. int step;
  751. {
  752. static unsigned char matx[16];
  753. int t0,qx,num;
  754. static long x,y;
  755.  
  756.    if (step == 0)
  757.       for (t0 = 0; t0 != 16; t0++)
  758.          matx[t0] = t0;
  759.    if ((step & 3) == 0)
  760.       {
  761.       num = step/4;
  762.       t0 = (rand() % (16-num))+num;
  763.       qx = matx[t0];
  764.       matx[t0] = matx[num];
  765.       matx[num] = qx;
  766.       x = (qx & 3)*96;
  767.       y = (qx >> 2)*60;
  768.       }
  769.    step &= 3;
  770.    RectFill(rp,CX(x+step*24L),CY(y),CX(x+(step+1)*24L)-1L,CY(y+60L)-1L);
  771. }
  772.  
  773. SymArr(rp,step)
  774. struct RastPort *rp;
  775. int step;
  776. {
  777. long x,y;
  778.  
  779.    x = 6*step;
  780.    if (x < 192)
  781.       {
  782.       y = (120*x)/192;
  783.       AreaMove(rp,0L,CY(119L-y));
  784.       AreaDraw(rp,CX(x),CY(120L)-1L);
  785.       AreaDraw(rp,0L,CY(120L+y));
  786.       AreaMove(rp,bx,CY(119L-y));
  787.       AreaDraw(rp,bx-CX(x),CY(120L)-1L);
  788.       AreaDraw(rp,bx,CY(120L+y));
  789.       AreaEnd(rp);
  790.       }
  791.    else
  792.       {
  793.       RectFill(rp,0L,0L,CX(x-192L),by);
  794.       RectFill(rp,CX(575L-x),0L,bx,by);
  795.       AreaMove(rp,CX(x-192L),0L);
  796.       AreaDraw(rp,CX(x),CY(119L));
  797.       AreaDraw(rp,CX(x-192L),by);
  798.       AreaEnd(rp);
  799.       AreaMove(rp,CX(575L-x),0L);
  800.       AreaDraw(rp,bx-CX(x),CY(119L));
  801.       AreaDraw(rp,CX(575L-x),by);
  802.       AreaEnd(rp);
  803.       }
  804. }
  805.  
  806. AreaClip(rp,x,y)
  807. long x,y;
  808. struct RastPort *rp;
  809. {
  810.    if (x > bx)
  811.       x = bx;
  812.    if (y > by)
  813.       y = by;
  814.    if (x < 0)
  815.       x = 0;
  816.    if (y < 0)
  817.       y = 0;
  818.    AreaDraw(rp,x,y);
  819. }
  820.  
  821. FourSweep(rp,step)
  822. struct RastPort *rp;
  823. int step;
  824. {
  825. static long x1,y1;
  826. long x2,y2,x3,y3;
  827.  
  828.    if (step == 0)
  829.       x1 = y1 = 0;
  830.    x2 = (step+1)*6-1;
  831.    y2 = ((step+1)*240)/64-1;
  832.    x1 = CX(x1);   y1 = CY(y1);
  833.    x3 = CX(x2);   y3 = CY(y2);
  834.    AreaMove(rp,x1,0L);
  835.    AreaDraw(rp,x3,0L);
  836.    AreaDraw(rp,bx-x3,by);
  837.    AreaDraw(rp,bx-x1,by);
  838.    AreaMove(rp,0L,by-y1);
  839.    AreaDraw(rp,0L,by-y3);
  840.    AreaDraw(rp,bx,y3);
  841.    AreaDraw(rp,bx,y1);
  842.    AreaEnd(rp);
  843.    x1 = x2;
  844.    y1 = y2;
  845. }
  846.  
  847. HexSweep(rp,step)
  848. struct RastPort *rp;
  849. int step;
  850. {
  851. long x,y,xa,ya;
  852.  
  853.    xa = (step * 95) / 63;
  854.    ya = (step * 59) / 63;
  855.    for (x = 0; x != 384; x += 96)
  856.       for (y = 0; y != 240; y += 60)
  857.          {
  858.          RectFill(rp,CX(x),CY(y),CX(x+96L-xa)-1L,CY(y+ya+1L));
  859.          RectFill(rp,CX(x+xa),CY(y+59L-ya)-1L,CX(x+96L)-1L,CY(y+60L)-1L);
  860.          }
  861. }
  862.  
  863. FourLines(rp,step)
  864. struct RastPort *rp;
  865. int step;
  866. {
  867. long z1,z2;
  868. int step8;
  869.  
  870.    if (step & 1)
  871.       return;
  872.    step8 = (step & 0x0f)/2;
  873.    switch (step >> 4)
  874.       {
  875.       case 0:
  876.       case 1:
  877.          step8 = (step & 0x1f)/2;
  878.          z1 = CX(24*step8);
  879.          for (z2 = 0; z2 != CX(24); z2 += 2)
  880.             {
  881.             Move(rp,z1+z2,0L);
  882.             Draw(rp,z1+z2,by);
  883.             }
  884.          break;
  885.       case 2:
  886.          z1 = CY(30*step8);
  887.          for (z2 = 0; z2 != CY(30); z2 += 2)
  888.             {
  889.             Move(rp,0L,z1+z2);
  890.             Draw(rp,bx,z1+z2);
  891.             }
  892.          break;
  893.       case 3:
  894.          z1 = CX(40*step8);
  895.          for (z2 = 0; z2 != CX(48); z2 += 2)
  896.             {
  897.             Move(rp,bx-(z1+z2),0L);
  898.             Draw(rp,bx-(z1+z2),by);
  899.             }
  900.          break;
  901.       }
  902. }
  903.  
  904. DiagSplit(rp,step)
  905. struct RastPort *rp;
  906. int step;
  907. {
  908. int qx;
  909. long x,y;
  910. static int split[64] = {
  911.    56,49,42,35,28,21,14,7,
  912.    6,13,20,27,34,41,48,
  913.    40,33,26,19,12,5,
  914.    4,11,18,25,32,
  915.    24,17,10,3,
  916.    2,9,16,
  917.    8,1,
  918.    0,
  919.    63,
  920.    62,55,
  921.    47,54,61,
  922.    60,53,46,39,
  923.    31,38,45,52,59,
  924.    58,51,44,37,30,23,
  925.    15,22,29,36,43,50,57
  926.    };
  927.  
  928.    qx = split[step];
  929.    x = (qx & 7)*48;
  930.    y = (qx >> 3)*30;
  931.    RectFill(rp,CX(x),CY(y),CX(x+48)-1L,CY(y+30)-1L);
  932. }
  933.  
  934. Xes(rp,step)
  935. struct RastPort *rp;
  936. int step;
  937. {
  938. static unsigned char matx[64];
  939. int t0,qx;
  940. long x,y;
  941.  
  942.    if (step == 0)
  943.       for (t0 = 0; t0 != 64; t0++)
  944.          matx[t0] = t0;
  945.    t0 = (rand() % (64-step))+step;
  946.    qx = matx[t0];
  947.    matx[t0] = matx[step];
  948.    matx[step] = qx;
  949.    x = (qx & 7)*48;
  950.    y = (qx >> 3)*30;
  951.    AreaMove(rp,CX(x),CY(y));
  952.    AreaClip(rp,CX(x+5L),CY(y));
  953.    AreaClip(rp,CX(x+23L),CY(y+12L));
  954.    AreaClip(rp,CX(x+41L),CY(y));
  955.    AreaClip(rp,CX(x+48L)-1L,CY(y));
  956.    AreaClip(rp,CX(x+48L)-1L,CY(y+4L));
  957.    AreaClip(rp,CX(x+30L),CY(y+14L));
  958.    AreaClip(rp,CX(x+48L)-1L,CY(y+25L));
  959.    AreaClip(rp,CX(x+48L)-1L,CY(y+30L)-1L);
  960.    AreaClip(rp,CX(x+41L),CY(y+30L)-1L);
  961.    AreaClip(rp,CX(x+23L),CY(y+17L));
  962.    AreaClip(rp,CX(x+5L),CY(y+30L)-1L);
  963.    AreaClip(rp,CX(x),CY(y+30L)-1L);
  964.    AreaClip(rp,CX(x),CY(y+25L));
  965.    AreaClip(rp,CX(x+18L),CY(y+14L));
  966.    AreaClip(rp,CX(x),CY(y+4L));
  967.    AreaEnd(rp);
  968.    if (step >= 32)
  969.       RectFill(rp,CX(step-32)*12L,0L,CX(step-31)*12L-1L,by);
  970. }
  971.  
  972. SlideBoxes(rp,step)
  973. struct RastPort *rp;
  974. int step;
  975. {
  976. long x,y,xa,ya;
  977.  
  978.    xa = (step * 95)/63;
  979.    ya = (step * 59)/63;
  980.    for (x = 0; x != 384; x += 96)
  981.       for (y = 0; y != 240; y += 60)
  982.          RectFill(rp,CX(x),CY(y),CX(x+xa),CY(y+ya));
  983. }
  984.  
  985. Cannon(rp,step)
  986. struct RastPort *rp;
  987. int step;
  988. {
  989. int sstep,tstep;
  990.  
  991.    sstep = step & 0x0f;
  992.    switch (step >> 4)
  993.       {
  994.       case 0:
  995.          RectFill(rp,CX(247L),CY(115L),CX(260L)-1L,CY(125L)-1L);
  996.          RectFill(rp,CX(sstep*5L),CY(108L),CX(sstep*5L+5L)-1L,CY(131L));
  997.          break;
  998.       case 1:
  999.          RectFill(rp,CX(80L+sstep*5L),CY(114L),CX(sstep*5L+85L)-1L,CY(126L)-1L);
  1000.          break;
  1001.       case 2:
  1002.          SetAPen(rp,0L);
  1003.          RectFill(rp,CX(160L),CY(119L),CX(247L)-1L,CY(120L));
  1004.          RectFill(rp,CX(155L-sstep*5L),CY(114L),CX(159L-sstep*5L),CY(126L)-1L);
  1005.          SetAPen(rp,1L);
  1006.          RectFill(rp,CX(160L+sstep*5L),CY(119L),CX(164L+sstep*5L),CY(120L));
  1007.          break;
  1008.       case 3:
  1009.          for (tstep = 0; tstep != 40; tstep++)
  1010.             {
  1011.             Move(rp,CX(247L),CY(119L));
  1012.             Draw(rp,rand() % mx,rand() % my);
  1013.             }
  1014.          if (sstep > 7)
  1015.             {
  1016.             tstep = sstep-8;
  1017.             RectFill(rp,CX(247L-(tstep*247L)/7L),CY(119L-(tstep*119L)/7L),
  1018.                CX(247L+(tstep*137L)/7L),CY(120L+(tstep*119L)/7L));
  1019.             }
  1020.          break;
  1021.       }
  1022. }
  1023.  
  1024. Drip(rp,step)
  1025. struct BitMap *rp;
  1026. int step;
  1027. {
  1028. static long y1[8] = {450,310,750,600,239,400,350,270};
  1029. long y;
  1030. int t0;
  1031.  
  1032.    for (t0 = 0; t0 != 8; t0++)
  1033.       {
  1034.       y = CY((y1[t0]*step)/63);
  1035.       if (y > by)
  1036.          y = by;
  1037.       RectFill(rp,CX(t0*48L),0L,CY((t0+1)*48L)-1L,y);
  1038.       }
  1039. }
  1040.  
  1041. MovingWindow(rp,step)
  1042. struct BitMap *rp;
  1043. int step;
  1044. {
  1045. long x,y;
  1046.  
  1047.    if (step < 48)
  1048.       {
  1049.       SetRast(rp,0L);
  1050.       x = (172L*step)/47;
  1051.       y = (100L*step)/47;
  1052.       yadd = bpr*(47-step);
  1053.       RectFill(rp,CX(x),CY(y),CX(x+40)-1L,CY(y+40)-1L);
  1054.       }
  1055.    else
  1056.       {
  1057.       x = ((step-48)*172L)/15L+20L;
  1058.       y = ((step-48)*100L)/15L+20L;
  1059.       RectFill(rp,CX(192L-x),CY(120L-y),CX(191L+x),CY(119L+y));
  1060.       }
  1061. }
  1062.  
  1063. int RoughSin(ang)
  1064. int ang;
  1065. {
  1066. static int sintab[8] = {
  1067.    1,7,8,5,-1,-7,-8,-5
  1068.    };
  1069.  
  1070.    return(sintab[ang & 0x07]);
  1071. }
  1072.  
  1073. Monolith(rp,step)
  1074. struct RastPort *rp;
  1075. int step;
  1076. {
  1077. long maxy,x1,x2,y,bx2,by2;
  1078.  
  1079.    bx2 = bx/2; by2 = by/2;
  1080.    SetRast(rp,0L);
  1081.    maxy = (120L*step)/63L;
  1082.    x1 = CX((170L*step)/63L);
  1083.    x2 = CX((190L*step)/63L);
  1084.    y = CY((maxy*RoughSin(step+4))/8);
  1085.    if (y < 0)
  1086.       {
  1087.       BMod = -2*bpr;
  1088.       yadd = bpr*by;
  1089.       }
  1090.    else
  1091.       {
  1092.       BMod = 0;
  1093.       yadd = 0;
  1094.       }
  1095.    AreaMove(rp,bx2,by2);
  1096.    AreaClip(rp,bx2-x1,by2-y);
  1097.    AreaClip(rp,bx2+x1,by2-y);
  1098.    AreaClip(rp,bx2+x2,by2+1+y);
  1099.    AreaClip(rp,bx2-x2,by2+y);
  1100.    AreaClip(rp,bx2-x1,by2+1-y);
  1101.    AreaEnd(rp);
  1102. }
  1103.  
  1104. Sun(rp,step)
  1105. struct RastPort *rp;
  1106. int step;
  1107. {
  1108. int t0;
  1109. long x,y;
  1110.  
  1111.    x = (191L*step)/63;
  1112.    y = (119L*step)/63;
  1113.    SetRast(rp,0L);
  1114.    for (t0 = 0; t0 != 50; t0++)
  1115.       {
  1116.       Move(rp,bx/2,by/2);
  1117.       Draw(rp,rand() % mx,rand() % my);
  1118.       }
  1119.    RectFill(rp,CX(191L-x),CY(119L-y),CX(192L+x),CY(120L+y));
  1120. }
  1121.  
  1122. MergeWindows(rp,step)
  1123. struct RastPort *rp;
  1124. int step;
  1125. {
  1126. long x,ss;
  1127.  
  1128.    SetRast(rp,0L);
  1129.    SetDrMd(rp,COMPLEMENT);
  1130.    x = (156L*step)/47L;
  1131.    if (step < 48)
  1132.       {
  1133.       RectFill(rp,CX(x),CY(78L),CX(x+71L),CY(137L));
  1134.       RectFill(rp,CX(312L-x),CY(102L),bx-CX(x),CY(161L));
  1135.       yadd = 2*bpr*(48-step);
  1136.       }
  1137.    if (step > 47 && step < 58)
  1138.       {
  1139.       ss = step-48;
  1140.       RectFill(rp,CX(156L),CY(78L+ss),CX(227L),CY(137L+ss));
  1141.       RectFill(rp,CX(156L),CY(102L-ss),CX(227L),CY(161L-ss));
  1142.       yadd = 0;
  1143.       }
  1144.    if (step > 47)
  1145.       {
  1146.       ss = CY((119L*(step-48))/15L);
  1147.       RectFill(rp,0L,0L,bx,ss);
  1148.       RectFill(rp,0L,by-ss,bx,by);
  1149.       }
  1150.    SetDrMd(rp,JAM1);
  1151. }
  1152.  
  1153. Slides(rp,step)
  1154. struct RastPort *rp;
  1155. int step;
  1156. {
  1157. static int right,brick;
  1158.  
  1159.    if (step == 0)
  1160.       {
  1161.       right = 11;
  1162.       brick = 0;
  1163.       }
  1164.    else
  1165.       {
  1166.       brick++;
  1167.       if (brick != right)
  1168.          {
  1169.          SetAPen(rp,0L);
  1170.          RectFill(rp,CX(34L*brick-35L),0L,CX(34L*brick)-1L,by);
  1171.          }
  1172.       else
  1173.          {
  1174.          right--; 
  1175.          brick = 0;
  1176.          }
  1177.       }
  1178.    SetAPen(rp,1L);
  1179.    RectFill(rp,CX(34L*brick),0L,34L*CX(brick+1)-1L,by);
  1180. }
  1181.  
  1182. Rain(rp,step)
  1183. struct RastPort *rp;
  1184. int step;
  1185. {
  1186. static unsigned char matx[64];
  1187. int t0,t1,qx;
  1188. long x,y;
  1189.  
  1190.    if (step == 0)
  1191.       for (t0 = 0; t0 != 64; t0++)
  1192.          matx[t0] = 0;
  1193.  
  1194.    for (t0 = 0; t0 != 8; t0++)
  1195.       for (t1 = 6; t1 >= 0; t1--)
  1196.          {
  1197.          qx = t0+t1*8;
  1198.          if (matx[qx] == 1 && matx[qx+8] == 0)
  1199.             {
  1200.             x = t0*48;
  1201.             y = t1*30;
  1202.             SetAPen(rp,0L);
  1203.             RectFill(rp,CX(x),CY(y),CX(x+48)-1L,CY(y+30)-1L);
  1204.             matx[qx] = 0;
  1205.             matx[qx+8] = 1;
  1206.             SetAPen(rp,1L);
  1207.             RectFill(rp,CX(x),CY(y+30L),CX(x+48L)-1L,CY(y+60L)-1L);
  1208.             }
  1209.          }
  1210.    while (matx[t0 = (rand() % 8)]);
  1211.    matx[t0] = 1;
  1212.    RectFill(rp,CX(t0*48L),0L,CX(t0+1)*48L-1L,CY(30L)-1L);
  1213. }
  1214.  
  1215. RandomDown(rp,step)
  1216. struct RastPort *rp;
  1217. int step;
  1218. {
  1219. static unsigned char matx[16];
  1220. int t0,qx,num;
  1221. static long x,y;
  1222.  
  1223.    if (step == 0)
  1224.       for (t0 = 0; t0 != 16; t0++)
  1225.          matx[t0] = t0;
  1226.    if ((step & 3) == 0)
  1227.       {
  1228.       num = step/4;
  1229.       t0 = (rand() % (16-num))+num;
  1230.       qx = matx[t0];
  1231.       matx[t0] = matx[num];
  1232.       matx[num] = qx;
  1233.       x = (qx & 3)*96;
  1234.       y = (qx >> 2)*60;
  1235.       }
  1236.    step &= 3;
  1237.    RectFill(rp,CX(x),CY(y+step*15),CX(x+96L)-1L,CY(y+step*15+15L)-1L);
  1238. }
  1239.  
  1240. Stretch(rp,step)
  1241. struct RastPort *rp;
  1242. int step;
  1243. {
  1244. long y,zmod;
  1245.  
  1246.    y = (by*step)/63;
  1247.    RectFill(rp,0L,by-y,bx,by);
  1248.    zmod = 16*bpr;
  1249.    if (y > 15)
  1250.       zmod = 8*bpr;
  1251.    if (y > 30)
  1252.       zmod = 4*bpr;
  1253.    if (y > 60)
  1254.       zmod = 2*bpr;
  1255.    if (y > 120)
  1256.       zmod = bpr;
  1257.    BMod = zmod-bpr;
  1258.    yadd = -(by-y)*zmod;
  1259. }
  1260.  
  1261. ExpandSlide(rp,step)
  1262. struct RastPort *rp;
  1263. int step;
  1264. {
  1265. long x,y,yz;
  1266. long x1,y1,x2,y2;
  1267.  
  1268.    yz = (my*step)/63;
  1269.    yadd = -bpr*(my-yz);
  1270.    x = step*mx/126;
  1271.    y = step*yz/126;
  1272.    x1 = mx/2-x;
  1273.    y1 = my-yz/2-y;
  1274.    x2 = mx/2+x;
  1275.    y2 = my-yz/2+y;
  1276.    if (x1 < 0)
  1277.       x1 = 0;
  1278.    if (y1 < 0)
  1279.       y1 = 0;
  1280.    if (x2 > bx)
  1281.       x2 = bx;
  1282.    if (y2 > by)
  1283.       y2 = by;
  1284.    if (x1 > x2)
  1285.       x1 = x2;
  1286.    if (y1 > y2)
  1287.       y1 = y2;
  1288.    RectFill(rp,x1,y1,x2,y2);
  1289. }
  1290.  
  1291. SlideSlabs(rp,step)
  1292. struct RastPort *rp;
  1293. int step;
  1294. {
  1295. long y,ya;
  1296.  
  1297.    ya = (step * 59)/63;
  1298.    for (y = 0; y != 240; y += 60)
  1299.       RectFill(rp,0L,CY(y),bx,CY(y+ya));
  1300.    yadd = (59-ya)*bpr;
  1301. }
  1302.  
  1303. HalfPic(rp,step)
  1304. struct RastPort *rp;
  1305. int step;
  1306. {
  1307. int step15;
  1308.  
  1309.    step15 = step & 15;
  1310.    switch (step / 16)
  1311.       {
  1312.       case 0:
  1313.          BMod = bpr;
  1314.          SetAPen(rp,1L);
  1315.          RectFill(rp,step15*bx/16,0L,(step15+1)*bx/16-1L,my/2-1L);
  1316.          break;
  1317.       case 1:
  1318.          SetAPen(rp,0L);
  1319.          RectFill(rp,step15*bx/16,0L,(step15+1)*bx/16-1L,my/2-1L);
  1320.          break;
  1321.       case 2:
  1322.       case 3:
  1323.          BMod = 0;
  1324.          SetAPen(rp,1L);
  1325.          step15 = step & 31;
  1326.          RectFill(rp,bx-(step15+1)*bx/32,0L,bx-step15*bx/32,by);
  1327.          break;
  1328.       }
  1329. }
  1330.  
  1331. Checkerboard(rp,step)
  1332. struct RastPort *rp;
  1333. int step;
  1334. {
  1335. long y;
  1336. int ww,wh,t0;
  1337.  
  1338.    if (step & 1)
  1339.       return;
  1340.    step >>= 1;
  1341.    ww = CX(16); wh = CY(15);
  1342.    if (step < 16)
  1343.       {
  1344.       y = (wh*step);
  1345.       wh--;
  1346.       for (t0 = (step & 1); t0 < 24; t0 += 2)
  1347.          RectFill(rp,(long) (t0*ww),y,(long) ((t0+1)*ww-1),y+wh);
  1348.       }
  1349.    else
  1350.       {
  1351.       y = by-(wh*(step & 15));
  1352.       wh--;
  1353.       for (t0 = (step & 1); t0 < 24; t0 += 2)
  1354.          RectFill(rp,(long) (t0*ww),y-wh,(long) ((t0+1)*ww-1),y);
  1355.       }
  1356. }
  1357.  
  1358. MiniRandom(rp,step)
  1359. struct RastPort *rp;
  1360. int step;
  1361. {
  1362. static unsigned char matx[256];
  1363. int t0,qx,t1,step4;
  1364. long x,y;
  1365.  
  1366.    if (step == 0)
  1367.       for (t0 = 0; t0 != 256; t0++)
  1368.          matx[t0] = t0;
  1369.    step4 = step << 2;
  1370.    for (t1 = 0; t1 != 4; t1++, step4++)
  1371.       {
  1372.       t0 = (rand() % (256-step4))+step4;
  1373.       qx = matx[t0];
  1374.       matx[t0] = matx[step4];
  1375.       matx[step4] = qx;
  1376.       x = CX((qx & 15)*24);
  1377.       y = CY((qx >> 4)*15);
  1378.       RectFill(rp,x,y,x+CX(24)-1L,y+CY(15)-1L);
  1379.       }
  1380. }
  1381.  
  1382. ConcentricRectangles(rp,step)
  1383. struct RastPort *rp;
  1384. int step;
  1385. {
  1386. long divx,divy,x30,y30;
  1387.  
  1388.    SetRast(rp,0L);
  1389.    divx = CX(15)*step/64;
  1390.    divy = CY(15)*step/64;
  1391.    x30 = CX(30); y30 = CY(30);
  1392.    SetDrMd(rp,COMPLEMENT);
  1393.    RectFill(rp,0L,0L,bx,by);
  1394.    RectFill(rp,divx,divy,bx-divx,by-divy);
  1395.    RectFill(rp,x30-divx,y30-divy,bx-x30+divx,by-y30+divy);
  1396.    RectFill(rp,x30+divx,y30+divy,bx-x30-divx,by-y30-divy);
  1397.    RectFill(rp,x30*2-divx,y30*2-divy,bx-x30*2+divx,by-y30*2+divy);
  1398.    RectFill(rp,x30*2+divx,y30*2+divy,bx-x30*2-divx,by-y30*2-divy);
  1399.    RectFill(rp,x30*3-divx,y30*3-divy,bx-x30*3+divx,by-y30*3+divy);
  1400.    RectFill(rp,x30*3+divx,y30*3+divy,bx-x30*3-divx,by-y30*3-divy);
  1401.    if (divx > 1)
  1402.       RectFill(rp,x30*4-divx,y30*4-divy,bx-x30*4+divx,by-y30*4+divy);
  1403.    SetDrMd(rp,JAM1);
  1404. }
  1405.  
  1406. Flash(rp,step)
  1407. struct RastPort *rp;
  1408. int step;
  1409. {
  1410.    SetRast(rp,(long) (step & 1));
  1411. }
  1412.  
  1413. Cloverleaf(rp,step)
  1414. struct RastPort *rp;
  1415. int step;
  1416. {
  1417. long tx,ty,hbx,hby,hmx,hmy;
  1418.  
  1419.    hmx = mx >> 1;
  1420.    hmy = my >> 1;
  1421.    hbx = (hmx-1);
  1422.    hby = (hmy-1);
  1423.    tx = step*hbx/64;
  1424.    ty = step*hby/64;
  1425.    RectFill(rp,0L,0L,tx,hby);
  1426.    RectFill(rp,hmx,0L,bx,ty);
  1427.    RectFill(rp,bx-tx,hmy,bx,by);
  1428.    RectFill(rp,0L,by-ty,hbx,by);
  1429. }
  1430.  
  1431. Cloverleaf2(rp,step)
  1432. struct RastPort *rp;
  1433. int step;
  1434. {
  1435. long tx,ty,hbx,hby,hmx,hmy;
  1436.  
  1437.    hmx = mx >> 1;
  1438.    hmy = my >> 1;
  1439.    hbx = (hmx-1);
  1440.    hby = (hmy-1);
  1441.    tx = step*hbx/64;
  1442.    ty = step*hby/64;
  1443.    RectFill(rp,0L,hby-ty,hbx,hby);
  1444.    RectFill(rp,hmx,0L,hmx+tx,hby);
  1445.    RectFill(rp,hmx,hmy,bx,ty+hmy);
  1446.    RectFill(rp,hbx-tx,hmy,hbx,by);
  1447. }
  1448.  
  1449. ConcentricRectangles2(rp,step)
  1450. struct RastPort *rp;
  1451. int step;
  1452. {
  1453. long divx,divy,x60,y60;
  1454.  
  1455.    SetRast(rp,0L);
  1456.    divx = CX(30)*step/64;
  1457.    divy = CY(30)*step/64;
  1458.    x60 = CX(60); y60 = CY(60);
  1459.    SetDrMd(rp,COMPLEMENT);
  1460.    RectFill(rp,0L,0L,bx,by);
  1461.    RectFill(rp,divx,divy,bx-divx,by-divy);
  1462.    RectFill(rp,x60-divx,y60-divy,bx-x60+divx,by-y60+divy);
  1463.    RectFill(rp,x60+divx,y60+divy,bx-x60-divx,by-y60-divy);
  1464.    if (divx > 1)
  1465.       RectFill(rp,x60*2-divx,y60*2-divy,bx-x60*2+divx,by-y60*2+divy);
  1466.    SetDrMd(rp,JAM1);
  1467. }
  1468.