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