qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
110b2a9207
xenocara/app/xlockmore/modes/life.c
matthieu 110b2a9207 Importing xlockmore 5.22
2006-11-26 11:07:42 +00:00

2683 lines
77 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4 -*- */
/* life --- Conway's game of Life */
#if !defined( lint ) && !defined( SABER )
static const char sccsid[] = "@(#)life.c 5.07 2003/02/27 xlockmore";
#endif
/*-
* Copyright (c) 1991 by Patrick J. Naughton.
* Copyright (c) 1997 by David Bagley.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appear in all copies and that
* both that copyright notice and this permission notice appear in
* supporting documentation.
*
* This file is provided AS IS with no warranties of any kind. The author
* shall have no liability with respect to the infringement of copyrights,
* trade secrets or any patents by this file or any part thereof. In no
* event will the author be liable for any lost revenue or profits or
* other special, indirect and consequential damages.
*
* Revision History:
* 01-Mar-2003: Added shooters for triangular life.
* 26-Feb-2003: Added LWSS, MWSS, HWSS in shooter.
* 25-Feb-2003: Randomly rotate trilife
* 25-Jan-2003: Spawned a life.h
* 23-Jan-2003: Added life from Stephen Silver's Life Lexicon
* http://www.argentum.freeserve.co.uk/lex_home.htm
* 23-Jan-2003: Tri life from Carter Bays. Added B45/S34 which I use as
* the true trilife, also available B456/S45 & B45/S23.
* Right now the glider for trilife is not integrated into
* the "shooter" part of the program.
* Other neat ones are B4/S456, B46/S24, B4/S35, B456/S12,
* B3/S23, & B4/S46. See:
* http://www.cse.sc.edu/~bays/trilife3/home.html
* 15-Jan-2003: Moves on if screen blank or static
* 15-Jan-2003: Alternate life rules from Nathan Thompson's "Day and Night"
* B3678/S34678 and David I. Bell's "HighLife" B36/S23.
* See http://www.tip.net.au/~dbell/
* Other rules that may be neat:
* http://entropymine.com/jason/life/alt/
* "Diamoeba" B35678/S5678, "Move" B36(8)/S245
* 01-Nov-2000: Allocation checks
* 03-Oct-2000: Added more randomness in pattern 90 degree orientation and
* mirror image.
* 08-Dec-1997: Paul Callahan's B2a/S2b34 rule added.
* Described on the news site for cellular-automata.
* <ppc997@aber.ac.uk>
* http://www.cs.jhu.edu/~callahan/lifepage.html
* http://www.cs.jhu.edu/~callahan/hexrule.txt
* B2a/S2b34: Birth of x if 2a,
* Survival of x if 2b, 3, or 4 neighbors
* Assume symmetry.
* (2a, 2b, 2c: 2o, 2m, 2p original notation)
* O O O . O .
* 2a: . x . 2b: . x O 2c: . x .
* . . . . . O
* Also Bob Andreen's rule (my own notation for consistency)
* B2a3a4b/S2a2b4a (original notation: 234'B/22'4S)
* <andreen@msmc.edu>
* O O O O O .
* 3a: . x O 3b: . x . 3c: . x O
* . . . O O .
*
* O O O O O O
* 4a: . x O 4b: . x O 4c: . x .
* . O O . O O
* Some other rules
* B2a3b3c5/S12b2c3a4b4c6
* B23a3c4b4c6/S12b2c3c4a56
* B2a2c6/S13b
* 27-Oct-1997: xpm and ras capability added.
* 04-Jun-1997: Removed old algorithm, now use wator's. I could not
* understand it and had trouble adding more features.
* New algorithm is more efficient iff there lots of blank
* areas (ptr loop rather than a double array loop)
* 10-May-1997: Compatible with xscreensaver
* 07-May-1997: life neighbor option. Still have to fix -neighbor 3
* 07-Jan-1995: life now has a random soup pattern.
* 07-Dec-1994: life now has new organisms. They are now better centered.
* Some of the nonperiodic forms were removed. New life
* forms were taken from xlife (an AMAZING collection of life
* forms). life's gliders now come from the edge of the screen
* except when generated by a life form.
* 23-Nov-1994: Bug fix for different iconified window sizes
* 21-Jul-1994: Took out bzero & bcopy since memset & memcpy is more portable
* 10-Jun-1994: Changed name of function 'kill', which is a libc function on
* many systems from Victor Langeveld <vic@mbfys.kun.nl>
* Changes in original xlock
* 24-May-1991: Added wraparound code from johnson@bugs.comm.mot.com.
* Made old cells stay blue.
* Made batchcount control the number of generations until restart.
* 29-Jul-1990: support for multiple screens.
* 07-Feb-1990: remove bogus semi-colon after #include line.
* 15-Dec-1989: Fix for proper skipping of {White,Black}Pixel() in colors.
* 08-Oct-1989: Moved seconds() to an extern.
* 20-Sep-1989: Written, life algorithm courtesy of Jim Graham <flar@sun.com>
*/
/*-
Grid Number of Neighbors
---- ------------------
Square 4 or 8
Hexagon 6
Triangle 3, 9, or 12
Conway's Life: -neighbors 8 -rule S23/B3 LIFE, CONWAY
Other things to try:
-neighbors 8 -rule S23/B36 <HIGHLIFE, BELL>
-neighbors 8 -rule S34678/B3678 <DAY_NIGHT, THOMPSON>
-neighbors 4 -rule S234/B2
-neighbors 6 -rule S23/B3
-neighbors 3 -rule S12/B23
-neighbors 6 -rule S2b34/B2a <CALLAHAN>
-neighbors 6 -rule S2a2b4a/B2b3a4b <ANDREEN>
-neighbors 12 -rule S34/B45 <TRILIFE, BAYS>
-neighbors 12 -rule S45/B456 <TRILIFE1, BAYS>
-neighbors 12 -rule S23/B45 <TRILIFE2, BAYS>
*/
#ifdef STANDALONE
#define MODE_life
#define PROGCLASS "Life"
#define HACK_INIT init_life
#define HACK_DRAW draw_life
#define life_opts xlockmore_opts
#define DEFAULTS "*delay: 750000 \n" \
"*count: 40 \n" \
"*cycles: 140 \n" \
"*size: 0 \n" \
"*ncolors: 200 \n" \
"*bitmap: \n" \
"*neighbors: 0 \n" \
"*verbose: False \n"
#define UNIFORM_COLORS
#include "xlockmore.h" /* in xscreensaver distribution */
#else /* STANDALONE */
#include "xlock.h" /* in xlockmore distribution */
#include "color.h"
#endif /* STANDALONE */
#include "iostuff.h"
#include "automata.h"
#ifdef MODE_life
#define LIFE_NAMES 1
#include "life.h"
#ifdef LIFE_NAMES
#define DEF_LABEL "True"
#define FONT_HEIGHT 19
#define FONT_WIDTH 15
#endif
#define DEF_NEIGHBORS "0" /* choose best value (8) */
#define DEF_SERIAL "False"
#if 1
#define DEF_RULE "G" /* All rules with known gliders */
#else
#define DEF_RULE "P" /* All rules with known patterns, currently G==P */
#define DEF_RULE "S23/B3" /* "B3/S23" LIFE */
#define DEF_RULE "S23/B36" /* "B36/S23" HIGHLIFE */
#define DEF_RULE "S34678/B3678" /* "B3678/S34678" DAY_NIGHT*/
#define DEF_RULE "S2b34/B2a" /* CALLAHAN */
#define DEF_RULE "S2a2b4a/B2b3a4b" /* ANDREEN */
#define DEF_RULE "S34/B45" /* TRILIFE */
#define DEF_RULE "S45/B456" /* TRILIFE1 */
#define DEF_RULE "S23/B45" /* TRILIFE2 */
#endif
#define DEF_CONWAY "False"
#define DEF_HIGHLIFE "False"
#define DEF_DAY_NIGHT "False"
#define DEF_CALLAHAN "False"
#define DEF_ANDREEN "False"
#define DEF_TRILIFE "False"
#define DEF_TRILIFE1 "False"
#define DEF_TRILIFE2 "False"
static int neighbors;
static char *rule;
static char *lifefile;
#ifdef LIFE_NAMES
static Bool label;
#endif
static Bool serial;
static Bool conway;
static Bool highlife;
static Bool daynight;
static Bool callahan;
static Bool andreen;
static Bool trilife;
static Bool trilife1;
static Bool trilife2;
static XrmOptionDescRec opts[] =
{
#ifdef LIFE_NAMES
{(char *) "-label", (char *) ".life.label", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+label", (char *) ".life.label", XrmoptionNoArg, (caddr_t) "off"},
#endif
{(char *) "-neighbors", (char *) ".life.neighbors", XrmoptionSepArg, (caddr_t) NULL},
{(char *) "-rule", (char *) ".life.rule", XrmoptionSepArg, (caddr_t) NULL},
{(char *) "-lifefile", (char *) ".life.lifefile", XrmoptionSepArg, (caddr_t) NULL},
{(char *) "-serial", (char *) ".life.serial", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+serial", (char *) ".life.serial", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-conway", (char *) ".life.conway", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+conway", (char *) ".life.conway", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-highlife", (char *) ".life.highlife", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+highlife", (char *) ".life.highlife", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-daynight", (char *) ".life.daynight", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+daynight", (char *) ".life.daynight", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-callahan", (char *) ".life.callahan", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+callahan", (char *) ".life.callahan", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-andreen", (char *) ".life.andreen", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+andreen", (char *) ".life.andreen", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-trilife", (char *) ".life.trilife", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+trilife", (char *) ".life.trilife", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-trilife1", (char *) ".life.trilife1", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+trilife1", (char *) ".life.trilife1", XrmoptionNoArg, (caddr_t) "off"},
{(char *) "-trilife2", (char *) ".life.trilife2", XrmoptionNoArg, (caddr_t) "on"},
{(char *) "+trilife2", (char *) ".life.trilife2", XrmoptionNoArg, (caddr_t) "off"}
};
static argtype vars[] =
{
#ifdef LIFE_NAMES
{(void *) & label, (char *) "label", (char *) "Label", (char *) DEF_LABEL, t_Bool},
#endif
{(void *) & neighbors, (char *) "neighbors", (char *) "Neighbors", (char *) DEF_NEIGHBORS, t_Int},
{(void *) & rule, (char *) "rule", (char *) "Rule", (char *) DEF_RULE, t_String},
{(void *) & lifefile, (char *) "lifefile", (char *) "LifeFile", (char *) "", t_String},
{(void *) & serial, (char *) "serial", (char *) "Serial", (char *) DEF_SERIAL, t_Bool},
{(void *) & conway, (char *) "conway", (char *) "Conway", (char *) DEF_CONWAY, t_Bool},
{(void *) & highlife, (char *) "highlife", (char *) "HighLife", (char *) DEF_HIGHLIFE, t_Bool},
{(void *) & daynight, (char *) "daynight", (char *) "DayNight", (char *) DEF_DAY_NIGHT, t_Bool},
{(void *) & callahan, (char *) "callahan", (char *) "Callahan", (char *) DEF_CALLAHAN, t_Bool},
{(void *) & andreen, (char *) "andreen", (char *) "Andreen", (char *) DEF_ANDREEN, t_Bool},
{(void *) & trilife, (char *) "trilife", (char *) "TriLife", (char *) DEF_TRILIFE, t_Bool},
{(void *) & trilife1, (char *) "trilife1", (char *) "TriLife1", (char *) DEF_TRILIFE1, t_Bool},
{(void *) & trilife2, (char *) "trilife2", (char *) "TriLife2", (char *) DEF_TRILIFE2, t_Bool}
};
static OptionStruct desc[] =
{
#ifdef LIFE_NAMES
{(char *) "-/+label", (char *) "turn on/off name labeling"},
#endif
{(char *) "-neighbors num", (char *) "squares 4 or 8, hexagons 6, triangles 3, 9 or 12"},
{(char *) "-rule string", (char *) "S<survival_neighborhood>/B<birth_neighborhood> parameters"},
{(char *) "-lifefile file", (char *) "life file"},
{(char *) "-/+serial", (char *) "turn on/off picking of sequential patterns"},
{(char *) "-/+conway", (char *) "turn on/off Conway's original Life rule B3/S23"},
{(char *) "-/+highlife", (char *) "turn on/off Bell's HighLife rule B36/S23"},
{(char *) "-/+daynight", (char *) "turn on/off Thompson's Day and Night rule B3678/S34678"},
{(char *) "-/+callahan", (char *) "turn on/off Callahan's hex rule B2a/S2b34"},
{(char *) "-/+andreen", (char *) "turn on/off Andreen's hex rule B2a3a4b/S2a2b4a"},
{(char *) "-/+trilife", (char *) "turn on/off Bay's tri rule B45/S34"},
{(char *) "-/+trilife1", (char *) "turn on/off Bay's tri rule B456/S45"},
{(char *) "-/+trilife2", (char *) "turn on/off Bay's tri rule B45/S23"}
};
ModeSpecOpt life_opts =
{sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
#ifdef USE_MODULES
ModStruct life_description =
{"life", "init_life", "draw_life", "release_life",
"refresh_life", "change_life", (char *) NULL, &life_opts,
750000, 40, 140, 0, 64, 1.0, "",
"Shows Conway's game of Life", 0, NULL};
#endif
/* aliases for vars defined in the bitmap file */
#define CELL_WIDTH image_width
#define CELL_HEIGHT image_height
#define CELL_BITS image_bits
#include "life.xbm"
#ifdef XBM_GRELB
#include "life2.xbm"
#define CELL2_WIDTH image2_width
#define CELL2_HEIGHT image2_height
#define CELL2_BITS image2_bits
static XImage bimage =
{
0, 0, 0, XYBitmap, 0, LSBFirst, 8, LSBFirst, 8, 1
};
#endif
#ifdef HAVE_XPM
#define CELL_NAME image_name
#if 1
static char *image_name[] =
{(char *) ""};
#else
/* Kind of boring... */
#include "life.xpm"
#endif
#define DEFAULT_XPM 0
#endif
#define REDRAWSTEP 2000 /* How many cells to draw per cycle */
#define MINGRIDSIZE 20
#define MINSIZE 4
#define DEAD 0
#define LIVE 1
#define STATES 2
#define SetList(c,r) if (!setcell(mi,c,r,LIVE)) return
typedef struct {
long position;
unsigned short age;
unsigned char state;
unsigned char toggle;
} cellstruct;
/* Singly linked list */
typedef struct _CellList {
cellstruct info;
struct _CellList *previous, *next;
} CellList;
typedef struct {
Bool painted;
paramstruct param;
int pattern, patterned_rule;
int pixelmode;
int generation;
int xs, ys, xb, yb; /* cell size, grid border */
int nrows, ncols, npositions;
int width, height;
int state;
int noChangeCount;
int redrawing, redrawpos;
int ncells[STATES];
CellList *last[STATES], *first[STATES];
CellList **arr;
union {
XPoint hexagon[6];
XPoint triangle[2][3];
} shape;
XImage *logo;
#ifdef XBM_GRELB
XImage *logo2;
#endif
Colormap cmap;
unsigned long black;
int graphics_format;
GC backGC;
int neighbors;
int conway, highlife, daynight, callahan, andreen;
int trilife, trilife1, trilife2;
int allPatterns, allGliders;
paramstruct input_param;
int labelOffsetX, labelOffsetY;
char ruleString[80], nameString[80];
} lifestruct;
static lifestruct *lifes = (lifestruct *) NULL;
static char *filePattern = (char *) NULL;
static int
invplot(int local_neighbors)
{
switch (local_neighbors) {
case 3:
return 0;
case 4:
return 1;
case 6:
return 2;
case 8:
return 3;
case 9:
return 4;
case 12:
return 5;
default:
(void) fprintf(stderr, "no neighborhood like %d known\n", local_neighbors);
return 3;
}
}
static int
codeToPatternedRule(int local_neighbors, paramstruct param)
{
unsigned int i;
int g, neighbor_kind;
neighbor_kind = invplot(local_neighbors);
switch (local_neighbors) {
case 6:
for (i = 0; i < LIFE_6RULES; i++)
if (param_6rules[i].survival == param.survival &&
param_6rules[i].birth == param.birth) {
for (g = 0; g < maxgroups[neighbor_kind]; g++) {
if (param_6rules[i].survival_group[g] !=
param.survival_group[g] ||
param_6rules[i].birth_group[g] !=
param.birth_group[g]) {
break;
}
}
if (g == maxgroups[neighbor_kind])
return i;
}
return LIFE_6RULES;
case 8:
for (i = 0; i < LIFE_8RULES; i++)
if (param_8rules[i].survival == param.survival &&
param_8rules[i].birth == param.birth) {
for (g = 0; g < maxgroups[neighbor_kind]; g++) {
if (param_8rules[i].survival_group[g] !=
param.survival_group[g] ||
param_8rules[i].birth_group[g] !=
param.birth_group[g]) {
break;
}
}
if (g == maxgroups[neighbor_kind])
return i;
}
return LIFE_8RULES;
case 12:
for (i = 0; i < LIFE_12RULES; i++)
if (param_12rules[i].survival == param.survival &&
param_12rules[i].birth == param.birth) {
for (g = 0; g < maxgroups[neighbor_kind]; g++) {
if (param_12rules[i].survival_group[g] !=
param.survival_group[g] ||
param_12rules[i].birth_group[g] !=
param.birth_group[g]) {
break;
}
}
if (g == maxgroups[neighbor_kind])
return i;
}
return LIFE_12RULES;
}
return 0;
}
static void
copyFromPatternedRule(int local_neighbors, paramstruct * param,
int patterned_rule)
{
int i, neighbor_kind;
neighbor_kind = invplot(local_neighbors);
switch (local_neighbors) {
case 6:
param->survival = param_6rules[patterned_rule].survival;
param->birth = param_6rules[patterned_rule].birth;
for (i = 0; i < maxgroups[neighbor_kind]; i++) {
param->survival_group[i] =
param_6rules[patterned_rule].survival_group[i];
param->birth_group[i] =
param_6rules[patterned_rule].birth_group[i];
}
break;
case 8:
param->survival = param_8rules[patterned_rule].survival;
param->birth = param_8rules[patterned_rule].birth;
for (i = 0; i < maxgroups[neighbor_kind]; i++) {
param->survival_group[i] =
param_8rules[patterned_rule].survival_group[i];
param->birth_group[i] =
param_8rules[patterned_rule].birth_group[i];
}
break;
case 12:
param->survival = param_12rules[patterned_rule].survival;
param->birth = param_12rules[patterned_rule].birth;
for (i = 0; i < maxgroups[neighbor_kind]; i++) {
param->survival_group[i] =
param_12rules[patterned_rule].survival_group[i];
param->birth_group[i] =
param_12rules[patterned_rule].birth_group[i];
}
break;
}
}
static void
printRule(int local_neighbors, char * string, paramstruct param, Bool verbose)
{
int i = 1, l, g, neighbor_kind;
Bool found;
string[0] = 'S';
if (verbose)
(void) fprintf(stdout, "rule (Survival/Birth neighborhood): ");
neighbor_kind = invplot(local_neighbors);
for (l = 0; l <= local_neighbors && l < 10; l++) {
if (param.survival & (1 << l)) {
(void) sprintf(&(string[i]), "%d", l);
i++;
} else if (l >= FIRSTGROUP && l < FIRSTGROUP + maxgroups[neighbor_kind]) {
for (g = 0; g < groupnumber[neighbor_kind][l - FIRSTGROUP]; g++) {
if (param.survival_group[l - FIRSTGROUP] & (1 << g)) {
(void) sprintf(&(string[i]), "%d%c",
l, 'a' + g);
i += 2;
}
}
}
}
(void) sprintf(&(string[i]), "/B");
i += 2;
for (l = 0; l <= local_neighbors && l < 10; l++) {
if (param.birth & (1 << l)) {
(void) sprintf(&(string[i]), "%d", l);
i++;
} else if (l >= FIRSTGROUP && l < FIRSTGROUP + maxgroups[neighbor_kind]) {
for (g = 0; g < groupnumber[neighbor_kind][l - FIRSTGROUP]; g++) {
if (param.birth_group[l - FIRSTGROUP] & (1 << g)) {
(void) sprintf(&(string[i]), "%d%c",
l, 'a' + g);
i += 2;
}
}
}
}
string[i] = '\0';
if (verbose)
(void) fprintf(stdout, "%s\nbinary rule: Survival 0x%X, Birth 0x%X\n",
string, param.survival, param.birth);
found = False;
for (l = 0; l <= maxgroups[neighbor_kind]; l++) {
if (param.survival_group[l] || param.birth_group[l]) {
found = True;
break;
}
}
if (found && verbose)
for (l = 0; l < maxgroups[neighbor_kind]; l++) {
(void) fprintf(stdout,
"groups in neighborhood %d: Survival 0x%X, Birth 0x%X\n",
l + FIRSTGROUP, param.survival_group[l], param.birth_group[l]);
}
}
static int
position_of_neighbor(lifestruct * lp, int n, int col, int row)
{
int dir = n * 360 / lp->neighbors;
if (lp->neighbors == 4 || lp->neighbors == 6 || lp->neighbors == 8) {
switch (dir) {
case 0:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
break;
case 45:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 60:
if (!(row & 1))
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 90:
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 120:
if (row & 1)
col = (!col) ? lp->ncols - 1 : col - 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 135:
col = (!col) ? lp->ncols - 1 : col - 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 180:
col = (!col) ? lp->ncols - 1 : col - 1;
break;
case 225:
col = (!col) ? lp->ncols - 1 : col - 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 240:
if (row & 1)
col = (!col) ? lp->ncols - 1 : col - 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 270:
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 300:
if (!(row & 1))
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 315:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
default:
(void) fprintf(stderr, "wrong direction %d\n", dir);
}
} else { /* TRI */
if ((col + row) % 2) { /* right */
switch (dir) {
case 0:
col = (!col) ? lp->ncols - 1 : col - 1;
break;
case 30:
case 40:
col = (!col) ? lp->ncols - 1 : col - 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 60:
col = (!col) ? lp->ncols - 1 : col - 1;
if (row + 1 == lp->nrows)
row = 1;
else if (row + 2 == lp->nrows)
row = 0;
else
row = row + 2;
break;
case 80:
case 90:
if (row + 1 == lp->nrows)
row = 1;
else if (row + 2 == lp->nrows)
row = 0;
else
row = row + 2;
break;
case 120:
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 150:
case 160:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 180:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
break;
case 200:
case 210:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 240:
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 270:
case 280:
if (!row)
row = lp->nrows - 2;
else if (!(row - 1))
row = lp->nrows - 1;
else
row = row - 2;
break;
case 300:
col = (!col) ? lp->ncols - 1 : col - 1;
if (!row)
row = lp->nrows - 2;
else if (!(row - 1))
row = lp->nrows - 1;
else
row = row - 2;
break;
case 320:
case 330:
col = (!col) ? lp->ncols - 1 : col - 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
default:
(void) fprintf(stderr, "wrong direction %d\n", dir);
}
} else { /* left */
switch (dir) {
case 0:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
break;
case 30:
case 40:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 60:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
if (!row)
row = lp->nrows - 2;
else if (row == 1)
row = lp->nrows - 1;
else
row = row - 2;
break;
case 80:
case 90:
if (!row)
row = lp->nrows - 2;
else if (row == 1)
row = lp->nrows - 1;
else
row = row - 2;
break;
case 120:
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 150:
case 160:
col = (!col) ? lp->ncols - 1 : col - 1;
row = (!row) ? lp->nrows - 1 : row - 1;
break;
case 180:
col = (!col) ? lp->ncols - 1 : col - 1;
break;
case 200:
case 210:
col = (!col) ? lp->ncols - 1 : col - 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 240:
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
case 270:
case 280:
if (row + 1 == lp->nrows)
row = 1;
else if (row + 2 == lp->nrows)
row = 0;
else
row = row + 2;
break;
case 300:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
if (row + 1 == lp->nrows)
row = 1;
else if (row + 2 == lp->nrows)
row = 0;
else
row = row + 2;
break;
case 320:
case 330:
col = (col + 1 == lp->ncols) ? 0 : col + 1;
row = (row + 1 == lp->nrows) ? 0 : row + 1;
break;
default:
(void) fprintf(stderr, "wrong direction %d\n", dir);
}
}
}
return (row * lp->ncols + col);
}
static void
parseRule(ModeInfo * mi, char * string)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int n, g = 0, l = 0, neighbor_kind;
char serving = 0;
static Bool found = False;
if (!found)
lp->input_param.survival = lp->input_param.birth = 0;
if (lp->input_param.survival || lp->input_param.birth)
return;
for (n = 0; n < MAXGROUPS; n++) {
lp->input_param.survival_group[n] = lp->input_param.birth_group[n] = 0;
}
if (lp->conway) {
lp->neighbors = 8;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_8rules[0].survival;
lp->input_param.birth = param_8rules[0].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_8rules[0].survival_group[n];
lp->input_param.birth_group[n] = param_8rules[0].birth_group[n];
}
return;
} else if (lp->highlife) {
lp->neighbors = 8;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_8rules[1].survival;
lp->input_param.birth = param_8rules[1].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_8rules[1].survival_group[n];
lp->input_param.birth_group[n] = param_8rules[1].birth_group[n];
}
return;
} else if (lp->daynight) {
lp->neighbors = 8;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_8rules[2].survival;
lp->input_param.birth = param_8rules[2].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_8rules[2].survival_group[n];
lp->input_param.birth_group[n] = param_8rules[2].birth_group[n];
}
return;
} else if (lp->callahan) {
lp->neighbors = 6;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_6rules[0].survival;
lp->input_param.birth = param_6rules[0].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_6rules[0].survival_group[n];
lp->input_param.birth_group[n] = param_6rules[0].birth_group[n];
}
return;
} else if (lp->andreen) {
lp->neighbors = 6;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_6rules[1].survival;
lp->input_param.birth = param_6rules[1].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_6rules[1].survival_group[n];
lp->input_param.birth_group[n] = param_6rules[1].birth_group[n];
}
return;
} else if (lp->trilife) {
lp->neighbors = 12;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_12rules[0].survival;
lp->input_param.birth = param_12rules[0].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_12rules[0].survival_group[n];
lp->input_param.birth_group[n] = param_12rules[0].birth_group[n];
}
return;
} else if (lp->trilife1) {
lp->neighbors = 12;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_12rules[1].survival;
lp->input_param.birth = param_12rules[1].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_12rules[1].survival_group[n];
lp->input_param.birth_group[n] = param_12rules[1].birth_group[n];
}
return;
} else if (lp->trilife2) {
lp->neighbors = 12;
neighbor_kind = invplot(lp->neighbors);
found = !MI_IS_FULLRANDOM(mi);
lp->input_param.survival = param_12rules[2].survival;
lp->input_param.birth = param_12rules[2].birth;
for (n = 0; n < maxgroups[neighbor_kind]; n++) {
lp->input_param.survival_group[n] = param_12rules[2].survival_group[n];
lp->input_param.birth_group[n] = param_12rules[2].birth_group[n];
}
return;
}
neighbor_kind = invplot(lp->neighbors);
if (rule) {
n = 0;
while (rule[n]) {
if (rule[n] == 'P' || rule[n] == 'p') {
lp->allPatterns = True;
found = True;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "rule: All rules with known patterns\n");
return;
} else if (rule[n] == 'G' || rule[n] == 'g') {
lp->allGliders = True;
found = True;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "rule: All rules with known gliders\n");
return;
} else if (rule[n] == 'S' || rule[n] == 'E' || rule[n] == 'L' || rule[n] == 's' || rule[n] == 'e' || rule[n] == 'l') {
serving = 'S';
} else if (rule[n] == 'B' || rule[n] == 'b') {
serving = 'B';
} else {
l = rule[n] - '0';
if (l >= 0 && l <= 9 && l <= lp->neighbors) { /* no 10, 11, 12 */
g = rule[n + 1] - 'a';
if (l >= FIRSTGROUP && l < FIRSTGROUP + maxgroups[neighbor_kind] &&
g >= 0 && g < groupnumber[neighbor_kind][l]) { /* Groupings */
if (serving == 'S' || rule[n] == 's') {
found = True;
lp->input_param.survival_group[l - FIRSTGROUP] |= (1 << g);
} else if (serving == 'B' || rule[n] == 'b') {
found = True;
lp->input_param.birth_group[l - FIRSTGROUP] |= (1 << g);
}
} else {
if (serving == 'S' || rule[n] == 's') {
found = True;
lp->input_param.survival |= (1 << l);
} else if (serving == 'B' || rule[n] == 'b') {
found = True;
lp->input_param.birth |= (1 << l);
}
}
}
}
n++;
}
}
if (!found || !(lp->input_param.survival || lp->input_param.birth)) {
/* Default to Conway's rule if rule does not make sense */
lp->allGliders = True;
found = !MI_IS_FULLRANDOM(mi);
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout,
"rule: Defaulting to all rules with known gliders\n");
return;
}
printRule(lp->neighbors, string, lp->input_param, MI_IS_VERBOSE(mi));
}
static void
parseFile(ModeInfo *mi)
{
FILE *file;
static Bool done = False;
int firstx, x = 0, y = 0, i = 0;
int c, size;
char line[256];
if (done)
return;
done = True;
if (MI_IS_FULLRANDOM(mi) || !lifefile || !*lifefile)
return;
if ((file = my_fopenSize(lifefile, "r", &size)) == NULL) {
(void) fprintf(stderr, "could not read file \"%s\"\n", lifefile);
return;
}
for (;;) {
if (!fgets(line, 256, file)) {
(void) fprintf(stderr, "could not read header of file \"%s\"\n",
lifefile);
(void) fclose(file);
return;
}
if (strncmp(line, "#P", (size_t) 2) == 0 &&
sscanf(line, "#P %d %d", &x, &y) == 2)
break;
}
c = getc(file);
while (c != EOF && !(c == '0' || c == 'O' || c == '*' || c == '.')) {
c = getc(file);
}
if (c == EOF || x <= -127 || y <= -127 || x >= 127 || y >= 127) {
(void) fprintf(stderr, "corrupt file \"%s\" or file to large\n",
lifefile);
(void) fclose(file);
return;
}
firstx = x;
if ((filePattern = (char *) malloc((2 * size) *
sizeof (char))) == NULL) {
(void) fprintf(stderr, "not enough memory\n");
(void) fclose(file);
return;
}
while (c != EOF && x < 127 && y < 127 && i < 2 * size) {
if (c == '0' || c == 'O' || c == '*') {
filePattern[i++] = x++;
filePattern[i++] = y;
} else if (c == '.') {
x++;
} else if (c == '\n') {
x = firstx;
y++;
}
c = getc(file);
}
(void) fclose(file);
filePattern[i] = 127;
}
static Bool
init_list(lifestruct * lp, int state)
{
/* Waste some space at the beginning and end of list
so we do not have to complicated checks against falling off the ends. */
if ((lp->last[state] = (CellList *) malloc(sizeof (CellList))) == NULL) {
return False;
}
if ((lp->first[state] = (CellList *) malloc(sizeof (CellList))) == NULL) {
free(lp->last[state]);
lp->last[state] = (CellList *) NULL;
return False;
}
lp->first[state]->previous = lp->last[state]->next =
(struct _CellList *) NULL;
lp->first[state]->next = lp->last[state]->previous =
(struct _CellList *) NULL;
lp->first[state]->next = lp->last[state];
lp->last[state]->previous = lp->first[state];
return True;
}
static Bool
addto_list(lifestruct * lp, int state, cellstruct info)
{
CellList *curr;
if ((curr = (CellList *) malloc(sizeof (CellList))) == NULL)
return False;
lp->last[state]->previous->next = curr;
curr->previous = lp->last[state]->previous;
curr->next = lp->last[state];
lp->last[state]->previous = curr;
curr->info = info;
if (info.position >= 0) {
lp->arr[info.position] = curr;
lp->ncells[state]++;
}
return True;
}
static void
removefrom_list(lifestruct * lp, int state, CellList * curr)
{
curr->previous->next = curr->next;
curr->next->previous = curr->previous;
if (curr->info.position >= 0) {
lp->arr[curr->info.position] = (CellList *) NULL;
lp->ncells[state]--;
}
free(curr);
}
#ifdef DEBUG
static void
print_state(ModeInfo * mi, int state)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
CellList *curr;
int i = 0;
curr = lp->first[state]->next;
(void) printf("state %d\n", state);
while (curr != lp->last[state]) {
(void) printf("%d: position %ld, age %d, state %d, toggle %d\n",
i, curr->info.position, curr->info.age,
curr->info.state, curr->info.toggle);
curr = curr->next;
i++;
}
}
#endif
static void
flush_list(lifestruct * lp, int state)
{
while (lp->last[state]->previous != lp->first[state]) {
CellList *curr = lp->last[state]->previous;
curr->previous->next = lp->last[state];
lp->last[state]->previous = curr->previous;
free(curr);
}
lp->ncells[state] = 0;
}
static void
draw_cell(ModeInfo * mi, cellstruct info)
{
Display *display = MI_DISPLAY(mi);
lifestruct *lp = &lifes[MI_SCREEN(mi)];
GC gc = lp->backGC;
int col, row;
col = (int) (info.position % lp->ncols);
row = (int) (info.position / lp->ncols);
if (info.state == LIVE) {
if (MI_NPIXELS(mi) > 2)
XSetForeground(display, gc, MI_PIXEL(mi, info.age));
else
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
} else
XSetForeground(display, gc, lp->black);
if (lp->neighbors == 6) {
int ccol = 2 * col + !(row & 1), crow = 2 * row;
lp->shape.hexagon[0].x = lp->xb + ccol * lp->xs;
lp->shape.hexagon[0].y = lp->yb + crow * lp->ys;
if (lp->xs == 1 && lp->ys == 1)
XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi),
lp->backGC, lp->shape.hexagon[0].x, lp->shape.hexagon[0].y);
else
XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), lp->backGC,
lp->shape.hexagon, 6, Convex, CoordModePrevious);
} else if (lp->neighbors == 4 || lp->neighbors == 8) {
if (lp->pixelmode || info.state == DEAD)
XFillRectangle(display, MI_WINDOW(mi), gc,
lp->xb + lp->xs * col, lp->yb + lp->ys * row,
lp->xs - (lp->xs > 3 && lp->pixelmode),
lp->ys - (lp->ys > 3 && lp->pixelmode));
else {
/*-
* PURIFY 4.0.1 on SunOS4 and on Solaris 2 reports a 132 byte memory leak on
* the next line */
#ifdef XBM_GRELB
if (lp->logo2) {
(void) XPutImage(display, MI_WINDOW(mi), gc,
(LRAND() & 1) ? lp->logo : lp->logo2,
0, 0, lp->xb + lp->xs * col, lp->yb + lp->ys * row,
lp->logo->width, lp->logo->height);
} else
#endif
{
(void) XPutImage(display, MI_WINDOW(mi), gc, lp->logo,
0, 0, lp->xb + lp->xs * col, lp->yb + lp->ys * row,
lp->logo->width, lp->logo->height);
}
}
} else { /* TRI */
int orient = (col + row) % 2; /* O left 1 right */
lp->shape.triangle[orient][0].x = lp->xb + col * lp->xs;
lp->shape.triangle[orient][0].y = lp->yb + row * lp->ys;
if (lp->xs <= 3 || lp->ys <= 3)
XDrawPoint(MI_DISPLAY(mi), MI_WINDOW(mi), lp->backGC,
((orient) ? -1 : 1) + lp->shape.triangle[orient][0].x,
lp->shape.triangle[orient][0].y);
else {
if (orient)
lp->shape.triangle[orient][0].x += (lp->xs / 2 - 1);
else
lp->shape.triangle[orient][0].x -= (lp->xs / 2 - 1);
XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), lp->backGC,
lp->shape.triangle[orient], 3, Convex, CoordModePrevious);
}
}
}
static void
setcelltoggles(ModeInfo * mi, int col, int row)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int position;
CellList *curr;
position = row * lp->ncols + col;
curr = lp->arr[position];
if (!curr) {
(void) fprintf(stderr, "state toggling but not on list\n");
return;
}
curr->info.toggle = True;
}
static void
free_cells(lifestruct * lp)
{
if (lp->arr != NULL) {
free(lp->arr);
lp->arr = (CellList **) NULL;
}
}
static void
free_stuff(Display * display, lifestruct * lp)
{
if (lp->cmap != None) {
XFreeColormap(display, lp->cmap);
if (lp->backGC != None) {
XFreeGC(display, lp->backGC);
lp->backGC = None;
}
lp->cmap = None;
} else
lp->backGC = None;
}
static void
free_life(Display * display, lifestruct * lp)
{
int state;
for (state = 0; state < STATES; state++) {
if (lp->first[state])
flush_list(lp, state);
if (lp->last[state])
free(lp->last[state]);
lp->last[state] = (CellList *) NULL;
if (lp->first[state])
free(lp->first[state]);
lp->first[state] = (CellList *) NULL;
}
free_cells(lp);
free_stuff(display, lp);
if (lp->logo != None) {
destroyImage(&lp->logo, &lp->graphics_format);
lp->logo = None;
}
}
static Bool
setcellfromtoggle(ModeInfo * mi, int col, int row)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int neighbor, n, position;
cellstruct info;
CellList *curr, *currn;
position = row * lp->ncols + col;
curr = lp->arr[position];
if ((curr && curr->info.state == DEAD && curr->info.toggle) ||
(curr && curr->info.state == LIVE && !curr->info.toggle)) {
for (n = 0; n < lp->neighbors; n++) {
neighbor = position_of_neighbor(lp, n, col, row);
currn = lp->arr[neighbor];
if (!currn) {
info.position = neighbor;
info.age = 0;
info.state = DEAD;
info.toggle = False;
if (!addto_list(lp, DEAD, info)) {
free_life(MI_DISPLAY(mi), lp);
return False;
}
}
}
}
if (curr && curr->info.state == DEAD && curr->info.toggle) {
removefrom_list(lp, DEAD, curr);
info.age = 0;
info.position = position;
info.toggle = False;
info.state = LIVE;
if (!addto_list(lp, LIVE, info)) {
free_life(MI_DISPLAY(mi), lp);
return False;
}
draw_cell(mi, info);
} else if (curr && curr->info.state == LIVE && !curr->info.toggle) {
info = curr->info;
/* if we aren't up to blue yet, then keep aging the cell. */
if ((MI_NPIXELS(mi) > 2) &&
(info.age < (unsigned short) (MI_NPIXELS(mi) * 0.7))) {
++(info.age);
/* cc: error 1405: "/opt/ansic/lbin/ccom"
terminated abnormally with signal 11.
*** Error exit code 9 */
/* Next 2 line trips up HP cc -g -O, remove a flag */
curr->info.age = info.age;
draw_cell(mi, info);
}
}
return True;
}
static Bool
setcell(ModeInfo * mi, int col, int row, int state)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int neighbor, n, position;
cellstruct info;
CellList *curr, *currn;
if (col < 0 || row < 0 || col >= lp->ncols || row >= lp->nrows) {
#ifdef DEBUG
(void) printf("col %d, row %d outside grid\n", col, row);
#endif
return True; /* Actually its a 3rd case */
}
position = row * lp->ncols + col;
curr = lp->arr[position];
/* cc: error 1405: "/opt/ansic/lbin/ccom"
terminated abnormally with signal 11.
*** Error exit code 9 */
/* Following lines trip up HP cc -g -O, remove a flag */
if (state == LIVE) {
if (curr && curr->info.state == DEAD) {
removefrom_list(lp, DEAD, curr);
curr = (CellList *) NULL;
}
if (!curr) {
for (n = 0; n < lp->neighbors; n++) {
neighbor = position_of_neighbor(lp, n, col, row);
currn = lp->arr[neighbor];
if (!currn) {
info.age = 0;
info.position = neighbor;
info.state = DEAD;
info.toggle = False;
if (!addto_list(lp, DEAD, info)) {
free_life(MI_DISPLAY(mi), lp);
return False;
}
}
}
info.age = 0;
info.position = position;
info.state = LIVE;
info.toggle = False;
if (!addto_list(lp, LIVE, info)) {
free_life(MI_DISPLAY(mi), lp);
return False;
}
draw_cell(mi, info);
} else {
info = curr->info;
info.age = 0;
draw_cell(mi, info);
}
} else if (curr && curr->info.state == LIVE) {
info.age = 0;
info.position = position;
info.state = DEAD;
info.toggle = False;
removefrom_list(lp, LIVE, curr); /* Just in case... */
if (!addto_list(lp, DEAD, info)) {
free_life(MI_DISPLAY(mi), lp);
return False;
}
draw_cell(mi, info);
}
return True;
}
#if 0
static int
n_neighbors(lifestruct * lp, CellList * curr)
{
int col, row, n, p, count = 0;
col = curr->info.position % lp->ncols;
row = curr->info.position / lp->ncols;
for (n = 0; n < lp->neighbors; n++) {
p = position_of_neighbor(lp, n, col, row);
if (lp->arr[p] && lp->arr[p]->info.state == LIVE) {
count++;
}
}
return count;
}
#endif
static int ceil2(int z)
{
if (z >= 0)
return (z + 1) / 2;
else
return z / 2;
}
static int
ng_neighbors(lifestruct * lp, CellList * curr, int *group)
{
int col, row, n, p, count = 0, gcount = 0;
col = (int) (curr->info.position % lp->ncols);
row = (int) (curr->info.position / lp->ncols);
for (n = 0; n < lp->neighbors; n++) {
p = position_of_neighbor(lp, n, col, row);
gcount <<= 1;
if (lp->arr[p] && lp->arr[p]->info.state == LIVE) {
count++;
gcount++;
}
}
*group = gcount;
return count;
}
static void
RandomSoup(ModeInfo * mi, int n, int v)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int row, col;
v /= 2;
if (v < 1)
v = 1;
for (row = lp->nrows / 2 - v; row < lp->nrows / 2 + v; ++row)
for (col = lp->ncols / 2 - v; col < lp->ncols / 2 + v; ++col)
if (NRAND(100) < n) {
SetList(col, row);
}
(void) strcpy(lp->nameString, "random pattern");
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "%s\n", lp->nameString);
}
static void
GetPattern(ModeInfo * mi, int pattern_rule, int pattern)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int row, col, orient, temp;
char *patptr = (char *) NULL;
#ifdef LIFE_NAMES
int pat = 2 * pattern + 1;
char * patstrg = (char *) "";
#else
int pat = pattern;
#endif
if (filePattern) {
patptr = &filePattern[0];
} else {
switch (lp->neighbors) {
case 6:
switch (pattern_rule) {
case LIFE_6S2b34B2a:
patptr = &patterns_6S2b34B2a[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_6S2b34B2a[2 * pattern][0];
#endif
break;
case LIFE_6S2a2b4aB2a3a4b:
patptr = &patterns_6S2a2b4aB2a3a4b[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_6S2a2b4aB2a3a4b[2 * pattern][0];
#endif
break;
}
break;
case 8:
switch (pattern_rule) {
case LIFE_8S23B3:
if (pattern < (int) common_8size) {
patptr = &patterns_8S23B3_6[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_8S23B3_6[2 * pattern][0];
#endif
} else {
patptr = &patterns_8S23B3[pat - DIV * common_8size][0];
#ifdef LIFE_NAMES
patstrg = &patterns_8S23B3[2 * pattern - 2 * common_8size][0];
#endif
}
break;
case LIFE_8S23B36:
if (pattern < (int) common_8size) {
patptr = &patterns_8S23B3_6[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_8S23B3_6[2 * pattern][0];
#endif
} else {
patptr = &patterns_8S23B36[pat - DIV * common_8size][0];
#ifdef LIFE_NAMES
patstrg = &patterns_8S23B36[2 * pattern - 2 * common_8size][0];
#endif
}
break;
case LIFE_8S34678B3678:
patptr = &patterns_8S34678B3678[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_8S34678B3678[2 * pattern][0];
#endif
break;
}
break;
case 12:
switch (pattern_rule) {
case LIFE_12S34B45:
patptr = &patterns_12S34B45[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_12S34B45[2 * pattern][0];
#endif
break;
case LIFE_12S45B456:
patptr = &patterns_12S45B456[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_12S45B456[2 * pattern][0];
#endif
break;
case LIFE_12S23B45:
patptr = &patterns_12S23B45[pat][0];
#ifdef LIFE_NAMES
patstrg = &patterns_12S23B45[2 * pattern][0];
#endif
break;
}
break;
}
#ifdef LIFE_NAMES
(void) strcpy(lp->nameString, patstrg);
#endif
}
#ifdef DEBUG
orient = 0;
#else
if (lp->neighbors == 4 || lp->neighbors == 8) {
orient = NRAND(8);
} else {
orient = NRAND(12);
}
#endif
if (MI_IS_VERBOSE(mi) && !filePattern) {
#ifdef LIFE_NAMES
(void) fprintf(stdout, "%s, ", patstrg);
#endif
(void) fprintf(stdout, "table number %d\n", pattern);
}
while ((col = *patptr++) != 127) {
row = *patptr++;
if (lp->neighbors == 6) {
if (orient >= 6) {
temp = col;
col = row;
row = temp;
}
/* (a,b) => (b, b-a) */
switch (orient % 6) {
case 0:
break;
case 1:
temp = row;
row = temp - col;
col = temp;
break;
case 2:
temp = -col;
col = temp + row;
row = temp;
break;
case 3:
col = -col;
row = -row;
break;
case 4:
temp = -row;
row = temp + col;
col = temp;
break;
case 5:
temp = col;
col = temp - row;
row = temp;
break;
}
} else if (lp->neighbors == 4 || lp->neighbors == 8) {
if (orient >= 4) {
temp = col;
col = row;
row = temp;
}
/* Could have made it symmetrical with hexagons where
(a,b) => (-b, a), this should be equivalent */
if (orient % 4 >= 2) {
row = -row;
}
if (orient % 2) {
col = -col;
}
} else {
if (orient >= 6) {
row = -row;
}
/* (a,b) => (b, b-a) */
switch (orient % 6) {
case 0:
break;
case 1:
temp = col;
col = ceil2(temp + row);
row = ceil2(row - temp + 1) - temp;
break;
case 2:
temp = col;
col = ceil2(temp - row);
row = temp - ceil2(1 - row - temp);
break;
case 3:
col = -col + 1;
row = -row;
break;
case 4:
temp = col;
col = 1 - ceil2(temp + row);
row = temp - ceil2(row - temp + 1);
break;
case 5:
temp = col;
col = 1 - ceil2(temp - row);
row = ceil2(1 - row - temp) - temp;
break;
}
}
col += lp->ncols / 2;
if (lp->neighbors == 6) {
if (row < 0)
col += (lp->nrows / 2 % 2) ? -row / 2 : -(row - 1) / 2;
else
col += (lp->nrows / 2 % 2) ? -(row + 1) / 2 : -row / 2;
}
row += lp->nrows / 2;
if (lp->neighbors % 3 == 0 && lp->neighbors != 6 &&
(lp->nrows / 2 + lp->ncols / 2 + 1) % 2) {
row++;
}
SetList(col, row);
}
}
static void
shooter(ModeInfo * mi)
{
lifestruct *lp = &lifes[MI_SCREEN(mi)];
int hsp, vsp, hoff = 1, voff = 1, temp;
/* Generate the glider at the edge of the screen */
if (lp->neighbors == 6 && (lp->patterned_rule == LIFE_6S2b34B2a ||
lp->patterned_rule == LIFE_6S2a2b4aB2a3a4b)) {
int hhex = 0, diagonal;
diagonal = NRAND(3);
if (diagonal) {
temp = MIN((lp->nrows + lp->ncols) / 3, 18);
temp = NRAND(temp) - temp / 2;
/* Take into account it is a 60 degree angle not 45 */
if ((lp->ncols + temp) * 1.35 > lp->nrows) {
hsp = (int) ((lp->ncols + temp) * 1.35 - lp->nrows) / 2;
vsp = 0;
} else {
hsp = 0;
vsp = (int) (lp->nrows - (lp->ncols - temp) * 1.35) / 2;
}
switch NRAND(4) {
case 0: /* Upper left */
break;
case 1: /* Upper right */
hhex = -1;
hoff = -1;
hsp = lp->ncols - 1 - hsp;
break;
case 2: /* Lower left */
hhex = 1;
voff = -1;
vsp = lp->nrows - 1 - vsp;
break;
case 3: /* Lower right */
voff = -1;
hoff = -1;
hsp = lp->ncols - 1 - hsp;
vsp = lp->nrows - 1 - vsp;
}
} else {
temp = MIN(lp->nrows / 3, 18);
vsp = lp->nrows / 2 + NRAND(temp) - temp / 2;
if (LRAND() & 1) {
hsp = lp->ncols - 1;
hoff = -1;
hhex = (vsp % 2) ? 0 : hoff;
} else {
hsp = 0;
hhex = (vsp % 2) ? hoff : 0;
}
voff = (LRAND() & 1) ? 1 : -1; /* Mirror image */
}
if (lp->patterned_rule == LIFE_6S2b34B2a) {
if (diagonal) {
SetList(hsp + hhex, vsp);
if (LRAND() & 1) {
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 2 * hoff, vsp + 3 * voff);
SetList(hsp + 1 * hoff + hhex, vsp + 4 * voff);
SetList(hsp + hhex, vsp + 4 * voff);
} else { /* Mirror image */
SetList(hsp + 3 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 0 * hoff, vsp + 3 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
SetList(hsp + 2 * hoff, vsp + 3 * voff);
SetList(hsp + 3 * hoff, vsp + 3 * voff);
}
} else {
SetList(hsp + 2 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 3 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 0 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 4 * hoff, vsp - 1 * voff);
SetList(hsp + 3 * hoff + hhex, vsp - 2 * voff);
}
} else /* if (lp->patterned_rule == LIFE_6S2a2b4aB2a3a4b) */ {
if (diagonal) {
switch (NRAND(3)) { /* 3 different gliders */
case 0:
/* No mirror image */
SetList(hsp + 2 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 3 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 1 * hoff, vsp + 1 * voff);
SetList(hsp + 2 * hoff, vsp + 1 * voff);
SetList(hsp + 0 * hoff + hhex, vsp + 2 * voff);
break;
case 1:
if (LRAND() & 1) {
SetList(hsp + 0 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 1 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 4 * hoff, vsp + 1 * voff);
SetList(hsp + 0 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 1 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 2 * voff);
} else {
SetList(hsp + 1 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 1 * hoff, vsp + 1 * voff);
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
SetList(hsp + 2 * hoff, vsp + 3 * voff);
SetList(hsp + 0 * hoff + hhex, vsp + 4 * voff);
}
break;
case 2:
if (LRAND() & 1) {
SetList(hsp + 1 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 3 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 0 * hoff, vsp + 3 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
SetList(hsp + 2 * hoff, vsp + 3 * voff);
} else {
SetList(hsp + 0 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 3 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 1 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
}
}
} else {
switch (NRAND(3)) { /* 3 different gliders */
case 0:
SetList(hsp + 0 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 0 * hoff + hhex, vsp - 2 * voff);
SetList(hsp + 0 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 0 * hoff, vsp - 1 * voff);
SetList(hsp + 0 * hoff, vsp + 1 * voff);
break;
case 1:
SetList(hsp + 0 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 0 * hoff, vsp + 1 * voff);
SetList(hsp + 1 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 2 * hoff + hhex, vsp - 2 * voff);
SetList(hsp + 2 * hoff, vsp - 1 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + 1 * voff);
break;
case 2:
SetList(hsp + 0 * hoff, vsp - 1 * voff);
SetList(hsp + 1 * hoff + hhex, vsp + 2 * voff);
SetList(hsp + 2 * hoff + hhex, vsp - 2 * voff);
SetList(hsp + 2 * hoff, vsp - 1 * voff);
SetList(hsp + 2 * hoff + hhex, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + 1 * voff);
}
}
}
} else if ((lp->neighbors == 8 && lp->patterned_rule == LIFE_8S23B3) ||
(lp->neighbors == 8 && lp->patterned_rule == LIFE_8S23B36)) {
if (NRAND(3) != 0) {
/* Generate a glider */
if (LRAND() & 1) {
hsp = (LRAND() & 1) ? 0 : lp->ncols - 1;
vsp = NRAND(lp->nrows);
} else {
vsp = (LRAND() & 1) ? 0 : lp->nrows - 1;
hsp = NRAND(lp->ncols);
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2)
hoff = -1;
SetList(hsp + 2 * hoff, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + 1 * voff);
SetList(hsp + 2 * hoff, vsp + 2 * voff);
SetList(hsp + 1 * hoff, vsp + 2 * voff);
SetList(hsp + 0 * hoff, vsp + 1 * voff);
} else {
/* Generate a space ship: LWSS, MWSS, HWSS */
/* where Light Weight ships are more common */
int coord;
int SS = NRAND(6);
SS = (SS < 3) ? 0 : ((SS >= 5) ? 2 : 1);
if (LRAND() & 1) {
hsp = (LRAND() & 1) ? 0 : lp->ncols - 1;
vsp = NRAND(lp->nrows / 2) + lp->nrows / 4;
coord = 1;
} else {
vsp = (LRAND() & 1) ? 0 : lp->nrows - 1;
hsp = NRAND(lp->ncols / 2) + lp->ncols / 4;
coord = 0;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2)
hoff = -1;
if (coord == 1) {
SetList(hsp + (SS + 4) * hoff, vsp + 0 * voff);
SetList(hsp + (SS + 3) * hoff, vsp + 0 * voff);
SetList(hsp + (SS + 2) * hoff, vsp + 0 * voff);
SetList(hsp + (SS + 1) * hoff, vsp + 0 * voff);
if (SS == 2)
SetList(hsp + 2 * hoff, vsp + 0 * voff);
if (SS != 0)
SetList(hsp + 1 * hoff, vsp + 0 * voff);
SetList(hsp + (SS + 4) * hoff, vsp + 1 * voff);
SetList(hsp + 0 * hoff, vsp + 1 * voff);
SetList(hsp + (SS + 4) * hoff, vsp + 2 * voff);
SetList(hsp + (SS + 3) * hoff, vsp + 3 * voff);
} else {
SetList(hsp + 0 * hoff, vsp + (SS + 4) * voff);
SetList(hsp + 0 * hoff, vsp + (SS + 3) * voff);
SetList(hsp + 0 * hoff, vsp + (SS + 2) * voff);
SetList(hsp + 0 * hoff, vsp + (SS + 1) * voff);
if (SS == 2)
SetList(hsp + 0 * hoff, vsp + 2 * voff);
if (SS != 0)
SetList(hsp + 0 * hoff, vsp + 1 * voff);
SetList(hsp + 1 * hoff, vsp + (SS + 4) * voff);
SetList(hsp + 1 * hoff, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + (SS + 4) * voff);
SetList(hsp + 3 * hoff, vsp + (SS + 3) * voff);
}
}
} else if (lp->neighbors == 8 && lp->patterned_rule == LIFE_8S34678B3678) {
/* Generate a butterfly */
if (LRAND() & 1) {
hsp = (LRAND() & 1) ? 0 : lp->ncols - 1;
vsp = NRAND(lp->nrows);
} else {
vsp = (LRAND() & 1) ? 0 : lp->nrows - 1;
hsp = NRAND(lp->ncols);
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2)
hoff = -1;
SetList(hsp + 4 * hoff, vsp + 3 * voff);
SetList(hsp + 4 * hoff, vsp + 2 * voff);
SetList(hsp + 4 * hoff, vsp + 1 * voff);
SetList(hsp + 3 * hoff, vsp + 4 * voff);
SetList(hsp + 3 * hoff, vsp + 2 * voff);
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 3 * hoff, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + 4 * voff);
SetList(hsp + 2 * hoff, vsp + 3 * voff);
SetList(hsp + 1 * hoff, vsp + 4 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
SetList(hsp + 0 * hoff, vsp + 3 * voff);
} else if (lp->neighbors == 12 && lp->patterned_rule == LIFE_12S34B45) {
/* no diagonal, be careful parity matters */
if (LRAND() & 1) {
vsp = NRAND(lp->nrows);
if (LRAND() & 1) {
hsp = 0;
if ((hsp + vsp) % 2 == 0)
hsp--;
} else {
hsp = lp->ncols - 1;
if ((hsp + vsp) % 2 == 1)
hsp--;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2)
hoff = -1;
/* glider (p7, c/7) lower right */
SetList(hsp + 1 * hoff, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + 0 * voff);
SetList(hsp + 1 * hoff, vsp + 1 * voff);
SetList(hsp + 2 * hoff, vsp + 1 * voff);
SetList(hsp + 4 * hoff, vsp + 1 * voff);
SetList(hsp + 1 * hoff, vsp + 2 * voff);
SetList(hsp + 2 * hoff, vsp + 2 * voff);
SetList(hsp + 4 * hoff, vsp + 2 * voff);
SetList(hsp + 5 * hoff, vsp + 2 * voff);
SetList(hsp + 4 * hoff, vsp + 3 * voff);
SetList(hsp + 5 * hoff, vsp + 3 * voff);
SetList(hsp + 4 * hoff, vsp + 4 * voff);
SetList(hsp + 4 * hoff, vsp + 5 * voff);
} else {
hsp = NRAND(lp->ncols / 2) + lp->ncols / 4;
if (LRAND() & 1) {
vsp = 0;
} else {
vsp = lp->nrows - 1;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2) {
hoff = -1;
if ((hsp + vsp) % 2 == 0)
hsp--;
} else {
if ((hsp + vsp) % 2 == 1)
hsp--;
}
SetList(hsp + 0 * hoff, vsp + 0 * voff);
SetList(hsp + 1 * hoff, vsp + 0 * voff);
SetList(hsp + 0 * hoff, vsp + 1 * voff);
SetList(hsp + 1 * hoff, vsp + 1 * voff);
SetList(hsp + 0 * hoff, vsp + 2 * voff);
SetList(hsp + 1 * hoff, vsp + 2 * voff);
SetList(hsp + 1 * hoff, vsp + 5 * voff);
SetList(hsp + 2 * hoff, vsp + 5 * voff);
SetList(hsp + 0 * hoff, vsp + 6 * voff);
SetList(hsp + 1 * hoff, vsp + 6 * voff);
SetList(hsp + 0 * hoff, vsp + 7 * voff);
SetList(hsp + 1 * hoff, vsp + 7 * voff);
SetList(hsp + 2 * hoff, vsp + 7 * voff);
}
} else if (lp->neighbors == 12 && lp->patterned_rule == LIFE_12S45B456) {
if (LRAND() & 1) {
vsp = NRAND(lp->nrows);
if (LRAND() & 1) {
hsp = 0;
if ((hsp + vsp) % 2 == 1)
hsp++;
} else {
hsp = lp->ncols - 1;
if ((hsp + vsp) % 2 == 0)
hsp--;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2)
hoff = -1;
SetList(hsp + 1 * hoff, vsp + 1 * voff);
SetList(hsp + 1 * hoff, vsp + 2 * voff);
SetList(hsp + 0 * hoff, vsp + 3 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
SetList(hsp + 0 * hoff, vsp + 4 * voff);
SetList(hsp + 1 * hoff, vsp + 4 * voff);
SetList(hsp + 2 * hoff, vsp + 4 * voff);
SetList(hsp + 1 * hoff, vsp + 5 * voff);
SetList(hsp + 2 * hoff, vsp + 5 * voff);
} else {
/* glider (c/4, p8) flutters down */
hsp = NRAND(lp->ncols / 2) + lp->ncols / 4;
if (LRAND() & 1) {
vsp = 0;
} else {
vsp = lp->nrows - 1;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2) {
hoff = -1;
if ((hsp + vsp) % 2 == 1)
hsp--;
} else {
if ((hsp + vsp) % 2 == 0)
hsp--;
}
SetList(hsp + 0 * hoff, vsp + 1 * voff);
SetList(hsp + 0 * hoff, vsp + 2 * voff);
SetList(hsp + 1 * hoff, vsp + 2 * voff);
SetList(hsp + 2 * hoff, vsp + 2 * voff);
SetList(hsp + 0 * hoff, vsp + 3 * voff);
SetList(hsp + 1 * hoff, vsp + 3 * voff);
SetList(hsp + 0 * hoff, vsp + 4 * voff);
SetList(hsp + 0 * hoff, vsp + 5 * voff);
SetList(hsp + 1 * hoff, vsp + 5 * voff);
}
} else if (lp->neighbors == 12 && lp->patterned_rule == LIFE_12S23B45) {
if (LRAND() & 1) {
vsp = NRAND(lp->nrows);
if (LRAND() & 1) {
hsp = 0;
if ((hsp + vsp) % 2 == 1)
hsp++;
} else {
hsp = lp->ncols - 1;
if ((hsp + vsp) % 2 == 0)
hsp--;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2)
hoff = -1;
SetList(hsp + 0 * hoff, vsp + 0 * voff);
SetList(hsp + 0 * hoff, vsp + 1 * voff);
SetList(hsp + 3 * hoff, vsp + 1 * voff);
SetList(hsp + 2 * hoff, vsp + 2 * voff);
SetList(hsp + 3 * hoff, vsp + 2 * voff);
SetList(hsp + 2 * hoff, vsp + 3 * voff);
SetList(hsp + 3 * hoff, vsp + 3 * voff);
SetList(hsp + 2 * hoff, vsp + 4 * voff);
SetList(hsp + 3 * hoff, vsp + 4 * voff);
SetList(hsp + 2 * hoff, vsp + 5 * voff);
} else {
/* glider (c/4, p8) flutters down */
hsp = NRAND(lp->ncols / 2) + lp->ncols / 4;
if (LRAND() & 1) {
vsp = 0;
} else {
vsp = lp->nrows - 1;
}
if (vsp > lp->nrows / 2)
voff = -1;
if (hsp > lp->ncols / 2) {
hoff = -1;
if ((hsp + vsp) % 2 == 1)
hsp--;
} else {
if ((hsp + vsp) % 2 == 0)
hsp--;
}
SetList(hsp + 1 * hoff, vsp + 0 * voff);
SetList(hsp + 2 * hoff, vsp + 0 * voff);
SetList(hsp + 1 * hoff, vsp + 4 * voff);
SetList(hsp + 2 * hoff, vsp + 4 * voff);
SetList(hsp + 0 * hoff, vsp + 5 * voff);
SetList(hsp + 1 * hoff, vsp + 5 * voff);
SetList(hsp + 2 * hoff, vsp + 5 * voff);
SetList(hsp + 3 * hoff, vsp + 5 * voff);
SetList(hsp + 1 * hoff, vsp + 6 * voff);
SetList(hsp + 2 * hoff, vsp + 6 * voff);
}
}
}
static Bool
init_stuff(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
lifestruct *lp = &lifes[MI_SCREEN(mi)];
if (lp->logo == NULL) {
getImage(mi, &lp->logo, CELL_WIDTH, CELL_HEIGHT, CELL_BITS,
#ifdef HAVE_XPM
DEFAULT_XPM, CELL_NAME,
#endif
&lp->graphics_format, &lp->cmap, &lp->black);
if (lp->logo == NULL) {
free_life(display, lp);
return False;
}
#ifdef XBM_GRELB
if (lp->cmap == None && lp->graphics_format == IS_XBM) {
/* probably do not need the first but I am cautious... */
if (!bimage.data) { /* Only need to do this once */
bimage.data = (char *) CELL2_BITS;
bimage.width = CELL2_WIDTH;
bimage.height = CELL2_HEIGHT;
bimage.bytes_per_line = (CELL2_WIDTH + 7) / 8;
}
lp->logo2 = &bimage;
}
#endif
}
#ifndef STANDALONE
if (lp->cmap != None) {
setColormap(display, window, lp->cmap, MI_IS_INWINDOW(mi));
if (lp->backGC == None) {
XGCValues xgcv;
xgcv.background = lp->black;
xgcv.foreground = lp->black;
if ((lp->backGC = XCreateGC(display, window,
GCForeground | GCBackground,
&xgcv)) == None) {
free_life(display, lp);
return False;
}
}
} else
#endif /* STANDALONE */
{
lp->black = MI_BLACK_PIXEL(mi);
lp->backGC = MI_GC(mi);
}
return True;
}
void
init_life(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
int size = MI_SIZE(mi), npats, i;
lifestruct *lp;
if (lifes == NULL) {
if ((lifes = (lifestruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (lifestruct))) == NULL)
return;
}
lp = &lifes[MI_SCREEN(mi)];
lp->generation = 0;
lp->redrawing = 0;
if (MI_IS_FULLRANDOM(mi)) {
int r6n1 = patterns_6rules[0] + patterns_6rules[1];
int r8n1 = patterns_8rules[0] + patterns_8rules[1];
int r8n2 = r8n1 + patterns_8rules[2];
int r12n1 = patterns_12rules[0] + patterns_12rules[1];
int r12n2 = r12n1 + patterns_12rules[2];
#if 1
lp->neighbors = (NRAND(r8n2 + r6n1 + r12n2) < r8n2) ? 8 :
(NRAND(r6n1 + r12n2) < r6n1) ? 6 : 12;
#else
lp->neighbors = 8;
#endif
if (lp->neighbors == 8) {
int n = NRAND(r8n2);
lp->conway = (n < patterns_8rules[0]);
lp->highlife = (n >= patterns_8rules[0] && n < r8n1);
lp->daynight = (n >= r8n1);
} else {
lp->conway = lp->highlife = lp->daynight = False;
}
if (lp->neighbors == 6) {
lp->callahan = (NRAND(r6n1) < patterns_6rules[0]);
lp->andreen = !lp->callahan;
} else {
lp->andreen = lp->callahan = False;
}
if (lp->neighbors == 12) {
int n = NRAND(r12n2);
lp->trilife = (n < patterns_12rules[0]);
lp->trilife1 = (n >= patterns_12rules[0] && n < r12n1);
lp->trilife2 = (n >= r12n1);
} else {
lp->trilife = lp->trilife1 = lp->trilife2 = False;
}
} else {
lp->conway = conway;
lp->highlife = highlife;
lp->daynight = daynight;
lp->callahan = callahan;
lp->andreen = andreen;
lp->trilife = trilife;
lp->trilife1 = trilife1;
lp->trilife2 = trilife2;
}
if (!lp->neighbors) {
for (i = 0; i < NEIGHBORKINDS; i++) {
if (neighbors == plots[i]) {
lp->neighbors = neighbors;
break;
}
if (i == NEIGHBORKINDS - 1) {
#if 0
lp->neighbors = plots[NRAND(NEIGHBORKINDS)];
lp->neighbors = (LRAND() & 1) ? 4 : 8;
#else
lp->neighbors = 8;
#endif
break;
}
}
}
lp->labelOffsetX = NRAND(8);
lp->labelOffsetY = NRAND(8);
parseRule(mi, lp->ruleString);
parseFile(mi);
if (lp->allPatterns) {
switch (lp->neighbors) {
case 6:
lp->patterned_rule = NRAND(LIFE_6RULES);
break;
case 8:
lp->patterned_rule = NRAND(LIFE_8RULES);
break;
case 12:
lp->patterned_rule = NRAND(LIFE_12RULES);
break;
}
copyFromPatternedRule(lp->neighbors, &lp->param, lp->patterned_rule);
printRule(lp->neighbors, lp->ruleString, lp->param,
MI_IS_VERBOSE(mi));
} else if (lp->allGliders) {
switch (lp->neighbors) {
case 6:
lp->patterned_rule = NRAND(LIFE_6GLIDERS);
break;
case 8:
lp->patterned_rule = NRAND(LIFE_8GLIDERS);
break;
case 12:
lp->patterned_rule = NRAND(LIFE_12GLIDERS);
break;
}
copyFromPatternedRule(lp->neighbors, &lp->param, lp->patterned_rule);
printRule(lp->neighbors, lp->ruleString, lp->param,
MI_IS_VERBOSE(mi));
} else {
lp->param.survival = lp->input_param.survival;
lp->param.birth = lp->input_param.birth;
for (i = 0; i < maxgroups[invplot(lp->neighbors)]; i++) {
lp->param.survival_group[i] = lp->input_param.survival_group[i];
lp->param.birth_group[i] = lp->input_param.birth_group[i];
}
lp->patterned_rule = codeToPatternedRule(lp->neighbors, lp->param);
printRule(lp->neighbors, lp->ruleString, lp->param,
MI_IS_VERBOSE(mi));
}
lp->width = MI_WIDTH(mi);
lp->height = MI_HEIGHT(mi);
if (lp->first[0]) {
for (i = 0; i < STATES; i++)
flush_list(lp, i);
} else {
for (i = 0; i < STATES; i++)
if (!init_list(lp, i)) {
free_life(display, lp);
return;
}
}
free_cells(lp);
free_stuff(display, lp);
if (lp->neighbors == 6) {
int nccols, ncrows, sides;
if (lp->width < 2)
lp->width = 2;
if (lp->height < 4)
lp->height = 4;
if (size < -MINSIZE)
lp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size) {
int min = MIN(lp->width, lp->height) / (4 * MINGRIDSIZE);
int max = MIN(lp->width, lp->height) / (2 * MINGRIDSIZE);
lp->ys = MAX(MINSIZE, min + NRAND(max - min + 1));
} else
lp->ys = MINSIZE;
} else
lp->ys = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE));
lp->xs = lp->ys;
nccols = MAX(lp->width / lp->xs - 2, 2);
ncrows = MAX(lp->height / lp->ys - 1, 2);
lp->ncols = nccols / 2;
lp->nrows = 2 * (ncrows / 4);
lp->xb = (lp->width - lp->xs * nccols) / 2 + lp->xs / 2;
lp->yb = (lp->height - lp->ys * (ncrows / 2) * 2) / 2 + lp->ys - 2;
for (sides = 0; sides < 6; sides++) {
lp->shape.hexagon[sides].x = (lp->xs - 1) * hexagonUnit[sides].x;
lp->shape.hexagon[sides].y =
((lp->ys - 1) * hexagonUnit[sides].y / 2) * 4 / 3;
}
lp->black = MI_BLACK_PIXEL(mi);
lp->backGC = MI_GC(mi);
} else if (lp->neighbors == 4 || lp->neighbors == 8) {
if (!init_stuff(mi))
return;
if (lp->width < 2)
lp->width = 2;
if (lp->height < 2)
lp->height = 2;
#if 0
if (size == 0 && !MI_IS_ICONIC(mi)) {
lp->pixelmode = False;
lp->xs = lp->logo->width;
lp->ys = lp->logo->height;
}
#else
if (size == 0 ||
MINGRIDSIZE * size > lp->width || MINGRIDSIZE * size > lp->height) {
if (lp->width > MINGRIDSIZE * lp->logo->width &&
lp->height > MINGRIDSIZE * lp->logo->height) {
lp->pixelmode = False;
lp->xs = lp->logo->width;
lp->ys = lp->logo->height;
} else
{
int min = MIN(lp->width, lp->height) / (8 * MINGRIDSIZE);
int max = MIN(lp->width, lp->height) / (2 * MINGRIDSIZE);
lp->xs = lp->ys = MAX(MINSIZE, min + NRAND(max - min + 1));
lp->pixelmode = True;
}
}
else
#endif
{
lp->pixelmode = True;
if (size < -MINSIZE)
lp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
lp->ys = MINSIZE;
else
lp->ys = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE));
lp->xs = lp->ys;
}
lp->ncols = MAX(lp->width / lp->xs, 4);
lp->nrows = MAX(lp->height / lp->ys, 4);
lp->xb = (lp->width - lp->xs * lp->ncols) / 2;
lp->yb = (lp->height - lp->ys * lp->nrows) / 2;
} else { /* TRI */
int orient, sides;
lp->black = MI_BLACK_PIXEL(mi);
lp->backGC = MI_GC(mi);
if (lp->width < 2)
lp->width = 2;
if (lp->height < 2)
lp->height = 2;
if (size < -MINSIZE)
lp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size) {
int min = MIN(lp->width, lp->height) / (4 * MINGRIDSIZE);
int max = MIN(lp->width, lp->height) / (MINGRIDSIZE);
lp->xs = lp->ys = MAX(MINSIZE, min + NRAND(max - min + 1));
} else
lp->ys = MINSIZE;
} else
lp->ys = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) /
MINGRIDSIZE));
lp->xs = (int) (1.52 * lp->ys);
lp->ncols = (MAX(lp->width / lp->xs - 1, 2) / 2) * 2;
lp->nrows = (MAX(lp->height / lp->ys - 1, 2) / 2) * 2;
lp->xb = (lp->width - lp->xs * lp->ncols) / 2 + lp->xs / 2;
lp->yb = (lp->height - lp->ys * lp->nrows) / 2 + lp->ys / 2;
for (orient = 0; orient < 2; orient++) {
for (sides = 0; sides < 3; sides++) {
lp->shape.triangle[orient][sides].x =
(lp->xs - 2) * triangleUnit[orient][sides].x;
lp->shape.triangle[orient][sides].y =
(lp->ys - 2) * triangleUnit[orient][sides].y;
}
}
}
lp->npositions = lp->nrows * lp->ncols;
MI_CLEARWINDOWCOLORMAP(mi, lp->backGC, lp->black);
lp->painted = False;
if ((lp->arr = (CellList **) calloc(lp->npositions,
sizeof (CellList *))) == NULL) {
free_life(display, lp);
return;
}
lp->patterned_rule = codeToPatternedRule(lp->neighbors, lp->param);
npats = 0;
switch (lp->neighbors) {
case 6:
if ((unsigned) lp->patterned_rule < LIFE_6RULES)
npats = patterns_6rules[lp->patterned_rule];
break;
case 8:
if ((unsigned) lp->patterned_rule < LIFE_8RULES)
npats = patterns_8rules[lp->patterned_rule];
break;
case 12:
if ((unsigned) lp->patterned_rule < LIFE_12RULES)
npats = patterns_12rules[lp->patterned_rule];
break;
}
lp->pattern = NRAND(npats + 2);
if (lp->pattern >= npats && !filePattern)
RandomSoup(mi, 30, MAX(2 * MIN(lp->nrows, lp->ncols) / 3, 15));
else
GetPattern(mi, lp->patterned_rule, lp->pattern);
}
void
draw_life(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GC gc = MI_GC(mi);
CellList *middle[STATES]; /* To distinguish between old and new stuff */
CellList *curr;
cellstruct info;
int i, count, gcount, neighbor_kind;
Bool visible = False;
lifestruct *lp;
if (lifes == NULL)
return;
lp = &lifes[MI_SCREEN(mi)];
/*-
* LIVE list are the on cells
* DEAD list are the cells that may go on in the next iteration.
* Init plan:
Create live list and dead list which border all live cells
(no good for rules like 0000 :) )
* Big loop plan:
Setup toggles, toggle state next iteration?
Remove all from dead list except toggled and remove all from live list
that are dead (but in this case draw background square)
Toggle toggled states, age existing ones, create a new dead list, draw
*/
/* Go through dead list to see if anything spawns (generate new lists),
then delete the used dead list */
MI_IS_DRAWN(mi) = True;
/* Setup toggles */
curr = lp->first[DEAD]->next;
while (curr != lp->last[DEAD]) {
count = ng_neighbors(lp, curr, &gcount);
if ((lp->param.birth & (1 << count)) || (count >= FIRSTGROUP &&
count < FIRSTGROUP + maxgroups[invplot(lp->neighbors)] &&
(lp->param.birth_group[count - FIRSTGROUP] &
(1 << style6[gcount])))) {
setcelltoggles(mi, (int) (curr->info.position % lp->ncols),
(int) (curr->info.position / lp->ncols));
visible = True;
}
curr = curr->next;
}
curr = lp->first[LIVE]->next;
neighbor_kind = invplot(lp->neighbors);
while (curr != lp->last[LIVE]) {
count = ng_neighbors(lp, curr, &gcount);
if (!((lp->param.survival & (1 << count)) || (count >= FIRSTGROUP &&
count < FIRSTGROUP + maxgroups[neighbor_kind] &&
(lp->param.survival_group[count - FIRSTGROUP] &
(1 << style6[gcount]))))) {
setcelltoggles(mi, (int) (curr->info.position % lp->ncols),
(int) (curr->info.position / lp->ncols));
visible = True;
}
curr = curr->next;
}
/* Bring out your dead! */
curr = lp->first[DEAD]->next;
while (curr != lp->last[DEAD]) {
curr = curr->next;
if (!curr->previous->info.toggle)
removefrom_list(lp, DEAD, curr->previous);
}
curr = lp->first[LIVE]->next;
while (curr != lp->last[LIVE]) {
if (curr->info.toggle) {
curr->info.state = DEAD;
draw_cell(mi, curr->info);
curr = curr->next;
removefrom_list(lp, LIVE, curr->previous);
} else
curr = curr->next;
}
/* Fence off the babies */
info.position = -1; /* dummy value */
info.age = 0; /* dummy value */
info.state = 0; /* dummy value */
info.toggle = 0; /* dummy value */
if (!addto_list(lp, DEAD, info)) {
free_life(MI_DISPLAY(mi), lp);
return;
}
if (!addto_list(lp, LIVE, info)) {
free_life(MI_DISPLAY(mi), lp);
return;
}
middle[DEAD] = lp->last[DEAD]->previous;
middle[LIVE] = lp->last[LIVE]->previous;
/* Toggle toggled states, age existing ones, create a new dead list */
while (lp->first[DEAD]->next != middle[DEAD]) {
curr = lp->first[DEAD]->next;
if (!setcellfromtoggle(mi, (int) (curr->info.position % lp->ncols),
(int) (curr->info.position / lp->ncols)))
return;
}
curr = lp->first[LIVE]->next;
while (curr != middle[LIVE]) {
if (!setcellfromtoggle(mi, (int) (curr->info.position % lp->ncols),
(int) (curr->info.position / lp->ncols)))
return;
curr = curr->next;
}
removefrom_list(lp, DEAD, middle[DEAD]);
removefrom_list(lp, LIVE, middle[LIVE]);
if (lp->redrawing) {
for (i = 0; i < REDRAWSTEP; i++) {
CellList *redraw_curr = lp->arr[lp->redrawpos];
/* TODO: More efficient to use list rather than array. */
if (redraw_curr && redraw_curr->info.state == LIVE) {
draw_cell(mi, redraw_curr->info);
}
if (++(lp->redrawpos) >= lp->npositions) {
lp->redrawing = 0;
break;
}
}
}
if (visible)
lp->noChangeCount = 0;
else
lp->noChangeCount++;
if (++lp->generation > MI_CYCLES(mi) || lp->noChangeCount >= 8)
init_life(mi);
else
lp->painted = True;
/*
* generate a randomized shooter aimed roughly toward the center of the
* screen after batchcount.
*/
if (MI_COUNT(mi)) {
if (lp->generation && lp->generation %
((MI_COUNT(mi) < 0) ? 1 : MI_COUNT(mi)) == 0)
shooter(mi);
}
if (label) {
int size = MAX(MIN(MI_WIDTH(mi), MI_HEIGHT(mi)) - 1, 1);
if (size >= 10 * FONT_WIDTH) {
/* hard code these to corners */
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
XDrawString(display, window, gc,
16 + lp->labelOffsetX,
16 + lp->labelOffsetY + FONT_HEIGHT,
lp->ruleString, strlen(lp->ruleString));
XDrawString(display, window, gc,
16 + lp->labelOffsetX, MI_HEIGHT(mi) - 16 -
lp->labelOffsetY - FONT_HEIGHT / 2,
lp->nameString, strlen(lp->nameString));
}
}
}
void
release_life(ModeInfo * mi)
{
if (lifes != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
free_life(MI_DISPLAY(mi), &lifes[screen]);
free(lifes);
lifes = (lifestruct *) NULL;
}
}
void
refresh_life(ModeInfo * mi)
{
lifestruct *lp;
if (lifes == NULL)
return;
lp = &lifes[MI_SCREEN(mi)];
#ifdef HAVE_XPM
if (lp->graphics_format >= IS_XPM) {
/* This is needed when another program changes the colormap. */
free_life(MI_DISPLAY(mi), lp);
init_life(mi);
return;
}
#endif
if (lp->painted) {
MI_CLEARWINDOWCOLORMAP(mi, lp->backGC, lp->black);
lp->redrawing = 1;
lp->redrawpos = 0;
lp->painted = False;
}
}
void
change_life(ModeInfo * mi)
{
int npats, i;
lifestruct *lp;
if (lifes == NULL)
return;
lp = &lifes[MI_SCREEN(mi)];
lp->generation = 0;
if (lp->first[0]) {
for (i = 0; i < STATES; i++)
flush_list(lp, i);
} else {
for (i = 0; i < STATES; i++)
if (!init_list(lp, i)) {
free_life(MI_DISPLAY(mi), lp);
return;
}
}
free_cells(lp);
if ((lp->arr = (CellList **) calloc(lp->npositions,
sizeof (CellList *))) == NULL) {
free_life(MI_DISPLAY(mi), lp);
return;
}
MI_CLEARWINDOWCOLORMAP(mi, lp->backGC, lp->black);
lp->pattern++;
lp->patterned_rule = codeToPatternedRule(lp->neighbors, lp->param);
npats = 0;
switch (lp->neighbors) {
case 6:
if ((unsigned) lp->patterned_rule < LIFE_6RULES)
npats = patterns_6rules[lp->patterned_rule];
break;
case 8:
if ((unsigned) lp->patterned_rule < LIFE_8RULES)
npats = patterns_8rules[lp->patterned_rule];
break;
case 12:
if ((unsigned) lp->patterned_rule < LIFE_12RULES)
npats = patterns_12rules[lp->patterned_rule];
break;
}
if (lp->pattern >= npats + 2) {
lp->pattern = 0;
if (lp->allPatterns) {
lp->patterned_rule++;
switch (lp->neighbors) {
case 6:
if ((unsigned) lp->patterned_rule >= LIFE_6RULES)
lp->patterned_rule = 0;
break;
case 8:
if ((unsigned) lp->patterned_rule >= LIFE_8RULES)
lp->patterned_rule = 0;
break;
case 12:
if ((unsigned) lp->patterned_rule >= LIFE_12RULES)
lp->patterned_rule = 0;
break;
}
copyFromPatternedRule(lp->neighbors, &lp->param,
lp->patterned_rule);
printRule(lp->neighbors, lp->ruleString, lp->param,
MI_IS_VERBOSE(mi));
} else if (lp->allGliders) {
lp->patterned_rule++;
switch (lp->neighbors) {
case 6:
if ((unsigned) lp->patterned_rule >= LIFE_6GLIDERS)
lp->patterned_rule = 0;
break;
case 8:
if ((unsigned) lp->patterned_rule >= LIFE_8GLIDERS)
lp->patterned_rule = 0;
break;
case 12:
if ((unsigned) lp->patterned_rule >= LIFE_12GLIDERS)
lp->patterned_rule = 0;
break;
}
copyFromPatternedRule(lp->neighbors, &lp->param, lp->patterned_rule);
printRule(lp->neighbors, lp->ruleString, lp->param,
MI_IS_VERBOSE(mi));
}
}
if (!serial)
lp->pattern = NRAND(npats + 2);
if (lp->pattern >= npats)
RandomSoup(mi, 30, MAX(2 * MIN(lp->nrows, lp->ncols) / 3, 15));
else
GetPattern(mi, lp->patterned_rule, lp->pattern);
}
#endif /* MODE_life */
Reference in New Issue View Git Blame Copy Permalink