* as Greg Turk's turmites) whose tape is the screen
*/
-#if !defined( lint ) && !defined( SABER )
-static const char sccsid[] = "@(#)ant.c 4.04 97/07/28 xlockmore";
-
+#if 0
+static const char sccsid[] = "@(#)ant.c 5.00 2000/11/01 xlockmore";
#endif
/*-
* other special, indirect and consequential damages.
*
* Revision History:
- * 10-May-97: Compatible with xscreensaver
- * 16-Apr-97: -neighbors 3 and 8 added
- * 01-Jan-97: Updated ant.c to handle more kinds of ants. Thanks to
- * J Austin David <Austin.David@tlogic.com>. Check it out in
- * java at http://havoc.gtf.gatech.edu/austin He thought up the
- * new Ladder ant.
- * 04-Apr-96: -neighbors 6 runtime-time option added for hexagonal ants
- * (bees), coded from an idea of Jim Propp's in Science News,
- * Oct 28, 1995 VOL. 148 page 287
- * 20-Sep-95: Memory leak in ant fixed. Now random colors.
- * 05-Sep-95: Coded from A.K. Dewdney's "Computer Recreations", Scientific
- * American Magazine" Sep 1989 pp 180-183, Mar 1990 p 121
- * Also used Ian Stewart's Mathematical Recreations, Scientific
- * American Jul 1994 pp 104-107
- * also used demon.c and life.c as a guide.
+ * 01-Nov-2000: Allocation checks
+ * 10-May-1997: Compatible with xscreensaver
+ * 16-Apr-1997: -neighbors 3 and 8 added
+ * 01-Jan-1997: Updated ant.c to handle more kinds of ants. Thanks to
+ * J Austin David <Austin.David@tlogic.com>. Check it out in
+ * java at http://havoc.gtf.gatech.edu/austin He thought up the
+ * new Ladder ant.
+ * 04-Apr-1996: -neighbors 6 runtime-time option added for hexagonal ants
+ * (bees), coded from an idea of Jim Propp's in Science News,
+ * Oct 28, 1995 VOL. 148 page 287
+ * 20-Sep-1995: Memory leak in ant fixed. Now random colors.
+ * 05-Sep-1995: Coded from A.K. Dewdney's "Computer Recreations", Scientific
+ * American Magazine" Sep 1989 pp 180-183, Mar 1990 p 121
+ * Also used Ian Stewart's Mathematical Recreations, Scientific
+ * American Jul 1994 pp 104-107
+ * also used demon.c and life.c as a guide.
*/
/*-
- Species Grid Number of Neigbors
+ Species Grid Number of Neighbors
------- ---- ------------------
- Ants Square 4 or 8
+ Ants Square 4 (or 8)
Bees Hexagon 6
- Bees Triangle 3 (9? or 12) <- 9 and 12 are not implemented
+ Bees Triangle 3 (or 9, 12)
Neighbors 6 and neighbors 3 produce the same Turk ants.
*/
#ifdef STANDALONE
-# define PROGCLASS "Ant"
-# define HACK_INIT init_ant
-# define HACK_DRAW draw_ant
-# define ant_opts xlockmore_opts
-# define DEFAULTS "*delay: 1000 \n" \
- "*count: -3 \n" \
- "*cycles: 40000 \n" \
- "*size: -7 \n" \
- "*ncolors: 64 \n"
-# include "xlockmore.h" /* in xscreensaver distribution */
-# include "erase.h"
+#define MODE_ant
+#define PROGCLASS "Ant"
+#define HACK_INIT init_ant
+#define HACK_DRAW draw_ant
+#define ant_opts xlockmore_opts
+#define DEFAULTS "*delay: 1000 \n" \
+ "*count: -3 \n" \
+ "*cycles: 40000 \n" \
+ "*size: -12 \n" \
+ "*ncolors: 64 \n" \
+ "*neighbors: 0 \n" \
+ "*sharpturn: False \n"
+#include "xlockmore.h" /* in xscreensaver distribution */
+#include "erase.h"
#else /* STANDALONE */
-# include "xlock.h" /* in xlockmore distribution */
-
+#include "xlock.h" /* in xlockmore distribution */
#endif /* STANDALONE */
+#include "automata.h"
-#define DEF_TRUCHET "False"
+#ifdef MODE_ant
-#ifdef STANDALONE
-static int neighbors;
-#else
-extern int neighbors;
-#endif /* !STANDALONE */
+/*-
+ * neighbors of 0 randomizes it for 3, 4, 6, 8, 12 (last 2 are less likely)
+ */
+#define DEF_NEIGHBORS "0" /* choose random value */
+#define DEF_TRUCHET "False"
+#define DEF_EYES "False"
+#define DEF_SHARPTURN "False"
+
+static int neighbors;
static Bool truchet;
+static Bool eyes;
+static Bool sharpturn;
static XrmOptionDescRec opts[] =
{
- {"-truchet", ".ant.truchet", XrmoptionNoArg, (caddr_t) "on"},
- {"+truchet", ".ant.truchet", XrmoptionNoArg, (caddr_t) "off"},
-
-#ifdef STANDALONE
- {"-neighbors", ".ant.neighbors", XrmoptionNoArg, (caddr_t) "on"},
- {"+neighbors", ".ant.neighbors", XrmoptionNoArg, (caddr_t) "off"}
-#endif /* STANDALONE */
-
+ {"-neighbors", ".ant.neighbors", XrmoptionSepArg, NULL},
+ {"-truchet", ".ant.truchet", XrmoptionNoArg, "on"},
+ {"+truchet", ".ant.truchet", XrmoptionNoArg, "off"},
+ {"-eyes", ".ant.eyes", XrmoptionNoArg, "on"},
+ {"+eyes", ".ant.eyes", XrmoptionNoArg, "off"},
+ {"-sharpturn", ".ant.sharpturn", XrmoptionNoArg, "on"},
+ {"+sharpturn", ".ant.sharpturn", XrmoptionNoArg, "off"},
+ {"-neighbors", ".ant.neighbors", XrmoptionSepArg, 0},
+ {"+neighbors", ".ant.neighbors", XrmoptionSepArg, 0}
};
static argtype vars[] =
{
- {(caddr_t *) & truchet, "truchet", "Truchet", DEF_TRUCHET, t_Bool},
-#ifdef STANDALONE
- {(caddr_t *) & neighbors, "neighbors", "Neighbors", 0, t_Bool}
-#endif /* STANDALONE */
+ {&neighbors, "neighbors", "Neighbors", DEF_NEIGHBORS, t_Int},
+ {&truchet, "truchet", "Truchet", DEF_TRUCHET, t_Bool},
+ {&eyes, "eyes", "Eyes", DEF_EYES, t_Bool},
+ {&sharpturn, "sharpturn", "SharpTurn", DEF_SHARPTURN, t_Bool},
+ {&neighbors, "neighbors", "Neighbors", DEF_NEIGHBORS, t_Int}
};
static OptionStruct desc[] =
{
- {"-/+truchet", "turn on/off Truchet lines"}
+ {"-neighbors num", "squares 4 or 8, hexagons 6, triangles 3 or 12"},
+ {"-/+truchet", "turn on/off Truchet lines"},
+ {"-/+eyes", "turn on/off eyes"},
+ {"-/+sharpturn", "turn on/off sharp turns (6, 8 or 12 neighbors only)"}
};
ModeSpecOpt ant_opts =
-{2, opts, 1, vars, desc};
+{sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
+#ifdef USE_MODULES
+const ModStruct ant_description =
+{"ant",
+ "init_ant", "draw_ant", "release_ant",
+ "refresh_ant", "init_ant", (char *) NULL, &ant_opts,
+ 1000, -3, 40000, -12, 64, 1.0, "",
+ "Shows Langton's and Turk's generalized ants", 0, NULL};
+
+#endif
#define ANTBITS(n,w,h)\
- ap->pixmaps[ap->init_bits++]=\
- XCreatePixmapFromBitmapData(display,window,(char *)n,w,h,1,0,1)
+ if ((ap->pixmaps[ap->init_bits]=\
+ XCreatePixmapFromBitmapData(display,window,(char *)n,w,h,1,0,1))==None){\
+ free_ant(display,ap); return;} else {ap->init_bits++;}
/* If you change the table you may have to change the following 2 constants */
#define STATES 2
-#define COLORS 11
#define MINANTS 1
-#define PATTERNSIZE 8
#define REDRAWSTEP 2000 /* How much tape to draw per cycle */
#define MINGRIDSIZE 24
#define MINSIZE 1
+#define MINRANDOMSIZE 5
#define ANGLES 360
-#define NEIGHBORKINDS 3
-
-#ifdef STANDALONE
-static XPoint hexagonUnit[6] =
-{
- {0, 0},
- {1, 1},
- {0, 2},
- {-1, 1},
- {-1, -1},
- {0, -2}
-};
-
-static XPoint triangleUnit[2][3] =
-{
- {
- {0, 0},
- {1, -1},
- {0, 2}
- },
- {
- {0, 0},
- {-1, 1},
- {0, -2}
- }
-};
-
-#endif /* STANDALONE */
-
-
-static unsigned char patterns[COLORS - 1][PATTERNSIZE] =
-{
- {0x11, 0x22, 0x11, 0x22, 0x11, 0x22, 0x11, 0x22}, /* grey+white | stripe */
- {0x00, 0x66, 0x66, 0x00, 0x00, 0x66, 0x66, 0x00}, /* spots */
- {0x89, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11}, /* lt. / stripe */
- {0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66}, /* | bars */
- {0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa}, /* 50% grey */
- {0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}, /* - bars */
- {0xee, 0xdd, 0xbb, 0x77, 0xee, 0xdd, 0xbb, 0x76}, /* dark \ stripe */
- {0xff, 0x99, 0x99, 0xff, 0xff, 0x99, 0x99, 0xff}, /* spots */
- {0xaa, 0xff, 0xff, 0x55, 0xaa, 0xff, 0xff, 0x55}, /* black+grey - stripe */
- {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} /* black */
-};
typedef struct {
unsigned char color;
} antstruct;
typedef struct {
- int init_bits;
+ Bool painted;
int neighbors;
int generation;
int xs, ys;
int xb, yb;
+ int init_dir;
int nrows, ncols;
int width, height;
unsigned char ncolors, nstates;
int n;
int redrawing, redrawpos;
int truchet; /* Only for Turk modes */
- statestruct machine[COLORS * STATES];
+ int eyes;
+ int sharpturn;
+ statestruct machine[NUMSTIPPLES * STATES];
unsigned char *tape;
unsigned char *truchet_state;
antstruct *ants;
- unsigned char colors[COLORS - 1];
+ int init_bits;
+ unsigned char colors[NUMSTIPPLES - 1];
GC stippledGC;
- Pixmap pixmaps[COLORS - 1];
- XPoint hexagonList[7];
- XPoint triangleList[2][4];
+ Pixmap pixmaps[NUMSTIPPLES - 1];
+ union {
+ XPoint hexagon[7]; /* Need more than 6 for truchet */
+ XPoint triangle[2][4]; /* Need more than 3 for truchet */
+ } shape;
} antfarmstruct;
-static int initVal[NEIGHBORKINDS] =
-{3, 4, 6}; /* Neighborhoods, 8 just makes a mess */
+static char plots[] =
+{3, 4, 6, 8,
+#ifdef NUMBER_9
+ 9,
+#endif
+ 12};
+#define NEIGHBORKINDS ((long) (sizeof plots / sizeof *plots))
+#define GOODNEIGHBORKINDS 3
/* Relative ant moves */
#define FS 0 /* Step */
#define STHL 10 /* Step then turn hard left */
#define STL 11 /* Step then turn left */
-static antfarmstruct *antfarms = NULL;
+static antfarmstruct *antfarms = (antfarmstruct *) NULL;
/* LANGTON'S ANT (10) Chaotic after 500, Builder after 10,000 (104p) */
/* TURK'S 100 ANT Always chaotic?, tested past 150,000,000 */
/* Even runs of 0's and 1's are also symmetric */
/* I have seen Hexagonal builders but they are more rare. */
-static unsigned char tables[][3 * COLORS * STATES + 2] =
+static unsigned char tables[][3 * NUMSTIPPLES * STATES + 2] =
{
#if 0
/* Here just so you can figure out notation */
if (ap->neighbors == 6) {
int ccol = 2 * col + !(row & 1), crow = 2 * row;
- ap->hexagonList[0].x = ap->xb + ccol * ap->xs;
- ap->hexagonList[0].y = ap->yb + crow * ap->ys;
+ ap->shape.hexagon[0].x = ap->xb + ccol * ap->xs;
+ ap->shape.hexagon[0].y = ap->yb + crow * ap->ys;
if (ap->xs == 1 && ap->ys == 1)
- XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
- ap->hexagonList[0].x, ap->hexagonList[0].y, 1, 1);
+ XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
+ ap->shape.hexagon[0].x, ap->shape.hexagon[0].y);
else
XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
- ap->hexagonList, 6, Convex, CoordModePrevious);
-
-#if 0 /* jwz sez: this looks like crap */
+ ap->shape.hexagon, 6, Convex, CoordModePrevious);
} else if (ap->neighbors == 4 || ap->neighbors == 8) {
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
- ap->xb + ap->xs * col, ap->yb + ap->ys * row, ap->xs, ap->ys);
-#endif
-
+ ap->xb + ap->xs * col, ap->yb + ap->ys * row,
+ ap->xs - (ap->xs > 3), ap->ys - (ap->ys > 3));
} else { /* TRI */
int orient = (col + row) % 2; /* O left 1 right */
- ap->triangleList[orient][0].x = ap->xb + col * ap->xs;
- ap->triangleList[orient][0].y = ap->yb + row * ap->ys;
+ ap->shape.triangle[orient][0].x = ap->xb + col * ap->xs;
+ ap->shape.triangle[orient][0].y = ap->yb + row * ap->ys;
if (ap->xs <= 3 || ap->ys <= 3)
- XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
- ((orient) ? -1 : 1) + ap->triangleList[orient][0].x,
- ap->triangleList[orient][0].y, 1, 1);
+ XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
+ ((orient) ? -1 : 1) + ap->shape.triangle[orient][0].x,
+ ap->shape.triangle[orient][0].y);
else {
if (orient)
- ap->triangleList[orient][0].x += (ap->xs / 2 - 1);
+ ap->shape.triangle[orient][0].x += (ap->xs / 2 - 1);
else
- ap->triangleList[orient][0].x -= (ap->xs / 2 - 1);
+ ap->shape.triangle[orient][0].x -= (ap->xs / 2 - 1);
XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc,
- ap->triangleList[orient], 3, Convex, CoordModePrevious);
+ ap->shape.triangle[orient], 3, Convex, CoordModePrevious);
}
}
}
antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
if (ap->neighbors == 6) {
+
int ccol = 2 * col + !(row & 1), crow = 2 * row;
int side;
+ int fudge = 7; /* fudge because the hexagons are not exact */
XPoint hex, hex2;
- /* Very crude approx of Sqrt 3, so it will not cause drawing errors. */
- hex.x = ap->xb + ccol * ap->xs - (int) ((double) ap->xs * 1.6 / 2.0);
- hex.y = ap->yb + crow * ap->ys - (int) ((double) ap->ys * 1.6 / 2.0);
- for (side = 0; side < 6; side++) {
- if (side > 0) {
- hex.x += ap->hexagonList[side].x;
- hex.y += ap->hexagonList[side].y;
+ if (ap->sharpturn) {
+ hex.x = ap->xb + ccol * ap->xs - (int) ((double) ap->xs / 2.0) - 1;
+ hex.y = ap->yb + crow * ap->ys - (int) ((double) ap->ys / 2.0) - 1;
+ for (side = 0; side < 6; side++) {
+ if (side) {
+ hex.x += ap->shape.hexagon[side].x;
+ hex.y += ap->shape.hexagon[side].y;
+ }
+ if (truchetstate == side % 2)
+ XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
+ hex.x, hex.y, ap->xs, ap->ys,
+ ((570 - (side * 60) + fudge) % 360) * 64, (120 - 2 * fudge) * 64);
+ }
+ } else {
+ /* Very crude approx of Sqrt 3, so it will not cause drawing errors. */
+ hex.x = ap->xb + ccol * ap->xs - (int) ((double) ap->xs * 1.6 / 2.0) - 1;
+ hex.y = ap->yb + crow * ap->ys - (int) ((double) ap->ys * 1.6 / 2.0) - 1;
+ for (side = 0; side < 6; side++) {
+ if (side) {
+ hex.x += ap->shape.hexagon[side].x;
+ hex.y += ap->shape.hexagon[side].y;
+ }
+ hex2.x = hex.x + ap->shape.hexagon[side + 1].x / 2;
+ hex2.y = hex.y + ap->shape.hexagon[side + 1].y / 2 + 1;
+ /* Lots of fudging here */
+ if (side == 1) {
+ hex2.x += (short) (ap->xs * 0.1 + 1);
+ hex2.y += (short) (ap->ys * 0.1 - ((ap->ys > 5) ? 1 : 0));
+ } else if (side == 2) {
+ hex2.x += (short) (ap->xs * 0.1);
+ } else if (side == 4) {
+ hex2.x += (short) (ap->xs * 0.1);
+ hex2.y += (short) (ap->ys * 0.1 - 1);
+ } else if (side == 5) {
+ hex2.x += (short) (ap->xs * 0.5);
+ hex2.y += (short) (-ap->ys * 0.3 + 1);
+ }
+ if (truchetstate == side % 3)
+ /* Crude approx of 120 deg, so it will not cause drawing errors. */
+ XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
+ hex2.x, hex2.y,
+ (int) ((double) ap->xs * 1.5), (int) ((double) ap->ys * 1.5),
+ ((555 - (side * 60)) % 360) * 64, 90 * 64);
}
- hex2.x = hex.x + ap->hexagonList[side + 1].x / 2;
- hex2.y = hex.y + ap->hexagonList[side + 1].y / 2;
- if (truchetstate == side % 3)
- /* Crude approx of 120 deg, so it will not cause drawing errors. */
- XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
- hex2.x, hex2.y,
- (int) ((double) ap->xs * 1.5), (int) ((double) ap->ys * 1.5),
- ((555 - (side * 60)) % 360) * 64, 90 * 64);
}
} else if (ap->neighbors == 4) {
if (truchetstate) {
XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
- ap->xb + ap->xs * col - ap->xs / 2,
- ap->yb + ap->ys * row + ap->ys / 2,
- ap->xs, ap->ys,
- 1 * 64, 88 * 64);
+ ap->xb + ap->xs * col - ap->xs / 2 + 1,
+ ap->yb + ap->ys * row + ap->ys / 2 - 1,
+ ap->xs - 2, ap->ys - 2,
+ 0 * 64, 90 * 64);
XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
- ap->xb + ap->xs * col + ap->xs / 2,
- ap->yb + ap->ys * row - ap->ys / 2,
- ap->xs, ap->ys,
- -91 * 64, -88 * 64);
+ ap->xb + ap->xs * col + ap->xs / 2 - 1,
+ ap->yb + ap->ys * row - ap->ys / 2 + 1,
+ ap->xs - 2, ap->ys - 2,
+ -90 * 64, -90 * 64);
} else {
XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
- ap->xb + ap->xs * col - ap->xs / 2,
- ap->yb + ap->ys * row - ap->ys / 2,
- ap->xs, ap->ys,
- -1 * 64, -88 * 64);
+ ap->xb + ap->xs * col - ap->xs / 2 + 1,
+ ap->yb + ap->ys * row - ap->ys / 2 + 1,
+ ap->xs - 2, ap->ys - 2,
+ 0 * 64, -90 * 64);
XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
- ap->xb + ap->xs * col + ap->xs / 2,
- ap->yb + ap->ys * row + ap->ys / 2,
- ap->xs, ap->ys,
- 91 * 64, 88 * 64);
+ ap->xb + ap->xs * col + ap->xs / 2 - 1,
+ ap->yb + ap->ys * row + ap->ys / 2 - 1,
+ ap->xs - 2, ap->ys - 2,
+ 90 * 64, 90 * 64);
}
} else if (ap->neighbors == 3) {
int orient = (col + row) % 2; /* O left 1 right */
int side, ang;
+ int fudge = 7; /* fudge because the triangles are not exact */
+ double fudge2 = 1.18;
XPoint tri;
tri.x = ap->xb + col * ap->xs;
tri.y = ap->yb + row * ap->ys;
if (orient) {
- tri.x += (ap->xs / 2 - 2);
+ tri.x += (ap->xs / 2 - 1);
} else {
- tri.x -= (ap->xs / 2 + 2);
+ tri.x -= (ap->xs / 2 - 1);
}
for (side = 0; side < 3; side++) {
if (side > 0) {
- tri.x += ap->triangleList[orient][side].x;
- tri.y += ap->triangleList[orient][side].y;
+ tri.x += ap->shape.triangle[orient][side].x;
+ tri.y += ap->shape.triangle[orient][side].y;
}
- if (truchetstate == side % 3) {
+ if (truchetstate == side) {
if (orient)
- ang = (518 - side * 120) % 360; /* Right */
+ ang = (510 - side * 120) % 360; /* Right */
else
ang = (690 - side * 120) % 360; /* Left */
XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
- tri.x - ap->xs / 2, tri.y - 3 * ap->ys / 4,
- ap->xs, 3 * ap->ys / 2,
- ang * 64, 45 * 64);
+ (int) (tri.x - ap->xs * fudge2 / 2),
+ (int) (tri.y - 3 * ap->ys * fudge2 / 4),
+ (unsigned int) (ap->xs * fudge2),
+ (unsigned int) (3 * ap->ys * fudge2 / 2),
+ (ang + fudge) * 64, (60 - 2 * fudge) * 64);
}
}
}
drawcell(ModeInfo * mi, int col, int row, unsigned char color)
{
antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
- GC gc;
+ GC gc;
if (!color) {
- XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_BLACK_PIXEL(mi));
+ XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi));
gc = MI_GC(mi);
} else if (MI_NPIXELS(mi) > 2) {
XSetForeground(MI_DISPLAY(mi), MI_GC(mi),
XGCValues gcv;
gcv.stipple = ap->pixmaps[color - 1];
- gcv.foreground = MI_WIN_WHITE_PIXEL(mi);
- gcv.background = MI_WIN_BLACK_PIXEL(mi);
+ gcv.foreground = MI_WHITE_PIXEL(mi);
+ gcv.background = MI_BLACK_PIXEL(mi);
XChangeGC(MI_DISPLAY(mi), ap->stippledGC,
GCStipple | GCForeground | GCBackground, &gcv);
gc = ap->stippledGC;
antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
if (!color)
- XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_WHITE_PIXEL(mi));
+ XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi));
else if (MI_NPIXELS(mi) > 2 || color > ap->ncolors / 2)
- XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_BLACK_PIXEL(mi));
+ XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi));
else
- XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_WHITE_PIXEL(mi));
+ XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi));
truchetcell(mi, col, row, truchetstate);
}
static void
-draw_anant(ModeInfo * mi, int col, int row)
+draw_anant(ModeInfo * mi, int direction, int col, int row)
{
- XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WIN_WHITE_PIXEL(mi));
- fillcell(mi, MI_GC(mi), col, row);
-#if 0 /* Can not see eyes */
- {
- antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
- Display *display = MI_DISPLAY(mi);
- Window window = MI_WINDOW(mi);
-
- if (ap->xs > 2 && ap->ys > 2) { /* Draw Eyes */
+ antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
+ Display *display = MI_DISPLAY(mi);
+ Window window = MI_WINDOW(mi);
- XSetForeground(display, MI_GC(mi), MI_WIN_BLACK_PIXEL(mi));
+ XSetForeground(display, MI_GC(mi), MI_WHITE_PIXEL(mi));
+ fillcell(mi, MI_GC(mi), col, row);
+ if (ap->eyes) { /* Draw Eyes */
+ XSetForeground(display, MI_GC(mi), MI_BLACK_PIXEL(mi));
+ if (ap->neighbors == 6) {
+ int ccol = 2 * col + !(row & 1), crow = 2 * row;
+ int side, ang;
+ XPoint hex;
+
+ if (!(ap->xs > 3 && ap->ys > 3))
+ return;
+ hex.x = ap->xb + ccol * ap->xs;
+ hex.y = ap->yb + crow * ap->ys + ap->ys / 2;
+ ang = direction * ap->neighbors / ANGLES;
+ for (side = 0; side < ap->neighbors; side++) {
+ if (side) {
+ hex.x -= ap->shape.hexagon[side].x / 2;
+ hex.y += ap->shape.hexagon[side].y / 2;
+ }
+ if (side == (ap->neighbors + ang - 2) % ap->neighbors)
+ XDrawPoint(display, window, MI_GC(mi), hex.x, hex.y);
+ if (side == (ap->neighbors + ang - 1) % ap->neighbors)
+ XDrawPoint(display, window, MI_GC(mi), hex.x, hex.y);
+ }
+ } else if (ap->neighbors == 4 || ap->neighbors == 8) {
+ if (!(ap->xs > 3 && ap->ys > 3))
+ return;
switch (direction) {
case 0:
XDrawPoint(display, window, MI_GC(mi),
- ap->xb + ap->xs - 1, ap->yb + 1);
+ ap->xb + ap->xs * (col + 1) - 3,
+ ap->yb + ap->ys * row + ap->ys / 2 - 2);
XDrawPoint(display, window, MI_GC(mi),
- ap->xb + ap->xs - 1, ap->yb + ap->ys - 2);
+ ap->xb + ap->xs * (col + 1) - 3,
+ ap->yb + ap->ys * row + ap->ys / 2);
break;
- case 180:
- XDrawPoint(display, window, MI_GC(mi), ap->xb, ap->yb + 1);
- XDrawPoint(display, window, MI_GC(mi), ap->xb, ap->yb + ap->ys - 2);
+ case 45:
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * (col + 1) - 4,
+ ap->yb + ap->ys * row + 1);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * (col + 1) - 3,
+ ap->yb + ap->ys * row + 2);
break;
- if (neighbors == 4) {
case 90:
- XDrawPoint(display, window, MI_GC(mi), ap->xb + 1, ap->yb);
- XDrawPoint(display, window, MI_GC(mi),
- ap->xb + ap->xs - 2, ap->yb);
- break;
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + ap->xs / 2 - 2,
+ ap->yb + ap->ys * row + 1);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + ap->xs / 2,
+ ap->yb + ap->ys * row + 1);
+ break;
+ case 135:
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + 2,
+ ap->yb + ap->ys * row + 1);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + 1,
+ ap->yb + ap->ys * row + 2);
+ break;
+ case 180:
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + 1,
+ ap->yb + ap->ys * row + ap->ys / 2 - 2);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + 1,
+ ap->yb + ap->ys * row + ap->ys / 2);
+ break;
+ case 225:
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + 2,
+ ap->yb + ap->ys * (row + 1) - 3);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + 1,
+ ap->yb + ap->ys * (row + 1) - 4);
+ break;
case 270:
- XDrawPoint(display, window, MI_GC(mi),
- ap->xb + 1, ap->yb + ap->ys - 1);
- XDrawPoint(display, window, MI_GC(mi),
- ap->xb + ap->xs - 2, ap->yb + ap->ys - 1);
- break;
- } /* else BEE */
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + ap->xs / 2 - 2,
+ ap->yb + ap->ys * (row + 1) - 3);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * col + ap->xs / 2,
+ ap->yb + ap->ys * (row + 1) - 3);
+ break;
+ case 315:
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * (col + 1) - 4,
+ ap->yb + ap->ys * (row + 1) - 3);
+ XDrawPoint(display, window, MI_GC(mi),
+ ap->xb + ap->xs * (col + 1) - 3,
+ ap->yb + ap->ys * (row + 1) - 4);
+ break;
default:
+ (void) fprintf(stderr, "wrong eyes direction %d for ant eyes\n", direction);
+ }
+ } else { /* TRI */
+ int orient = (col + row) % 2; /* O left 1 right */
+ int side, ang;
+ XPoint tri;
+
+ if (!(ap->xs > 6 && ap->ys > 6))
+ return;
+ tri.x = ap->xb + col * ap->xs;
+ tri.y = ap->yb + row * ap->ys;
+ if (orient)
+ tri.x += (ap->xs / 6 - 1);
+ else
+ tri.x -= (ap->xs / 6 - 1);
+ ang = direction * ap->neighbors / ANGLES;
+ /* approx... does not work that well for even numbers */
+ if (
+#ifdef NUMBER_9
+ ap->neighbors == 9 ||
+#endif
+ ap->neighbors == 12) {
+#ifdef UNDER_CONSTRUCTION
+ /* Not sure why this does not work */
+ ang = ((ang + ap->neighbors / 6) / (ap->neighbors / 3)) % 3;
+#else
+ return;
+#endif
+ }
+ for (side = 0; side < 3; side++) {
+ if (side) {
+ tri.x += ap->shape.triangle[orient][side].x / 3;
+ tri.y += ap->shape.triangle[orient][side].y / 3;
+ }
+ /* Either you have the eyes in back or one eye in front */
+#if 0
+ if (side == ang)
+ XDrawPoint(display, window, MI_GC(mi), tri.x, tri.y);
+#else
+ if (side == (ang + 2) % 3)
+ XDrawPoint(display, window, MI_GC(mi), tri.x, tri.y);
+ if (side == (ang + 1) % 3)
+ XDrawPoint(display, window, MI_GC(mi), tri.x, tri.y);
+#endif
}
}
}
-#endif
}
#if 0
#endif
static short
-fromTableDirection(unsigned char dir, int neighbors)
+fromTableDirection(unsigned char dir, int local_neighbors)
{
+ /* Crafted to work for odd number of neighbors */
switch (dir) {
case FS:
return 0;
- case TRS:
- return (ANGLES / neighbors);
- case THRS:
- return (ANGLES / (2 * neighbors));
- case TBS:
- return (ANGLES / 2);
- case THLS:
- return (ANGLES - ANGLES / (2 * neighbors));
case TLS:
- return (ANGLES - ANGLES / neighbors);
+ return (ANGLES / local_neighbors);
+ case THLS:
+ return (2 * ANGLES / local_neighbors);
+ case TBS:
+ return ((local_neighbors / 2) * ANGLES / local_neighbors);
+ case THRS:
+ return (ANGLES - 2 * ANGLES / local_neighbors);
+ case TRS:
+ return (ANGLES - ANGLES / local_neighbors);
case SF:
return ANGLES;
- case STR:
- return (ANGLES + ANGLES / neighbors);
- case STHR:
- return (ANGLES + ANGLES / (2 * neighbors));
- case STB:
- return (3 * ANGLES / 2);
- case STHL:
- return (2 * ANGLES - ANGLES / (2 * neighbors));
case STL:
- return (2 * ANGLES - ANGLES / neighbors);
+ return (ANGLES + ANGLES / local_neighbors);
+ case STHL:
+ return (ANGLES + 2 * ANGLES / local_neighbors);
+ case STB:
+ return (ANGLES + (local_neighbors / 2) * ANGLES / local_neighbors);
+ case STHR:
+ return (2 * ANGLES - 2 * ANGLES / local_neighbors);
+ case STR:
+ return (2 * ANGLES - ANGLES / local_neighbors);
default:
- (void) fprintf(stderr, "wrong direction %d\n", dir);
+ (void) fprintf(stderr, "wrong direction %d from table\n", dir);
}
return -1;
}
ap->ncolors = *patptr++;
ap->nstates = *patptr++;
total = ap->ncolors * ap->nstates;
- if (MI_WIN_IS_VERBOSE(mi))
+ if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout,
- "neighbors %d, table number %d, colors %d, states %d\n",
- ap->neighbors, i, ap->ncolors, ap->nstates);
+ "ants %d, neighbors %d, table number %d, colors %d, states %d\n",
+ ap->n, ap->neighbors, i, ap->ncolors, ap->nstates);
for (j = 0; j < total; j++) {
ap->machine[j].color = *patptr++;
- ap->machine[j].direction = fromTableDirection(*patptr++, ap->neighbors);
+ if (ap->sharpturn && ap->neighbors > 4) {
+ int k = *patptr++;
+
+ switch (k) {
+ case TRS:
+ k = THRS;
+ break;
+ case THRS:
+ k = TRS;
+ break;
+ case THLS:
+ k = TLS;
+ break;
+ case TLS:
+ k = THLS;
+ break;
+ case STR:
+ k = STHR;
+ break;
+ case STHR:
+ k = STR;
+ break;
+ case STHL:
+ k = STL;
+ break;
+ case STL:
+ k = STHL;
+ break;
+ default:
+ break;
+ }
+ ap->machine[j].direction = fromTableDirection(k, ap->neighbors);
+ } else {
+ ap->machine[j].direction = fromTableDirection(*patptr++, ap->neighbors);
+ }
ap->machine[j].next = *patptr++;
}
ap->truchet = False;
antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
int power2, j, number, total;
- /* To force a number, say <i = 2;> has i + 2 (or 4) digits in binary */
+ /* To force a number, say <i = 2;> has i + 2 (or 4) binary digits */
power2 = 1 << (i + 1);
- /* Dont want numbers which in binary are all 1's. */
+ /* Do not want numbers which in binary are all 1's. */
number = NRAND(power2 - 1) + power2;
/* To force a particular number, say <number = 10;> */
total = ap->ncolors * ap->nstates;
for (j = 0; j < total; j++) {
ap->machine[j].color = (j + 1) % total;
- ap->machine[j].direction = (power2 & number) ?
- fromTableDirection(TRS, ap->neighbors) :
- fromTableDirection(TLS, ap->neighbors);
+ if (ap->sharpturn && ap->neighbors > 4) {
+ ap->machine[j].direction = (power2 & number) ?
+ fromTableDirection(THRS, ap->neighbors) :
+ fromTableDirection(THLS, ap->neighbors);
+ } else {
+ ap->machine[j].direction = (power2 & number) ?
+ fromTableDirection(TRS, ap->neighbors) :
+ fromTableDirection(TLS, ap->neighbors);
+ }
ap->machine[j].next = 0;
power2 >>= 1;
}
- if (ap->neighbors != 3 && ap->neighbors != 4 && ap->neighbors != 6)
- ap->truchet = False;
- else if (truchet)
- ap->truchet = True;
- if (MI_WIN_IS_VERBOSE(mi))
- (void) fprintf(stdout, "neighbors %d, Turk's number %d, colors %d\n",
- ap->neighbors, number, ap->ncolors);
+ ap->truchet = (ap->truchet && ap->xs > 2 && ap->ys > 2 &&
+ (ap->neighbors == 3 || ap->neighbors == 4 || ap->neighbors == 6));
+ if (MI_IS_VERBOSE(mi))
+ (void) fprintf(stdout,
+ "ants %d, neighbors %d, Turk's number %d, colors %d\n",
+ ap->n, ap->neighbors, number, ap->ncolors);
+}
+
+static void
+free_ant(Display *display, antfarmstruct *ap)
+{
+ int shade;
+
+ if (ap->stippledGC != None) {
+ XFreeGC(display, ap->stippledGC);
+ ap->stippledGC = None;
+ }
+ for (shade = 0; shade < ap->init_bits; shade++) {
+ XFreePixmap(display, ap->pixmaps[shade]);
+ }
+ ap->init_bits = 0;
+ if (ap->tape != NULL) {
+ (void) free((void *) ap->tape);
+ ap->tape = (unsigned char *) NULL;
+ }
+ if (ap->ants != NULL) {
+ (void) free((void *) ap->ants);
+ ap->ants = (antstruct *) NULL;
+ }
+ if (ap->truchet_state != NULL) {
+ (void) free((void *) ap->truchet_state);
+ ap->truchet_state = (unsigned char *) NULL;
+ }
}
void
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int size = MI_SIZE(mi);
- XGCValues gcv;
antfarmstruct *ap;
- int col, row, i, dir;
-
- /* jwz sez: small sizes look like crap */
- if (size < 0)
- size = NRAND(-size)+1;
- if (size < 5)
- size += 5;
+ int col, row, dir;
+ int i;
if (antfarms == NULL) {
if ((antfarms = (antfarmstruct *) calloc(MI_NUM_SCREENS(mi),
return;
}
ap = &antfarms[MI_SCREEN(mi)];
+
ap->redrawing = 0;
if (MI_NPIXELS(mi) <= 2) {
if (ap->stippledGC == None) {
+ XGCValues gcv;
+
gcv.fill_style = FillOpaqueStippled;
- ap->stippledGC = XCreateGC(display, window, GCFillStyle, &gcv);
+ if ((ap->stippledGC = XCreateGC(display, window, GCFillStyle,
+ &gcv)) == None) {
+ free_ant(display, ap);
+ return;
+ }
}
if (ap->init_bits == 0) {
- for (i = 0; i < COLORS - 1; i++)
- ANTBITS(patterns[i], PATTERNSIZE, PATTERNSIZE);
+ for (i = 1; i < NUMSTIPPLES; i++) {
+ ANTBITS(stipples[i], STIPPLESIZE, STIPPLESIZE);
+ }
}
}
ap->generation = 0;
- ap->n = MI_BATCHCOUNT(mi);
+ ap->n = MI_COUNT(mi);
if (ap->n < -MINANTS) {
/* if ap->n is random ... the size can change */
if (ap->ants != NULL) {
(void) free((void *) ap->ants);
- ap->ants = NULL;
+ ap->ants = (antstruct *) NULL;
}
ap->n = NRAND(-ap->n - MINANTS + 1) + MINANTS;
} else if (ap->n < MINANTS)
ap->n = MINANTS;
- ap->width = MI_WIN_WIDTH(mi);
- ap->height = MI_WIN_HEIGHT(mi);
+ ap->width = MI_WIDTH(mi);
+ ap->height = MI_HEIGHT(mi);
- if (neighbors == 8 || neighbors == 9 || neighbors == 12)
- ap->neighbors = neighbors; /* Discourage but not deny use... */
- else
- for (i = 0; i < NEIGHBORKINDS; i++) {
- if (neighbors == initVal[i]) {
- ap->neighbors = initVal[i];
- break;
- }
- if (i == NEIGHBORKINDS - 1) {
- ap->neighbors = initVal[NRAND(NEIGHBORKINDS)];
- break;
+ for (i = 0; i < NEIGHBORKINDS; i++) {
+ if (neighbors == plots[i]) {
+ ap->neighbors = plots[i];
+ break;
+ }
+ if (i == NEIGHBORKINDS - 1) {
+ if (!NRAND(10)) {
+ /* Make above 6 rare */
+ ap->neighbors = plots[NRAND(NEIGHBORKINDS)];
+ } else {
+ ap->neighbors = plots[NRAND(GOODNEIGHBORKINDS)];
}
+ break;
}
+ }
if (ap->neighbors == 6) {
int nccols, ncrows;
- if (ap->width < 2)
- ap->width = 2;
- if (ap->height < 4)
- ap->height = 4;
- if (size < -MINSIZE)
+ if (ap->width < 8)
+ ap->width = 8;
+ if (ap->height < 8)
+ ap->height = 8;
+ if (size < -MINSIZE) {
ap->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(ap->width, ap->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
- else if (size < MINSIZE) {
+ if (ap->ys < MINRANDOMSIZE)
+ ap->ys = MIN(MINRANDOMSIZE,
+ MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE));
+ } else if (size < MINSIZE) {
if (!size)
ap->ys = MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE);
else
MINGRIDSIZE));
ap->xs = ap->ys;
nccols = MAX(ap->width / ap->xs - 2, 2);
- ncrows = MAX(ap->height / ap->ys - 1, 2);
+ ncrows = MAX(ap->height / ap->ys - 1, 4);
ap->ncols = nccols / 2;
ap->nrows = 2 * (ncrows / 4);
ap->xb = (ap->width - ap->xs * nccols) / 2 + ap->xs / 2;
- ap->yb = (ap->height - ap->ys * (ncrows / 2) * 2) / 2 + ap->ys;
- for (i = 0; i < 7; i++) {
- ap->hexagonList[i].x = (ap->xs - 1) * hexagonUnit[i].x;
- ap->hexagonList[i].y = ((ap->ys - 1) * hexagonUnit[i].y / 2) * 4 / 3;
+ ap->yb = (ap->height - ap->ys * (ncrows / 2) * 2) / 2 + ap->ys - 2;
+ for (i = 0; i < 6; i++) {
+ ap->shape.hexagon[i].x = (ap->xs - 1) * hexagonUnit[i].x;
+ ap->shape.hexagon[i].y = ((ap->ys - 1) * hexagonUnit[i].y / 2) * 4 / 3;
}
- } else if (ap->neighbors == 4 && ap->neighbors == 8) {
- if (size < -MINSIZE)
+ /* Avoid array bounds read of hexagonUnit */
+ ap->shape.hexagon[6].x = 0;
+ ap->shape.hexagon[6].y = 0;
+ } else if (ap->neighbors == 4 || ap->neighbors == 8) {
+ if (size < -MINSIZE) {
ap->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(ap->width, ap->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
- else if (size < MINSIZE) {
+ if (ap->ys < MINRANDOMSIZE)
+ ap->ys = MIN(MINRANDOMSIZE,
+ MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE));
+ } else if (size < MINSIZE) {
if (!size)
ap->ys = MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE);
else
ap->width = 2;
if (ap->height < 2)
ap->height = 2;
- if (size < -MINSIZE)
+ if (size < -MINSIZE) {
ap->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(ap->width, ap->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
- else if (size < MINSIZE) {
+ if (ap->ys < MINRANDOMSIZE)
+ ap->ys = MIN(MINRANDOMSIZE,
+ MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE));
+ } else if (size < MINSIZE) {
if (!size)
ap->ys = MAX(MINSIZE, MIN(ap->width, ap->height) / MINGRIDSIZE);
else
ap->xb = (ap->width - ap->xs * ap->ncols) / 2 + ap->xs / 2;
ap->yb = (ap->height - ap->ys * ap->nrows) / 2 + ap->ys;
for (orient = 0; orient < 2; orient++) {
- for (i = 0; i < 4; i++) {
- ap->triangleList[orient][i].x =
+ for (i = 0; i < 3; i++) {
+ ap->shape.triangle[orient][i].x =
(ap->xs - 2) * triangleUnit[orient][i].x;
- ap->triangleList[orient][i].y =
+ ap->shape.triangle[orient][i].y =
(ap->ys - 2) * triangleUnit[orient][i].y;
}
+ /* Avoid array bounds read of triangleUnit */
+ ap->shape.triangle[orient][3].x = 0;
+ ap->shape.triangle[orient][3].y = 0;
}
}
- XClearWindow(display, MI_WINDOW(mi));
- /* Exclude odd # of neighbors, stepping forward not defined */
- if (!NRAND(COLORS) && ((ap->neighbors + 1) % 2)) {
+ XSetLineAttributes(display, MI_GC(mi), 1, LineSolid, CapNotLast, JoinMiter);
+ MI_CLEARWINDOW(mi);
+ ap->painted = False;
+
+ if (MI_IS_FULLRANDOM(mi)) {
+ ap->truchet = (Bool) (LRAND() & 1);
+ ap->eyes = (Bool) (LRAND() & 1);
+ ap->sharpturn = (Bool) (LRAND() & 1);
+ } else {
+ ap->truchet = truchet;
+ ap->eyes = eyes;
+ ap->sharpturn = sharpturn;
+ }
+ if (!NRAND(NUMSTIPPLES)) {
getTable(mi, (int) (NRAND(NTABLES)));
} else
- getTurk(mi, (int) (NRAND(COLORS - 1)));
+ getTurk(mi, (int) (NRAND(NUMSTIPPLES - 1)));
if (MI_NPIXELS(mi) > 2)
for (i = 0; i < (int) ap->ncolors - 1; i++)
- ap->colors[i] = (NRAND(MI_NPIXELS(mi)) +
+ ap->colors[i] = (unsigned char) (NRAND(MI_NPIXELS(mi)) +
i * MI_NPIXELS(mi)) / ((int) (ap->ncolors - 1));
- if (ap->ants == NULL)
- ap->ants = (antstruct *) malloc(ap->n * sizeof (antstruct));
- if (ap->tape != NULL)
+ if (ap->ants == NULL) {
+ if ((ap->ants = (antstruct *) malloc(ap->n * sizeof (antstruct))) ==
+ NULL) {
+ free_ant(display, ap);
+ return;
+ }
+ }
+ if (ap->tape != NULL)
(void) free((void *) ap->tape);
- ap->tape = (unsigned char *)
- calloc(ap->ncols * ap->nrows, sizeof (unsigned char));
-
+ if ((ap->tape = (unsigned char *) calloc(ap->ncols * ap->nrows,
+ sizeof (unsigned char))) == NULL) {
+ free_ant(display, ap);
+ return;
+ }
if (ap->truchet_state != NULL)
(void) free((void *) ap->truchet_state);
- ap->truchet_state = (unsigned char *)
- calloc(ap->ncols * ap->nrows, sizeof (unsigned char));
+ if ((ap->truchet_state = (unsigned char *) calloc(ap->ncols * ap->nrows,
+ sizeof (unsigned char))) == NULL) {
+ free_ant(display, ap);
+ return;
+ }
- col = ap->ncols / 2;
row = ap->nrows / 2;
+ col = ap->ncols / 2;
+ if (col > 0 && ((ap->neighbors % 2) || ap->neighbors == 12) && (LRAND() & 1))
+ col--;
dir = NRAND(ap->neighbors) * ANGLES / ap->neighbors;
+ ap->init_dir = dir;
+#ifdef NUMBER_9
+ if (ap->neighbors == 9 && !((col + row) & 1))
+ dir = (dir + ANGLES - ANGLES / (ap->neighbors * 2)) % ANGLES;
+#endif
/* Have them all start in the same spot, why not? */
for (i = 0; i < ap->n; i++) {
ap->ants[i].col = col;
ap->ants[i].direction = dir;
ap->ants[i].state = 0;
}
- draw_anant(mi, col, row);
+ draw_anant(mi, dir, col, row);
}
void
draw_ant(ModeInfo * mi)
{
- antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
antstruct *anant;
statestruct *status;
int i, state_pos, tape_pos;
unsigned char color;
short chg_dir, old_dir;
+ antfarmstruct *ap;
+ if (antfarms == NULL)
+ return;
+ ap = &antfarms[MI_SCREEN(mi)];
+ if (ap->ants == NULL)
+ return;
+
+ MI_IS_DRAWN(mi) = True;
+ ap->painted = True;
for (i = 0; i < ap->n; i++) {
anant = &ap->ants[i];
tape_pos = anant->col + anant->row * ap->ncols;
int a = 0, b;
if (ap->neighbors == 6) {
- a = (old_dir / 60) % 3;
- b = (anant->direction / 60) % 3;
- a = (a + b + 1) % 3;
- drawtruchet(mi, anant->col, anant->row, status->color, a);
+ if (ap->sharpturn) {
+ a = (((ANGLES + anant->direction - old_dir) % ANGLES) == 240);
+ /* should be some way of getting rid of the init_dir dependency... */
+ b = !(ap->init_dir % 120);
+ a = ((a && !b) || (b && !a));
+ drawtruchet(mi, anant->col, anant->row, status->color, a);
+ } else {
+ a = (old_dir / 60) % 3;
+ b = (anant->direction / 60) % 3;
+ a = (a + b + 1) % 3;
+ drawtruchet(mi, anant->col, anant->row, status->color, a);
+ }
} else if (ap->neighbors == 4) {
a = old_dir / 180;
b = anant->direction / 180;
}
anant->state = status->next;
- /* If edge than wrap it */
+ /* Allow step first and turn */
old_dir = ((status->direction < ANGLES) ? anant->direction : old_dir);
+#if DEBUG
+ (void) printf("old_dir %d, col %d, row %d", old_dir, anant->col, anant->row);
+#endif
position_of_neighbor(ap, old_dir, &(anant->col), &(anant->row));
- draw_anant(mi, anant->col, anant->row);
+#if DEBUG
+ (void) printf(", ncol %d, nrow %d\n", anant->col, anant->row);
+#endif
+ draw_anant(mi, anant->direction, anant->col, anant->row);
}
if (++ap->generation > MI_CYCLES(mi)) {
#ifdef STANDALONE
erase_full_window(MI_DISPLAY(mi), MI_WINDOW(mi));
#endif
- init_ant(mi);
+ init_ant(mi);
}
if (ap->redrawing) {
for (i = 0; i < REDRAWSTEP; i++) {
if (antfarms != NULL) {
int screen;
- for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
- antfarmstruct *ap = &antfarms[screen];
- int shade;
-
- if (ap->stippledGC != None) {
- XFreeGC(MI_DISPLAY(mi), ap->stippledGC);
- }
- for (shade = 0; shade < ap->init_bits; shade++)
- XFreePixmap(MI_DISPLAY(mi), ap->pixmaps[shade]);
- if (ap->tape != NULL)
- (void) free((void *) ap->tape);
- if (ap->ants != NULL)
- (void) free((void *) ap->ants);
- if (ap->truchet_state != NULL)
- (void) free((void *) ap->truchet_state);
- }
+ for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
+ free_ant(MI_DISPLAY(mi), &antfarms[screen]);
(void) free((void *) antfarms);
- antfarms = NULL;
+ antfarms = (antfarmstruct *) NULL;
}
}
void
refresh_ant(ModeInfo * mi)
{
- antfarmstruct *ap = &antfarms[MI_SCREEN(mi)];
+ antfarmstruct *ap;
+
+ if (antfarms == NULL)
+ return;
+ ap = &antfarms[MI_SCREEN(mi)];
- ap->redrawing = 1;
- ap->redrawpos = 0;
+ if (ap->painted) {
+ MI_CLEARWINDOW(mi);
+ ap->redrawing = 1;
+ ap->redrawpos = 0;
+ }
}
+
+#endif /* MODE_ant */
projects / xscreensaver / blobdiff