ENTRYPOINT void
init_demon (ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
int size = MI_SIZE(mi), nk;
demonstruct *dp;
if (demons == NULL) {
if ((demons = (demonstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (demonstruct))) == NULL)
return;
}
dp = &demons[MI_SCREEN(mi)];
dp->generation = 0;
dp->redrawing = 0;
#ifdef DO_STIPPLE
if (MI_NPIXELS(mi) < NUMSTIPPLES) {
Window window = MI_WINDOW(mi);
if (dp->stippledGC == None) {
XGCValues gcv;
gcv.fill_style = FillOpaqueStippled;
if ((dp->stippledGC = XCreateGC(display, window,
GCFillStyle, &gcv)) == None) {
free_demon(display, dp);
return;
}
}
if (dp->init_bits == 0) {
int i;
for (i = 1; i < NUMSTIPPLES; i++) {
DEMONBITS(stipples[i], STIPPLESIZE, STIPPLESIZE);
}
}
}
#endif /* DO_STIPPLE */
free_struct(dp);
for (nk = 0; nk < NEIGHBORKINDS; nk++) {
if (neighbors == plots[0][nk]) {
dp->neighbors = plots[0][nk];
break;
}
if (nk == NEIGHBORKINDS - 1) {
nk = NRAND(NEIGHBORKINDS);
dp->neighbors = plots[0][nk];
break;
}
}
dp->states = MI_COUNT(mi);
if (dp->states < -MINSTATES)
dp->states = NRAND(-dp->states - MINSTATES + 1) + MINSTATES;
else if (dp->states < MINSTATES)
dp->states = plots[1][nk];
if ((dp->cellList = (CellList **) calloc(dp->states,
sizeof (CellList *))) == NULL) {
free_demon(display, dp);
return;
}
if ((dp->ncells = (int *) calloc(dp->states, sizeof (int))) == NULL) {
free_demon(display, dp);
return;
}
dp->state = 0;
dp->width = MI_WIDTH(mi);
dp->height = MI_HEIGHT(mi);
if (dp->neighbors == 6) {
int nccols, ncrows, i;
if (dp->width < 8)
dp->width = 8;
if (dp->height < 8)
dp->height = 8;
if (size < -MINSIZE)
dp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
dp->ys = MAX(MINSIZE, MIN(dp->width, dp->height) / MINGRIDSIZE);
else
dp->ys = MINSIZE;
} else
dp->ys = MIN(size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE));
dp->xs = dp->ys;
nccols = MAX(dp->width / dp->xs - 2, 2);
ncrows = MAX(dp->height / dp->ys - 1, 4);
dp->ncols = nccols / 2;
dp->nrows = 2 * (ncrows / 4);
dp->xb = (dp->width - dp->xs * nccols) / 2 + dp->xs / 2;
dp->yb = (dp->height - dp->ys * (ncrows / 2) * 2) / 2 + dp->ys - 2;
for (i = 0; i < 6; i++) {
dp->shape.hexagon[i].x = (dp->xs - 1) * hexagonUnit[i].x;
dp->shape.hexagon[i].y = ((dp->ys - 1) * hexagonUnit[i].y / 2) * 4 / 3;
}
} else if (dp->neighbors == 4 || dp->neighbors == 8) {
if (size < -MINSIZE)
dp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
dp->ys = MAX(MINSIZE, MIN(dp->width, dp->height) / MINGRIDSIZE);
else
dp->ys = MINSIZE;
} else
dp->ys = MIN(size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE));
dp->xs = dp->ys;
dp->ncols = MAX(dp->width / dp->xs, 2);
dp->nrows = MAX(dp->height / dp->ys, 2);
dp->xb = (dp->width - dp->xs * dp->ncols) / 2;
dp->yb = (dp->height - dp->ys * dp->nrows) / 2;
} else { /* TRI */
int orient, i;
if (dp->width < 2)
dp->width = 2;
if (dp->height < 2)
dp->height = 2;
if (size < -MINSIZE)
dp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
dp->ys = MAX(MINSIZE, MIN(dp->width, dp->height) / MINGRIDSIZE);
else
dp->ys = MINSIZE;
} else
dp->ys = MIN(size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE));
dp->xs = (int) (1.52 * dp->ys);
dp->ncols = (MAX(dp->width / dp->xs - 1, 2) / 2) * 2;
dp->nrows = (MAX(dp->height / dp->ys - 1, 2) / 2) * 2;
dp->xb = (dp->width - dp->xs * dp->ncols) / 2 + dp->xs / 2;
dp->yb = (dp->height - dp->ys * dp->nrows) / 2 + dp->ys / 2;
for (orient = 0; orient < 2; orient++) {
for (i = 0; i < 3; i++) {
dp->shape.triangle[orient][i].x =
(dp->xs - 2) * triangleUnit[orient][i].x;
dp->shape.triangle[orient][i].y =
(dp->ys - 2) * triangleUnit[orient][i].y;
}
}
}
MI_CLEARWINDOW(mi);
if ((dp->oldcell = (unsigned char *)
malloc(dp->ncols * dp->nrows * sizeof (unsigned char))) == NULL) {
free_demon(display, dp);
return;
}
if ((dp->newcell = (unsigned char *)
malloc(dp->ncols * dp->nrows * sizeof (unsigned char))) == NULL) {
free_demon(display, dp);
return;
}
RandomSoup(mi);
}
void
init_life1d(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int size = MI_SIZE(mi);
int i;
life1dstruct *lp;
if (life1ds == NULL) {
if ((life1ds = (life1dstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (life1dstruct))) == NULL)
return;
}
lp = &life1ds[MI_SCREEN(mi)];
if (!init_stuff(mi)) {
free_life1d(display, lp);
return;
}
lp->screen_generation = 0;
lp->row = 0;
if (totalistic) {
maxstates = MAXSTATES;
maxradius = 4;
maxsum_size = (maxstates - 1) * (maxradius * 2 + 1) + 1;
} else {
maxstates = MAXSTATES - 1;
maxradius = 1;
maxsum_size = (int) power(maxstates, (2 * maxradius + 1));
}
if (lp->nextstate == NULL) {
if ((lp->nextstate = (char *) malloc(maxsum_size *
sizeof (char))) == NULL) {
free_life1d(display, lp);
return;
}
}
if (lp->init_bits == 0) {
XGCValues gcv;
gcv.fill_style = FillOpaqueStippled;
if ((lp->stippledGC = XCreateGC(display, window, GCFillStyle,
&gcv)) == None) {
free_life1d(display, lp);
return;
}
for (i = 0; i < MAXSTATES - 1; i++) {
LIFE1DBITS(stipples[i + NUMSTIPPLES - MAXSTATES + 1],
STIPPLESIZE, STIPPLESIZE);
}
LIFE1DBITS(stipples[NUMSTIPPLES / 2],
STIPPLESIZE, STIPPLESIZE); /* grey */
}
if (lp->newcells != NULL)
free(lp->newcells);
if (lp->oldcells != NULL)
free(lp->oldcells);
if (lp->buffer != NULL)
free(lp->buffer);
if (lp->previousBuffer != NULL)
free(lp->previousBuffer);
lp->previousBuffer = (unsigned char *) NULL;
lp->width = MI_WIDTH(mi);
lp->height = MI_HEIGHT(mi);
if (lp->width < 2)
lp->width = 2;
if (lp->height < 2)
lp->height = 2;
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) / (12 * MINGRIDSIZE);
int max = MIN(lp->width, lp->height) / (4 * MINGRIDSIZE);
lp->xs = lp->ys = MAX(MINSIZE, min + NRAND(max - min + 1));
lp->pixelmode = True;
}
} else {
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, 2);
lp->nrows = MAX(lp->height / lp->ys, 2);
lp->border = (lp->nrows / 2 + 1) * MI_CYCLES(mi);
if ((lp->newcells = (unsigned char *) calloc(lp->ncols + 2 * lp->border,
sizeof (unsigned char))) == NULL) {
free_life1d(display, lp);
return;
}
if ((lp->oldcells = (unsigned char *) calloc(lp->ncols + 2 *
(maxradius + lp->border),
sizeof (unsigned char))) == NULL) {
free_life1d(display, lp);
return;
}
if ((lp->buffer = (unsigned char *) calloc(lp->ncols * lp->nrows,
sizeof (unsigned char))) == NULL) {
free_life1d(display, lp);
return;
}
lp->xb = (lp->width - lp->xs * lp->ncols) / 2;
lp->yb = (lp->height - lp->ys * lp->nrows) / 2;
GetRule(lp, (int) NRAND((totalistic) ? TOTALISTICRULES : LCAURULES));
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stdout, "colors %d, radius %d, code %ld, ",
lp->k, lp->r, lp->code);
if (totalistic) {
(void) fprintf(stdout, "totalistic rule ");
for (i = (lp->k - 1) * (lp->r * 2 + 1); i >= 0; i--)
(void) fprintf(stdout, "%d", (int) lp->nextstate[i]);
} else {
(void) fprintf(stdout, "LCAU rule ");
for (i = (int) power(lp->k, (lp->r * 2 + 1)); i >= 0; i--)
(void) fprintf(stdout, "%d", (int) lp->nextstate[i]);
}
(void) fprintf(stdout, "\n");
}
if (MI_NPIXELS(mi) > 2) {
int offset = NRAND(MI_NPIXELS(mi));
for (i = 0; i < lp->k - 1; i++) {
lp->colors[i] = ((offset +
(i * MI_NPIXELS(mi) / (lp->k - 1))) %
MI_NPIXELS(mi));
}
}
RandomSoup(lp, 40, 25);
(void) memcpy((char *) (lp->oldcells + maxradius + lp->border),
(char *) (lp->newcells + lp->border), lp->ncols);
lp->busyLoop = 0;
MI_CLEARWINDOWCOLORMAP(mi, lp->backGC, lp->black);
}
