home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3634 / zot.c
Encoding:
C/C++ Source or Header  |  1991-07-16  |  26.3 KB  |  959 lines
  1. /********************************************************************
  2.  **                                                                **
  3.  **  ZOT! - a Pixrect-based screen manipulation package            **
  4.  **         written for SUN workstations                           **
  5.  **                                                                **
  6.  **  Version 1.1 written by:                                       **
  7.  **    Mark "Crimson" Friedman  (friedman@cis.ohio-state.edu)      **
  8.  **    and John "Rawhide" Wile  (wile@cis.ohio-state.edu)          **
  9.  **                                                                **
  10.  **  Zot allows you to manipulate the pixels of your (or another   **
  11.  **  user's)  screen in  several interesting, clever, and highly   **
  12.  **  annoying ways.  Amaze your friends!  Bother your neighbors!   **
  13.  **  Enrage your sysadmins!  All this in one neat little package.  **
  14.  **                                                                **
  15.  **                                           Enjoy!               **
  16.  **                                           - Mark Friedman      **
  17.  **                                                                **
  18.  **  COMPILING:                                                    **
  19.  **                                                                **
  20.  **  To compile, type (or cut-n-paste) the following line:         **
  21.  **                                                                **
  22.        cc zot.c -o zot -lpixrect
  23.  **                                                                **
  24.  **  Please  note that Zot! was  written on a monochrome Sun 4     **
  25.  **  SPARCstation  SLC.  It may not  work on other Suns (read:     **
  26.  **  DISCLAIMER!), though the  standard Pixrect library should     **
  27.  **  eliminate this  possibility.  Zot! has not been tested on     **
  28.  **  any other system, and it is unknown how Zot! will perform     **
  29.  **  on a color monitor.  If  you get Zot! working  on another     **
  30.  **  platform, drop us a line  and tell us  about it (well, if     **
  31.  **  you feel like it...).                                         **
  32.  **                                                                **
  33.  **  And yes, we know it's messy, but it's just for fun, right?    **
  34.  **                                                                **
  35.  **  COMMAND LINE OPTIONS:                                         **
  36.  **                                                                **
  37.  **  Standard modes are invoked by typing:                         **
  38.  **                                                                **
  39.  **    zot -<mode>                                                 **
  40.  **                                                                **
  41.  **  where <mode> is one of the following:                         **
  42.  **                                                                **
  43.  **    block       swaps blocks of pixels around the screen        **
  44.  **    flip        flip and mirror your screen in half             **
  45.  **    melt        slides the screen off in a melting fashion      **
  46.  **    negative    gives a photo-negative of the screen            **
  47.  **    slide       creates a worm that wanders the screen          **
  48.  **    snow        snow falls down from the top of the screen      **
  49.  **    static      another type of snow, like on your TV           **
  50.  **    vh          vertical hold problems (like on your TV)        **
  51.  **    weasel      weasely critters burrow across the screen       **
  52.  **    zigzag      draws random connected vectors                  **
  53.  **                                                                **
  54.  **  For a list of modes, try typing 'zot' (or 'zot -help').       **
  55.  **                                                                **
  56.  **  Options for each mode are specified with:                     **
  57.  **                                                                **
  58.  **    zot -<mode> [options]                                       **
  59.  **                                                                **
  60.  **  Also, 'zot -<mode> -help' will give you the options for       **
  61.  **  that particular mode.                                         **
  62.  **                                                                **
  63.  ********************************************************************/
  64.  
  65. #include <pixrect/pixrect_hs.h>
  66. #include <stdio.h>
  67. #include <signal.h>
  68.  
  69. /* define your favorite number generator here */
  70. #define RANDOM  random
  71. #define SRANDOM srandom
  72.  
  73. /* this is the flag to keeps track of interrupt signals for forever loops */
  74.   static int cont = 1;
  75.  
  76. /********************************************************************
  77.  **  signal routines                                               **
  78.  ********************************************************************/
  79.  
  80. /* upon an interrupt signal, this procedure will be called */
  81. void bailout()
  82. {
  83.   cont = 0;  /* signal an exit in a forever loop */
  84. }
  85.  
  86. /* catch interrupt signals for a clean get-away */
  87. void set_signals()
  88. {
  89.   signal(SIGINT,  bailout);
  90.   signal(SIGTERM, bailout);
  91.   signal(SIGQUIT, bailout);
  92. }
  93.  
  94. /********************************************************************
  95.  **  block-mode procedure                                          **
  96.  ********************************************************************/
  97.  
  98. block_main(argc, argv)
  99.      int   argc;
  100.      char *argv[];
  101. {
  102.   Pixrect *screen;
  103.   int     x, y, max_x, max_y, xx, yy, count, bsize = 50;
  104.  
  105.   /* parse arguments */
  106.   if(argc > 1)
  107.     for(count = 0; count < argc; count++)
  108.       if(*argv[count] == '-')
  109.     switch (*(++argv[count])) {
  110.     case 'h':  /* help option */
  111.       printf("Usage: zot -block [-z <size>]\n");
  112.       printf("<size> is between 1 and 200 (inclusive) ");
  113.       printf("and defaults to 50.\n");
  114.       exit(0);
  115.       break;
  116.     case 'z':  /* block size option */
  117.       if(count<argc-1)
  118.         bsize = atol(argv[++count]);
  119.       if(bsize < 1)
  120.         bsize = 1;
  121.       if(bsize > 200)
  122.         bsize = 200;
  123.       break;
  124.         default:
  125.       break;
  126.     }
  127.  
  128.   /* open the frame buffer and set signals */
  129.   screen = pr_open("/dev/fb");
  130.   set_signals();
  131.  
  132.   /* get screen dimensions */
  133.   max_x = screen->pr_size.x;
  134.   max_y = screen->pr_size.y;
  135.  
  136.   /* until an interrupt... */
  137.   while(cont)
  138.     {
  139.       /* initial coordinates */
  140.       x =  RANDOM() % (max_x / bsize) * bsize;
  141.       y =  RANDOM() % (max_y / bsize) * bsize;
  142.       /* new coordinates */
  143.       xx = RANDOM() % (max_x / bsize) * bsize;
  144.       yy = RANDOM() % (max_y / bsize) * bsize;
  145.       /* copy block */
  146.       pr_rop(screen, x, y, bsize, bsize, PIX_SRC, screen, xx, yy);
  147.     }
  148.  
  149.   /* close the buffer */
  150.   pr_close(screen);
  151. }
  152.  
  153. /********************************************************************
  154.  **  flip-mode procedure                                           **
  155.  ********************************************************************/
  156.  
  157. void flip_main(argc, argv)
  158.      int   argc;
  159.      char *argv[];
  160. {
  161.   Pixrect *screen;
  162.   int     max_x, max_y;
  163.   int     count, high, low, flipmode = 1, mirror = 0;
  164.  
  165.   /* parse arguments */
  166.   if(argc > 1)
  167.     for(count = 1; count < argc; count++)
  168.       if(*argv[count] == '-')
  169.     switch (*(++argv[count])) {
  170.         case 'b':  /* both option */
  171.       flipmode = 2;
  172.       break;
  173.         case 'h':
  174.       switch (*(++argv[count])) {
  175.       case 'o':  /* horizontal option */
  176.         flipmode = 3;
  177.         break;
  178.       default:  /* help option */
  179.         printf("Usage: zot -flip [flipmode]\n");
  180.         printf("flipmodes: -horizontal, -vertical (default), ");
  181.         printf("-both, -mirror\n");
  182.         exit (0);
  183.         break;
  184.       }
  185.       break;
  186.         case 'm':  /* mirror option */
  187.       mirror = 1;
  188.       break;
  189.     case 'v':  /* vertical option */
  190.       flipmode = 1;
  191.       break;
  192.         default:
  193.       break;
  194.     }
  195.  
  196.   /* open frame buffer */
  197.   screen = pr_open("/dev/fb");
  198.  
  199.   /* get screen dimensions */
  200.   max_x = screen->pr_size.x;
  201.   max_y = screen->pr_size.y;
  202.  
  203.   /* decide flipmode */
  204.   switch(flipmode) {
  205.   case 3:  /* horizontal mode */
  206.     for(low = 0, high = max_x - 2; low < high; low++, high--) {
  207.       if(!mirror)
  208.     pr_rop(screen, max_x - 1, 0, 1, max_y, PIX_SRC,
  209.            screen, low, 0);
  210.       pr_rop(screen, low, 0, 1, max_y, PIX_SRC,
  211.          screen, high, 0);
  212.       if(!mirror)
  213.     pr_rop(screen, high, 0, 1, max_y, PIX_SRC,
  214.            screen, max_x - 1, 0);
  215.     }
  216.     break;
  217.   case 2:  /* both mode */
  218.     for(low = 0, high = max_x - 2; low < high; low++, high--) {
  219.       if(!mirror)
  220.     pr_rop(screen, max_x - 1, 0, 1, max_y, PIX_SRC,
  221.            screen, low, 0);
  222.       pr_rop(screen, low, 0, 1, max_y, PIX_SRC,
  223.          screen, high, 0);
  224.       if(!mirror)
  225.     pr_rop(screen, high, 0, 1, max_y, PIX_SRC,
  226.            screen, max_x - 1, 0);
  227.     }
  228.     /* fall through to next case! */
  229.   default:  /* vertical mode */
  230.     for(low = 0, high = max_y - 2; low < high; low++, high--) {
  231.       if(!mirror)
  232.     pr_rop(screen, 0, max_y - 1, max_x, 1, PIX_SRC,
  233.            screen, 0, low);
  234.       pr_rop(screen, 0, low, max_x, 1, PIX_SRC,
  235.          screen, 0, high);
  236.       if(!mirror)
  237.     pr_rop(screen, 0, high, max_x, 1, PIX_SRC,
  238.            screen, 0, max_y - 1);
  239.     }
  240.     break;
  241.   }
  242.  
  243.   /* close frame buffer */
  244.   pr_close(screen);
  245. }
  246.  
  247. /********************************************************************
  248.  **  melt-mode procedure                                           **
  249.  ********************************************************************/
  250.  
  251. /* random function according to gaussian distribution */
  252. int randx(max, glevel)
  253.      int  max, glevel;
  254. {
  255.   double rnum;
  256.   int    ret;
  257.  
  258.   rnum = 0;
  259.   for(ret = 0;ret<glevel;ret++)
  260.     rnum+=((double) (RANDOM()%10000000))/10000000.0/((double)glevel);
  261.   return((int) (rnum*((double) max)));
  262. }
  263.  
  264. /* the melt procedure */
  265. melt_main(argc, argv)
  266.      int   argc;
  267.      char *argv[];
  268. {
  269.   Pixrect *screen;
  270.   int     x, y, max_x, max_y, ylim[1192];
  271.   int     count, gauss = 3, size = 5, color = PIX_SET;
  272.  
  273.   /* parse arguments */
  274.   if(argc > 1)
  275.     for(count = 1; count < argc; count++)
  276.       if(*argv[count] == '-')
  277.     switch (*(++argv[count])) {
  278.         case 'b':  /* black option */
  279.       color = PIX_SET;
  280.       break;
  281.     case 'h':  /* help option */
  282.       printf("Usage: zot -melt [options]\n");
  283.       printf(" Option:                range:   default:\n");
  284.       printf(" -gaussian_dist level   [1..>]      3\n");
  285.       printf(" -s size               [1..%d]     5\n", max_x/2);
  286.       printf(" -black/-white          -b/-w    -black\n");
  287.       exit(0);
  288.       break;
  289.     case 'g':  /* gaussian dist option */
  290.       if(count < argc - 1)
  291.         gauss = atol(argv[++count]);
  292.       if(gauss < 1) gauss = 1;
  293.       break;
  294.         case 's':  /* size option */
  295.       if(count < argc - 1)
  296.         size = atol(argv[++count]);
  297.       if(size < 1) size = 1;
  298.       break;
  299.         case 'w':  /* white option */
  300.       color = PIX_CLR;
  301.       break;
  302.         default:
  303.       break;
  304.     }
  305.  
  306.   /* open frame buffer and set signals */
  307.   screen = pr_open("/dev/fb");
  308.   set_signals();
  309.  
  310.   /* find screen dimensions */
  311.   max_x = screen->pr_size.x;
  312.   max_y = screen->pr_size.y;
  313.  
  314.   /* set random seed */
  315.   SRANDOM(time(0));
  316.  
  317.   /* initialize ylim */
  318.   for(x = 0;x<max_x;x++)
  319.     ylim[x] = 0;
  320.  
  321.   /* until an interrupt... */
  322.   while(cont)
  323.     {
  324.       x = randx(max_x-size+1,gauss);
  325.       y = ylim[x];
  326.       ylim[x]++;
  327.       if(ylim[x]>=max_y)
  328.     break;
  329.       pr_rop(screen,x,y+1,size,(max_y-y-2),PIX_SRC,screen,x,y);
  330.       pr_vector(screen,x,y,x+size-1,y,color,1);
  331.     }
  332.  
  333.   /* close frame buffer */
  334.   pr_close(screen);
  335. }
  336.  
  337. /********************************************************************
  338.  **  negative-mode procedure                                       **
  339.  ********************************************************************/
  340.  
  341. void negative_main(argc, argv)
  342.      int   argc;
  343.      char *argv[];
  344. {
  345.   Pixrect *screen;
  346.   int     max_x, max_y;
  347.   int     count;
  348.  
  349.   /* parse arguments */
  350.   if(argc > 1)
  351.     for(count = 1; count < argc; count++)
  352.       if(*argv[count] == '-')
  353.     switch (*(++argv[count])) {
  354.         case 'h':  /* help option */
  355.       printf("Usage: zot -negative\n");
  356.       exit (0);
  357.       break;
  358.         default:
  359.       break;
  360.     }
  361.  
  362.   /* open frame buffer */
  363.   screen = pr_open("/dev/fb");
  364.  
  365.   /* get screen dimensions */
  366.   max_x = screen->pr_size.x;
  367.   max_y = screen->pr_size.y;
  368.  
  369.   /* flip it */
  370.   for(count = 0; count < max_y; ++count)
  371.       pr_vector(screen, 0, count, max_x, count, PIX_NOT(PIX_DST), 1);
  372.  
  373.   /* close frame buffer */
  374.   pr_close(screen);
  375. }
  376.  
  377. /********************************************************************
  378.  **  slide-mode procedure                                          **
  379.  ********************************************************************/
  380.  
  381. void slide_main(argc, argv)
  382.      int   argc;
  383.      char *argv[];
  384. {
  385.   Pixrect *screen;
  386.   int     max_x, max_y;
  387.   int     x[50], y[50];
  388.   int     count, speed = 10, move = 5, segments = 10, trail = 0;
  389.  
  390.   /* parse arguments */
  391.   if(argc > 1)
  392.     for(count = 1; count < argc; count++)
  393.       if(*argv[count] == '-')
  394.     switch (*(++argv[count])) {
  395.     case 'h':  /* help option */
  396.       printf("Usage: zot -slide [options...]\n");
  397.       printf(" Option:    range:   default:\n");
  398.       printf("-velocity  [1..100]     10\n");
  399.       printf("-length    [5...50]      5\n");
  400.       printf("-segments  [5...50]     10\n");
  401.       printf("-trail      on/off     off\n");
  402.       printf("-help    what? are you kidding?\n");
  403.       exit (0);
  404.       break;
  405.         case 'l':  /* length option */
  406.       if(count < argc - 1)
  407.         move = atol(argv[++count]);
  408.       if(move < 5) move = 5;
  409.       if(move > 50) move = 50;
  410.       break;
  411.         case 's':  /* segments option */
  412.       if(count < argc - 1)
  413.         segments = atol(argv[++count]);
  414.       if(segments < 5) segments = 5;
  415.       if(segments > 50) segments = 50;
  416.       break;
  417.         case 't':
  418.       trail = 1;
  419.       break;
  420.     case 'v':  /* trail option */
  421.       if(count < argc - 1)
  422.         speed = atol(argv[++count]);
  423.       if(speed < 1) speed = 1;
  424.       if(speed > 100) speed = 100;
  425.       break;
  426.         default:
  427.       break;
  428.     }
  429.  
  430.   /* open frame buffer and set signals */
  431.   screen = pr_open("/dev/fb");
  432.   set_signals();
  433.  
  434.   /* find screen dimensions */
  435.   max_x = screen->pr_size.x;
  436.   max_y = screen->pr_size.y;
  437.  
  438.   /* set random seed */
  439.   SRANDOM(time(0));
  440.  
  441.   /* set initial speed */
  442.   speed = 100000 / speed;
  443.  
  444.   /* initialize x[] and y[] */
  445.   for(count = 0; count < segments; count++) {
  446.     x[count] = max_x /2;
  447.     y[count] = max_y /2;
  448.   }
  449.  
  450.   /* until an interrupt... */
  451.   while (cont) {
  452.     x[segments - 1] = x[segments - 2] - move + RANDOM() % (move * 2 + 1);
  453.     y[segments - 1] = y[segments - 2] - move + RANDOM() % (move * 2 + 1);
  454.  
  455.     /* set boundaries */
  456.     if(x[segments - 1] > max_x) x[segments - 1] = max_x;
  457.     if(x[segments - 1] < 0)     x[segments - 1] = 0;
  458.     if(y[segments - 1] > max_y) y[segments - 1] = max_y;
  459.     if(y[segments - 1] < 0)     y[segments - 1] = 0;
  460.  
  461.     pr_vector(screen, x[segments - 2], y[segments - 2],
  462.           x[segments - 1], y[segments - 1], PIX_NOT(PIX_DST), 1);
  463.     if(!trail)
  464.       pr_vector(screen, x[0], y[0], x[1], y[1], PIX_NOT(PIX_DST), 1);
  465.  
  466.     for(count = 1; count < speed; count++) ;
  467.  
  468.     for(count = 0; count < segments - 1; count++) {
  469.       x[count] = x[count + 1];
  470.       y[count] = y[count + 1];
  471.     }
  472.   }
  473.  
  474.   /* close frame buffer */
  475.   pr_close(screen);
  476. }
  477.  
  478. /********************************************************************
  479.  **  snow-mode procedure                                           **
  480.  ********************************************************************/
  481.  
  482. void snow_main(argc, argv)
  483.      int argc;
  484.      char *argv[];
  485. {
  486.   Pixrect *screen;
  487.   int     count, x,*y, max_x, max_y;
  488.  
  489.   /* parse arguments */
  490.   if(argc > 1)
  491.     for(count = 1; count < argc; count++)
  492.       if(*argv[count] == '-')
  493.     switch (*(++argv[count])) {
  494.         case 'h':  /* help option */
  495.       printf("Usage: zot -snow\n");
  496.       exit (0);
  497.       break;
  498.         default:
  499.       break;
  500.     }
  501.  
  502.   /* open frame buffer and set signals */
  503.   screen =  pr_open("/dev/fb");
  504.   set_signals();
  505.  
  506.   /* find screen dimensions */
  507.   max_x = (screen->pr_size.x);
  508.   max_y = (screen->pr_size.y);
  509.  
  510.   y = (int *) (malloc(max_x * sizeof(int)));
  511.  
  512.   for(x = 0; x < max_x; x++)
  513.     {
  514.       y[x] = RANDOM() % max_y;
  515.       pr_vector(screen, x, y[x], x, y[x], PIX_NOT(PIX_DST), 0);
  516.     }
  517.  
  518.   /* until an interrupt... */
  519.   while(cont)
  520.     for(x = 0; x < max_x; x++)
  521.       {
  522.     pr_vector(screen, x, y[x], x, y[x], PIX_NOT(PIX_DST), 0);
  523.     y[x] = (y[x] + (RANDOM() % 5 +1)) % max_y;
  524.     pr_vector(screen, x, y[x], x, y[x], PIX_NOT(PIX_DST), 0);
  525.       }
  526.  
  527.   /* close frame buffer */
  528.   pr_close(screen);
  529. }
  530.  
  531. /********************************************************************
  532.  **  static-mode procedure                                         **
  533.  ********************************************************************/
  534.  
  535. #define CYCLES 10
  536. #define NUMTIMES 20
  537. void static_main(argc, argv)
  538.      int   argc;
  539.      char *argv[];
  540. {
  541.   Pixrect        *screen, *savebuf, *temp[CYCLES];
  542.   int            count, max_x, max_y, numbytes, cnt, lbytes;
  543.   short          rr, *addr[CYCLES];
  544.   unsigned char  i, j;
  545.  
  546.   /* parse arguments */
  547.   if(argc > 1)
  548.     for(count = 1; count < argc; count++)
  549.       if(*argv[count] == '-')
  550.     switch (*(++argv[count])) {
  551.         case 'h':  /* help option */
  552.       printf("Usage: zot -static\n");
  553.       exit (0);
  554.       break;
  555.         default:
  556.       break;
  557.     }
  558.  
  559.   /* open frame buffer */
  560.   screen = pr_open("/dev/fb");
  561.  
  562.   /* find screen dimensions */
  563.   max_x = screen->pr_size.x;
  564.   max_y = screen->pr_size.y;
  565.  
  566.   /* set random seed */
  567.   SRANDOM(time(0));
  568.  
  569.   /* save the screen for restoring */
  570.   savebuf = mem_create(max_x, max_y, 1);
  571.  
  572.   /* initialize temp[] */
  573.   for(i = 0; i < CYCLES; i++)
  574.     temp[i] = mem_create(max_x, max_y, 1);
  575.  
  576.   pr_rop(savebuf,0,0,max_x,max_y,PIX_SRC,screen,0,0);
  577.   numbytes = (mpr_d(temp[0])->md_linebytes)*max_y;
  578.   for(i = 0;i<CYCLES;i++)
  579.     addr[i] = (mpr_d(temp[i])->md_image);
  580.  
  581.   for(i = 0;i<CYCLES;i++)
  582.     {
  583.       for(cnt = 0;cnt<numbytes/2;cnt++)
  584.     addr[i][cnt] = (short) (RANDOM());
  585.     }
  586.   for(j = 0;j<NUMTIMES;j++)
  587.     for(i = 0;i<CYCLES;i++)
  588.       pr_rop(screen, 0, 0, max_x, max_y, PIX_SRC, temp[i], 0, 0);
  589.  
  590.   pr_rop(screen, 0, 0, max_x, max_y, PIX_SRC, savebuf, 0, 0);
  591.  
  592.   /* close frame buffers */
  593.   pr_close(savebuf);
  594.   for(i = 0; i<CYCLES; i++)
  595.     pr_close(temp[i]);
  596.   pr_close(screen);
  597. }
  598.  
  599. /********************************************************************
  600.  **  vh-mode procedure                                             **
  601.  ********************************************************************/
  602.  
  603. void vh_main(argc, argv)
  604.      int   argc;
  605.      char *argv[];
  606. {
  607.   Pixrect *screen;
  608.   int     max_x, max_y, scroll_rate = 1, vert = 1, count;
  609.  
  610.   /* parse arguments */
  611.   if(argc > 1)
  612.     for(count = 1; count < argc; count++)
  613.       if(*argv[count] == '-')
  614.     switch (*(++argv[count])) {
  615.         case 'h':
  616.       switch (*(++argv[count])) {
  617.       case 'o':  /* horizontal mode */
  618.         vert = 0;
  619.         break;
  620.       default:  /* help mode */
  621.         printf("Usage: zot -vh [-speed <int>] [scrollmode]\n");
  622.         printf("scrollmodes: -vertical (default) -horizontal\n");
  623.         exit (0);
  624.         break;
  625.       }
  626.       break;
  627.     case 's':  /* speed mode */
  628.       if(count < argc - 1)
  629.         scroll_rate = atol(argv[++count]);
  630.       if(scroll_rate < 1) scroll_rate = 1;
  631.       if(scroll_rate > 100) scroll_rate = 100;
  632.       break;
  633.         case 'v':  /* vertical mode */
  634.       vert = 1;
  635.       break;
  636.         default:
  637.       break;
  638.     }
  639.  
  640.   /* open frame buffer and set signals */
  641.   screen = pr_open("/dev/fb");
  642.   set_signals();
  643.  
  644.   /* find screen dimensions */
  645.   max_x = screen->pr_size.x;
  646.   max_y = screen->pr_size.y;
  647.  
  648.   if(scroll_rate > 0 && vert == 1)
  649.     while(cont)
  650.       {
  651.     pr_rop(screen, 0, scroll_rate, max_x, max_y - scroll_rate,
  652.            PIX_SRC, screen, 0, 0);
  653.     pr_rop(screen, 0, 0, max_x, scroll_rate,
  654.            PIX_SRC, screen, 0, max_y - scroll_rate);
  655.       }
  656.   else if(scroll_rate < 0 && vert == 1)
  657.     {
  658.       scroll_rate = -scroll_rate;
  659.       while(cont)
  660.     {
  661.       pr_rop(screen, 0, max_y - scroll_rate, max_x, scroll_rate,
  662.          PIX_SRC, screen, 0, 0);
  663.       pr_rop(screen, 0, 0, max_x, max_y - scroll_rate,
  664.          PIX_SRC, screen, 0, scroll_rate);
  665.     }
  666.     }
  667.   else if(scroll_rate > 0)
  668.     while(cont)
  669.       {
  670.     pr_rop(screen, scroll_rate, 0, max_x - scroll_rate, max_y,
  671.            PIX_SRC, screen, 0, 0);
  672.     pr_rop(screen, 0, 0, scroll_rate, max_y,
  673.            PIX_SRC, screen, max_x - scroll_rate, 0);
  674.       }
  675.   else if(scroll_rate < 0)
  676.     {
  677.       scroll_rate = -scroll_rate;
  678.       while(cont)
  679.     {
  680.       pr_rop(screen, max_x - scroll_rate, 0, scroll_rate, max_y,
  681.          PIX_SRC, screen, 0, 0);
  682.       pr_rop(screen, 0, 0, max_x - scroll_rate, max_y,
  683.          PIX_SRC, screen, scroll_rate, 0);
  684.     }
  685.     }
  686.  
  687.   /* close frame buffer */
  688.   pr_close(screen);
  689. }
  690.  
  691. /********************************************************************
  692.  **  weasel-mode procedure                                         **
  693.  ********************************************************************/
  694.  
  695. #define MAXBITS 1024
  696. void weasel_main(argc, argv)
  697.      int   argc;
  698.      char *argv[];
  699. {
  700.   Pixrect *screen;
  701.   int     count, max_x, max_y, x, y, new_x, new_y, lim_y, lim_x, a, counter;
  702.   double  bitx[MAXBITS], bity[MAXBITS], speed[MAXBITS];
  703.  
  704.   /* parse arguments */
  705.   if(argc > 1)
  706.     for(count = 1; count < argc; count++)
  707.       if(*argv[count] == '-')
  708.     switch (*(++argv[count])) {
  709.         case 'h':  /* help option */
  710.       printf("Usage: zot -weasel\n");
  711.       exit (0);
  712.       break;
  713.         default:
  714.       break;
  715.     }
  716.  
  717.   /* open frame buffer */
  718.   screen = pr_open("/dev/fb");
  719.  
  720.   /* find screen dimensions */
  721.   max_x = screen->pr_size.x;
  722.   max_y = screen->pr_size.y;
  723.  
  724.   /* set random seed */
  725.   SRANDOM(time(0));
  726.  
  727.   /* set limits */
  728.   lim_y = max_y * 3 / 4;
  729.   lim_x = max_x * 3 / 4;
  730.  
  731.   /* initialize arrays */
  732.   /* note that the speed array stays constant once intialized */
  733.   /* (this speeds weasel up) */
  734.   for(x = 0; x < MAXBITS; x++)
  735.     {
  736.       speed[x] = ((double) (RANDOM() % 100)) / 50.0 + 1.0;
  737.       bitx[x] = lim_x;
  738.       bity[x] = max_y;
  739.     } /* for */
  740.   x = lim_x;
  741.   y = lim_y;
  742.   counter = 0;
  743.  
  744.   /* weasel away until weasel falls off the screen */
  745.   while(1)
  746.     {
  747.       new_x = x + (RANDOM() % 10 - 5);
  748.       new_y = y + (RANDOM() % 10 - 5);
  749.       if((new_x >= max_x) || (new_x < 0) || (new_y >= max_y) || (new_y < 0))
  750.     break;
  751.       pr_vector(screen, x, y, new_x, new_y, PIX_NOT(PIX_DST), 1);
  752.  
  753.       bitx[counter] = (double) (new_x);
  754.       bity[counter] = (double) (new_y);
  755.       pr_vector(screen, bitx[counter], bity[counter],
  756.         bitx[counter], bity[counter], PIX_NOT(PIX_DST), 1);
  757.       
  758.       for(a = 0; a < MAXBITS; a++)
  759.     {
  760.       if(bity[a] < (double) max_y)
  761.         {
  762.           pr_vector(screen, (int) bitx[a], (int) bity[a],
  763.             (int) bitx[a], (int) bity[a], PIX_NOT(PIX_DST), 1);
  764.           bity[a] += speed[a];
  765.         }
  766.       if(bity[a] < (double) max_y)
  767.         pr_vector(screen, (int) bitx[a], (int) bity[a],
  768.               (int) bitx[a], (int) bity[a], PIX_NOT(PIX_DST), 1);
  769.     }
  770.       counter = (counter + 1) % MAXBITS;
  771.       x = new_x;
  772.       y = new_y;
  773.  
  774.     }
  775.  
  776.   /* finish letting the bits fall to the bottom of the screen */
  777.   x = 1;
  778.   while(x)
  779.     {
  780.       x = 0;
  781.       for(a = 0; a < MAXBITS; a++)
  782.     {
  783.       if(bity[a] < (double) max_y)
  784.         {
  785.           pr_vector(screen, (int) bitx[a], (int) bity[a],
  786.             (int) bitx[a], (int) bity[a], PIX_NOT(PIX_DST), 1);
  787.           bity[a] += speed[a];
  788.         }
  789.       if(bity[a] < (double) max_y)
  790.         {
  791.           pr_vector(screen, (int) bitx[a], (int) bity[a],
  792.             (int) bitx[a], (int) bity[a], PIX_NOT(PIX_DST), 1);
  793.           x = 1;
  794.         }
  795.     }
  796.     }
  797.  
  798.   /* close frame buffer */
  799.   pr_close(screen);
  800. }
  801.  
  802. /********************************************************************
  803.  **  zigzag-mode procedure                                         **
  804.  ********************************************************************/
  805.  
  806. void zigzag_main(argc, argv)
  807.      int   argc;
  808.      char *argv[];
  809. {
  810.   Pixrect *screen;
  811.   int     x, y, max_x, max_y, new_x, new_y;
  812.   int     count, setmode = -2;
  813.  
  814.   /* parse arguments */
  815.   if(argc > 1)
  816.     for(count = 1; count < argc; count++)
  817.       if(*argv[count] == '-')
  818.     switch (*(++argv[count])) {
  819.     case 'b':  /* black option */
  820.       setmode = 1;
  821.       break;
  822.     case 'h':  /* help option */
  823.       printf("Usage: zot -zigzag [setmode]\n");
  824.       printf("setmodes: -black, -white, -fuzzy, ");
  825.       printf("-invert/-reverse (default)\n");
  826.       exit (0);
  827.       break;
  828.     case 'f':  /* fuzzy option */
  829.       setmode = -1;
  830.       break;
  831.         case 'i':  /* invert option */
  832.         case 'r':
  833.       setmode = -2;
  834.       break;
  835.         case 'w':  /* white option */
  836.       setmode = 0;
  837.       break;
  838.         default:
  839.       break;
  840.     }
  841.  
  842.   /* open frame buffer and set signals */
  843.   screen = pr_open("/dev/fb");
  844.   set_signals();
  845.  
  846.   /* find screen dimensions */
  847.   max_x = screen->pr_size.x;
  848.   max_y = screen->pr_size.y;
  849.  
  850.   /* set random seed */
  851.   SRANDOM(time(0));
  852.  
  853.   x = max_x / 2;
  854.   y = max_y / 2;
  855.  
  856.   /* until an interrupt... */
  857.   while (cont) {
  858.     new_x = RANDOM() % max_x;
  859.     new_y = RANDOM() % max_y;
  860.  
  861.     switch(setmode) {
  862.     case 1:  /* black mode */
  863.       pr_vector(screen, x, y, new_x, new_y, PIX_SET, 1);
  864.       break;
  865.     case 0:  /* white mode */
  866.       pr_vector(screen, x, y, new_x, new_y, PIX_CLR, 1);
  867.       break;
  868.     case -1:  /* fuzzy mode */
  869.       pr_vector(screen, x, y, new_x, new_y, PIX_NOT(PIX_DST), 1);
  870.       /* fall through to next case! */
  871.     default:  /* invert mode */
  872.       pr_vector(screen, x, y, new_x, new_y, PIX_NOT(PIX_DST), 1);
  873.       break;
  874.     }
  875.  
  876.     x = new_x;
  877.     y = new_y;
  878.   }
  879.  
  880.   /* close frame buffer */
  881.   pr_close(screen);
  882. }
  883.  
  884. /********************************************************************
  885.  **  the main procedure                                            **
  886.  ********************************************************************/
  887.  
  888. void main(argc, argv)
  889.      int   argc;
  890.      char *argv[];
  891. {
  892.   int help = 0;
  893.  
  894.   /* parse arguments */
  895.   if(argc > 1) {
  896.     if(*argv[1] == '-') {
  897.       switch (*(++argv[1])) {
  898.       case 'b':  /* block option */
  899.     block_main((--argc), &argv[1]);
  900.     break;
  901.       case 'f':  /* flip option */
  902.     flip_main((--argc), &argv[1]);
  903.     break;
  904.       case 'h':  /* help option */
  905.     help = 1;
  906.     break;
  907.       case 'm':  /* melt option */
  908.     melt_main((--argc), &argv[1]);
  909.     break;
  910.       case 'n':  /* negative option */
  911.     negative_main((--argc), &argv[1]);
  912.     break;
  913.       case 's':
  914.     switch (*(++argv[1])) {
  915.     case 'l':  /* slide option */
  916.       slide_main((--argc), &argv[1]);
  917.       break;
  918.     case 'n':  /* snow option */
  919.       snow_main((--argc), &argv[1]);
  920.       break;
  921.     case 't':  /* static option */
  922.       static_main((--argc), &argv[1]);
  923.       break;
  924.     default:  /* help option */
  925.       help = 1;
  926.       break;
  927.     }
  928.     break;
  929.       case 'v':  /* vh option */
  930.     vh_main((--argc), &argv[1]);
  931.     break;
  932.       case 'w':  /* weasel option */
  933.     weasel_main((--argc), &argv[1]);
  934.     break;
  935.       case 'z':  /* zigzagoption */
  936.     zigzag_main((--argc), &argv[1]);
  937.     break;
  938.       default:
  939.     help = 1;
  940.     break;
  941.       }
  942.     } else {
  943.       help = 1;
  944.     }
  945.   } else {
  946.     help = 1;
  947.   }
  948.  
  949.   /* print help */
  950.   if(help) {
  951.     printf("Usage: zot <mode [options]>\n");
  952.     printf("  modes: -block -flip -melt -negative -slide -snow -static");
  953.     printf(" -vh -weasel -zigzag\n");
  954.     printf("  note: ` zot -<mode> -help ' will list options for that mode.\n");
  955.     printf("ZOT! was created by Mark \"Crimson\" Friedman ");
  956.     printf("and John \"Rawhide\" Wile.\n");
  957.   }
  958. }
  959.