void
init_galaxy(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
unistruct *gp;
if (universes == NULL) {
if ((universes = (unistruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (unistruct))) == NULL)
return;
}
gp = &universes[MI_SCREEN(mi)];
gp->f_hititerations = MI_CYCLES(mi);
gp->clip.left = 0;
gp->clip.top = 0;
gp->clip.right = MI_WIDTH(mi);
gp->clip.bottom = MI_HEIGHT(mi);
gp->scale = (double) (gp->clip.right + gp->clip.bottom) / 8.0;
gp->midx = gp->clip.right / 2;
gp->midy = gp->clip.bottom / 2;
if (MI_IS_FULLRANDOM(mi)) {
gp->fisheye = !(NRAND(3));
if (!gp->fisheye)
gp->tracks = (Bool) (LRAND() & 1);
} else {
gp->fisheye = fisheye;
gp->tracks = tracks;
}
if (!startover(mi))
return;
if (gp->fisheye) {
if (gp->pixmap != None)
XFreePixmap(display, gp->pixmap);
if ((gp->pixmap = XCreatePixmap(display, MI_WINDOW(mi),
MI_WIDTH(mi), MI_HEIGHT(mi),
MI_DEPTH(mi))) == None) {
gp->fisheye = False;
}
}
if (gp->fisheye) {
XSetGraphicsExposures(display, MI_GC(mi), False);
gp->scale *= Z_OFFSET;
gp->star_scale_Z = (gp->scale * .005);
/* don't want any exposure events from XCopyPlane */
}
}
void
init_petal(ModeInfo * mi)
{
petalstruct *pp;
if (petals == NULL) {
if ((petals = (petalstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (petalstruct))) == NULL)
return;
}
pp = &petals[MI_SCREEN(mi)];
pp->lines = MI_COUNT(mi);
if (pp->lines > MAXLINES)
pp->lines = MAXLINES;
else if (pp->lines < -MINLINES) {
if (pp->points) {
free(pp->points);
pp->points = (XPoint *) NULL;
}
pp->lines = NRAND(-pp->lines - MINLINES + 1) + MINLINES;
} else if (pp->lines < MINLINES)
pp->lines = MINLINES;
if (!pp->points)
if ((pp->points = (XPoint *) malloc((pp->lines + 1) *
sizeof (XPoint))) == NULL) {
return;
}
pp->width = MI_WIDTH(mi);
pp->height = MI_HEIGHT(mi);
pp->time = 0;
if (MI_IS_FULLRANDOM(mi))
pp->wireframe = (Bool) (LRAND() & 1);
else
pp->wireframe = MI_IS_WIREFRAME(mi);
MI_CLEARWINDOW(mi);
pp->painted = False;
random_petal(mi);
}
void
init_toneclock(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i, size_hour, istart;
toneclockstruct *tclock;
/* initialize */
if (toneclocks == NULL) {
if ((toneclocks = (toneclockstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (toneclockstruct))) == NULL)
return;
}
tclock = &toneclocks[MI_SCREEN(mi)];
tclock->mi = mi;
if (tclock->gc == None) {
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XColor color;
#ifndef STANDALONE
tclock->fg = MI_FG_PIXEL(mi);
tclock->bg = MI_BG_PIXEL(mi);
#endif
tclock->blackpixel = MI_BLACK_PIXEL(mi);
tclock->whitepixel = MI_WHITE_PIXEL(mi);
if ((tclock->cmap = XCreateColormap(display, window,
MI_VISUAL(mi), AllocNone)) == None) {
free_toneclock(display, tclock);
return;
}
XSetWindowColormap(display, window, tclock->cmap);
(void) XParseColor(display, tclock->cmap, "black", &color);
(void) XAllocColor(display, tclock->cmap, &color);
MI_BLACK_PIXEL(mi) = color.pixel;
(void) XParseColor(display, tclock->cmap, "white", &color);
(void) XAllocColor(display, tclock->cmap, &color);
MI_WHITE_PIXEL(mi) = color.pixel;
#ifndef STANDALONE
(void) XParseColor(display, tclock->cmap, background, &color);
(void) XAllocColor(display, tclock->cmap, &color);
MI_BG_PIXEL(mi) = color.pixel;
(void) XParseColor(display, tclock->cmap, foreground, &color);
(void) XAllocColor(display, tclock->cmap, &color);
MI_FG_PIXEL(mi) = color.pixel;
#endif
tclock->colors = (XColor *) NULL;
tclock->ncolors = 0;
}
if ((tclock->gc = XCreateGC(display, MI_WINDOW(mi),
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_toneclock(display, tclock);
return;
}
}
/* Clear Display */
MI_CLEARWINDOW(mi);
tclock->painted = False;
XSetFunction(display, tclock->gc, GXxor);
/*Set up toneclock data */
if (MI_IS_FULLRANDOM(mi)) {
if (NRAND(10))
tclock->original = False;
else
tclock->original = True;
} else {
tclock->original = original;
}
tclock->direction = (LRAND() & 1) ? 1 : -1;
tclock->win_width = MI_WIDTH(mi);
tclock->win_height = MI_HEIGHT(mi);
if (tclock->hour != NULL)
free_hour(tclock);
if ( tclock->original )
{
tclock->num_hour = 12;
}
else
{
tclock->num_hour = MI_COUNT(mi);
}
tclock->x0 = tclock->win_width / 2;
tclock->y0 = tclock->win_height / 2;
if (tclock->num_hour == 0) {
tclock->num_hour = DEF_NUM_hour;
} else if (tclock->num_hour < 0) {
tclock->num_hour = NRAND(-tclock->num_hour) + 1;
}
if ( tclock->num_hour < 12 )
istart = NRAND( 12 - tclock->num_hour );
else
istart = 0;
if ((tclock->hour = (toneclockhour *) calloc(tclock->num_hour,
sizeof (toneclockhour))) == NULL) {
free_toneclock(display, tclock);
return;
}
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
/* Set up colour map */
if (tclock->colors != NULL) {
if (tclock->ncolors && !tclock->no_colors)
free_colors(display, tclock->cmap, tclock->colors, tclock->ncolors);
free(tclock->colors);
tclock->colors = (XColor *) NULL;
}
tclock->ncolors = MI_NCOLORS(mi);
if (tclock->ncolors < 2)
tclock->ncolors = 2;
if (tclock->ncolors <= 2)
tclock->mono_p = True;
else
tclock->mono_p = False;
if (tclock->mono_p)
tclock->colors = (XColor *) NULL;
else
if ((tclock->colors = (XColor *) malloc(sizeof (*tclock->colors) *
(tclock->ncolors + 1))) == NULL) {
free_toneclock(display, tclock);
return;
}
tclock->cycle_p = has_writable_cells(mi);
if (tclock->cycle_p) {
if (MI_IS_FULLRANDOM(mi)) {
if (!NRAND(8))
tclock->cycle_p = False;
else
tclock->cycle_p = True;
} else {
tclock->cycle_p = cycle_p;
}
}
if (!tclock->mono_p) {
if (!(LRAND() % 10))
make_random_colormap(
#ifdef STANDALONE
MI_DISPLAY(mi), MI_WINDOW(mi),
#else
mi,
#endif
tclock->cmap, tclock->colors, &tclock->ncolors,
True, True, &tclock->cycle_p);
else if (!(LRAND() % 2))
make_uniform_colormap(
#ifdef STANDALONE
MI_DISPLAY(mi), MI_WINDOW(mi),
#else
mi,
#endif
tclock->cmap, tclock->colors, &tclock->ncolors,
True, &tclock->cycle_p);
else
make_smooth_colormap(
#ifdef STANDALONE
MI_DISPLAY(mi), MI_WINDOW(mi),
#else
mi,
#endif
tclock->cmap, tclock->colors, &tclock->ncolors,
True, &tclock->cycle_p);
}
XInstallColormap(display, tclock->cmap);
if (tclock->ncolors < 2) {
tclock->ncolors = 2;
tclock->no_colors = True;
} else
tclock->no_colors = False;
if (tclock->ncolors <= 2)
tclock->mono_p = True;
if (tclock->mono_p)
tclock->cycle_p = False;
}
#ifndef NO_DBUF
if (tclock->dbuf != None)
XFreePixmap(display, tclock->dbuf);
tclock->dbuf = XCreatePixmap(display, window,
tclock->win_width,
tclock->win_height,
MI_DEPTH(mi));
/* Allocation checked */
if (tclock->dbuf != None) {
XGCValues gcv;
gcv.foreground = 0;
gcv.background = 0;
gcv.graphics_exposures = False;
gcv.function = GXcopy;
if (tclock->dbuf_gc != None)
XFreeGC(display, tclock->dbuf_gc);
if ((tclock->dbuf_gc = XCreateGC(display, (Drawable) tclock->dbuf,
GCForeground | GCBackground | GCGraphicsExposures | GCFunction,
&gcv)) == None) {
XFreePixmap(display, tclock->dbuf);
tclock->dbuf = None;
} else {
XFillRectangle(display, (Drawable) tclock->dbuf, tclock->dbuf_gc,
0, 0, tclock->win_width, tclock->win_height);
/*XSetBackground(display, MI_GC(mi), MI_BLACK_PIXEL(mi));
XSetFunction(display, MI_GC(mi), GXcopy);*/
}
}
#endif
tclock->angle = NRAND(360) * PI_RAD;
tclock->velocity = (NRAND(7) - 3) * PI_RAD;
size_hour = MIN( tclock->win_width , tclock->win_height) / 3;
tclock->pulsating = False;
tclock->moving = False;
tclock->anglex = 0.0;
tclock->angley = 0.0;
tclock->fill = 0;
tclock->radius = size_hour;
tclock->max_radius =0.0;
if ( ( !tclock->original && NRAND( 15 ) == 3 ) || tclock->num_hour > 12 )
tclock->randomhour = True;
else
tclock->randomhour = False;
if ( !tclock->original && tclock->win_width > 20 )
{
if ( abs( MI_SIZE(mi) ) > size_hour ) {
if ( MI_SIZE( mi ) < 0 )
{
size_hour = -size_hour;
}
}
else
{
size_hour = MI_SIZE(mi);
}
if ( size_hour < 0 )
{
tclock->radius = MIN(NRAND( size_hour - 10) + 10,
tclock->radius );
}
else
{
tclock->radius = MIN( size_hour , tclock->radius );
}
if ( MI_IS_FULLRANDOM( mi ) )
{
if ( NRAND(2) )
tclock->pulsating = True;
else
tclock->pulsating = False;
tclock->fill = NRAND( 101 );
}
else
{
tclock->pulsating = pulsating;
tclock->fill = fill;
}
}
tclock->phase = 0.0;
if ( tclock->pulsating )
tclock->ph_vel = (NRAND(7) - 3) * PI_RAD;
for (i = 0; i < tclock->num_hour; i++) {
toneclockhour *hour0;
hour0 = &tclock->hour[i];
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (tclock->ncolors > 2)
hour0->colour = NRAND(tclock->ncolors - 2) + 2;
else
hour0->colour = 1; /* Just in case */
XSetForeground(display, tclock->gc, tclock->colors[hour0->colour].pixel);
} else {
if (MI_NPIXELS(mi) > 2)
hour0->colour = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
else
hour0->colour = 1; /*Xor'red so WHITE may not be appropriate */
XSetForeground(display, tclock->gc, hour0->colour);
}
hour0->angle = NRAND(360) * PI_RAD;
hour0->velocity = (NRAND(7) - 3) * PI_RAD;
hour0->radius = tclock->radius / 5.0;
tclock->max_radius = MAX( tclock->max_radius , hour0->radius );
hour0->num_point = 12;
hour0->num_point1 = 16;
if ( tclock->randomhour )
{
int j;
hour0->point_numbers = tclock->hexadecimal_clock + i *
hour0->num_point1;
if ( NRAND( 14 ) == 4 )
{
for (j = 0; j < ( hour0->num_point1 / 4 ) - 1 ; j++)
{
hour0->point_numbers[ j * 4 ] = NRAND( 12 ) + 1;
hour0->point_numbers[ j * 4 + 1 ] = NRAND( 12 )
+ 1;
hour0->point_numbers[ j * 4 + 2 ] = NRAND( 12 )
+ 1;
hour0->point_numbers[ j * 4 + 3 ] = NRAND( 12 )
+ 1;
}
hour0->point_numbers[ hour0->num_point1 / 4 ] = 1;
hour0->point_numbers[ 1 + hour0->num_point1 / 4 ] =
1;
hour0->point_numbers[ 2 + hour0->num_point1 / 4 ] =
1;
hour0->point_numbers[ 3 + hour0->num_point1 / 4 ] =
1;
}
else
{
for (j = 0; j < hour0->num_point1 / 4 ; j++)
{
hour0->point_numbers[ j * 4 ] = NRAND( 12 ) + 1;
hour0->point_numbers[ j * 4 + 1 ] =
hour0->point_numbers[ j * 4 ];
hour0->point_numbers[ j * 4 + 2 ] = NRAND( 12 )
+ 1;
hour0->point_numbers[ j * 4 + 3 ] = NRAND( 12 )
+ 1;
}
}
}
else
hour0->point_numbers = original_clock[i+istart];
if ( NRAND( 100 ) >= tclock->fill )
hour0->draw = True;
else
hour0->draw = False;
#ifdef NO_DBUF
{
int x0 , y0;
x0 = (int) (tclock->radius * sin( -tclock->angle - PI_RAD * i *
360.0 / tclock->num_hour ) *
0.5 * ( 1 + cos( tclock->phase ) ) + tclock->x0 +
tclock->a_x * sin( tclock->anglex ) );
y0 = (int) (tclock->radius * cos( -tclock->angle - PI_RAD * i *
360.0 / tclock->num_hour ) *
0.5 * ( 1 + cos( tclock->phase ) ) + tclock->y0 +
tclock->a_y * sin( tclock->angley ) );
toneclock_drawhour(mi , hour0 , x0 , y0 );
}
#endif
}
tclock->a_x = 0;
tclock->a_y = 0;
if ( !tclock->original && tclock->win_width > 20 )
{
if ( tclock->radius < MIN( tclock->win_width , tclock->win_height) /
4 )
{
if ( MI_IS_FULLRANDOM( mi ) )
{
if ( NRAND(2) )
tclock->moving = True;
}
else
{
tclock->moving = move_clock;
}
if ( tclock->moving )
{
tclock->a_x = (int) floor( ( tclock->win_width / 2 ) - 1.05 *
( tclock->radius + tclock->max_radius )
);
tclock->a_y = (int) floor( ( tclock->win_height / 2 ) - 1.05 *
( tclock->radius + tclock->max_radius )
);
tclock->vx = (NRAND(15) - 7) * PI_RAD;
tclock->vy = (NRAND(15) - 7) * PI_RAD;
}
}
}
XFlush(display);
XSetFunction(display, tclock->gc, GXcopy);
}
void
init_mandelbrot(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
mandelstruct *mp;
if (mandels == NULL) {
if ((mandels = (mandelstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (mandelstruct))) == NULL)
return;
}
mp = &mandels[MI_SCREEN(mi)];
mp->mi = mi;
mp->screen_width = MI_WIDTH(mi);
mp->screen_height = MI_HEIGHT(mi);
mp->backwards = (Bool) (LRAND() & 1);
if (mp->backwards)
mp->column = mp->screen_width - 1;
else
mp->column = 0;
mp->power = NRAND(3) + MINPOWER;
mp->counter = 0;
MI_CLEARWINDOW(mi);
if (MI_IS_FULLRANDOM(mi)) {
mp->binary = (Bool) (LRAND() & 1);
mp->dem = (Bool) (LRAND() & 1);
mp->interior = NRAND(interior_size);
#if 0
/* too slow */
mp->pow = (NRAND(5) == 0);
mp->sin = (NRAND(5) == 0);
#endif
} else {
mp->binary = binary_p;
mp->dem = dem_p;
if (index_p) {
mp->interior = INDEX;
} else if(alpha_p) {
mp->interior = ALPHA;
} else if(lyap_p) {
mp->interior = LYAPUNOV;
} else {
mp->interior = NONE;
}
mp->pow = pow_p;
mp->sin = sin_p;
}
mp->reptop = 300;
/* these could be tuned a little closer, but the selection
** process throws out the chaf anyway, it just takes slightly
** longer
*/
mp->extreme_ul.real = -3.0;
mp->extreme_ul.imag = -3.0;
mp->extreme_lr.real = 3.0;
mp->extreme_lr.imag = 3.0;
if (!mp->gc) {
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XColor color;
#ifndef STANDALONE
mp->fg = MI_FG_PIXEL(mi);
mp->bg = MI_BG_PIXEL(mi);
#endif
mp->blackpixel = MI_BLACK_PIXEL(mi);
mp->whitepixel = MI_WHITE_PIXEL(mi);
if ((mp->cmap = XCreateColormap(display, window,
MI_VISUAL(mi), AllocNone)) == None) {
free_mandelbrot(display, mp);
return;
}
XSetWindowColormap(display, window, mp->cmap);
(void) XParseColor(display, mp->cmap, "black", &color);
(void) XAllocColor(display, mp->cmap, &color);
MI_BLACK_PIXEL(mi) = color.pixel;
(void) XParseColor(display, mp->cmap, "white", &color);
(void) XAllocColor(display, mp->cmap, &color);
MI_WHITE_PIXEL(mi) = color.pixel;
#ifndef STANDALONE
(void) XParseColor(display, mp->cmap, background, &color);
(void) XAllocColor(display, mp->cmap, &color);
MI_BG_PIXEL(mi) = color.pixel;
(void) XParseColor(display, mp->cmap, foreground, &color);
(void) XAllocColor(display, mp->cmap, &color);
MI_FG_PIXEL(mi) = color.pixel;
#endif
mp->colors = (XColor *) NULL;
mp->ncolors = 0;
}
if ((mp->gc = XCreateGC(display, MI_WINDOW(mi),
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_mandelbrot(display, mp);
return;
}
}
MI_CLEARWINDOW(mi);
/* Set up colour map */
mp->direction = (LRAND() & 1) ? 1 : -1;
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (mp->colors != NULL) {
if (mp->ncolors && !mp->no_colors)
free_colors(display, mp->cmap, mp->colors, mp->ncolors);
free(mp->colors);
mp->colors = (XColor *) NULL;
}
mp->ncolors = MI_NCOLORS(mi);
if (mp->ncolors < 2)
mp->ncolors = 2;
if (mp->ncolors <= 2)
mp->mono_p = True;
else
mp->mono_p = False;
if (mp->mono_p)
mp->colors = (XColor *) NULL;
else
if ((mp->colors = (XColor *) malloc(sizeof (*mp->colors) *
(mp->ncolors + 1))) == NULL) {
free_mandelbrot(display, mp);
return;
}
mp->cycle_p = has_writable_cells(mi);
if (mp->cycle_p) {
if (MI_IS_FULLRANDOM(mi)) {
if (!NRAND(8))
mp->cycle_p = False;
else
mp->cycle_p = True;
} else {
mp->cycle_p = cycle_p;
}
}
if (!mp->mono_p) {
if (!(LRAND() % 10))
make_random_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
mp->cmap, mp->colors, &mp->ncolors,
True, True, &mp->cycle_p);
else if (!(LRAND() % 2))
make_uniform_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
mp->cmap, mp->colors, &mp->ncolors,
True, &mp->cycle_p);
else
make_smooth_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
mp->cmap, mp->colors, &mp->ncolors,
True, &mp->cycle_p);
}
XInstallColormap(display, mp->cmap);
if (mp->ncolors < 2) {
mp->ncolors = 2;
mp->no_colors = True;
} else
mp->no_colors = False;
if (mp->ncolors <= 2)
mp->mono_p = True;
if (mp->mono_p)
mp->cycle_p = False;
}
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (mp->mono_p) {
mp->cur_color = MI_BLACK_PIXEL(mi);
}
}
Select(&mp->extreme_ul,&mp->extreme_lr,
mp->screen_width,mp->screen_height,
(int) mp->power,mp->reptop, mp->pow, mp->sin,
&mp->ul,&mp->lr);
}
ENTRYPOINT void
init_mountain (ModeInfo * mi)
{
int i, j, x, y;
XGCValues gcv;
mountainstruct *mp;
if (mountains == NULL) {
if ((mountains = (mountainstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (mountainstruct))) == NULL)
return;
}
mp = &mountains[MI_SCREEN(mi)];
mp->width = MI_WIDTH(mi);
mp->height = MI_HEIGHT(mi);
mp->pixelmode = (mp->width + mp->height < 200);
mp->stage = 0;
mp->time = 0;
mp->x = mp->y = 0;
if (MI_IS_FULLRANDOM(mi)) {
mp->joke = (Bool) (NRAND(10) == 0);
mp->wireframe = (Bool) (LRAND() & 1);
} else {
mp->joke = False;
mp->wireframe = MI_IS_WIREFRAME(mi);
}
if (mp->stippledGC == None) {
gcv.foreground = MI_WHITE_PIXEL(mi);
gcv.background = MI_BLACK_PIXEL(mi);
if ((mp->stippledGC = XCreateGC(MI_DISPLAY(mi), MI_WINDOW(mi),
GCForeground | GCBackground, &gcv)) == None)
return;
}
MI_CLEARWINDOW(mi);
for (y = 0; y < (int) WORLDWIDTH; y++)
for (x = 0; x < (int) WORLDWIDTH; x++)
mp->h[x][y] = 0;
j = MI_COUNT(mi);
if (j < 0)
j = NRAND(-j) + 1;
for (i = 0; i < j; i++)
mp->h[RANGE_RAND(1, WORLDWIDTH - 1)][RANGE_RAND(1, WORLDWIDTH - 1)] =
NRAND(MAXHEIGHT);
for (y = 0; y < WORLDWIDTH; y++)
for (x = 0; x < WORLDWIDTH; x++)
spread(mp->h, x, y);
for (y = 0; y < WORLDWIDTH; y++)
for (x = 0; x < WORLDWIDTH; x++) {
mp->h[x][y] = mp->h[x][y] + NRAND(10) - 5;
if (mp->h[x][y] < 10)
mp->h[x][y] = 0;
}
if (MI_NPIXELS(mi) > 2)
mp->offset = NRAND(MI_NPIXELS(mi));
else
mp->offset = 0;
}
void
init_dilemma(ModeInfo * mi)
{
int size = MI_SIZE(mi);
int i, col, row, colrow, mrow;
dilemmastruct *dp;
if (dilemmas == NULL) {
if ((dilemmas = (dilemmastruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (dilemmastruct))) == NULL)
return;
}
dp = &dilemmas[MI_SCREEN(mi)];
dp->generation = 0;
dp->redrawing = 0;
dp->state = 0;
free_dilemma(dp);
if (!dp->initialized) { /* Genesis */
icon_width = cooperat_width;
icon_height = cooperat_height;
dp->initialized = 1;
for (i = 0; i < BITMAPS; i++) {
logo[i].width = icon_width;
logo[i].height = icon_height;
logo[i].bytes_per_line = (icon_width + 7) / 8;
}
}
if (MI_IS_FULLRANDOM(mi)) {
dp->vertical = (Bool) (LRAND() & 1);
} else {
dp->vertical = vertical;
}
dp->width = MI_WIDTH(mi);
dp->height = MI_HEIGHT(mi);
for (i = 0; i < NEIGHBORKINDS; i++) {
if (neighbors == plots[i]) {
dp->neighbors = neighbors;
break;
}
if (i == NEIGHBORKINDS - 1) {
#if 0
dp->neighbors = plots[NRAND(NEIGHBORKINDS)];
dp->neighbors = (LRAND() & 1) ? 4 : 8;
#else
dp->neighbors = 8;
#endif
break;
}
}
if (dp->neighbors == 6) {
int nccols, ncrows, sides;
if (!dp->vertical) {
dp->height = MI_WIDTH(mi);
dp->width = MI_HEIGHT(mi);
}
if (dp->width < 2)
dp->width = 2;
if (dp->height < 4)
dp->height = 4;
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->pixelmode = True;
nccols = MAX(dp->width / dp->xs - 2, 2);
ncrows = MAX(dp->height / dp->ys - 1, 2);
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 (sides = 0; sides < 6; sides++) {
if (dp->vertical) {
dp->shape.hexagon[sides].x =
(dp->xs - 1) * hexagonUnit[sides].x;
dp->shape.hexagon[sides].y =
((dp->ys - 1) * hexagonUnit[sides].y /
2) * 4 / 3;
} else {
dp->shape.hexagon[sides].y =
(dp->xs - 1) * hexagonUnit[sides].x;
dp->shape.hexagon[sides].x =
((dp->ys - 1) * hexagonUnit[sides].y /
2) * 4 / 3;
}
}
} else if (dp->neighbors == 4 || dp->neighbors == 8) {
if (dp->width < 2)
dp->width = 2;
if (dp->height < 2)
dp->height = 2;
if (size == 0 ||
MINGRIDSIZE * size > dp->width || MINGRIDSIZE * size > dp->height) {
if (dp->width > MINGRIDSIZE * icon_width &&
dp->height > MINGRIDSIZE * icon_height) {
dp->pixelmode = False;
dp->xs = icon_width;
dp->ys = icon_height;
} else {
dp->pixelmode = True;
dp->xs = dp->ys = MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE);
}
} else {
dp->pixelmode = True;
if (size < -MINSIZE)
dp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(dp->width, dp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
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;
if (!dp->vertical) {
dp->height = MI_WIDTH(mi);
dp->width = MI_HEIGHT(mi);
}
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->pixelmode = True;
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++) {
if (dp->vertical) {
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;
} else {
dp->shape.triangle[orient][i].y =
(dp->xs - 2) * triangleUnit[orient][i].x;
dp->shape.triangle[orient][i].x =
(dp->ys - 2) * triangleUnit[orient][i].y;
}
}
}
}
dp->npositions = dp->ncols * dp->nrows;
dp->pm[0][0] = 1, dp->pm[0][1] = 0;
if (bonus < 1.0 || bonus > 4.0)
dp->pm[1][0] = 1.85;
else
dp->pm[1][0] = bonus;
dp->pm[1][1] = 0;
if (MI_NPIXELS(mi) >= COLORS) {
dp->colors[0][0] = MI_PIXEL(mi, BLUE); /* COOPERATING, was cooperating */
dp->colors[0][1] = MI_PIXEL(mi, GREEN); /* COOPERATING, was defecting */
dp->colors[1][0] = MI_PIXEL(mi, YELLOW); /* DEFECTING, was cooperating */
dp->colors[1][1] = MI_PIXEL(mi, RED); /* DEFECTING, was defecting */
} else {
dp->colors[0][0] = MI_WHITE_PIXEL(mi);
dp->colors[0][1] = MI_WHITE_PIXEL(mi);
dp->colors[1][0] = MI_WHITE_PIXEL(mi);
dp->colors[1][1] = MI_WHITE_PIXEL(mi);
}
alloc_dilemma(dp);
if (dp->s == NULL)
return;
MI_CLEARWINDOW(mi);
dp->defectors = MI_COUNT(mi);
if (dp->defectors < -MINDEFECT) {
dp->defectors = NRAND(-dp->defectors - MINDEFECT + 1) + MINDEFECT;
} else if (dp->defectors < MINDEFECT)
dp->defectors = MINDEFECT;
if (dp->defectors > dp->npositions)
dp->defectors = dp->npositions;
for (i = 0; i < dp->defectors; i++) {
do {
colrow = NRAND(dp->npositions);
} while (dp->sn[colrow]);
dp->sn[colrow] = 1;
}
#if 0 /* if p was a float... */
mrow = 0;
for (row = 0; row < dp->nrows; row++) {
for (col = 0; col < dp->ncols; col++) {
dp->sn[col + mrow] = ((float) LRAND() / MAXRAND < dp->p);
}
mrow += dp->ncols;
}
#endif
dp->defectors = 0;
/* Show initial state... real important for debugging */
mrow = 0;
for (row = 0; row < dp->nrows; ++row) {
for (col = 0; col < dp->ncols; ++col) {
addtolist(mi, col, row,
dp->sn[col + mrow] * BITMAPS + dp->s[col + mrow]);
}
mrow += dp->ncols;
}
}
ENTRYPOINT void
init_hop(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
GC gc = MI_GC(mi);
double range;
hopstruct *hp;
if (hops == NULL) {
if ((hops = (hopstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (hopstruct))) == NULL)
return;
}
hp = &hops[MI_SCREEN(mi)];
hp->centerx = MI_WIDTH(mi) / 2;
hp->centery = MI_HEIGHT(mi) / 2;
/* Make the other operations less common since they are less interesting */
if (MI_IS_FULLRANDOM(mi)) {
hp->op = NRAND(OPS);
} else {
if (martin)
hp->op = MARTIN;
else if (popcorn)
hp->op = POPCORN;
else if (ejk1)
hp->op = EJK1;
else if (ejk2)
hp->op = EJK2;
else if (ejk3)
hp->op = EJK3;
else if (ejk4)
hp->op = EJK4;
else if (ejk5)
hp->op = EJK5;
else if (ejk6)
hp->op = EJK6;
else if (rr)
hp->op = RR;
else if (jong)
hp->op = JONG;
else if (sine)
hp->op = SINE;
else
hp->op = NRAND(OPS);
}
range = sqrt((double) hp->centerx * hp->centerx +
(double) hp->centery * hp->centery) / (1.0 + LRAND() / MAXRAND);
hp->i = hp->j = 0.0;
hp->inc = (int) ((LRAND() / MAXRAND) * 200) - 100;
#undef XMARTIN
switch (hp->op) {
case MARTIN:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 1500.0 + 40.0;
hp->b = (LRAND() / MAXRAND) * 17.0 + 3.0;
hp->c = (LRAND() / MAXRAND) * 3000.0 + 100.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
hp->b = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
if (LRAND() & 1)
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
else
hp->c = 0.0;
#endif
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "sqrt a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK1:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 500.0;
hp->c = (LRAND() / MAXRAND) * 100.0 + 10.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 40.0;
#endif
hp->b = (LRAND() / MAXRAND) * 0.4;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk1 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK2:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 500.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
#endif
hp->b = pow(10.0, 6.0 + (LRAND() / MAXRAND) * 24.0);
if (LRAND() & 1)
hp->b = -hp->b;
hp->c = pow(10.0, (LRAND() / MAXRAND) * 9.0);
if (LRAND() & 1)
hp->c = -hp->c;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk2 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK3:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 500.0;
hp->c = (LRAND() / MAXRAND) * 80.0 + 30.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 70.0;
#endif
hp->b = (LRAND() / MAXRAND) * 0.35 + 0.5;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk3 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK4:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 1000.0;
hp->c = (LRAND() / MAXRAND) * 40.0 + 30.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 2.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 200.0;
#endif
hp->b = (LRAND() / MAXRAND) * 9.0 + 1.0;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk4 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK5:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 600.0;
hp->c = (LRAND() / MAXRAND) * 90.0 + 20.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 2.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 200.0;
#endif
hp->b = (LRAND() / MAXRAND) * 0.3 + 0.1;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk5 a=%g, b=%g, c=%g\n", hp->a, hp->b, hp->c);
break;
case EJK6:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 100.0 + 550.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 30.0;
#endif
hp->b = (LRAND() / MAXRAND) + 0.5;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "ejk6 a=%g, b=%g\n", hp->a, hp->b);
break;
case RR:
#ifdef XMARTIN
hp->a = (LRAND() / MAXRAND) * 100.0;
hp->b = (LRAND() / MAXRAND) * 20.0;
hp->c = (LRAND() / MAXRAND) * 200.0;
#else
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 40.0;
hp->b = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 200.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * range / 20.0;
#endif
hp->d = (LRAND() / MAXRAND) * 0.9;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "rr a=%g, b=%g, c=%g, d=%g\n",
hp->a, hp->b, hp->c, hp->d);
break;
case POPCORN:
hp->a = 0.0;
hp->b = 0.0;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * 0.24 + 0.25;
hp->inc = 100;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "popcorn a=%g, b=%g, c=%g, d=%g\n",
hp->a, hp->b, hp->c, hp->d);
break;
case JONG:
hp->a = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
hp->b = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
hp->c = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
hp->d = ((LRAND() / MAXRAND) * 2.0 - 1.0) * M_PI;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "jong a=%g, b=%g, c=%g, d=%g\n",
hp->a, hp->b, hp->c, hp->d);
break;
case SINE: /* MARTIN2 */
#ifdef XMARTIN
hp->a = M_PI + ((LRAND() / MAXRAND) * 2.0 - 1.0) * 0.07;
#else
hp->a = M_PI + ((LRAND() / MAXRAND) * 2.0 - 1.0) * 0.7;
#endif
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout, "sine a=%g\n", hp->a);
break;
}
if (MI_NPIXELS(mi) > 2)
hp->pix = NRAND(MI_NPIXELS(mi));
hp->bufsize = MI_COUNT(mi);
if (hp->pointBuffer == NULL) {
if ((hp->pointBuffer = (XPoint *) malloc(hp->bufsize *
sizeof (XPoint))) == NULL)
return;
}
#ifndef STANDALONE
MI_CLEARWINDOW(mi);
#endif
XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
hp->count = 0;
}
void
init_voters(ModeInfo * mi)
{
int size = MI_SIZE(mi);
int i, col, row, colrow;
voterstruct *vp;
if (voters == NULL) {
if ((voters = (voterstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (voterstruct))) == NULL)
return;
}
vp = &voters[MI_SCREEN(mi)];
vp->generation = 0;
if (!vp->first) { /* Genesis of democracy */
icon_width = donkey_width;
icon_height = donkey_height;
if (!init_list(vp)) {
free_voters(vp);
return;
}
for (i = 0; i < BITMAPS; i++) {
logo[i].width = icon_width;
logo[i].height = icon_height;
logo[i].bytes_per_line = (icon_width + 7) / 8;
}
} else /* Exterminate all free thinking individuals */
flush_list(vp);
if (MI_IS_FULLRANDOM(mi)) {
vp->vertical = (Bool) (LRAND() & 1);
} else {
vp->vertical = vertical;
}
vp->width = MI_WIDTH(mi);
vp->height = MI_HEIGHT(mi);
for (i = 0; i < NEIGHBORKINDS; i++) {
if (neighbors == plots[i]) {
vp->neighbors = neighbors;
break;
}
if (i == NEIGHBORKINDS - 1) {
#if 0
vp->neighbors = plots[NRAND(NEIGHBORKINDS)];
vp->neighbors = (LRAND() & 1) ? 4 : 8;
#else
vp->neighbors = 8;
#endif
break;
}
}
if (vp->neighbors == 6) {
int nccols, ncrows, sides;
if (!vp->vertical) {
vp->height = MI_WIDTH(mi);
vp->width = MI_HEIGHT(mi);
}
if (vp->width < 8)
vp->width = 8;
if (vp->height < 8)
vp->height = 8;
if (size < -MINSIZE)
vp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
vp->ys = MAX(MINSIZE, MIN(vp->width, vp->height) / MINGRIDSIZE);
else
vp->ys = MINSIZE;
} else
vp->ys = MIN(size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE));
vp->xs = vp->ys;
vp->pixelmode = True;
nccols = MAX(vp->width / vp->xs - 2, 2);
ncrows = MAX(vp->height / vp->ys - 1, 4);
vp->ncols = nccols / 2;
vp->nrows = 2 * (ncrows / 4);
vp->xb = (vp->width - vp->xs * nccols) / 2 + vp->xs / 2;
vp->yb = (vp->height - vp->ys * (ncrows / 2) * 2) / 2 +
vp->ys - 2;
for (sides = 0; sides < 6; sides++) {
if (vp->vertical) {
vp->shape.hexagon[sides].x =
(vp->xs - 1) * hexagonUnit[sides].x;
vp->shape.hexagon[sides].y =
((vp->ys - 1) * hexagonUnit[sides].y /
2) * 4 / 3;
} else {
vp->shape.hexagon[sides].y =
(vp->xs - 1) * hexagonUnit[sides].x;
vp->shape.hexagon[sides].x =
((vp->ys - 1) * hexagonUnit[sides].y /
2) * 4 / 3;
}
}
} else if (vp->neighbors == 4 || vp->neighbors == 8) {
if (vp->width < 2)
vp->width = 2;
if (vp->height < 2)
vp->height = 2;
if (size == 0 ||
MINGRIDSIZE * size > vp->width || MINGRIDSIZE * size > vp->height) {
if (vp->width > MINGRIDSIZE * icon_width &&
vp->height > MINGRIDSIZE * icon_height) {
vp->pixelmode = False;
vp->xs = icon_width;
vp->ys = icon_height;
} else {
vp->pixelmode = True;
vp->xs = vp->ys = MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE);
}
} else {
vp->pixelmode = True;
if (size < -MINSIZE)
vp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
vp->ys = MINSIZE;
else
vp->ys = MIN(size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE));
vp->xs = vp->ys;
}
vp->ncols = MAX(vp->width / vp->xs, 2);
vp->nrows = MAX(vp->height / vp->ys, 2);
vp->xb = (vp->width - vp->xs * vp->ncols) / 2;
vp->yb = (vp->height - vp->ys * vp->nrows) / 2;
} else { /* TRI */
int orient, sides;
if (!vp->vertical) {
vp->height = MI_WIDTH(mi);
vp->width = MI_HEIGHT(mi);
}
if (vp->width < 2)
vp->width = 2;
if (vp->height < 2)
vp->height = 2;
if (size < -MINSIZE)
vp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
vp->ys = MAX(MINSIZE, MIN(vp->width, vp->height) / MINGRIDSIZE);
else
vp->ys = MINSIZE;
} else
vp->ys = MIN(size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE));
vp->xs = (int) (1.52 * vp->ys);
vp->pixelmode = True;
vp->ncols = (MAX(vp->width / vp->xs - 1, 2) / 2) * 2;
vp->nrows = (MAX(vp->height / vp->ys - 1, 2) / 2) * 2;
vp->xb = (vp->width - vp->xs * vp->ncols) / 2 + vp->xs / 2;
vp->yb = (vp->height - vp->ys * vp->nrows) / 2 + vp->ys / 2;
for (orient = 0; orient < 2; orient++) {
for (sides = 0; sides < 3; sides++) {
if (vp->vertical) {
vp->shape.triangle[orient][sides].x =
(vp->xs - 2) * triangleUnit[orient][sides].x;
vp->shape.triangle[orient][sides].y =
(vp->ys - 2) * triangleUnit[orient][sides].y;
} else {
vp->shape.triangle[orient][sides].y =
(vp->xs - 2) * triangleUnit[orient][sides].x;
vp->shape.triangle[orient][sides].x =
(vp->ys - 2) * triangleUnit[orient][sides].y;
}
}
}
}
vp->npositions = vp->ncols * vp->nrows;
if (vp->arr != NULL)
free(vp->arr);
if ((vp->arr = (char *) calloc(vp->npositions, sizeof (char))) == NULL) {
free_voters(vp);
return;
}
/* Play G-d with these numbers */
vp->nparties = MI_COUNT(mi);
if (vp->nparties < MINPARTIES || vp->nparties > BITMAPS)
vp->nparties = NRAND(BITMAPS - MINPARTIES + 1) + MINPARTIES;
if (vp->pixelmode)
vp->nparties = 2;
vp->busyLoop = 0;
MI_CLEARWINDOW(mi);
vp->painted = False;
for (i = 0; i < BITMAPS; i++)
vp->number_in_party[i] = 0;
for (row = 0; row < vp->nrows; row++)
for (col = 0; col < vp->ncols; col++) {
colrow = col + row * vp->ncols;
if (vp->nparties == 2)
i = (NRAND(vp->nparties) + 2) % BITMAPS;
else
i = NRAND(vp->nparties);
vp->arr[colrow] = (char) i;
drawcell(mi, col, row, (unsigned long) (MI_NPIXELS(mi) * i / BITMAPS),
i, False);
vp->number_in_party[i]++;
}
}
void
init_tik_tak(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i, max_objects, size_object;
tik_takstruct *tiktak;
/* initialize */
if (tik_taks == NULL) {
if ((tik_taks = (tik_takstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (tik_takstruct))) == NULL)
return;
}
tiktak = &tik_taks[MI_SCREEN(mi)];
tiktak->mi = mi;
if (tiktak->gc == None) {
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XColor color;
#ifndef STANDALONE
tiktak->fg = MI_FG_PIXEL(mi);
tiktak->bg = MI_BG_PIXEL(mi);
#endif
tiktak->blackpixel = MI_BLACK_PIXEL(mi);
tiktak->whitepixel = MI_WHITE_PIXEL(mi);
if ((tiktak->cmap = XCreateColormap(display, window,
MI_VISUAL(mi), AllocNone)) == None) {
free_tik_tak(display, tiktak);
return;
}
XSetWindowColormap(display, window, tiktak->cmap);
(void) XParseColor(display, tiktak->cmap, "black", &color);
(void) XAllocColor(display, tiktak->cmap, &color);
MI_BLACK_PIXEL(mi) = color.pixel;
(void) XParseColor(display, tiktak->cmap, "white", &color);
(void) XAllocColor(display, tiktak->cmap, &color);
MI_WHITE_PIXEL(mi) = color.pixel;
#ifndef STANDALONE
(void) XParseColor(display, tiktak->cmap, background, &color);
(void) XAllocColor(display, tiktak->cmap, &color);
MI_BG_PIXEL(mi) = color.pixel;
(void) XParseColor(display, tiktak->cmap, foreground, &color);
(void) XAllocColor(display, tiktak->cmap, &color);
MI_FG_PIXEL(mi) = color.pixel;
#endif
tiktak->colors = (XColor *) NULL;
tiktak->ncolors = 0;
}
if ((tiktak->gc = XCreateGC(display, MI_WINDOW(mi),
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_tik_tak(display, tiktak);
return;
}
}
/* Clear Display */
MI_CLEARWINDOW(mi);
tiktak->painted = False;
XSetFunction(display, tiktak->gc, GXxor);
/*Set up tik_tak data */
tiktak->direction = (LRAND() & 1) ? 1 : -1;
tiktak->win_width = MI_WIDTH(mi);
tiktak->win_height = MI_HEIGHT(mi);
tiktak->num_object = MI_COUNT(mi);
tiktak->x0 = tiktak->win_width / 2;
tiktak->y0 = tiktak->win_height / 2;
max_objects = MI_COUNT(mi);
if (tiktak->num_object == 0) {
tiktak->num_object = DEF_NUM_OBJECT;
max_objects = DEF_NUM_OBJECT;
} else if (tiktak->num_object < 0) {
max_objects = -tiktak->num_object;
tiktak->num_object = NRAND(-tiktak->num_object) + 1;
}
if (tiktak->object == NULL)
if ((tiktak->object = (tik_takobject *) calloc(max_objects,
sizeof (tik_takobject))) == NULL) {
free_tik_tak(display, tiktak);
return;
}
size_object = MIN( tiktak->win_width , tiktak->win_height) / 3;
if ( abs( MI_SIZE(mi) ) > size_object) {
if ( MI_SIZE( mi ) < 0 )
{
size_object = -size_object;
}
}
else
{
size_object = MI_SIZE(mi);
}
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
/* Set up colour map */
if (tiktak->colors != NULL) {
if (tiktak->ncolors && !tiktak->no_colors)
free_colors(display, tiktak->cmap, tiktak->colors, tiktak->ncolors);
free(tiktak->colors);
tiktak->colors = (XColor *) NULL;
}
tiktak->ncolors = MI_NCOLORS(mi);
if (tiktak->ncolors < 2)
tiktak->ncolors = 2;
if (tiktak->ncolors <= 2)
tiktak->mono_p = True;
else
tiktak->mono_p = False;
if (tiktak->mono_p)
tiktak->colors = (XColor *) NULL;
else
if ((tiktak->colors = (XColor *) malloc(sizeof (*tiktak->colors) *
(tiktak->ncolors + 1))) == NULL) {
free_tik_tak(display, tiktak);
return;
}
tiktak->cycle_p = has_writable_cells(mi);
if (tiktak->cycle_p) {
if (MI_IS_FULLRANDOM(mi)) {
if (!NRAND(8))
tiktak->cycle_p = False;
else
tiktak->cycle_p = True;
} else {
tiktak->cycle_p = cycle_p;
}
}
if (!tiktak->mono_p) {
if (!(LRAND() % 10))
make_random_colormap(
#ifdef STANDALONE
MI_DISPLAY(mi), MI_WINDOW(mi),
#else
mi,
#endif
tiktak->cmap, tiktak->colors, &tiktak->ncolors,
True, True, &tiktak->cycle_p);
else if (!(LRAND() % 2))
make_uniform_colormap(
#ifdef STANDALONE
MI_DISPLAY(mi), MI_WINDOW(mi),
#else
mi,
#endif
tiktak->cmap, tiktak->colors, &tiktak->ncolors,
True, &tiktak->cycle_p);
else
make_smooth_colormap(
#ifdef STANDALONE
MI_DISPLAY(mi), MI_WINDOW(mi),
#else
mi,
#endif
tiktak->cmap, tiktak->colors, &tiktak->ncolors,
True, &tiktak->cycle_p);
}
XInstallColormap(display, tiktak->cmap);
if (tiktak->ncolors < 2) {
tiktak->ncolors = 2;
tiktak->no_colors = True;
} else
tiktak->no_colors = False;
if (tiktak->ncolors <= 2)
tiktak->mono_p = True;
if (tiktak->mono_p)
tiktak->cycle_p = False;
}
for (i = 0; i < tiktak->num_object; i++) {
tik_takobject *object0;
object0 = &tiktak->object[i];
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (tiktak->ncolors > 2)
object0->colour = NRAND(tiktak->ncolors - 2) + 2;
else
object0->colour = 1; /* Just in case */
XSetForeground(display, tiktak->gc, tiktak->colors[object0->colour].pixel);
} else {
if (MI_NPIXELS(mi) > 2)
object0->colour = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
else
object0->colour = 1; /*Xor'red so WHITE may not be appropriate */
XSetForeground(display, tiktak->gc, object0->colour);
}
object0->angle = NRAND(90) * PI_RAD;
object0->angle1 = NRAND(90) * PI_RAD;
object0->velocity_a = (NRAND(7) - 3) * PI_RAD;
object0->velocity_a1 = (NRAND(7) - 3) * PI_RAD;
if (size_object == 0)
object0->size_ob = 9;
else if (size_object > 0)
object0->size_ob = size_object;
else
object0->size_ob = NRAND(-size_object) + 1;
object0->size_ob++;
object0->num_point = NRAND(6)+3;
if (LRAND() & 1)
object0->size_mult = 1.0;
else
{
object0->num_point *= 2;
object0->size_mult = 1.0 - ( 1.0 / (float) ((LRAND() & 1) +
2 ) );
}
if (object0->xy != NULL)
free(object0->xy);
if ((object0->xy = (XPoint *) malloc(sizeof( XPoint ) *
(2 * object0->num_point + 2))) == NULL) {
free_tik_tak(display, tiktak);
return;
}
if ((LRAND() & 1) || object0->size_ob < 10 )
{
object0->inner = False;
if ( object0->xy1 != NULL ) free( object0->xy1 );
object0->xy1 = (XPoint *) NULL;
}
else
{
object0->inner = True;
object0->size_ob1 = object0->size_ob -
NRAND( object0->size_ob / 5 ) - 1;
object0->num_point1 = NRAND(6)+3;
if (LRAND() & 1)
object0->size_mult1 = 1.0;
else
{
object0->num_point1 *= 2;
object0->size_mult1 = 1.0 -
( 1.0 / (float) ((LRAND() & 1) + 2 ) );
}
if (object0->xy1 != NULL)
free(object0->xy1);
if ((object0->xy1 = (XPoint *) malloc(sizeof( XPoint ) *
(2 * object0->num_point1 + 2))) == NULL) {
free_tik_tak(display, tiktak);
return;
}
object0->size_mult1 = 1.0;
}
tik_tak_setupobject( mi , object0);
tik_tak_reset_object( object0);
tik_tak_drawobject(mi, object0 );
}
XFlush(display);
XSetFunction(display, tiktak->gc, GXcopy);
}
void
getImage(ModeInfo * mi, XImage ** logo,
int default_width, int default_height, unsigned char *default_bits,
#ifdef HAVE_XPM
int default_xpm, char **name,
#endif
int *graphics_format, Colormap * ncm,
unsigned long *black)
{
Display *display = MI_DISPLAY(mi);
static char *bitmap_local = (char *) NULL;
#ifndef STANDALONE
#ifdef HAVE_XPM
XpmAttributes attrib;
#endif
#if 0
/* This probably works best in most cases but for random mode used
with random selection of a file it will fail often. */
*ncm = None;
#else
if (!fixedColors(mi))
*ncm = XCreateColormap(display, MI_WINDOW(mi), MI_VISUAL(mi), AllocNone);
else
*ncm = None;
#endif
#ifdef HAVE_XPM
attrib.visual = MI_VISUAL(mi);
if (*ncm == None) {
attrib.colormap = MI_COLORMAP(mi);
} else {
attrib.colormap = *ncm;
}
attrib.depth = MI_DEPTH(mi);
attrib.valuemask = XpmVisual | XpmColormap | XpmDepth;
#endif
#endif /* !STANDALONE */
*graphics_format = 0;
if (bitmap_local != NULL) {
free(bitmap_local);
bitmap_local = (char *) NULL;
}
if (MI_BITMAP(mi) && strlen(MI_BITMAP(mi))) {
#ifdef STANDALONE
bitmap_local = MI_BITMAP(mi);
#else
if ((bitmap_local = (char *) malloc(256)) == NULL) {
(void) fprintf(stderr , "no memory for \"%s\"\n" ,
MI_BITMAP(mi));
return;
}
(void) strncpy(bitmap_local, MI_BITMAP(mi), 256);
#if HAVE_DIRENT_H
getRandomFile(MI_BITMAP(mi), bitmap_local);
#endif
#endif /* STANDALONE */
}
if (bitmap_local && strlen(bitmap_local)) {
#if defined( USE_MAGICK ) && !defined( STANDALONE )
if ( readable( bitmap_local ) )
{
if ( MI_NPIXELS( mi ) > 2 )
{
Colormap magick_colormap;
if (*ncm == None) {
magick_colormap = MI_COLORMAP(mi);
} else {
magick_colormap = *ncm;
}
if ( MagickSuccess == MagickFileToImage( mi ,
bitmap_local ,
logo ,
magick_colormap
) )
{
*graphics_format = IS_MAGICKFILE;
*black = GetColor(mi, MI_BLACK_PIXEL(mi));
(void) GetColor(mi, MI_WHITE_PIXEL(mi));
(void) GetColor(mi, MI_BG_PIXEL(mi));
(void) GetColor(mi, MI_FG_PIXEL(mi));
}
}
}
else
{
(void) fprintf(stderr , "could not read file \"%s\"\n" ,
bitmap_local);
}
#else
# ifndef STANDALONE
if (readable(bitmap_local)) {
if (MI_NPIXELS(mi) > 2) {
Colormap ras_colormap;
if (*ncm == None) {
ras_colormap = MI_COLORMAP(mi);
} else {
ras_colormap = *ncm;
}
if (RasterSuccess == RasterFileToImage(mi,
bitmap_local, logo ,
ras_colormap )) {
*graphics_format = IS_RASTERFILE;
*black = GetColor(mi, MI_BLACK_PIXEL(mi));
(void) GetColor(mi, MI_WHITE_PIXEL(mi));
(void) GetColor(mi, MI_BG_PIXEL(mi));
(void) GetColor(mi, MI_FG_PIXEL(mi));
}
}
} else {
(void) fprintf(stderr,
"could not read file \"%s\"\n", bitmap_local);
}
#ifdef HAVE_XPM
#ifndef USE_MONOXPM
if (MI_NPIXELS(mi) > 2)
#endif
{
if (*graphics_format <= 0) {
if (*ncm != None)
reserveColors(mi, *ncm, black);
if (XpmSuccess == XpmReadFileToImage(display,
bitmap_local, logo,
(XImage **) NULL, &attrib))
*graphics_format = IS_XPMFILE;
}
}
#endif
#endif /* !STANDALONE */
if (*graphics_format <= 0) {
if (!blogo.data) {
if (BitmapSuccess == XbmReadFileToImage(bitmap_local,
&blogo.width, &blogo.height,
(unsigned char **) &blogo.data)) {
blogo.bytes_per_line = (blogo.width + 7) / 8;
*graphics_format = IS_XBMFILE;
*logo = &blogo;
}
} else {
*graphics_format = IS_XBMDONE;
*logo = &blogo;
}
}
#endif
if (*graphics_format <= 0 && MI_IS_VERBOSE(mi))
(void) fprintf(stderr,
"\"%s\" is in an unrecognized format or not compatible with screen\n",
bitmap_local);
}
#ifndef STANDALONE
#ifdef HAVE_XPM
if (*graphics_format <= 0 &&
((MI_IS_FULLRANDOM(mi)) ? LRAND() & 1: default_xpm))
#ifndef USE_MONOXPM
if (MI_NPIXELS(mi) > 2)
#endif
if (XpmSuccess == XpmCreateImageFromData(display, name,
logo, (XImage **) NULL, &attrib))
*graphics_format = IS_XPM;
#endif
#endif /* STANDALONE */
if (*graphics_format <= 0) {
if (!blogo.data) {
blogo.data = (char *) default_bits;
blogo.width = default_width;
blogo.height = default_height;
blogo.bytes_per_line = (blogo.width + 7) / 8;
*graphics_format = IS_XBM;
} else
*graphics_format = IS_XBMDONE;
*logo = &blogo;
}
#ifndef STANDALONE /* Come back later */
if (*ncm != None && *graphics_format != IS_RASTERFILE &&
*graphics_format != IS_XPMFILE && *graphics_format != IS_XPM &&
*graphics_format != IS_MAGICKFILE) {
XFreeColormap(display, *ncm);
*ncm = None;
}
#endif /* STANDALONE */ /* Come back later */
}
void
init_dragon(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int size = MI_SIZE(mi);
dragonstruct *dp;
if (dragons == NULL) {
if ((dragons = (dragonstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (dragonstruct))) == NULL)
return;
}
dp = &dragons[MI_SCREEN(mi)];
dp->generation = 0;
dp->redrawing = 0;
if (MI_NPIXELS(mi) <= 2) {
if (dp->stippledGC == None) {
XGCValues gcv;
gcv.fill_style = FillOpaqueStippled;
if ((dp->stippledGC = XCreateGC(display, window,
GCFillStyle, &gcv)) == None) {
free_dragon(display, dp);
return;
}
}
if (dp->graypix == None) {
if ((dp->graypix = XCreateBitmapFromData(display, window,
(char *) gray1_bits, gray1_width, gray1_height)) == None) {
free_dragon(display, dp);
return;
}
}
}
free_struct(dp);
if (MI_NPIXELS(mi) > 2)
dp->color = MI_PIXEL(mi, NRAND(MI_NPIXELS(mi)));
if ((dp->cellList = (CellList **) calloc(STATES,
sizeof (CellList *))) == NULL) {
free_dragon(display, dp);
return;
}
if ((dp->ncells = (int *) calloc(STATES, sizeof (int))) == NULL) {
free_dragon(display, dp);
return;
}
dp->addlist = 0;
if (MI_IS_FULLRANDOM(mi)) {
dp->vertical = (Bool) (LRAND() & 1);
} else {
dp->vertical = vertical;
}
dp->width = MI_WIDTH(mi);
dp->height = MI_HEIGHT(mi);
{
int nccols, ncrows, i;
if (!dp->vertical) {
dp->height = MI_WIDTH(mi);
dp->width = MI_HEIGHT(mi);
}
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 / 4;
for (i = 0; i < 6; i++) {
if (dp->vertical) {
dp->hexagon[i].x =
dp->xs * hexagonUnit[i].x;
dp->hexagon[i].y =
((dp->ys + 1) * hexagonUnit[i].y /
2) * 4 / 3;
} else {
dp->hexagon[i].y =
dp->xs * hexagonUnit[i].x;
dp->hexagon[i].x =
((dp->ys + 1) * hexagonUnit[i].y /
2) * 4 / 3;
}
}
}
MI_CLEARWINDOW(mi);
if ((dp->oldcell = (unsigned char *)
calloc(dp->ncols * dp->nrows,
sizeof (unsigned char))) == NULL) {
free_dragon(display, dp);
return;
}
if (!SetSoup(mi)) {
free_dragon(display, dp);
return;
}
}
/*-
* init_swirl
*
* Initialise things for swirling
*
* - win is the window to draw in
*/
void
init_swirl(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
swirlstruct *sp;
/* does the swirls array exist? */
if (swirls == NULL) {
int i;
/* allocate an array, one entry for each screen */
if ((swirls = (swirlstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (swirlstruct))) == NULL)
return;
/* initialise them all */
for (i = 0; i < MI_NUM_SCREENS(mi); i++)
initialise_swirl(&swirls[i]);
}
/* get a pointer to this swirl */
sp = &(swirls[MI_SCREEN(mi)]);
sp->mi = mi;
/* get window parameters */
sp->width = MI_WIDTH(mi);
sp->height = MI_HEIGHT(mi);
sp->depth = MI_DEPTH(mi);
sp->rdepth = sp->depth;
sp->visual = MI_VISUAL(mi);
if (sp->depth > 16)
sp->depth = 16;
/* initialise image for speeding up drawing */
if (!initialise_image(display, sp)) {
free_swirl(display, sp);
return;
}
MI_CLEARWINDOW(mi);
if (!sp->gc) {
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XColor color;
#ifndef STANDALONE
sp->fg = MI_FG_PIXEL(mi);
sp->bg = MI_BG_PIXEL(mi);
#endif
sp->blackpixel = MI_BLACK_PIXEL(mi);
sp->whitepixel = MI_WHITE_PIXEL(mi);
if ((sp->cmap = XCreateColormap(display, window,
MI_VISUAL(mi), AllocNone)) == None) {
free_swirl(display, sp);
return;
}
XSetWindowColormap(display, window, sp->cmap);
(void) XParseColor(display, sp->cmap, "black", &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_BLACK_PIXEL(mi) = color.pixel;
(void) XParseColor(display, sp->cmap, "white", &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_WHITE_PIXEL(mi) = color.pixel;
#ifndef STANDALONE
(void) XParseColor(display, sp->cmap, background, &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_BG_PIXEL(mi) = color.pixel;
(void) XParseColor(display, sp->cmap, foreground, &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_FG_PIXEL(mi) = color.pixel;
#endif
sp->colors = (XColor *) NULL;
sp->ncolors = 0;
}
if ((sp->gc = XCreateGC(display, MI_WINDOW(mi),
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_swirl(display, sp);
return;
}
}
MI_CLEARWINDOW(mi);
/* Set up colour map */
sp->direction = (LRAND() & 1) ? 1 : -1;
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (sp->colors != NULL) {
if (sp->ncolors && !sp->no_colors)
free_colors(display, sp->cmap, sp->colors, sp->ncolors);
free(sp->colors);
sp->colors = (XColor *) NULL;
}
sp->ncolors = MI_NCOLORS(mi);
if (sp->ncolors < 2)
sp->ncolors = 2;
if (sp->ncolors <= 2)
sp->mono_p = True;
else
sp->mono_p = False;
if (sp->mono_p)
sp->colors = (XColor *) NULL;
else
if ((sp->colors = (XColor *) malloc(sizeof (*sp->colors) *
(sp->ncolors + 1))) == NULL) {
free_swirl(display, sp);
return;
}
sp->cycle_p = has_writable_cells(mi);
if (sp->cycle_p) {
if (MI_IS_FULLRANDOM(mi)) {
if (!NRAND(8))
sp->cycle_p = False;
else
sp->cycle_p = True;
} else {
sp->cycle_p = cycle_p;
}
}
if (!sp->mono_p) {
if (!(LRAND() % 10))
make_random_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, True, &sp->cycle_p);
else if (!(LRAND() % 2))
make_uniform_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, &sp->cycle_p);
else
make_smooth_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, &sp->cycle_p);
}
XInstallColormap(display, sp->cmap);
if (sp->ncolors < 2) {
sp->ncolors = 2;
sp->no_colors = True;
} else
sp->no_colors = False;
if (sp->ncolors <= 2)
sp->mono_p = True;
if (sp->mono_p)
sp->cycle_p = False;
}
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (sp->mono_p) {
sp->cur_color = MI_BLACK_PIXEL(mi);
}
}
/* resolution starts off chunky */
sp->resolution = MIN_RES + 1;
/* calculate the pixel step for this resulution */
sp->r = (1 << (sp->resolution - 1));
/* how many knots? */
sp->n_knots = random_no((unsigned int) MI_COUNT(mi) / 2) +
MI_COUNT(mi) + 1;
/* what type of knots? */
sp->knot_type = ALL; /* for now */
/* use two_plane mode occaisionally */
if (random_no(100) <= TWO_PLANE_PCNT) {
sp->two_plane = sp->first_plane = True;
sp->max_resolution = 2;
} else
sp->two_plane = False;
/* fix the knot values */
if (!create_knots(sp)) {
free_swirl(display, sp);
return;
}
/* we are off */
sp->started = True;
sp->drawing = False;
}
/* Called to init the mode. */
void
init_penrose(ModeInfo * mi)
{
tiling_c *tp;
fringe_node_c *fp;
int i, size;
if (tilings == NULL) {
if ((tilings = (tiling_c *) calloc(MI_NUM_SCREENS(mi),
sizeof (tiling_c))) == NULL)
return;
}
tp = &tilings[MI_SCREEN(mi)];
if (MI_IS_FULLRANDOM(mi))
tp->ammann = (Bool) (LRAND() & 1);
else
tp->ammann = ammann;
tp->done = False;
tp->busyLoop = 0;
tp->failures = 0;
tp->width = MI_WIDTH(mi);
tp->height = MI_HEIGHT(mi);
if (MI_NPIXELS(mi) > 2) {
tp->thick_color = NRAND(MI_NPIXELS(mi));
/* Insure good contrast */
tp->thin_color = (NRAND(2 * MI_NPIXELS(mi) / 3) + tp->thick_color +
MI_NPIXELS(mi) / 6) % MI_NPIXELS(mi);
} else {
if (LRAND() & 1) {
tp->thick_color = MI_WHITE_PIXEL(mi);
tp->thin_color = MI_BLACK_PIXEL(mi);
} else {
tp->thick_color = MI_BLACK_PIXEL(mi);
tp->thin_color = MI_WHITE_PIXEL(mi);
}
}
size = MI_SIZE(mi);
if (size < -MINSIZE)
tp->edge_length = NRAND(MIN(-size, MAX(MINSIZE,
MIN(tp->width, tp->height) / 2)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
tp->edge_length = MAX(MINSIZE, MIN(tp->width, tp->height) / 2);
else
tp->edge_length = MINSIZE;
} else
tp->edge_length = MIN(size, MAX(MINSIZE,
MIN(tp->width, tp->height) / 2));
tp->origin.x = (tp->width / 2 + NRAND(tp->width)) / 2;
tp->origin.y = (tp->height / 2 + NRAND(tp->height)) / 2;
tp->fringe.n_nodes = 2;
if (tp->fringe.nodes != NULL)
free_penrose(tp);
if (tp->fringe.nodes != NULL || tp->forced.first != 0) {
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr, "Weirdness in init_penrose()\n");
(void) fprintf(stderr, "tp->fringe.nodes = NULL && tp->forced.first = 0\n");
}
free_penrose(tp); /* Try again */
tp->done = True;
}
tp->forced.n_nodes = tp->forced.n_visible = 0;
if ((fp = tp->fringe.nodes = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
if (fp == 0) {
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr, "Weirdness in init_penrose()\n");
(void) fprintf(stderr, "fp = 0\n");
}
if ((fp = tp->fringe.nodes = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
tp->done = True;
}
/* First vertex. */
fp->rule_mask = (1 << N_VERTEX_RULES) - 1;
fp->list_ptr = 0;
if ((fp->prev = fp->next = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
if (fp->next == 0) {
if (MI_IS_VERBOSE(mi)) {
(void) fprintf(stderr, "Weirdness in init_penrose()\n");
(void) fprintf(stderr, "fp->next = 0\n");
}
if ((fp->prev = fp->next = ALLOC_NODE(fringe_node_c)) == NULL) {
free_penrose(tp);
return;
}
tp->done = True;
}
fp->n_tiles = 0;
fp->loc = tp->origin;
fp->off_screen = False;
for (i = 0; i < 5; i++)
fp->fived[i] = 0;
/* Second vertex. */
*(fp->next) = *fp;
fp->next->prev = fp->next->next = fp;
fp = fp->next;
i = NRAND(5);
fp->fived[i] = 2 * NRAND(2) - 1;
fived_to_loc(fp->fived, tp, &(fp->loc));
/* That's it! We have created our first edge. */
}
void
init_wire(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i, size = MI_SIZE(mi), n;
circuitstruct *wp;
XGCValues gcv;
if (circuits == NULL) {
if ((circuits = (circuitstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (circuitstruct))) == NULL)
return;
}
wp = &circuits[MI_SCREEN(mi)];
wp->redrawing = 0;
if ((MI_NPIXELS(mi) <= 2) && (wp->init_bits == 0)) {
if (wp->stippledGC == None) {
gcv.fill_style = FillOpaqueStippled;
if ((wp->stippledGC = XCreateGC(display, window, GCFillStyle,
&gcv)) == None) {
free_wire(display, wp);
return;
}
}
WIREBITS(stipples[NUMSTIPPLES - 1], STIPPLESIZE, STIPPLESIZE);
WIREBITS(stipples[NUMSTIPPLES - 3], STIPPLESIZE, STIPPLESIZE);
WIREBITS(stipples[2], STIPPLESIZE, STIPPLESIZE);
}
if (MI_NPIXELS(mi) > 2) {
wp->colors[0] = (NRAND(MI_NPIXELS(mi)));
wp->colors[1] = (wp->colors[0] + MI_NPIXELS(mi) / 6 +
NRAND(MI_NPIXELS(mi) / 4 + 1)) % MI_NPIXELS(mi);
wp->colors[2] = (wp->colors[1] + MI_NPIXELS(mi) / 6 +
NRAND(MI_NPIXELS(mi) / 4 + 1)) % MI_NPIXELS(mi);
}
free_list(wp);
wp->generation = 0;
if (MI_IS_FULLRANDOM(mi)) {
wp->vertical = (Bool) (LRAND() & 1);
} else {
wp->vertical = vertical;
}
wp->width = MI_WIDTH(mi);
wp->height = MI_HEIGHT(mi);
for (i = 0; i < NEIGHBORKINDS; i++) {
if (neighbors == plots[i]) {
wp->neighbors = plots[i];
break;
}
if (i == NEIGHBORKINDS - 1) {
i = NRAND(NEIGHBORKINDS - 3) + 1; /* Skip triangular ones */
wp->neighbors = plots[i];
break;
}
}
wp->prob_array[wp->neighbors - 1] = 100;
if (wp->neighbors == 3) {
wp->prob_array[1] = 67;
wp->prob_array[0] = 33;
} else {
int incr = 24 / wp->neighbors;
for (i = wp->neighbors - 2; i >= 0; i--) {
wp->prob_array[i] = wp->prob_array[i + 1] - incr -
incr * ((i + 1) != wp->neighbors / 2);
}
}
if (wp->neighbors == 6) {
int nccols, ncrows;
wp->polygon = 6;
if (!wp->vertical) {
wp->height = MI_WIDTH(mi);
wp->width = MI_HEIGHT(mi);
}
if (wp->width < 8)
wp->width = 8;
if (wp->height < 8)
wp->height = 8;
if (size < -MINSIZE)
wp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
wp->ys = MAX(MINSIZE, MIN(wp->width, wp->height) / MINGRIDSIZE);
else
wp->ys = MINSIZE;
} else
wp->ys = MIN(size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE));
wp->xs = wp->ys;
nccols = MAX(wp->width / wp->xs - 2, 16);
ncrows = MAX(wp->height / wp->ys - 1, 16);
wp->ncols = nccols / 2;
wp->nrows = ncrows / 2;
wp->nrows -= !(wp->nrows & 1); /* Must be odd */
wp->xb = (wp->width - wp->xs * nccols) / 2 + wp->xs;
wp->yb = (wp->height - wp->ys * ncrows) / 2 + wp->ys;
for (i = 0; i < 6; i++) {
if (wp->vertical) {
wp->shape.hexagon[i].x =
(wp->xs - 1) * hexagonUnit[i].x;
wp->shape.hexagon[i].y =
((wp->ys - 1) * hexagonUnit[i].y /
2) * 4 / 3;
} else {
wp->shape.hexagon[i].y =
(wp->xs - 1) * hexagonUnit[i].x;
wp->shape.hexagon[i].x =
((wp->ys - 1) * hexagonUnit[i].y /
2) * 4 / 3;
}
}
} else if (wp->neighbors == 4 || wp->neighbors == 8) {
wp->polygon = 4;
if (size < -MINSIZE)
wp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
wp->ys = MAX(MINSIZE, MIN(wp->width, wp->height) / MINGRIDSIZE);
else
wp->ys = MINSIZE;
} else
wp->ys = MIN(size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE));
wp->xs = wp->ys;
wp->ncols = MAX(wp->width / wp->xs, 8);
wp->nrows = MAX(wp->height / wp->ys, 8);
wp->xb = (wp->width - wp->xs * wp->ncols) / 2;
wp->yb = (wp->height - wp->ys * wp->nrows) / 2;
} else { /* TRI */
int orient;
wp->polygon = 3;
if (!wp->vertical) {
wp->height = MI_WIDTH(mi);
wp->width = MI_HEIGHT(mi);
}
if (wp->width < 4)
wp->width = 4;
if (wp->height < 2)
wp->height = 2;
if (size < -MINSIZE)
wp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
wp->ys = MAX(MINSIZE, MIN(wp->width, wp->height) / MINGRIDSIZE);
else
wp->ys = MINSIZE;
} else
wp->ys = MIN(size, MAX(MINSIZE, MIN(wp->width, wp->height) /
MINGRIDSIZE));
wp->xs = (int) (1.52 * wp->ys);
wp->ncols = (MAX(wp->width / wp->xs - 1, 8) / 2) * 2;
wp->nrows = (MAX(wp->height / wp->ys - 1, 8) / 2) * 2 - 1;
wp->xb = (wp->width - wp->xs * wp->ncols) / 2 + wp->xs / 2;
wp->yb = (wp->height - wp->ys * wp->nrows) / 2 + wp->ys;
for (orient = 0; orient < 2; orient++) {
for (i = 0; i < 3; i++) {
if (wp->vertical) {
wp->shape.triangle[orient][i].x =
(wp->xs - 2) * triangleUnit[orient][i].x;
wp->shape.triangle[orient][i].y =
(wp->ys - 2) * triangleUnit[orient][i].y;
} else {
wp->shape.triangle[orient][i].y =
(wp->xs - 2) * triangleUnit[orient][i].x;
wp->shape.triangle[orient][i].x =
(wp->ys - 2) * triangleUnit[orient][i].y;
}
}
}
}
/*
* I am being a bit naughty here wasting a little bit of memory
* but it will give me a real headache to figure out the logic
* and to refigure the mappings to save a few bytes
* ncols should only need a border of 2 and nrows should only need
* a border of 4 when in the neighbors = 9 or 12
*/
wp->bncols = wp->ncols + 4;
wp->bnrows = wp->nrows + 4;
if (MI_IS_VERBOSE(mi))
(void) fprintf(stdout,
"neighbors %d, ncols %d, nrows %d\n",
wp->neighbors, wp->ncols, wp->nrows);
MI_CLEARWINDOW(mi);
if (wp->oldcells != NULL) {
free(wp->oldcells);
wp->oldcells = (unsigned char *) NULL;
}
if ((wp->oldcells = (unsigned char *) calloc(wp->bncols * wp->bnrows,
sizeof (unsigned char))) == NULL) {
free_wire(display, wp);
return;
}
if (wp->newcells != NULL) {
free(wp->newcells);
wp->newcells = (unsigned char *) NULL;
}
if ((wp->newcells = (unsigned char *) calloc(wp->bncols * wp->bnrows,
sizeof (unsigned char))) == NULL) {
free_wire(display, wp);
return;
}
n = MI_COUNT(mi);
i = (1 + (wp->neighbors == 6)) * wp->ncols * wp->nrows / 4;
if (n < -MINWIRES && i > MINWIRES) {
n = NRAND(MIN(-n, i) - MINWIRES + 1) + MINWIRES;
} else if (n < MINWIRES) {
n = MINWIRES;
} else if (n > i) {
n = MAX(MINWIRES, i);
}
create_path(wp, n);
}