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