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

   1 /* -*- Mode: C; tab-width: 4 -*- */
   2 /*-
   3  * ant --- Chris Langton's generalized turing machine ants (also known
   4  *         as Greg Turk's turmites) whose tape is the screen
   5  */
   6
   7 #if 0
   8 static const char sccsid[] = "@(#)ant.c 5.00 2000/11/01 xlockmore";
   9 #endif
  10
  11 /*-
  12  * Copyright (c) 1995 by David Bagley.
  13  *
  14  * Permission to use, copy, modify, and distribute this software and its
  15  * documentation for any purpose and without fee is hereby granted,
  16  * provided that the above copyright notice appear in all copies and that
  17  * both that copyright notice and this permission notice appear in
  18  * supporting documentation.
  19  *
  20  * This file is provided AS IS with no warranties of any kind.  The author
  21  * shall have no liability with respect to the infringement of copyrights,
  22  * trade secrets or any patents by this file or any part thereof.  In no
  23  * event will the author be liable for any lost revenue or profits or
  24  * other special, indirect and consequential damages.
  25  *
  26  * Revision History:
  27  * 01-Nov-2000: Allocation checks
  28  * 10-May-1997: Compatible with xscreensaver
  29  * 16-Apr-1997: -neighbors 3 and 8 added
  30  * 01-Jan-1997: Updated ant.c to handle more kinds of ants.  Thanks to
  31  *              J Austin David <Austin.David@tlogic.com>.  Check it out in
  32  *              java at http://havoc.gtf.gatech.edu/austin  He thought up the
  33  *              new Ladder ant.
  34  * 04-Apr-1996: -neighbors 6 runtime-time option added for hexagonal ants
  35  *              (bees), coded from an idea of Jim Propp's in Science News,
  36  *              Oct 28, 1995 VOL. 148 page 287
  37  * 20-Sep-1995: Memory leak in ant fixed.  Now random colors.
  38  * 05-Sep-1995: Coded from A.K. Dewdney's "Computer Recreations", Scientific
  39  *              American Magazine" Sep 1989 pp 180-183, Mar 1990 p 121
  40  *              Also used Ian Stewart's Mathematical Recreations, Scientific
  41  *              American Jul 1994 pp 104-107
  42  *              also used demon.c and life.c as a guide.
  43  */
  44
  45 /*-
  46   Species Grid     Number of Neighbors
  47   ------- ----     ------------------
  48   Ants    Square   4 (or 8)
  49   Bees    Hexagon  6
  50   Bees    Triangle 3 (or 9, 12)
  51
  52   Neighbors 6 and neighbors 3 produce the same Turk ants.
  53 */
  54
  55 #ifdef STANDALONE
  56 #define MODE_ant
  57 #define PROGCLASS "Ant"
  58 #define HACK_INIT init_ant
  59 #define HACK_DRAW draw_ant
  60 #define ant_opts xlockmore_opts
  61 #define DEFAULTS "*delay: 1000 \n" \
  62  "*count: -3 \n" \
  63  "*cycles: 40000 \n" \
  64  "*size: -12 \n" \
  65  "*ncolors: 64 \n" \
  66
  67 #include "xlockmore.h"          /* in xscreensaver distribution */
  68 #include "erase.h"
  69 #else /* STANDALONE */
  70 #include "xlock.h"              /* in xlockmore distribution */
  71 #endif /* STANDALONE */
  72 #include "automata.h"
  73
  74 #ifdef MODE_ant
  75
  76 /*-
  77  * neighbors of 0 randomizes it for 3, 4, 6, 8, 12 (last 2 are less likely)
  78  */
  79
  80 #define DEF_NEIGHBORS  "0"      /* choose random value */
  81 #define DEF_TRUCHET  "False"
  82 #define DEF_EYES  "False"
  83 #define DEF_SHARPTURN  "False"
  84
  85 static int  neighbors;
  86 static Bool truchet;
  87 static Bool eyes;
  88 static Bool sharpturn;
  89
  90 static XrmOptionDescRec opts[] =
  91 {
  92         {"-neighbors", ".ant.neighbors", XrmoptionSepArg, 0},
  93         {"-truchet", ".ant.truchet", XrmoptionNoArg, "on"},
  94         {"+truchet", ".ant.truchet", XrmoptionNoArg, "off"},
  95         {"-eyes", ".ant.eyes", XrmoptionNoArg, "on"},
  96         {"+eyes", ".ant.eyes", XrmoptionNoArg, "off"},
  97         {"-sharpturn", ".ant.sharpturn", XrmoptionNoArg, "on"},
  98         {"+sharpturn", ".ant.sharpturn", XrmoptionNoArg, "off"},
  99 };
 100 static argtype vars[] =
 101 {
 102         {&neighbors, "neighbors", "Neighbors", DEF_NEIGHBORS, t_Int},
 103         {&truchet,   "truchet",   "Truchet",   DEF_TRUCHET,   t_Bool},
 104         {&eyes,      "eyes",      "Eyes",      DEF_EYES,      t_Bool},
 105     {&sharpturn, "sharpturn", "SharpTurn", DEF_SHARPTURN, t_Bool},
 106 };
 107 static OptionStruct desc[] =
 108 {
 109         {"-neighbors num", "squares 4 or 8, hexagons 6, triangles 3 or 12"},
 110         {"-/+truchet", "turn on/off Truchet lines"},
 111         {"-/+eyes", "turn on/off eyes"},
 112         {"-/+sharpturn", "turn on/off sharp turns (6, 8 or 12 neighbors only)"}
 113 };
 114
 115 ModeSpecOpt ant_opts =
 116 {sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
 117
 118 #ifdef USE_MODULES
 119 const ModStruct ant_description =
 120 {"ant",
 121  "init_ant", "draw_ant", "release_ant",
 122  "refresh_ant", "init_ant", (char *) NULL, &ant_opts,
 123  1000, -3, 40000, -12, 64, 1.0, "",
 124  "Shows Langton's and Turk's generalized ants", 0, NULL};
 125
 126 #endif
 127
 128 #define ANTBITS(n,w,h)\
 129   if ((ap->pixmaps[ap->init_bits]=\
 130   XCreatePixmapFromBitmapData(display,window,(char *)n,w,h,1,0,1))==None){\
 131   free_ant(display,ap); return;} else {ap->init_bits++;}
 132
 133 /* If you change the table you may have to change the following 2 constants */
 134 #define STATES 2
 135 #define MINANTS 1
 136 #define REDRAWSTEP 2000         /* How much tape to draw per cycle */
 137 #define MINGRIDSIZE 24
 138 #define MINSIZE 1
 139 #define MINRANDOMSIZE 5
 140 #define ANGLES 360
 141
 142 typedef struct {
 143         unsigned char color;
 144         short       direction;
 145         unsigned char next;
 146 } statestruct;
 147
 148 typedef struct {
 149         int         col, row;
 150         short       direction;
 151         unsigned char state;
 152 } antstruct;
 153
 154 typedef struct {
 155         Bool        painted;
 156         int         neighbors;
 157         int         generation;
 158         int         xs, ys;
 159         int         xb, yb;
 160         int         init_dir;
 161         int         nrows, ncols;
 162         int         width, height;
 163         unsigned char ncolors, nstates;
 164         int         n;
 165         int         redrawing, redrawpos;
 166         int         truchet;    /* Only for Turk modes */
 167         int         eyes;
 168         int         sharpturn;
 169         statestruct machine[NUMSTIPPLES * STATES];
 170         unsigned char *tape;
 171         unsigned char *truchet_state;
 172         antstruct  *ants;
 173         int         init_bits;
 174         unsigned char colors[NUMSTIPPLES - 1];
 175         GC          stippledGC;
 176         Pixmap      pixmaps[NUMSTIPPLES - 1];
 177         union {
 178                 XPoint      hexagon[7];         /* Need more than 6 for truchet */
 179                 XPoint      triangle[2][4];     /* Need more than 3 for truchet */
 180         } shape;
 181 } antfarmstruct;
 182
 183 static char plots[] =
 184 {3, 4, 6, 8,
 185 #ifdef NUMBER_9
 186  9,
 187 #endif
 188  12};
 189
 190 #define NEIGHBORKINDS ((long) (sizeof plots / sizeof *plots))
 191 #define GOODNEIGHBORKINDS 3
 192
 193 /* Relative ant moves */
 194 #define FS 0                    /* Step */
 195 #define TRS 1                   /* Turn right, then step */
 196 #define THRS 2                  /* Turn hard right, then step */
 197 #define TBS 3                   /* Turn back, then step */
 198 #define THLS 4                  /* Turn hard left, then step */
 199 #define TLS 5                   /* Turn left, then step */
 200 #define SF 6                    /* Step */
 201 #define STR 7                   /* Step then turn right */
 202 #define STHR 8                  /* Step then turn hard right */
 203 #define STB 9                   /* Step then turn back */
 204 #define STHL 10                 /* Step then turn hard left */
 205 #define STL 11                  /* Step then turn left */
 206
 207 static antfarmstruct *antfarms = (antfarmstruct *) NULL;
 208
 209 /* LANGTON'S ANT (10) Chaotic after 500, Builder after 10,000 (104p) */
 210 /* TURK'S 100 ANT Always chaotic?, tested past 150,000,000 */
 211 /* TURK'S 101 ANT Always chaotic? */
 212 /* TURK'S 110 ANT Builder at 150 (18p) */
 213 /* TURK'S 1000 ANT Always chaotic? */
 214 /* TURK'S 1100 SYMMETRIC ANT  all even run 1's and 0's are symmetric */
 215 /* other examples 1001, 110011, 110000, 1001101 */
 216 /* TURK'S 1101 ANT Builder after 250,000 (388p) */
 217 /* Once saw a chess horse type builder (i.e. non-45 degree builder) */
 218
 219 /* BEE ONLY */
 220 /* All alternating 10 appear symmetric, no proof (i.e. 10, 1010, etc) */
 221 /* Even runs of 0's and 1's are also symmetric */
 222 /* I have seen Hexagonal builders but they are more rare. */
 223
 224 static unsigned char tables[][3 * NUMSTIPPLES * STATES + 2] =
 225 {
 226 #if 0
 227   /* Here just so you can figure out notation */
 228         {                       /* Langton's ant */
 229                 2, 1,
 230                 1, TLS, 0, 0, TRS, 0
 231         },
 232 #else
 233   /* First 2 numbers are the size (ncolors, nstates) */
 234         {                       /* LADDER BUILDER */
 235                 4, 1,
 236                 1, STR, 0, 2, STL, 0, 3, TRS, 0, 0, TLS, 0
 237         },
 238         {                       /* SPIRALING PATTERN */
 239                 2, 2,
 240                 1, TLS, 0, 0, FS, 1,
 241                 1, TRS, 0, 1, TRS, 0
 242         },
 243         {                       /* SQUARE (HEXAGON) BUILDER */
 244                 2, 2,
 245                 1, TLS, 0, 0, FS, 1,
 246                 0, TRS, 0, 1, TRS, 0
 247         },
 248 #endif
 249 };
 250
 251 #define NTABLES   (sizeof tables / sizeof tables[0])
 252
 253 static void
 254 position_of_neighbor(antfarmstruct * ap, int dir, int *pcol, int *prow)
 255 {
 256         int         col = *pcol, row = *prow;
 257
 258         if (ap->neighbors == 6) {
 259                 switch (dir) {
 260                         case 0:
 261                                 col = (col + 1 == ap->ncols) ? 0 : col + 1;
 262                                 break;
 263                         case 60:
 264                                 if (!(row & 1))
 265                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 266                                 row = (!row) ? ap->nrows - 1 : row - 1;
 267                                 break;
 268                         case 120:
 269                                 if (row & 1)
 270                                         col = (!col) ? ap->ncols - 1 : col - 1;
 271                                 row = (!row) ? ap->nrows - 1 : row - 1;
 272                                 break;
 273                         case 180:
 274                                 col = (!col) ? ap->ncols - 1 : col - 1;
 275                                 break;
 276                         case 240:
 277                                 if (row & 1)
 278                                         col = (!col) ? ap->ncols - 1 : col - 1;
 279                                 row = (row + 1 == ap->nrows) ? 0 : row + 1;
 280                                 break;
 281                         case 300:
 282                                 if (!(row & 1))
 283                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 284                                 row = (row + 1 == ap->nrows) ? 0 : row + 1;
 285                                 break;
 286                         default:
 287                                 (void) fprintf(stderr, "wrong direction %d\n", dir);
 288                 }
 289         } else if (ap->neighbors == 4 || ap->neighbors == 8) {
 290                 switch (dir) {
 291                         case 0:
 292                                 col = (col + 1 == ap->ncols) ? 0 : col + 1;
 293                                 break;
 294                         case 45:
 295                                 col = (col + 1 == ap->ncols) ? 0 : col + 1;
 296                                 row = (!row) ? ap->nrows - 1 : row - 1;
 297                                 break;
 298                         case 90:
 299                                 row = (!row) ? ap->nrows - 1 : row - 1;
 300                                 break;
 301                         case 135:
 302                                 col = (!col) ? ap->ncols - 1 : col - 1;
 303                                 row = (!row) ? ap->nrows - 1 : row - 1;
 304                                 break;
 305                         case 180:
 306                                 col = (!col) ? ap->ncols - 1 : col - 1;
 307                                 break;
 308                         case 225:
 309                                 col = (!col) ? ap->ncols - 1 : col - 1;
 310                                 row = (row + 1 == ap->nrows) ? 0 : row + 1;
 311                                 break;
 312                         case 270:
 313                                 row = (row + 1 == ap->nrows) ? 0 : row + 1;
 314                                 break;
 315                         case 315:
 316                                 col = (col + 1 == ap->ncols) ? 0 : col + 1;
 317                                 row = (row + 1 == ap->nrows) ? 0 : row + 1;
 318                                 break;
 319                         default:
 320                                 (void) fprintf(stderr, "wrong direction %d\n", dir);
 321                 }
 322         } else {                /* TRI */
 323                 if ((col + row) % 2) {  /* right */
 324                         switch (dir) {
 325                                 case 0:
 326                                         col = (!col) ? ap->ncols - 1 : col - 1;
 327                                         break;
 328                                 case 30:
 329                                 case 40:
 330                                         col = (!col) ? ap->ncols - 1 : col - 1;
 331                                         row = (!row) ? ap->nrows - 1 : row - 1;
 332                                         break;
 333                                 case 60:
 334                                         col = (!col) ? ap->ncols - 1 : col - 1;
 335                                         if (!row)
 336                                                 row = ap->nrows - 2;
 337                                         else if (!(row - 1))
 338                                                 row = ap->nrows - 1;
 339                                         else
 340                                                 row = row - 2;
 341                                         break;
 342                                 case 80:
 343                                 case 90:
 344                                         if (!row)
 345                                                 row = ap->nrows - 2;
 346                                         else if (!(row - 1))
 347                                                 row = ap->nrows - 1;
 348                                         else
 349                                                 row = row - 2;
 350                                         break;
 351                                 case 120:
 352                                         row = (!row) ? ap->nrows - 1 : row - 1;
 353                                         break;
 354                                 case 150:
 355                                 case 160:
 356                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 357                                         row = (!row) ? ap->nrows - 1 : row - 1;
 358                                         break;
 359                                 case 180:
 360                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 361                                         break;
 362                                 case 200:
 363                                 case 210:
 364                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 365                                         row = (row + 1 == ap->nrows) ? 0 : row + 1;
 366                                         break;
 367                                 case 240:
 368                                         row = (row + 1 == ap->nrows) ? 0 : row + 1;
 369                                         break;
 370                                 case 270:
 371                                 case 280:
 372                                         if (row + 1 == ap->nrows)
 373                                                 row = 1;
 374                                         else if (row + 2 == ap->nrows)
 375                                                 row = 0;
 376                                         else
 377                                                 row = row + 2;
 378                                         break;
 379                                 case 300:
 380                                         col = (!col) ? ap->ncols - 1 : col - 1;
 381                                         if (row + 1 == ap->nrows)
 382                                                 row = 1;
 383                                         else if (row + 2 == ap->nrows)
 384                                                 row = 0;
 385                                         else
 386                                                 row = row + 2;
 387                                         break;
 388                                 case 320:
 389                                 case 330:
 390                                         col = (!col) ? ap->ncols - 1 : col - 1;
 391                                         row = (row + 1 == ap->nrows) ? 0 : row + 1;
 392                                         break;
 393                                 default:
 394                                         (void) fprintf(stderr, "wrong direction %d\n", dir);
 395                         }
 396                 } else {        /* left */
 397                         switch (dir) {
 398                                 case 0:
 399                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 400                                         break;
 401                                 case 30:
 402                                 case 40:
 403                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 404                                         row = (row + 1 == ap->nrows) ? 0 : row + 1;
 405                                         break;
 406                                 case 60:
 407                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 408                                         if (row + 1 == ap->nrows)
 409                                                 row = 1;
 410                                         else if (row + 2 == ap->nrows)
 411                                                 row = 0;
 412                                         else
 413                                                 row = row + 2;
 414                                         break;
 415                                 case 80:
 416                                 case 90:
 417                                         if (row + 1 == ap->nrows)
 418                                                 row = 1;
 419                                         else if (row + 2 == ap->nrows)
 420                                                 row = 0;
 421                                         else
 422                                                 row = row + 2;
 423                                         break;
 424                                 case 120:
 425                                         row = (row + 1 == ap->nrows) ? 0 : row + 1;
 426                                         break;
 427                                 case 150:
 428                                 case 160:
 429                                         col = (!col) ? ap->ncols - 1 : col - 1;
 430                                         row = (row + 1 == ap->nrows) ? 0 : row + 1;
 431                                         break;
 432                                 case 180:
 433                                         col = (!col) ? ap->ncols - 1 : col - 1;
 434                                         break;
 435                                 case 200:
 436                                 case 210:
 437                                         col = (!col) ? ap->ncols - 1 : col - 1;
 438                                         row = (!row) ? ap->nrows - 1 : row - 1;
 439                                         break;
 440                                 case 240:
 441                                         row = (!row) ? ap->nrows - 1 : row - 1;
 442                                         break;
 443                                 case 270:
 444                                 case 280:
 445                                         if (!row)
 446                                                 row = ap->nrows - 2;
 447                                         else if (row == 1)
 448                                                 row = ap->nrows - 1;
 449                                         else
 450                                                 row = row - 2;
 451                                         break;
 452                                 case 300:
 453                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 454                                         if (!row)
 455                                                 row = ap->nrows - 2;
 456                                         else if (row == 1)
 457                                                 row = ap->nrows - 1;
 458                                         else
 459                                                 row = row - 2;
 460                                         break;
 461                                 case 320:
 462                                 case 330:
 463                                         col = (col + 1 == ap->ncols) ? 0 : col + 1;
 464                                         row = (!row) ? ap->nrows - 1 : row - 1;
 465                                         break;
 466                                 default:
 467                                         (void) fprintf(stderr, "wrong direction %d\n", dir);
 468                         }
 469                 }
 470         }
 471         *pcol = col;
 472         *prow = row;
 473 }
 474
 475 static void
 476 fillcell(ModeInfo * mi, GC gc, int col, int row)
 477 {
 478         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 479
 480         if (ap->neighbors == 6) {
 481                 int         ccol = 2 * col + !(row & 1), crow = 2 * row;
 482
 483                 ap->shape.hexagon[0].x = ap->xb + ccol * ap->xs;
 484                 ap->shape.hexagon[0].y = ap->yb + crow * ap->ys;
 485                 if (ap->xs == 1 && ap->ys == 1)
 486                         XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
 487                         ap->shape.hexagon[0].x, ap->shape.hexagon[0].y);
 488                 else
 489                         XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
 490                             ap->shape.hexagon, 6, Convex, CoordModePrevious);
 491         } else if (ap->neighbors == 4 || ap->neighbors == 8) {
 492                 XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
 493                 ap->xb + ap->xs * col, ap->yb + ap->ys * row,
 494                 ap->xs - (ap->xs > 3), ap->ys - (ap->ys > 3));
 495         } else {                /* TRI */
 496                 int         orient = (col + row) % 2;   /* O left 1 right */
 497
 498                 ap->shape.triangle[orient][0].x = ap->xb + col * ap->xs;
 499                 ap->shape.triangle[orient][0].y = ap->yb + row * ap->ys;
 500                 if (ap->xs <= 3 || ap->ys <= 3)
 501                         XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
 502                         ((orient) ? -1 : 1) + ap->shape.triangle[orient][0].x,
 503                                        ap->shape.triangle[orient][0].y);
 504                 else {
 505                         if (orient)
 506                                 ap->shape.triangle[orient][0].x += (ap->xs / 2 - 1);
 507                         else
 508                                 ap->shape.triangle[orient][0].x -= (ap->xs / 2 - 1);
 509                         XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
 510                                      ap->shape.triangle[orient], 3, Convex, CoordModePrevious);
 511                 }
 512         }
 513 }
 514
 515 static void
 516 truchetcell(ModeInfo * mi, int col, int row, int truchetstate)
 517 {
 518         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 519
 520         if (ap->neighbors == 6) {
 521
 522                 int         ccol = 2 * col + !(row & 1), crow = 2 * row;
 523                 int         side;
 524                 int         fudge = 7;  /* fudge because the hexagons are not exact */
 525                 XPoint      hex, hex2;
 526
 527                 if (ap->sharpturn) {
 528                         hex.x = ap->xb + ccol * ap->xs - (int) ((double) ap->xs / 2.0) - 1;
 529                         hex.y = ap->yb + crow * ap->ys - (int) ((double) ap->ys / 2.0) - 1;
 530                         for (side = 0; side < 6; side++) {
 531                                 if (side) {
 532                                         hex.x += ap->shape.hexagon[side].x;
 533                                         hex.y += ap->shape.hexagon[side].y;
 534                                 }
 535                                 if (truchetstate == side % 2)
 536                                         XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 537                                                  hex.x, hex.y, ap->xs, ap->ys,
 538                                                  ((570 - (side * 60) + fudge) % 360) * 64, (120 - 2 * fudge) * 64);
 539                         }
 540                 } else {
 541                         /* Very crude approx of Sqrt 3, so it will not cause drawing errors. */
 542                         hex.x = ap->xb + ccol * ap->xs - (int) ((double) ap->xs * 1.6 / 2.0) - 1;
 543                         hex.y = ap->yb + crow * ap->ys - (int) ((double) ap->ys * 1.6 / 2.0) - 1;
 544                         for (side = 0; side < 6; side++) {
 545                                 if (side) {
 546                                         hex.x += ap->shape.hexagon[side].x;
 547                                         hex.y += ap->shape.hexagon[side].y;
 548                                 }
 549                                 hex2.x = hex.x + ap->shape.hexagon[side + 1].x / 2;
 550                                 hex2.y = hex.y + ap->shape.hexagon[side + 1].y / 2 + 1;
 551                                 /* Lots of fudging here */
 552                                 if (side == 1) {
 553                                         hex2.x += (short) (ap->xs * 0.1 + 1);
 554                                         hex2.y += (short) (ap->ys * 0.1 - ((ap->ys > 5) ? 1 : 0));
 555                                 } else if (side == 2) {
 556                                         hex2.x += (short) (ap->xs * 0.1);
 557                                 } else if (side == 4) {
 558                                         hex2.x += (short) (ap->xs * 0.1);
 559                                         hex2.y += (short) (ap->ys * 0.1 - 1);
 560                                 } else if (side == 5) {
 561                                         hex2.x += (short) (ap->xs * 0.5);
 562                                         hex2.y += (short) (-ap->ys * 0.3 + 1);
 563                                 }
 564                                 if (truchetstate == side % 3)
 565                                         /* Crude approx of 120 deg, so it will not cause drawing errors. */
 566                                         XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 567                                                  hex2.x, hex2.y,
 568                                                  (int) ((double) ap->xs * 1.5), (int) ((double) ap->ys * 1.5),
 569                                                  ((555 - (side * 60)) % 360) * 64, 90 * 64);
 570                         }
 571                 }
 572         } else if (ap->neighbors == 4) {
 573                 if (truchetstate) {
 574                         XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 575                                  ap->xb + ap->xs * col - ap->xs / 2 + 1,
 576                                  ap->yb + ap->ys * row + ap->ys / 2 - 1,
 577                                  ap->xs - 2, ap->ys - 2,
 578                                  0 * 64, 90 * 64);
 579                         XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 580                                  ap->xb + ap->xs * col + ap->xs / 2 - 1,
 581                                  ap->yb + ap->ys * row - ap->ys / 2 + 1,
 582                                  ap->xs - 2, ap->ys - 2,
 583                                  -90 * 64, -90 * 64);
 584                 } else {
 585                         XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 586                                  ap->xb + ap->xs * col - ap->xs / 2 + 1,
 587                                  ap->yb + ap->ys * row - ap->ys / 2 + 1,
 588                                  ap->xs - 2, ap->ys - 2,
 589                                  0 * 64, -90 * 64);
 590                         XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 591                                  ap->xb + ap->xs * col + ap->xs / 2 - 1,
 592                                  ap->yb + ap->ys * row + ap->ys / 2 - 1,
 593                                  ap->xs - 2, ap->ys - 2,
 594                                  90 * 64, 90 * 64);
 595                 }
 596         } else if (ap->neighbors == 3) {
 597                 int         orient = (col + row) % 2;   /* O left 1 right */
 598                 int         side, ang;
 599                 int         fudge = 7;  /* fudge because the triangles are not exact */
 600                 double      fudge2 = 1.18;
 601                 XPoint      tri;
 602
 603                 tri.x = ap->xb + col * ap->xs;
 604                 tri.y = ap->yb + row * ap->ys;
 605                 if (orient) {
 606                         tri.x += (ap->xs / 2 - 1);
 607                 } else {
 608                         tri.x -= (ap->xs / 2 - 1);
 609                 }
 610                 for (side = 0; side < 3; side++) {
 611                         if (side > 0) {
 612                                 tri.x += ap->shape.triangle[orient][side].x;
 613                                 tri.y += ap->shape.triangle[orient][side].y;
 614                         }
 615                         if (truchetstate == side) {
 616                                 if (orient)
 617                                         ang = (510 - side * 120) % 360;         /* Right */
 618                                 else
 619                                         ang = (690 - side * 120) % 360;         /* Left */
 620                                 XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
 621                                   (int) (tri.x - ap->xs * fudge2 / 2),
 622           (int) (tri.y - 3 * ap->ys * fudge2 / 4),
 623                                   (unsigned int) (ap->xs * fudge2),
 624           (unsigned int) (3 * ap->ys * fudge2 / 2),
 625                                   (ang + fudge) * 64, (60 - 2 * fudge) * 64);
 626                         }
 627                 }
 628         }
 629 }
 630
 631 static void
 632 drawcell(ModeInfo * mi, int col, int row, unsigned char color)
 633 {
 634         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 635         GC          gc;
 636
 637         if (!color) {
 638                 XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi));
 639                 gc = MI_GC(mi);
 640         } else if (MI_NPIXELS(mi) > 2) {
 641                 XSetForeground(MI_DISPLAY(mi), MI_GC(mi),
 642                                MI_PIXEL(mi, ap->colors[color - 1]));
 643                 gc = MI_GC(mi);
 644         } else {
 645                 XGCValues   gcv;
 646
 647                 gcv.stipple = ap->pixmaps[color - 1];
 648                 gcv.foreground = MI_WHITE_PIXEL(mi);
 649                 gcv.background = MI_BLACK_PIXEL(mi);
 650                 XChangeGC(MI_DISPLAY(mi), ap->stippledGC,
 651                           GCStipple | GCForeground | GCBackground, &gcv);
 652                 gc = ap->stippledGC;
 653         }
 654         fillcell(mi, gc, col, row);
 655 }
 656
 657 static void
 658 drawtruchet(ModeInfo * mi, int col, int row,
 659             unsigned char color, unsigned char truchetstate)
 660 {
 661         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 662
 663         if (!color)
 664                 XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi));
 665         else if (MI_NPIXELS(mi) > 2 || color > ap->ncolors / 2)
 666                 XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi));
 667         else
 668                 XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi));
 669         truchetcell(mi, col, row, truchetstate);
 670 }
 671
 672 static void
 673 draw_anant(ModeInfo * mi, int direction, int col, int row)
 674 {
 675         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 676         Display    *display = MI_DISPLAY(mi);
 677         Window      window = MI_WINDOW(mi);
 678
 679         XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
 680         fillcell(mi, MI_GC(mi), col, row);
 681         if (ap->eyes) {         /* Draw Eyes */
 682                 XSetForeground(display, MI_GC(mi), MI_BLACK_PIXEL(mi));
 683                 if (ap->neighbors == 6) {
 684                         int         ccol = 2 * col + !(row & 1), crow = 2 * row;
 685                         int         side, ang;
 686                         XPoint      hex;
 687
 688                         if (!(ap->xs > 3 && ap->ys > 3))
 689                                 return;
 690                         hex.x = ap->xb + ccol * ap->xs;
 691                         hex.y = ap->yb + crow * ap->ys + ap->ys / 2;
 692                         ang = direction * ap->neighbors / ANGLES;
 693                         for (side = 0; side < ap->neighbors; side++) {
 694                                 if (side) {
 695                                         hex.x -= ap->shape.hexagon[side].x / 2;
 696                                         hex.y += ap->shape.hexagon[side].y / 2;
 697                                 }
 698                                 if (side == (ap->neighbors + ang - 2) % ap->neighbors)
 699                                         XDrawPoint(display, window, MI_GC(mi), hex.x, hex.y);
 700                                 if (side == (ap->neighbors + ang - 1) % ap->neighbors)
 701                                         XDrawPoint(display, window, MI_GC(mi), hex.x, hex.y);
 702                         }
 703                 } else if (ap->neighbors == 4 || ap->neighbors == 8) {
 704                         if (!(ap->xs > 3 && ap->ys > 3))
 705                                 return;
 706                         switch (direction) {
 707                                 case 0:
 708                                         XDrawPoint(display, window, MI_GC(mi),
 709                                                 ap->xb + ap->xs * (col + 1) - 3,
 710                                                 ap->yb + ap->ys * row + ap->ys / 2 - 2);
 711                                         XDrawPoint(display, window, MI_GC(mi),
 712                                                 ap->xb + ap->xs * (col + 1) - 3,
 713                                                 ap->yb + ap->ys * row + ap->ys / 2);
 714                                         break;
 715                                 case 45:
 716                                         XDrawPoint(display, window, MI_GC(mi),
 717                                                 ap->xb + ap->xs * (col + 1) - 4,
 718                                                 ap->yb + ap->ys * row + 1);
 719                                         XDrawPoint(display, window, MI_GC(mi),
 720                                                 ap->xb + ap->xs * (col + 1) - 3,
 721                                                 ap->yb + ap->ys * row + 2);
 722                                         break;
 723                                 case 90:
 724                                         XDrawPoint(display, window, MI_GC(mi),
 725                                                 ap->xb + ap->xs * col + ap->xs / 2 - 2,
 726                                                 ap->yb + ap->ys * row + 1);
 727                                         XDrawPoint(display, window, MI_GC(mi),
 728                                                 ap->xb + ap->xs * col + ap->xs / 2,
 729                                                 ap->yb + ap->ys * row + 1);
 730                                         break;
 731                                 case 135:
 732                                         XDrawPoint(display, window, MI_GC(mi),
 733                                                 ap->xb + ap->xs * col + 2,
 734                                                 ap->yb + ap->ys * row + 1);
 735                                         XDrawPoint(display, window, MI_GC(mi),
 736                                                 ap->xb + ap->xs * col + 1,
 737                                                 ap->yb + ap->ys * row + 2);
 738                                         break;
 739                                 case 180:
 740                                         XDrawPoint(display, window, MI_GC(mi),
 741                                                 ap->xb + ap->xs * col + 1,
 742                                                 ap->yb + ap->ys * row + ap->ys / 2 - 2);
 743                                         XDrawPoint(display, window, MI_GC(mi),
 744                                                 ap->xb + ap->xs * col + 1,
 745                                                 ap->yb + ap->ys * row + ap->ys / 2);
 746                                         break;
 747                                 case 225:
 748                                         XDrawPoint(display, window, MI_GC(mi),
 749                                                 ap->xb + ap->xs * col + 2,
 750                                                 ap->yb + ap->ys * (row + 1) - 3);
 751                                         XDrawPoint(display, window, MI_GC(mi),
 752                                                 ap->xb + ap->xs * col + 1,
 753                                                 ap->yb + ap->ys * (row + 1) - 4);
 754                                         break;
 755                                 case 270:
 756                                         XDrawPoint(display, window, MI_GC(mi),
 757                                                 ap->xb + ap->xs * col + ap->xs / 2 - 2,
 758                                                 ap->yb + ap->ys * (row + 1) - 3);
 759                                         XDrawPoint(display, window, MI_GC(mi),
 760                                                 ap->xb + ap->xs * col + ap->xs / 2,
 761                                                 ap->yb + ap->ys * (row + 1) - 3);
 762                                         break;
 763                                 case 315:
 764                                         XDrawPoint(display, window, MI_GC(mi),
 765                                                 ap->xb + ap->xs * (col + 1) - 4,
 766                                                 ap->yb + ap->ys * (row + 1) - 3);
 767                                         XDrawPoint(display, window, MI_GC(mi),
 768                                                 ap->xb + ap->xs * (col + 1) - 3,
 769                                                 ap->yb + ap->ys * (row + 1) - 4);
 770                                         break;
 771                                 default:
 772                                         (void) fprintf(stderr, "wrong eyes direction %d for ant eyes\n", direction);
 773                         }
 774                 } else {                /* TRI */
 775                         int         orient = (col + row) % 2;   /* O left 1 right */
 776                         int         side, ang;
 777                         XPoint      tri;
 778
 779                         if (!(ap->xs > 6 && ap->ys > 6))
 780                                 return;
 781                         tri.x = ap->xb + col * ap->xs;
 782                         tri.y = ap->yb + row * ap->ys;
 783                         if (orient)
 784                                 tri.x += (ap->xs / 6 - 1);
 785                         else
 786                                 tri.x -= (ap->xs / 6 - 1);
 787                         ang = direction * ap->neighbors / ANGLES;
 788                         /* approx... does not work that well for even numbers */
 789                         if (
 790 #ifdef NUMBER_9
 791                         ap->neighbors == 9 ||
 792 #endif
 793                         ap->neighbors == 12) {
 794 #ifdef UNDER_CONSTRUCTION
 795                                 /* Not sure why this does not work */
 796                                 ang = ((ang + ap->neighbors / 6) / (ap->neighbors / 3)) % 3;
 797 #else
 798                                 return;
 799 #endif
 800                         }
 801                         for (side = 0; side < 3; side++) {
 802                                 if (side) {
 803                                         tri.x += ap->shape.triangle[orient][side].x / 3;
 804                                         tri.y += ap->shape.triangle[orient][side].y / 3;
 805                                 }
 806                                 /* Either you have the eyes in back or one eye in front */
 807 #if 0
 808                                 if (side == ang)
 809                                         XDrawPoint(display, window, MI_GC(mi), tri.x, tri.y);
 810 #else
 811                                 if (side == (ang + 2) % 3)
 812                                         XDrawPoint(display, window, MI_GC(mi), tri.x, tri.y);
 813                                 if (side == (ang + 1) % 3)
 814                                         XDrawPoint(display, window, MI_GC(mi), tri.x, tri.y);
 815 #endif
 816                         }
 817                 }
 818         }
 819 }
 820
 821 #if 0
 822 static void
 823 RandomSoup(mi)
 824         ModeInfo   *mi;
 825 {
 826         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 827         int         row, col, mrow = 0;
 828
 829         for (row = 0; row < ap->nrows; ++row) {
 830                 for (col = 0; col < ap->ncols; ++col) {
 831                         ap->old[col + mrow] = (unsigned char) NRAND((int) ap->ncolors);
 832                         drawcell(mi, col, row, ap->old[col + mrow]);
 833                 }
 834                 mrow += ap->nrows;
 835         }
 836 }
 837
 838 #endif
 839
 840 static short
 841 fromTableDirection(unsigned char dir, int local_neighbors)
 842 {
 843         /* Crafted to work for odd number of neighbors */
 844         switch (dir) {
 845                 case FS:
 846                         return 0;
 847                 case TLS:
 848                         return (ANGLES / local_neighbors);
 849                 case THLS:
 850                         return (2 * ANGLES / local_neighbors);
 851                 case TBS:
 852                         return ((local_neighbors / 2) * ANGLES / local_neighbors);
 853                 case THRS:
 854                         return (ANGLES - 2 * ANGLES / local_neighbors);
 855                 case TRS:
 856                         return (ANGLES - ANGLES / local_neighbors);
 857                 case SF:
 858                         return ANGLES;
 859                 case STL:
 860                         return (ANGLES + ANGLES / local_neighbors);
 861                 case STHL:
 862                         return (ANGLES + 2 * ANGLES / local_neighbors);
 863                 case STB:
 864                         return (ANGLES + (local_neighbors / 2) * ANGLES / local_neighbors);
 865                 case STHR:
 866                         return (2 * ANGLES - 2 * ANGLES / local_neighbors);
 867                 case STR:
 868                         return (2 * ANGLES - ANGLES / local_neighbors);
 869                 default:
 870                         (void) fprintf(stderr, "wrong direction %d from table\n", dir);
 871         }
 872         return -1;
 873 }
 874
 875 static void
 876 getTable(ModeInfo * mi, int i)
 877 {
 878         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 879         int         j, total;
 880         unsigned char *patptr;
 881
 882         patptr = &tables[i][0];
 883         ap->ncolors = *patptr++;
 884         ap->nstates = *patptr++;
 885         total = ap->ncolors * ap->nstates;
 886         if (MI_IS_VERBOSE(mi))
 887                 (void) fprintf(stdout,
 888                                "ants %d, neighbors %d, table number %d, colors %d, states %d\n",
 889                           ap->n, ap->neighbors, i, ap->ncolors, ap->nstates);
 890         for (j = 0; j < total; j++) {
 891                 ap->machine[j].color = *patptr++;
 892                 if (ap->sharpturn && ap->neighbors > 4) {
 893                         int         k = *patptr++;
 894
 895                         switch (k) {
 896                                 case TRS:
 897                                         k = THRS;
 898                                         break;
 899                                 case THRS:
 900                                         k = TRS;
 901                                         break;
 902                                 case THLS:
 903                                         k = TLS;
 904                                         break;
 905                                 case TLS:
 906                                         k = THLS;
 907                                         break;
 908                                 case STR:
 909                                         k = STHR;
 910                                         break;
 911                                 case STHR:
 912                                         k = STR;
 913                                         break;
 914                                 case STHL:
 915                                         k = STL;
 916                                         break;
 917                                 case STL:
 918                                         k = STHL;
 919                                         break;
 920                                 default:
 921                                         break;
 922                         }
 923                         ap->machine[j].direction = fromTableDirection(k, ap->neighbors);
 924                 } else {
 925                         ap->machine[j].direction = fromTableDirection(*patptr++, ap->neighbors);
 926                 }
 927                 ap->machine[j].next = *patptr++;
 928         }
 929         ap->truchet = False;
 930 }
 931
 932 static void
 933 getTurk(ModeInfo * mi, int i)
 934 {
 935         antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
 936         int         power2, j, number, total;
 937
 938         /* To force a number, say <i = 2;> has  i + 2 (or 4) binary digits */
 939         power2 = 1 << (i + 1);
 940         /* Do not want numbers which in binary are all 1's. */
 941         number = NRAND(power2 - 1) + power2;
 942         /* To force a particular number, say <number = 10;> */
 943
 944         ap->ncolors = i + 2;
 945         ap->nstates = 1;
 946         total = ap->ncolors * ap->nstates;
 947         for (j = 0; j < total; j++) {
 948                 ap->machine[j].color = (j + 1) % total;
 949                 if (ap->sharpturn && ap->neighbors > 4) {
 950                         ap->machine[j].direction = (power2 & number) ?
 951                                 fromTableDirection(THRS, ap->neighbors) :
 952                                 fromTableDirection(THLS, ap->neighbors);
 953                 } else {
 954                         ap->machine[j].direction = (power2 & number) ?
 955                                 fromTableDirection(TRS, ap->neighbors) :
 956                                 fromTableDirection(TLS, ap->neighbors);
 957                 }
 958                 ap->machine[j].next = 0;
 959                 power2 >>= 1;
 960         }
 961         ap->truchet = (ap->truchet && ap->xs > 2 && ap->ys > 2 &&
 962            (ap->neighbors == 3 || ap->neighbors == 4 || ap->neighbors == 6));
 963         if (MI_IS_VERBOSE(mi))
 964                 (void) fprintf(stdout,
 965                       "ants %d, neighbors %d, Turk's number %d, colors %d\n",
 966                                ap->n, ap->neighbors, number, ap->ncolors);
 967 }
 968
 969 static void
 970 free_ant(Display *display, antfarmstruct *ap)
 971 {
 972         int         shade;
 973
 974         if (ap->stippledGC != None) {
 975                 XFreeGC(display, ap->stippledGC);
 976                 ap->stippledGC = None;
 977         }
 978         for (shade = 0; shade < ap->init_bits; shade++) {
 979                 XFreePixmap(display, ap->pixmaps[shade]);
 980         }
 981         ap->init_bits = 0;
 982         if (ap->tape != NULL) {
 983                 (void) free((void *) ap->tape);
 984                 ap->tape = (unsigned char *) NULL;
 985         }
 986         if (ap->ants != NULL) {
 987                 (void) free((void *) ap->ants);
 988                 ap->ants = (antstruct *) NULL;
 989         }
 990         if (ap->truchet_state != NULL) {
 991                 (void) free((void *) ap->truchet_state);
 992                 ap->truchet_state = (unsigned char *) NULL;
 993         }
 994 }
 995
 996 void
 997 init_ant(ModeInfo * mi)
 998 {
 999         Display    *display = MI_DISPLAY(mi);
1000         Window      window = MI_WINDOW(mi);
1001         int         size = MI_SIZE(mi);
1002         antfarmstruct *ap;
1003         int         col, row, dir;
1004         int         i;
1005
1006         if (antfarms == NULL) {
1007                 if ((antfarms = (antfarmstruct *) calloc(MI_NUM_SCREENS(mi),
1008                                             sizeof (antfarmstruct))) == NULL)
1009                         return;
1010         }
1011         ap = &antfarms[MI_SCREEN(mi)];
1012
1013         ap->redrawing = 0;
1014         if (MI_NPIXELS(mi) <= 2) {
1015                 if (ap->stippledGC == None) {
1016                         XGCValues   gcv;
1017
1018                         gcv.fill_style = FillOpaqueStippled;
1019                         if ((ap->stippledGC = XCreateGC(display, window, GCFillStyle,
1020                                         &gcv)) == None) {
1021                                 free_ant(display, ap);
1022                                 return;
1023                         }
1024                 }
1025                 if (ap->init_bits == 0) {
1026                         for (i = 1; i < NUMSTIPPLES; i++) {
1027                                 ANTBITS(stipples[i], STIPPLESIZE, STIPPLESIZE);
1028                         }
1029                 }
1030         }
1031         ap->generation = 0;
1032         ap->n = MI_COUNT(mi);
1033         if (ap->n < -MINANTS) {
1034                 /* if ap->n is random ... the size can change */
1035                 if (ap->ants != NULL) {
1036                         (void) free((void *) ap->ants);
1037                         ap->ants = (antstruct *) NULL;
1038                 }
1039                 ap->n = NRAND(-ap->n - MINANTS + 1) + MINANTS;
1040         } else if (ap->n < MINANTS)
1041                 ap->n = MINANTS;
1042
1043         ap->width = MI_WIDTH(mi);
1044         ap->height = MI_HEIGHT(mi);
1045
1046         for (i = 0; i < NEIGHBORKINDS; i++) {
1047                 if (neighbors == plots[i]) {
1048                         ap->neighbors = plots[i];
1049                         break;
1050                 }
1051                 if (i == NEIGHBORKINDS - 1) {
1052                         if (!NRAND(10)) {
1053                                 /* Make above 6 rare */
1054                                 ap->neighbors = plots[NRAND(NEIGHBORKINDS)];
1055                         } else {
1056                                 ap->neighbors = plots[NRAND(GOODNEIGHBORKINDS)];
1057                         }
1058                         break;
1059                 }
1060         }
1061
1062         if (ap->neighbors == 6) {
1063                 int         nccols, ncrows;
1064
1065                 if (ap->width < 8)
1066                         ap->width = 8;
1067                 if (ap->height < 8)
1068                         ap->height = 8;
1069                 if (size < -MINSIZE) {
1070                         ap->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(ap->width, ap->height) /
1071                                       MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
1072                         if (ap->ys < MINRANDOMSIZE)
1073                                 ap->ys = MIN(MINRANDOMSIZE,
1074                                              MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE));
1075                 } else if (size < MINSIZE) {
1076                         if (!size)
1077                                 ap->ys = MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE);
1078                         else
1079                                 ap->ys = MINSIZE;
1080                 } else
1081                         ap->ys = MIN(size, MAX(MINSIZE, MIN(ap->width, ap->height) /
1082                                                MINGRIDSIZE));
1083                 ap->xs = ap->ys;
1084                 nccols = MAX(ap->width / ap->xs - 2, 2);
1085                 ncrows = MAX(ap->height / ap->ys - 1, 4);
1086                 ap->ncols = nccols / 2;
1087                 ap->nrows = 2 * (ncrows / 4);
1088                 ap->xb = (ap->width - ap->xs * nccols) / 2 + ap->xs / 2;
1089                 ap->yb = (ap->height - ap->ys * (ncrows / 2) * 2) / 2 + ap->ys - 2;
1090                 for (i = 0; i < 6; i++) {
1091                         ap->shape.hexagon[i].x = (ap->xs - 1) * hexagonUnit[i].x;
1092                         ap->shape.hexagon[i].y = ((ap->ys - 1) * hexagonUnit[i].y / 2) * 4 / 3;
1093                 }
1094                 /* Avoid array bounds read of hexagonUnit */
1095                 ap->shape.hexagon[6].x = 0;
1096                 ap->shape.hexagon[6].y = 0;
1097         } else if (ap->neighbors == 4 || ap->neighbors == 8) {
1098                 if (size < -MINSIZE) {
1099                         ap->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(ap->width, ap->height) /
1100                                       MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
1101                         if (ap->ys < MINRANDOMSIZE)
1102                                 ap->ys = MIN(MINRANDOMSIZE,
1103                                              MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE));
1104                 } else if (size < MINSIZE) {
1105                         if (!size)
1106                                 ap->ys = MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE);
1107                         else
1108                                 ap->ys = MINSIZE;
1109                 } else
1110                         ap->ys = MIN(size, MAX(MINSIZE, MIN(ap->width, ap->height) /
1111                                                MINGRIDSIZE));
1112                 ap->xs = ap->ys;
1113                 ap->ncols = MAX(ap->width / ap->xs, 2);
1114                 ap->nrows = MAX(ap->height / ap->ys, 2);
1115                 ap->xb = (ap->width - ap->xs * ap->ncols) / 2;
1116                 ap->yb = (ap->height - ap->ys * ap->nrows) / 2;
1117         } else {                /* TRI */
1118                 int         orient;
1119
1120                 if (ap->width < 2)
1121                         ap->width = 2;
1122                 if (ap->height < 2)
1123                         ap->height = 2;
1124                 if (size < -MINSIZE) {
1125                         ap->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(ap->width, ap->height) /
1126                                       MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
1127                         if (ap->ys < MINRANDOMSIZE)
1128                                 ap->ys = MIN(MINRANDOMSIZE,
1129                                              MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE));
1130                 } else if (size < MINSIZE) {
1131                         if (!size)
1132                                 ap->ys = MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE);
1133                         else
1134                                 ap->ys = MINSIZE;
1135                 } else
1136                         ap->ys = MIN(size, MAX(MINSIZE, MIN(ap->width, ap->height) /
1137                                                MINGRIDSIZE));
1138                 ap->xs = (int) (1.52 * ap->ys);
1139                 ap->ncols = (MAX(ap->width / ap->xs - 1, 2) / 2) * 2;
1140                 ap->nrows = (MAX(ap->height / ap->ys - 1, 2) / 2) * 2;
1141                 ap->xb = (ap->width - ap->xs * ap->ncols) / 2 + ap->xs / 2;
1142                 ap->yb = (ap->height - ap->ys * ap->nrows) / 2 + ap->ys;
1143                 for (orient = 0; orient < 2; orient++) {
1144                         for (i = 0; i < 3; i++) {
1145                                 ap->shape.triangle[orient][i].x =
1146                                         (ap->xs - 2) * triangleUnit[orient][i].x;
1147                                 ap->shape.triangle[orient][i].y =
1148                                         (ap->ys - 2) * triangleUnit[orient][i].y;
1149                         }
1150                         /* Avoid array bounds read of triangleUnit */
1151                         ap->shape.triangle[orient][3].x = 0;
1152                         ap->shape.triangle[orient][3].y = 0;
1153                 }
1154         }
1155
1156         XSetLineAttributes(display, MI_GC(mi), 1, LineSolid, CapNotLast, JoinMiter);
1157         MI_CLEARWINDOW(mi);
1158         ap->painted = False;
1159
1160         if (MI_IS_FULLRANDOM(mi)) {
1161                 ap->truchet = (Bool) (LRAND() & 1);
1162                 ap->eyes = (Bool) (LRAND() & 1);
1163                 ap->sharpturn = (Bool) (LRAND() & 1);
1164         } else {
1165                 ap->truchet = truchet;
1166                 ap->eyes = eyes;
1167                 ap->sharpturn = sharpturn;
1168         }
1169         if (!NRAND(NUMSTIPPLES)) {
1170                 getTable(mi, (int) (NRAND(NTABLES)));
1171         } else
1172                 getTurk(mi, (int) (NRAND(NUMSTIPPLES - 1)));
1173         if (MI_NPIXELS(mi) > 2)
1174                 for (i = 0; i < (int) ap->ncolors - 1; i++)
1175                         ap->colors[i] = (unsigned char) (NRAND(MI_NPIXELS(mi)) +
1176                              i * MI_NPIXELS(mi)) / ((int) (ap->ncolors - 1));
1177         if (ap->ants == NULL) {
1178                 if ((ap->ants = (antstruct *) malloc(ap->n * sizeof (antstruct))) ==
1179                                 NULL) {
1180                         free_ant(display, ap);
1181                         return;
1182                 }
1183         }
1184         if (ap->tape != NULL)
1185                 (void) free((void *) ap->tape);
1186         if ((ap->tape = (unsigned char *) calloc(ap->ncols * ap->nrows,
1187                         sizeof (unsigned char))) == NULL) {
1188                 free_ant(display, ap);
1189                 return;
1190         }
1191         if (ap->truchet_state != NULL)
1192                 (void) free((void *) ap->truchet_state);
1193         if ((ap->truchet_state = (unsigned char *) calloc(ap->ncols * ap->nrows,
1194                         sizeof (unsigned char))) == NULL) {
1195                 free_ant(display, ap);
1196                 return;
1197         }
1198
1199         row = ap->nrows / 2;
1200         col = ap->ncols / 2;
1201         if (col > 0 && ((ap->neighbors % 2) || ap->neighbors == 12) && (LRAND() & 1))
1202                 col--;
1203         dir = NRAND(ap->neighbors) * ANGLES / ap->neighbors;
1204         ap->init_dir = dir;
1205 #ifdef NUMBER_9
1206         if (ap->neighbors == 9 && !((col + row) & 1))
1207                 dir = (dir + ANGLES - ANGLES / (ap->neighbors * 2)) % ANGLES;
1208 #endif
1209         /* Have them all start in the same spot, why not? */
1210         for (i = 0; i < ap->n; i++) {
1211                 ap->ants[i].col = col;
1212                 ap->ants[i].row = row;
1213                 ap->ants[i].direction = dir;
1214                 ap->ants[i].state = 0;
1215         }
1216         draw_anant(mi, dir, col, row);
1217 }
1218
1219 void
1220 draw_ant(ModeInfo * mi)
1221 {
1222         antstruct  *anant;
1223         statestruct *status;
1224         int         i, state_pos, tape_pos;
1225         unsigned char color;
1226         short       chg_dir, old_dir;
1227         antfarmstruct *ap;
1228
1229         if (antfarms == NULL)
1230                 return;
1231         ap = &antfarms[MI_SCREEN(mi)];
1232         if (ap->ants == NULL)
1233                 return;
1234
1235         MI_IS_DRAWN(mi) = True;
1236         ap->painted = True;
1237         for (i = 0; i < ap->n; i++) {
1238                 anant = &ap->ants[i];
1239                 tape_pos = anant->col + anant->row * ap->ncols;
1240                 color = ap->tape[tape_pos];     /* read tape */
1241                 state_pos = color + anant->state * ap->ncolors;
1242                 status = &(ap->machine[state_pos]);
1243                 drawcell(mi, anant->col, anant->row, status->color);
1244                 ap->tape[tape_pos] = status->color;     /* write on tape */
1245
1246                 /* Find direction of Bees or Ants. */
1247                 /* Translate relative direction to actual direction */
1248                 old_dir = anant->direction;
1249                 chg_dir = (2 * ANGLES - status->direction) % ANGLES;
1250                 anant->direction = (chg_dir + old_dir) % ANGLES;
1251                 if (ap->truchet) {
1252                         int         a = 0, b;
1253
1254                         if (ap->neighbors == 6) {
1255                                 if (ap->sharpturn) {
1256                                         a = (((ANGLES + anant->direction - old_dir) % ANGLES) == 240);
1257         /* should be some way of getting rid of the init_dir dependency... */
1258                                         b = !(ap->init_dir % 120);
1259                                         a = ((a && !b) || (b && !a));
1260                                         drawtruchet(mi, anant->col, anant->row, status->color, a);
1261                                 } else {
1262                                         a = (old_dir / 60) % 3;
1263                                         b = (anant->direction / 60) % 3;
1264                                         a = (a + b + 1) % 3;
1265                                         drawtruchet(mi, anant->col, anant->row, status->color, a);
1266                                 }
1267                         } else if (ap->neighbors == 4) {
1268                                 a = old_dir / 180;
1269                                 b = anant->direction / 180;
1270                                 a = ((a && !b) || (b && !a));
1271                                 drawtruchet(mi, anant->col, anant->row, status->color, a);
1272                         } else if (ap->neighbors == 3) {
1273                                 if (chg_dir == 240)
1274                                         a = (2 + anant->direction / 120) % 3;
1275                                 else
1276                                         a = (1 + anant->direction / 120) % 3;
1277                                 drawtruchet(mi, anant->col, anant->row, status->color, a);
1278                         }
1279                         ap->truchet_state[tape_pos] = a + 1;
1280                 }
1281                 anant->state = status->next;
1282
1283                 /* Allow step first and turn */
1284                 old_dir = ((status->direction < ANGLES) ? anant->direction : old_dir);
1285 #if DEBUG
1286                 (void) printf("old_dir %d, col %d, row %d", old_dir, anant->col, anant->row);
1287 #endif
1288                 position_of_neighbor(ap, old_dir, &(anant->col), &(anant->row));
1289 #if DEBUG
1290                 (void) printf(", ncol %d, nrow %d\n", anant->col, anant->row);
1291 #endif
1292                 draw_anant(mi, anant->direction, anant->col, anant->row);
1293         }
1294         if (++ap->generation > MI_CYCLES(mi)) {
1295 #ifdef STANDALONE
1296           erase_full_window(MI_DISPLAY(mi), MI_WINDOW(mi));
1297 #endif
1298                 init_ant(mi);
1299         }
1300         if (ap->redrawing) {
1301                 for (i = 0; i < REDRAWSTEP; i++) {
1302                         if (ap->tape[ap->redrawpos] ||
1303                          (ap->truchet && ap->truchet_state[ap->redrawpos])) {
1304                                 drawcell(mi, ap->redrawpos % ap->ncols, ap->redrawpos / ap->ncols,
1305                                          ap->tape[ap->redrawpos]);
1306                                 if (ap->truchet)
1307                                         drawtruchet(mi, ap->redrawpos % ap->ncols, ap->redrawpos / ap->ncols,
1308                                                     ap->tape[ap->redrawpos],
1309                                         ap->truchet_state[ap->redrawpos] - 1);
1310                         }
1311                         if (++(ap->redrawpos) >= ap->ncols * ap->nrows) {
1312                                 ap->redrawing = 0;
1313                                 break;
1314                         }
1315                 }
1316         }
1317 }
1318
1319 void
1320 release_ant(ModeInfo * mi)
1321 {
1322         if (antfarms != NULL) {
1323                 int         screen;
1324
1325                 for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
1326                         free_ant(MI_DISPLAY(mi), &antfarms[screen]);
1327                 (void) free((void *) antfarms);
1328                 antfarms = (antfarmstruct *) NULL;
1329         }
1330 }
1331
1332 void
1333 refresh_ant(ModeInfo * mi)
1334 {
1335         antfarmstruct *ap;
1336
1337         if (antfarms == NULL)
1338                 return;
1339         ap = &antfarms[MI_SCREEN(mi)];
1340
1341         if (ap->painted) {
1342                 MI_CLEARWINDOW(mi);
1343                 ap->redrawing = 1;
1344                 ap->redrawpos = 0;
1345         }
1346 }
1347
1348 #endif /* MODE_ant */