git.hungrycats.org Git - xscreensaver/blob - hacks/vermiculate.c

   1 /*
   2  *  @(#) vermiculate.c
   3  *  @(#) Copyright (C) 2001 Tyler Pierce (tyler@alumni.brown.edu)
   4  *  The full program, with documentation, is available at:
   5  *    http://freshmeat.net/projects/fdm
   6  *
   7  * Permission to use, copy, modify, distribute, and sell this software and its
   8  * documentation for any purpose is hereby granted without fee, provided that
   9  * the above copyright notice appear in all copies and that both that
  10  * copyright notice and this permission notice appear in supporting
  11  * documentation.  No representations are made about the suitability of this
  12  * software for any purpose.  It is provided "as is" without express or
  13  * implied warranty.
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include "config.h"
  18 #endif
  19
  20 #include <ctype.h>
  21 #include <math.h>
  22 #include "screenhack.h"
  23
  24 #define degs 360
  25 #define degs2 (degs/2)
  26 #define degs4 (degs/4)
  27 #define degs8 (degs/8)
  28 #define dtor 0.0174532925       /*  pi / degs2; */
  29 #define thrmax 120
  30 #define tailmax (thrmax * 2 + 1)
  31 #define tmodes '7'
  32 #define ymax (st->hei - 1)
  33 #define ymin 0
  34 #define xmax (st->wid - 1)
  35 #define xmin 0
  36 #define rlmax 200
  37 #define SPEEDINC 10
  38 #define SPEEDMAX 1000
  39 #define wraparound(VAL,LOWER,UPPER) {   \
  40                     if (VAL >= UPPER)   \
  41                       VAL -= UPPER - LOWER;     \
  42                     else if (VAL < LOWER)       \
  43                       VAL += UPPER - LOWER; }
  44 #define arrcpy(DEST,SRC) memcpy (DEST, SRC, sizeof(DEST))
  45
  46 typedef double real;
  47 typedef unsigned char banktype[thrmax];
  48
  49 typedef struct linedata
  50 {
  51   int deg, spiturn, turnco, turnsize;
  52   unsigned char col;
  53   Bool dead;
  54
  55   char orichar;
  56   real x, y;
  57   int tmode, tsc, tslen, tclim, otslen, ctinc, reclen, recpos, circturn, prey,
  58     slice;
  59   int xrec[rlmax + 1], yrec[rlmax + 1];
  60   int turnseq[50];
  61   Bool filled, killwalls, vhfollow,
  62     selfbounce, tailfollow, realbounce, little;
  63 }
  64 linedata;
  65
  66 static const struct stringAndSpeed
  67 {
  68   char *str;
  69   int speed;
  70 }
  71 sampleStrings[] =
  72 {
  73 /*  { "]]]]]]]]7ces123400-9-8#c123456#s9998880004#ma3#car9ma6#c-#r1", 600} ,
  74         { "bmarrrr#c1234#lc5678#lyet]", 600} , */
  75   { "AEBMN222222223#CAR9CAD4CAOV", 150} ,
  76   { "mn333#c23#f1#]]]]]]]]]]]3bc9#r9#c78#f9#ma4#", 600} ,
  77   { "AEBMN22222#CAD4CAORc1#f2#c1#r6", 100} ,
  78 /*  { "mn6666666#c1i#f1#y2#sy2#vyety1#ry13i#l", 40} , */
  79   { "aebmnrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr#", 500} ,
  80 /*  { "bg+++++++++++++++++++++++#mnrrrrrrrrrrrrrrrrrrrrrrr#y1#k", 500},  */
  81 /*  { "BMN22222223#CAD4CAOVYAS", 150}, */
  82 /*  { "aebmnrrrrrrrrrrrrrrrr#yaryakg--#", 100} , */
  83   { "mn6rrrrrrrrrrrrrrr#by1i#lcalc1#fnyav" , 200 } ,
  84   { "mn1rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr#by1i#lcalc1#fn", 2000 },
  85   { "baeMn333333333333333333333333#CerrYerCal", 800 },
  86   { "baeMn1111111111111111111111111111111111111111111111111111111111#Cer9YesYevYerCal", 1200 },
  87   { "baMn111111222222333333444444555555#Ct1#lCt2#lCt3#lCt4#lCt5#lCerrYerYet", 1400 },
  88   { "baMn111111222222333333444444555555#Ct1#lCt2#lCt3#lCt4#lCt5#lCerrYerYetYt1i#lYt1i#sYt1#v", 1400 }
  89 };
  90
  91 struct state {
  92   Display *dpy;
  93   Window window;
  94
  95   GC mygc;
  96   Colormap mycmap;
  97   XWindowAttributes xgwa;
  98   XColor mycolors[tailmax];
  99
 100   int hei, wid, speed;
 101   Bool erasing, cleared, autopal;
 102   char *instring;
 103   int max_ticks;
 104
 105   real sinof[degs], cosof[degs], tanof[degs];
 106   unsigned char *point;
 107
 108   linedata thread[thrmax];
 109   banktype bank;
 110   int bnkt;
 111   int boxw, boxh, curviness, gridden, ogd, bordcorn;
 112   unsigned char bordcol, threads;
 113   char ch, boolop;
 114
 115   int reset_p;
 116   int cyc;
 117 };
 118
 119
 120
 121 static void
 122 consume_instring(struct state *st);
 123
 124 static Bool
 125 wasakeypressed (struct state *st)
 126 {
 127   if (*st->instring != 0)
 128     return True;
 129   else
 130     return False;
 131 }
 132
 133 static char
 134 readkey (struct state *st)
 135 {
 136   char readkey_result;
 137   if (*st->instring == 0)
 138     {
 139       readkey_result = '#';
 140     }
 141   else
 142     {
 143       readkey_result = *st->instring;
 144       st->instring++;
 145     };
 146   return toupper (readkey_result);
 147 }
 148
 149 static unsigned int
 150 random1 (unsigned int i)
 151 {
 152   return (ya_random () % i);
 153 }
 154
 155 static unsigned long
 156 waitabit (struct state *st)
 157 {
 158   int result = 0;
 159   st->cyc += st->threads;
 160   while (st->cyc > st->speed)
 161     {
 162       result += 10000;
 163       st->cyc -= st->speed;
 164     }
 165   return result;
 166 }
 167
 168 static void
 169 clearscreen (struct state *st)
 170 {
 171   XClearWindow (st->dpy, st->window);
 172   memset (st->point, 0, st->wid * st->hei);
 173 }
 174
 175 static void
 176 sp (struct state *st, int x, int y, int c)
 177 {
 178   XSetForeground (st->dpy, st->mygc, st->mycolors[c].pixel);
 179   XDrawPoint (st->dpy, st->window, st->mygc, x, y);
 180   st->point[(st->wid * y) + x] = c;
 181 }
 182
 183 static int
 184 gp (struct state *st, int x, int y)
 185 {
 186   return st->point[(st->wid * y) + x];
 187 }
 188
 189 static void
 190 redraw (struct state *st, int x, int y, int width, int height)
 191 {
 192   int xc, yc;
 193   for (xc = x; xc <= x + width - 1; xc++)
 194     for (yc = y; yc <= y + height - 1; yc++)
 195       if (st->point[st->wid * yc + xc] != 0)
 196         sp (st, xc, yc, st->point[st->wid * yc + xc]);
 197 }
 198
 199 static void
 200 palupdate (struct state *st, Bool forceUpdate)
 201 {
 202   if (forceUpdate || *st->instring == 0)
 203     {
 204       redraw (st, xmin, ymin, st->wid, st->hei);
 205     }
 206 }
 207
 208 static void
 209 randpal (struct state *st)
 210 {
 211   int ncolors = tailmax - 1;
 212   make_random_colormap (st->dpy,
 213                         st->xgwa.visual,
 214                         st->mycmap, &st->mycolors[1], &ncolors, True, True, 0, True);
 215   if (ncolors < tailmax - 1)
 216     {
 217       int c;
 218       for (c = 1; c < tailmax; c++)
 219         st->mycolors[c].pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
 220     }
 221 }
 222
 223 static void
 224 gridupdate (struct state *st, Bool interruptible)
 225 {
 226   int x, y;
 227   if (st->gridden > 0)
 228     for (x = 0; x <= xmax && !(wasakeypressed (st) && interruptible); x += st->boxw)
 229       for (y = 0; y <= ymax; y += st->boxh)
 230         {
 231           if (random1 (15) < st->gridden)
 232             {
 233 #define lesser(A,B) ( ((A)<(B)) ? (A) : (B) )
 234               int max = lesser (x + st->boxw, xmax);
 235               int xc;
 236               for (xc = x; xc <= max; xc++)
 237                 sp (st, xc, y, 1);
 238             }
 239           if (random1 (15) < st->gridden)
 240             {
 241               int max = lesser (y + st->boxh, ymax);
 242               int yc;
 243               for (yc = y; yc <= max; yc++)
 244                 sp (st, x, yc, 1);
 245             }
 246         }
 247 }
 248
 249 static void
 250 bordupdate (struct state *st)
 251 {
 252   int xbord, ybord;
 253
 254   if (st->bordcorn == 0 || st->bordcorn == 1)
 255     ybord = ymin;
 256   else
 257     ybord = ymax;
 258   if (st->bordcorn == 0 || st->bordcorn == 3)
 259     xbord = xmin;
 260   else
 261     xbord = xmax;
 262   {
 263     int x, y;
 264     for (x = xmin; x <= xmax; x++)
 265       sp (st, x, ybord, st->bordcol);
 266     for (y = ymin; y <= ymax; y++)
 267       sp (st, ybord, y, st->bordcol);
 268   }
 269 }
 270
 271 static Bool
 272 inbank (struct state *st, unsigned char thr)
 273 {
 274   int c;
 275   if (st->bnkt > 0)
 276     for (c = 1; c <= st->bnkt; c++)
 277       if (st->bank[c - 1] == thr)
 278         return True;
 279   return False;
 280 }
 281
 282 static void
 283 pickbank (struct state *st)
 284 {
 285   unsigned char thr = 1;
 286   st->bnkt = 0;
 287   st->ch = '\0';
 288   do
 289     {
 290       while (inbank (st, thr))
 291         thr = thr % st->threads + 1;
 292
 293       palupdate (st, False);
 294       st->ch = readkey (st);
 295       palupdate (st, False);
 296       switch (st->ch)
 297         {
 298         case '+':
 299         case '-':
 300           do
 301             {
 302               if (st->ch == '+')
 303                 thr++;
 304               else
 305                 thr--;
 306               wraparound (thr, 1, st->threads + 1);
 307             }
 308           while (inbank (st, thr));
 309           break;
 310         case ' ':
 311           st->bank[++st->bnkt - 1] = thr;
 312           break;
 313         case '1': case '2': case '3':
 314         case '4': case '5': case '6':
 315         case '7': case '8': case '9':
 316
 317           st->bank[++st->bnkt - 1] = st->ch - '0';
 318           if (st->bank[st->bnkt - 1] > st->threads)
 319             st->bnkt--;
 320           break;
 321         case 'I':
 322           {
 323             banktype tbank;
 324             int tbankt = 0;
 325             int c;
 326             for (c = 1; c <= st->threads; c++)
 327               if (!inbank (st, c))
 328                 tbank[++tbankt - 1] = c;
 329             st->bnkt = tbankt;
 330             arrcpy (st->bank, tbank);
 331           }
 332           break;
 333         case 'T':
 334           st->ch = readkey (st);
 335           switch (st->ch)
 336             {
 337             case '1': case '2': case '3':
 338             case '4': case '5': case '6':
 339             case '7': case '8': case '9':
 340
 341               {
 342                 int c;
 343                 for (c = 1; c <= st->threads; c++)
 344                   if (st->thread[c - 1].tmode == st->ch - '0')
 345                     st->bank[++st->bnkt - 1] = c;
 346               }
 347               break;
 348             }
 349           break;
 350         case 'A':
 351           for (st->bnkt = 1; st->bnkt <= st->threads; st->bnkt++)
 352             st->bank[st->bnkt - 1] = st->bnkt;
 353           st->bnkt = st->threads;
 354           break;
 355         case 'E':
 356           for (st->bnkt = 1; st->bnkt <= thrmax; st->bnkt++)
 357             st->bank[st->bnkt - 1] = st->bnkt;
 358           st->bnkt = thrmax;
 359           break;
 360         }
 361     }
 362   while (!(st->bnkt >= st->threads || st->ch == 'N' || st->ch == '\15' || st->ch == '#'));
 363   if (st->bnkt == 0 && st->ch != 'N')
 364     {
 365       st->bnkt = 1;
 366       st->bank[0] = thr;
 367     }
 368   palupdate (st, False);
 369 }
 370
 371 static void
 372 bankmod (char boolop, Bool * Bool_)
 373 {
 374   switch (boolop)
 375     {
 376     case 'T':
 377       *Bool_ = !*Bool_;
 378       break;
 379     case 'Y':
 380       *Bool_ = True;
 381       break;
 382     case 'N':
 383       *Bool_ = False;
 384       break;
 385     }
 386 }
 387
 388 static void
 389 newonscreen (struct state *st, unsigned char thr)
 390 {
 391   linedata *LP = &st->thread[thr - 1];
 392   LP->filled = False;
 393   LP->dead = False;
 394   LP->reclen = (LP->little) ?
 395         random1 (10) + 5 : random1 (rlmax - 30) + 30;
 396   LP->deg = random1 (degs);
 397   LP->y = random1 (st->hei);
 398   LP->x = random1 (st->wid);
 399   LP->recpos = 0;
 400   LP->turnco = 2;
 401   LP->turnsize = random1 (4) + 2;
 402 }
 403
 404 static void
 405 firstinit (struct state *st, unsigned char thr)
 406 {
 407   linedata *LP = &st->thread[thr - 1];
 408   LP->col = thr + 1;
 409   LP->prey = 0;
 410   LP->tmode = 1;
 411   LP->slice = degs / 3;
 412   LP->orichar = 'R';
 413   LP->spiturn = 5;
 414   LP->selfbounce = False;
 415   LP->realbounce = False;
 416   LP->vhfollow = False;
 417   LP->tailfollow = False;
 418   LP->killwalls = False;
 419   LP->little = False;
 420   LP->ctinc = random1 (2) * 2 - 1;
 421   LP->circturn = ((thr % 2) * 2 - 1) * ((thr - 1) % 7 + 1);
 422   LP->tsc = 1;
 423   LP->tslen = 6;
 424   LP->turnseq[0] = 6;
 425   LP->turnseq[1] = -6;
 426   LP->turnseq[2] = 6;
 427   LP->turnseq[3] = 6;
 428   LP->turnseq[4] = -6;
 429   LP->turnseq[5] = 6;
 430   LP->tclim = (unsigned char) (((real) degs) / 2 / 12);
 431 }
 432
 433 static void
 434 maininit (struct state *st)
 435 {
 436   if (!st->instring)
 437     {
 438       int n = random1 (sizeof (sampleStrings) / sizeof (sampleStrings[0]));
 439       st->instring = sampleStrings[n].str;
 440       st->speed = sampleStrings[n].speed;
 441     }
 442   if (st->speed == 0)
 443     {
 444           st->speed = 200;
 445     }
 446   st->boxh = 10;
 447   st->boxw = 10;
 448   st->gridden = 0;
 449   st->bordcorn = 0;
 450   st->threads = 4;
 451   st->curviness = 30;
 452   st->bordcol = 1;
 453   st->ogd = 8;
 454   st->ch = '\0';
 455   st->erasing = True;
 456   {
 457     unsigned char thr;
 458     for (thr = 1; thr <= thrmax; thr++)
 459       {
 460         firstinit (st, thr);
 461         newonscreen (st, thr);
 462       }
 463   }
 464   {
 465     int d;
 466     for (d = degs - 1; d >= 0; d--)
 467       {
 468         st->sinof[d] = sin (d * dtor);
 469         st->cosof[d] = cos (d * dtor);
 470         if (d % degs4 == 0)
 471           st->tanof[d] = st->tanof[d + 1];
 472         else
 473           st->tanof[d] = tan (d * dtor);
 474       }
 475   }
 476   randpal (st);
 477 }
 478
 479 static Bool
 480 move (struct state *st, unsigned char thr)
 481 {
 482   linedata *LP = &st->thread[thr - 1];
 483   if (LP->dead)
 484     return (False);
 485   if (LP->prey == 0)
 486     switch (LP->tmode)
 487       {
 488       case 1:
 489         LP->deg += random1 (2 * LP->turnsize + 1) - LP->turnsize;
 490         break;
 491       case 2:
 492         if (LP->slice == degs || LP->slice == degs2 || LP->slice == degs4)
 493           {
 494             if (LP->orichar == 'D')
 495               {
 496                 if (LP->deg % degs4 != degs8)
 497                   LP->deg = degs4 * random1 (4) + degs8;
 498               }
 499             else if (LP->orichar == 'V')
 500               if (LP->deg % degs4 != 0)
 501                 LP->deg = degs4 * random1 (4);
 502           }
 503         if (random1 (100) == 0)
 504           {
 505             if (LP->slice == 0)
 506               LP->deg = LP->deg - degs4 + random1 (degs2);
 507             else
 508               LP->deg += (random1 (2) * 2 - 1) * LP->slice;
 509           }
 510         break;
 511       case 3:
 512         LP->deg += LP->circturn;
 513         break;
 514       case 4:
 515         if (abs (LP->spiturn) > 11)
 516           LP->spiturn = 5;
 517         else
 518           LP->deg += LP->spiturn;
 519         if (random1 (15 - abs (LP->spiturn)) == 0)
 520           {
 521             LP->spiturn += LP->ctinc;
 522             if (abs (LP->spiturn) > 10)
 523               LP->ctinc *= -1;
 524           }
 525         break;
 526       case 5:
 527         LP->turnco = abs (LP->turnco) - 1;
 528         if (LP->turnco == 0)
 529           {
 530             LP->turnco = st->curviness + random1 (10);
 531             LP->circturn *= -1;
 532           }
 533         LP->deg += LP->circturn;
 534         break;
 535       case 6:
 536         if (abs (LP->turnco) == 1)
 537           LP->turnco *= -1 * (random1 (degs2 / abs (LP->circturn)) + 5);
 538         else if (LP->turnco == 0)
 539           LP->turnco = 2;
 540         else if (LP->turnco > 0)
 541           {
 542             LP->turnco--;
 543             LP->deg += LP->circturn;
 544           }
 545         else
 546           LP->turnco++;
 547         break;
 548       case 7:
 549         LP->turnco++;
 550         if (LP->turnco > LP->tclim)
 551           {
 552             LP->turnco = 1;
 553             LP->tsc = (LP->tsc % LP->tslen) + 1;
 554           }
 555         LP->deg += LP->turnseq[LP->tsc - 1];
 556         break;
 557       }
 558   else
 559     {
 560       int desdeg;
 561       real dy, dx;
 562       if (LP->tailfollow || LP->prey == thr)
 563         {
 564           dx = st->thread[LP->prey - 1].xrec[st->thread[LP->prey - 1].recpos] - LP->x;
 565           dy = st->thread[LP->prey - 1].yrec[st->thread[LP->prey - 1].recpos] - LP->y;
 566         }
 567       else
 568         {
 569           dx = st->thread[LP->prey - 1].x - LP->x;
 570           dy = st->thread[LP->prey - 1].y - LP->y;
 571         }
 572       desdeg =
 573         (LP->vhfollow) ?
 574         ((fabs (dx) > fabs (dy)) ?
 575          ((dx > 0) ?
 576           0 * degs4
 577           :
 578           2 * degs4)
 579          :
 580          ((dy > 0) ?
 581           1 * degs4
 582           :
 583           3 * degs4))
 584         :
 585         ((dx > 0) ?
 586          ((dy > 0) ?
 587           1 * degs8 : 7 * degs8) : ((dy > 0) ? 3 * degs8 : 5 * degs8));
 588       if (desdeg - desdeg % degs4 != LP->deg - LP->deg % degs4
 589           || LP->vhfollow)
 590         {
 591           if (!LP->vhfollow)
 592            {
 593               /* Using atan2 here doesn't seem to slow things down: */
 594               desdeg = atan2 (dy, dx) / dtor;
 595               wraparound (desdeg, 0, degs);
 596            }
 597           if (abs (desdeg - LP->deg) <= abs (LP->circturn))
 598             LP->deg = desdeg;
 599           else
 600             LP->deg +=
 601               (desdeg > LP->deg) ?
 602               ((desdeg - LP->deg > degs2) ?
 603                -abs (LP->circturn) : abs (LP->circturn))
 604               : ((LP->deg - desdeg > degs2) ?
 605                  abs (LP->circturn) : -abs (LP->circturn));
 606         }
 607       else
 608         LP->deg +=
 609           (st->tanof[LP->deg] >
 610            dy / dx) ? -abs (LP->circturn) : abs (LP->circturn);
 611     }
 612
 613   wraparound (LP->deg, 0, degs);
 614   {
 615     unsigned char oldcol;
 616     real oldy = LP->y, oldx = LP->x;
 617     LP->x += st->cosof[LP->deg];
 618     wraparound (LP->x, xmin, xmax + 1);
 619     LP->y += st->sinof[LP->deg];
 620     wraparound (LP->y, ymin, ymax + 1);
 621 #define xi ((int) LP->x)
 622 #define yi ((int) LP->y)
 623
 624     oldcol = gp (st, xi, yi);
 625     if (oldcol != 0)
 626       {
 627         Bool vertwall = False, horiwall = False;
 628         if (oldcol == 1 && ((LP->killwalls && st->gridden > 0) || LP->realbounce))
 629           {
 630             vertwall = (gp (st, xi, (int) oldy) == 1);
 631             horiwall = (gp (st, (int) oldx, yi) == 1);
 632           }
 633         if (oldcol == 1 && LP->realbounce && (vertwall || horiwall))
 634           {
 635             if (vertwall)
 636               LP->deg = -LP->deg + degs2;
 637             else
 638               LP->deg = -LP->deg;
 639           }
 640         else
 641           {
 642             if ((oldcol != LP->col && LP->realbounce)
 643                 || (oldcol == LP->col && LP->selfbounce))
 644               LP->deg += degs4 * (random1 (2) * 2 - 1);
 645             else if (oldcol != LP->col)
 646               LP->deg += degs2;
 647           }
 648         if (LP->killwalls && st->gridden > 0 && oldcol == 1)
 649           {
 650             if (vertwall && xi + 1 <= xmax)
 651               {
 652                 int yy;
 653                 for (yy = yi - yi % st->boxh;
 654                      yy <= yi - yi % st->boxh + st->boxh && yy <= ymax; yy++)
 655                   if (gp (st, xi + 1, yy) != 1 || yy == ymax)
 656                     sp (st, xi, yy, 0);
 657               }
 658             if (horiwall && yi + 1 <= ymax)
 659               {
 660                 int xx;
 661                 for (xx = xi - xi % st->boxw;
 662                      xx <= xi - xi % st->boxw + st->boxw && xx <= xmax; xx++)
 663                   if (gp (st, xx, yi + 1) != 1 || xx == xmax)
 664                     sp (st, xx, yi, 0);
 665               }
 666           }
 667         if (oldcol != LP->col || LP->selfbounce)
 668           {
 669             LP->x = oldx;
 670             LP->y = oldy;
 671           }
 672         wraparound (LP->deg, 0, degs);
 673       }
 674   }
 675
 676   sp (st, xi, yi, LP->col);
 677   if (LP->filled)
 678     {
 679       if (st->erasing)
 680         sp (st, LP->xrec[LP->recpos], LP->yrec[LP->recpos], 0);
 681       else
 682         sp (st, LP->xrec[LP->recpos], LP->yrec[LP->recpos], LP->col + thrmax);
 683     }
 684   LP->yrec[LP->recpos] = yi;
 685   LP->xrec[LP->recpos] = xi;
 686   if (LP->recpos == LP->reclen - 1)
 687     LP->filled = True;
 688   if (LP->filled && !st->erasing)
 689     {
 690       int co = LP->recpos;
 691       LP->dead = True;
 692       do
 693         {
 694           int nextco = co + 1;
 695           wraparound (nextco, 0, LP->reclen);
 696           if (LP->yrec[co] != LP->yrec[nextco]
 697               || LP->xrec[co] != LP->xrec[nextco])
 698             LP->dead = False;
 699           co = nextco;
 700         }
 701       while (!(!LP->dead || co == LP->recpos));
 702     }
 703   LP->recpos++;
 704   wraparound (LP->recpos, 0, LP->reclen);
 705   return (!LP->dead);
 706 }
 707
 708 static unsigned long
 709 vermiculate_draw (Display *dpy, Window window, void *closure)
 710 {
 711   struct state *st = (struct state *) closure;
 712   int had_instring = (st->instring != 0);
 713   int tick = 0;
 714   int this_delay = 0;
 715   int loop = 0;
 716
 717
 718  AGAIN:
 719   if (st->reset_p)
 720     {
 721       st->reset_p = 0;
 722
 723       clearscreen (st);
 724       {
 725         unsigned char thr;
 726         for (thr = 1; thr <= st->threads; thr++)
 727           newonscreen (st, thr);
 728       }
 729       if (st->autopal)
 730         {
 731           randpal (st);
 732           palupdate (st, False);
 733         }
 734       bordupdate (st);
 735       gridupdate (st, False);
 736     }
 737
 738   {
 739     Bool alltrap = True;
 740     unsigned char thr;
 741     for (thr = 1; thr <= st->threads; thr++)
 742       if (move (st, thr))
 743         alltrap = False;
 744     if (alltrap)        /* all threads are trapped */
 745       st->reset_p = True;
 746     if (st->speed != SPEEDMAX)
 747       this_delay = waitabit (st);
 748   }
 749
 750   if (tick++ > st->max_ticks && !had_instring)
 751     {
 752       tick = 0;
 753       st->instring = 0;
 754       maininit(st);
 755       st->reset_p = True;
 756       st->autopal = False;
 757     }
 758
 759   if (this_delay == 0 && loop++ < 1000)
 760     goto AGAIN;
 761
 762   return this_delay;
 763 }
 764
 765 static void *
 766 vermiculate_init (Display *d, Window w)
 767 {
 768   struct state *st = (struct state *) calloc (1, sizeof(*st));
 769   st->dpy = d;
 770   st->window = w;
 771   st->reset_p = 1;
 772   st->instring = get_string_resource (st->dpy, "instring", "Instring");
 773   if (st->instring && !*st->instring)
 774     st->instring = 0;
 775
 776   st->max_ticks = get_integer_resource (st->dpy, "ticks", "Integer");
 777   {
 778     int temp = get_integer_resource (st->dpy, "speed", "Speed");
 779     if (temp != 0)
 780       st->speed = temp;
 781   }
 782
 783   st->mycolors[0].pixel = BlackPixel (st->dpy, DefaultScreen (st->dpy));
 784
 785   XSetWindowBackground (st->dpy, st->window,
 786                         BlackPixel (st->dpy, DefaultScreen (st->dpy)));
 787   {
 788     XGetWindowAttributes (st->dpy, st->window, &st->xgwa);
 789     st->wid = st->xgwa.width;
 790     st->hei = st->xgwa.height;
 791     st->mycmap = st->xgwa.colormap;
 792   }
 793   {
 794     XGCValues mygcv;
 795     st->mygc = XCreateGC (st->dpy, st->window, 0, &mygcv);
 796   }
 797
 798   st->point = (unsigned char *) malloc (st->wid * st->hei);
 799   maininit (st);
 800   palupdate (st, True);
 801   consume_instring(st);
 802   return st;
 803 }
 804
 805
 806 static void
 807 vermiculate_reshape (Display *dpy, Window window, void *closure,
 808                  unsigned int w, unsigned int h)
 809 {
 810 }
 811
 812 static Bool
 813 vermiculate_event (Display *dpy, Window window, void *closure, XEvent *event)
 814 {
 815   return False;
 816 }
 817
 818 static void
 819 consume_instring(struct state *st)
 820 {
 821   char boolop;
 822
 823           while (wasakeypressed (st))
 824             {
 825               st->ch = readkey (st);
 826               switch (st->ch)
 827                 {
 828                 case 'M':
 829                   st->ch = readkey (st);
 830                   switch (st->ch)
 831                     {
 832                     case 'A':
 833                     case 'N':
 834                       {
 835                         unsigned char othreads = st->threads;
 836                         if (st->ch == 'N')
 837                           st->threads = 0;
 838                         do
 839                           {
 840                             st->ch = readkey (st);
 841                             switch (st->ch)
 842                               {
 843                               case '1': case '2': case '3':
 844                               case '4': case '5': case '6':
 845                               case '7': case '8': case '9':
 846                                 st->thread[++st->threads - 1].tmode = st->ch - '0';
 847                                 break;
 848                               case 'R':
 849                                 st->thread[++st->threads - 1].tmode =
 850                                   random1 (tmodes - '0') + 1;
 851                                 break;
 852                               }
 853                           }
 854                         while (!(st->ch == '\15' || st->ch == '#'
 855                                  || st->threads == thrmax));
 856                         if (st->threads == 0)
 857                           st->threads = othreads;
 858                         st->reset_p = 1;
 859                       }
 860                       break;
 861                     }
 862                   break;
 863                 case 'C':
 864                   pickbank (st);
 865                   if (st->bnkt > 0)
 866                     {
 867                       st->ch = readkey (st);
 868                       switch (st->ch)
 869                         {
 870                         case 'D':
 871                           st->ch = readkey (st);
 872                           switch (st->ch)
 873                             {
 874                             case '1': case '2': case '3':
 875                             case '4': case '5': case '6':
 876                             case '7': case '8': case '9':
 877 /* Careful!  The following macro needs to be at the beginning of any
 878 block in which it's invoked, since it declares variables: */
 879 #define forallinbank(LDP) linedata *LDP; int bankc; \
 880                 for (bankc = 1; \
 881                 (LDP = &st->thread[st->bank[bankc - 1] - 1],    \
 882                 bankc <= st->bnkt); bankc++)
 883                               {
 884                                 forallinbank (L) L->slice = degs / (st->ch - '0');
 885                               }
 886                               break;
 887                             case 'M':
 888                               {
 889                                 forallinbank (L) L->slice = 0;
 890                               }
 891                               break;
 892                             }
 893                           break;
 894                         case 'S':
 895                           {
 896                             forallinbank (L)
 897                             {
 898                               L->otslen = L->tslen;
 899                               L->tslen = 0;
 900                             }
 901                           }
 902                           do
 903                             {
 904                               char oldch = st->ch;
 905                               st->ch = readkey (st);
 906                               {
 907                                 forallinbank (L)
 908                                 {
 909                                   switch (st->ch)
 910                                     {
 911                                     case '0':
 912                                     case '1': case '2': case '3':
 913                                     case '4': case '5': case '6':
 914                                     case '7': case '8': case '9':
 915                                       L->tslen++;
 916                                       L->turnseq[L->tslen - 1] = st->ch - '0';
 917                                       if (oldch == '-')
 918                                         L->turnseq[L->tslen - 1] *= -1;
 919                                       if (bankc % 2 == 0)
 920                                         L->turnseq[L->tslen - 1] *= -1;
 921                                       break;
 922                                     }
 923                                 }
 924                               }
 925                             }
 926                           while (!(st->ch == '\15' || st->ch == '#'
 927                                    || st->thread[st->bank[0] - 1].tslen == 50));
 928                           {
 929                             forallinbank (L)
 930                             {
 931                               int seqSum = 0, c;
 932
 933                               if (L->tslen == 0)
 934                                 L->tslen = L->otslen;
 935                               for (c = 1; c <= L->tslen; c++)
 936                                 seqSum += L->turnseq[c - 1];
 937                               if (seqSum == 0)
 938                                 L->tclim = 1;
 939                               else
 940                                 L->tclim =
 941                                   (int) (((real) degs2) / abs (seqSum));
 942                               L->tsc = random1 (L->tslen) + 1;
 943                             }
 944                           }
 945                           break;
 946                         case 'T':
 947                           {
 948                             st->ch = readkey (st);
 949                             {
 950                               forallinbank (L)
 951                               {
 952                                 switch (st->ch)
 953                                   {
 954                                   case '1': case '2': case '3':
 955                                   case '4': case '5': case '6':
 956                                   case '7': case '8': case '9':
 957                                     L->tmode = st->ch - '0';
 958                                     break;
 959                                   case 'R':
 960                                     L->tmode = random1 (tmodes - '0') + 1;
 961                                     break;
 962                                   }
 963                               }
 964                             }
 965                           }
 966                           break;
 967                         case 'O':
 968                           st->ch = readkey (st);
 969                           {
 970                             forallinbank (L) L->orichar = st->ch;
 971                           }
 972                           break;
 973                         case 'F':
 974                           {
 975                             banktype fbank;
 976                             arrcpy (fbank, st->bank);
 977                             {
 978                               int fbnkt = st->bnkt;
 979                               int bankc;
 980                               pickbank (st);
 981                               for (bankc = 1; bankc <= fbnkt; bankc++)
 982                                 {
 983                                   linedata *L = &st->thread[fbank[bankc - 1] - 1];
 984                                   if (st->ch == 'N')
 985                                     L->prey = 0;
 986                                   else
 987                                     L->prey = st->bank[0 + (bankc - 1) % st->bnkt];
 988                                 }
 989                             }
 990                           }
 991                           break;
 992                         case 'L':
 993                           {
 994                             forallinbank (L) L->prey = st->bank[bankc % st->bnkt];
 995                           }
 996                           break;
 997                         case 'R':
 998                           st->ch = readkey (st);
 999                           {
1000                             forallinbank (L) switch (st->ch)
1001                               {
1002                               case '1': case '2': case '3':
1003                               case '4': case '5': case '6':
1004                               case '7': case '8': case '9':
1005                                 L->circturn = 10 - (st->ch - '0');
1006                                 break;
1007                               case 'R':
1008                                 L->circturn = random1 (7) + 1;
1009                                 break;
1010                               }
1011                           }
1012                           break;
1013                         }
1014                     }
1015                   break;
1016                 case 'T':
1017                 case 'Y':
1018                 case 'N':
1019                   boolop = st->ch;
1020                   pickbank (st);
1021                   if (st->bnkt > 0)
1022                     {
1023                       st->ch = readkey (st);
1024                       {
1025                         forallinbank (L)
1026                         {
1027                           switch (st->ch)
1028                             {
1029                             case 'S':
1030                               bankmod (boolop, &L->selfbounce);
1031                               break;
1032                             case 'V':
1033                               bankmod (boolop, &L->vhfollow);
1034                               break;
1035                             case 'R':
1036                               bankmod (boolop, &L->realbounce);
1037                               break;
1038                             case 'L':
1039                               bankmod (boolop, &L->little);
1040                               st->cleared = True;
1041                               break;
1042                             case 'T':
1043                               bankmod (boolop, &L->tailfollow);
1044                               break;
1045                             case 'K':
1046                               bankmod (boolop, &L->killwalls);
1047                               break;
1048                             }
1049                         }
1050                       }
1051                     }
1052                   break;
1053                 case 'R':
1054                   if (st->bordcol == 1)
1055                     {
1056                       st->bordcol = 0;
1057                       bordupdate (st);
1058                       st->bordcorn = (st->bordcorn + 1) % 4;
1059                       st->bordcol = 1;
1060                       bordupdate (st);
1061                     }
1062                   break;
1063                 case '1': case '2': case '3':
1064                 case '4': case '5': case '6':
1065                 case '7': case '8': case '9':
1066                   {
1067                     int c;
1068                     for (c = 1; c <= thrmax; c++)
1069                       st->thread[c - 1].tmode = st->ch - '0';
1070                   }
1071                   break;
1072                 case '\40':
1073                   st->cleared = True;
1074                   break;
1075                 case 'E':
1076                   st->erasing = !st->erasing;
1077                   break;
1078                 case 'P':
1079                   randpal (st);
1080                   palupdate (st, True);
1081                   break;
1082                 case 'G':
1083                   {
1084                     char dimch = 'B';
1085                     Bool gridchanged = True;
1086                     if (st->gridden == 0)
1087                       st->gridden = st->ogd;
1088                     do
1089                       {
1090                         int msize = 0;
1091                         if (gridchanged)
1092                           {
1093                             clearscreen (st);
1094                             gridupdate (st, True);
1095                           }
1096                         st->ch = readkey (st);
1097                         gridchanged = True;
1098                         switch (st->ch)
1099                           {
1100                           case '+':
1101                             msize = 1;
1102                             break;
1103                           case '-':
1104                             msize = -1;
1105                             break;
1106                           case ']':
1107                             if (st->gridden < 15)
1108                               st->gridden++;
1109                             break;
1110                           case '[':
1111                             if (st->gridden > 0)
1112                               st->gridden--;
1113                             break;
1114                           case 'O':
1115                             st->ogd = st->gridden;
1116                             st->gridden = 0;
1117                             break;
1118                           case 'S':
1119                             st->boxw = st->boxh;
1120                           case 'W':
1121                           case 'H':
1122                           case 'B':
1123                             dimch = st->ch;
1124                             break;
1125                           default:
1126                             gridchanged = False;
1127                           }
1128                         if (dimch == 'W' || dimch == 'B')
1129                           st->boxw += msize;
1130                         if (dimch == 'H' || dimch == 'B')
1131                           st->boxh += msize;
1132                         if (st->boxw == 0)
1133                           st->boxw = 1;
1134                         if (st->boxh == 0)
1135                           st->boxh = 1;
1136                       }
1137                     while (!(st->ch == '\15' || st->ch == '#' || st->ch == 'O'));
1138                     st->cleared = True;
1139                   }
1140                   break;
1141                 case 'A':
1142                   st->autopal = !st->autopal;
1143                   break;
1144                 case 'B':
1145                   st->bordcol = 1 - st->bordcol;
1146                   bordupdate (st);
1147                   break;
1148                 case '-':
1149                   st->speed -= SPEEDINC;
1150                   if (st->speed < 1)
1151                     st->speed = 1;
1152                   break;
1153                 case '+':
1154                   st->speed += SPEEDINC;
1155                   if (st->speed > SPEEDMAX)
1156                     st->speed = SPEEDMAX;
1157                   break;
1158                 case '/':
1159                   if (st->curviness > 5)
1160                     st->curviness -= 5;
1161                   break;
1162                 case '*':
1163                   if (st->curviness < 50)
1164                     st->curviness += 5;
1165                   break;
1166                 case ']':
1167                   if (st->threads < thrmax)
1168                     newonscreen (st, ++st->threads);
1169                   break;
1170                 case '[':
1171                   if (st->threads > 1)
1172                     {
1173                       linedata *L = &st->thread[st->threads - 1];
1174                       int lastpos = (L->filled) ? L->reclen - 1 : L->recpos;
1175                       int c;
1176                       for (c = 0; c <= lastpos; c++)
1177                         sp (st, L->xrec[c], L->yrec[c], 0);
1178                       st->threads--;
1179                     }
1180                   break;
1181                 }
1182             }
1183 }
1184
1185 static void
1186 vermiculate_free (Display *dpy, Window window, void *closure)
1187 {
1188   struct state *st = (struct state *) closure;
1189
1190   if (st->point)
1191     {
1192       free(st->point);
1193     }
1194   free (st);
1195 }
1196
1197
1198 static const char *vermiculate_defaults[] = {
1199   ".background: Black",
1200   "*ticks: 20000",
1201   "*fpsSolid:   true",
1202   "*speed: 0",
1203   "*instring: ",
1204   0
1205 };
1206
1207 static XrmOptionDescRec vermiculate_options[] = {
1208   {"-speed", ".speed", XrmoptionSepArg, 0},
1209   {"-instring", ".instring", XrmoptionSepArg, 0},
1210   {0, 0, 0, 0}
1211 };
1212
1213
1214 XSCREENSAVER_MODULE ("Vermiculate", vermiculate)