static void
startover(ModeInfo * mi)
{
unistruct *gp = &universes[MI_SCREEN(mi)];
int i, j; /* more tmp */
double w1, w2; /* more tmp */
double d, v, w, h; /* yet more tmp */
gp->step = 0;
gp->rot_y = 0;
gp->rot_x = 0;
if (MI_BATCHCOUNT(mi) < -MINGALAXIES)
free_galaxies(gp);
gp->ngalaxies = MI_BATCHCOUNT(mi);
if (gp->ngalaxies < -MINGALAXIES)
gp->ngalaxies = NRAND(-gp->ngalaxies - MINGALAXIES + 1) + MINGALAXIES;
else if (gp->ngalaxies < MINGALAXIES)
gp->ngalaxies = MINGALAXIES;
if (gp->galaxies == NULL)
gp->galaxies = (Galaxy *) calloc(gp->ngalaxies, sizeof (Galaxy));
for (i = 0; i < gp->ngalaxies; ++i) {
Galaxy *gt = &gp->galaxies[i];
double sinw1, sinw2, cosw1, cosw2;
#if 1 // hacked by katahiromz
gt->galcol = NRAND(NCOLORS);
#else
gt->galcol = NRAND(COLORBASE - 2);
if (gt->galcol > 1)
gt->galcol += 2; /* Mult 8; 16..31 no green stars */
/* Galaxies still may have some green stars but are not all green. */
#endif
if (gt->stars != NULL) {
(void) free((void *) gt->stars);
gt->stars = NULL;
}
gt->nstars = (NRAND(MAX_STARS / 2)) + MAX_STARS / 2;
gt->stars = (Star *) malloc(gt->nstars * sizeof (Star));
gt->oldpoints = (XPoint *) malloc(gt->nstars * sizeof (XPoint));
gt->newpoints = (XPoint *) malloc(gt->nstars * sizeof (XPoint));
w1 = 2.0 * M_PI * FLOATRAND;
w2 = 2.0 * M_PI * FLOATRAND;
sinw1 = SINF(w1);
sinw2 = SINF(w2);
cosw1 = COSF(w1);
cosw2 = COSF(w2);
gp->mat[0][0] = cosw2;
gp->mat[0][1] = -sinw1 * sinw2;
gp->mat[0][2] = cosw1 * sinw2;
gp->mat[1][0] = 0.0;
gp->mat[1][1] = cosw1;
gp->mat[1][2] = sinw1;
gp->mat[2][0] = -sinw2;
gp->mat[2][1] = -sinw1 * cosw2;
gp->mat[2][2] = cosw1 * cosw2;
gt->vel[0] = FLOATRAND * 2.0 - 1.0;
gt->vel[1] = FLOATRAND * 2.0 - 1.0;
gt->vel[2] = FLOATRAND * 2.0 - 1.0;
gt->pos[0] = -gt->vel[0] * DELTAT * gp->f_hititerations + FLOATRAND -
0.5;
gt->pos[1] = -gt->vel[1] * DELTAT * gp->f_hititerations + FLOATRAND -
0.5;
gt->pos[2] = -gt->vel[2] * DELTAT * gp->f_hititerations + FLOATRAND -
0.5;
gt->mass = (int) (FLOATRAND * 1000.0) + 1;
gp->size = GALAXYRANGESIZE * FLOATRAND + GALAXYMINSIZE;
for (j = 0; j < gt->nstars; ++j) {
Star *st = >->stars[j];
XPoint *oldp = >->oldpoints[j];
XPoint *newp = >->newpoints[j];
double sinw, cosw;
w = 2.0 * M_PI * FLOATRAND;
sinw = SINF(w);
cosw = COSF(w);
d = FLOATRAND * gp->size;
h = FLOATRAND * exp(-2.0 * (d / gp->size)) / 5.0 * gp->size;
if (FLOATRAND < 0.5)
h = -h;
st->pos[0] = gp->mat[0][0] * d * cosw + gp->mat[1][0] * d * sinw +
gp->mat[2][0] * h + gt->pos[0];
st->pos[1] = gp->mat[0][1] * d * cosw + gp->mat[1][1] * d * sinw +
gp->mat[2][1] * h + gt->pos[1];
st->pos[2] = gp->mat[0][2] * d * cosw + gp->mat[1][2] * d * sinw +
gp->mat[2][2] * h + gt->pos[2];
v = sqrt(gt->mass * QCONS / sqrt(d * d + h * h));
st->vel[0] = -gp->mat[0][0] * v * sinw + gp->mat[1][0] * v * cosw +
gt->vel[0];
st->vel[1] = -gp->mat[0][1] * v * sinw + gp->mat[1][1] * v * cosw +
gt->vel[1];
st->vel[2] = -gp->mat[0][2] * v * sinw + gp->mat[1][2] * v * cosw +
gt->vel[2];
st->vel[0] *= DELTAT;
st->vel[1] *= DELTAT;
st->vel[2] *= DELTAT;
oldp->x = 0;
oldp->y = 0;
newp->x = 0;
newp->y = 0;
}
}
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
#if 0
(void) printf("ngalaxies=%d, f_hititerations=%d\n", gp->ngalaxies,
gp->f_hititerations);
(void) printf("f_deltat=%g\n", DELTAT);
(void) printf("Screen: ");
#endif /*0 */
}
ENTRYPOINT void
init_bouboule(ModeInfo * mi)
/***************/
/*-
* The stars init part was first inspirated from the net3d game starfield
* code. But net3d starfield is not really 3d starfield, and I needed real 3d,
* so only remains the net3d starfield initialization main idea, that is
* the stars distribution on a sphere (theta and omega computing)
*/
{
StarField *sp;
int size = MI_SIZE(mi);
int i;
double theta, omega;
if (starfield == NULL) {
if ((starfield = (StarField *) calloc(MI_NUM_SCREENS(mi),
sizeof (StarField))) == NULL)
return;
}
sp = &starfield[MI_SCREEN(mi)];
sp->width = MI_WIN_WIDTH(mi);
sp->height = MI_WIN_HEIGHT(mi);
/* use the right `black' pixel values: */
if (MI_WIN_IS_INSTALL(mi) && MI_WIN_IS_USE3D(mi)) {
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_NONE_COLOR(mi));
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
0, 0, sp->width, sp->height);
} else
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
if (size < -MINSIZE)
sp->max_star_size = NRAND(-size - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
sp->max_star_size = MINSIZE;
else
sp->max_star_size = size;
sp->NbStars = MI_BATCHCOUNT(mi);
if (sp->NbStars < -MINSTARS) {
if (sp->star) {
(void) free((void *) sp->star);
sp->star = NULL;
}
if (sp->xarc) {
(void) free((void *) sp->xarc);
sp->xarc = NULL;
}
if (sp->xarcleft) {
(void) free((void *) sp->xarcleft);
sp->xarcleft = NULL;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
if (sp->oldxarc) {
(void) free((void *) sp->oldxarc);
sp->oldxarc = NULL;
}
if (sp->oldxarcleft) {
(void) free((void *) sp->oldxarcleft);
sp->oldxarcleft = NULL;
}
#endif
sp->NbStars = NRAND(-sp->NbStars - MINSTARS + 1) + MINSTARS;
} else if (sp->NbStars < MINSTARS)
sp->NbStars = MINSTARS;
/* We get memory for lists of objects */
if (sp->star == NULL)
sp->star = (Star *) malloc(sp->NbStars * sizeof (Star));
if (sp->xarc == NULL)
sp->xarc = (XArc *) malloc(sp->NbStars * sizeof (XArc));
if (MI_WIN_IS_USE3D(mi) && sp->xarcleft == NULL)
sp->xarcleft = (XArc *) malloc(sp->NbStars * sizeof (XArc));
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
if (sp->oldxarc == NULL)
sp->oldxarc = (XArc *) malloc(sp->NbStars * sizeof (XArc));
if (MI_WIN_IS_USE3D(mi) && sp->oldxarcleft == NULL)
sp->oldxarcleft = (XArc *) malloc(sp->NbStars * sizeof (XArc));
#endif
{
/* We initialize evolving variables */
sininit(&sp->x,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
((double) sp->width) / 4.0,
3.0 * ((double) sp->width) / 4.0,
POSCANRAND);
sininit(&sp->y,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
((double) sp->height) / 4.0,
3.0 * ((double) sp->height) / 4.0,
POSCANRAND);
/* for z, we have to ensure that the bouboule does not get behind */
/* the eyes of the viewer. His/Her eyes are at 0. Because the */
/* bouboule uses the x-radius for the z-radius, too, we have to */
/* use the x-values. */
sininit(&sp->z,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
((double) sp->width / 2.0 + MINZVAL),
((double) sp->width / 2.0 + MAXZVAL),
POSCANRAND);
sininit(&sp->sizex,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
MIN(((double) sp->width) - sp->x.value,
sp->x.value) / 5.0,
MIN(((double) sp->width) - sp->x.value,
sp->x.value),
SIZECANRAND);
sininit(&sp->sizey,
NRAND(3142) / 1000.0, M_PI / (NRAND(100) + 100.0),
MAX(sp->sizex.value / MAX_SIZEX_SIZEY,
sp->sizey.maximum / 5.0),
MIN(sp->sizex.value * MAX_SIZEX_SIZEY,
MIN(((double) sp->height) -
sp->y.value,
sp->y.value)),
SIZECANRAND);
sininit(&sp->thetax,
NRAND(3142) / 1000.0, M_PI / (NRAND(200) + 200.0),
-M_PI, M_PI,
THETACANRAND);
sininit(&sp->thetay,
NRAND(3142) / 1000.0, M_PI / (NRAND(200) + 200.0),
-M_PI, M_PI,
THETACANRAND);
sininit(&sp->thetaz,
NRAND(3142) / 1000.0, M_PI / (NRAND(400) + 400.0),
-M_PI, M_PI,
THETACANRAND);
}
for (i = 0; i < sp->NbStars; i++) {
Star *star;
XArc *arc = NULL, *arcleft = NULL;
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
XArc *oarc = NULL, *oarcleft = NULL;
#endif
star = &(sp->star[i]);
arc = &(sp->xarc[i]);
if (MI_WIN_IS_USE3D(mi))
arcleft = &(sp->xarcleft[i]);
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc = &(sp->oldxarc[i]);
if (MI_WIN_IS_USE3D(mi))
oarcleft = &(sp->oldxarcleft[i]);
#endif
/* Elevation and bearing of the star */
theta = dtor((NRAND(1800)) / 10.0 - 90.0);
omega = dtor((NRAND(3600)) / 10.0 - 180.0);
/* Stars coordinates in a 3D space */
star->x = cos(theta) * sin(omega);
star->y = sin(omega) * sin(theta);
star->z = cos(omega);
/* We set the stars size */
star->size = NRAND(2 * sp->max_star_size);
if (star->size < sp->max_star_size)
star->size = 0;
else
star->size -= sp->max_star_size;
/* We set default values for the XArc lists elements */
arc->x = arc->y = 0;
if (MI_WIN_IS_USE3D(mi)) {
arcleft->x = arcleft->y = 0;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc->x = oarc->y = 0;
if (MI_WIN_IS_USE3D(mi)) {
oarcleft->x = oarcleft->y = 0;
}
#endif
arc->width = 2 + star->size;
arc->height = 2 + star->size;
if (MI_WIN_IS_USE3D(mi)) {
arcleft->width = 2 + star->size;
arcleft->height = 2 + star->size;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc->width = 2 + star->size;
oarc->height = 2 + star->size;
if (MI_WIN_IS_USE3D(mi)) {
oarcleft->width = 2 + star->size;
oarcleft->height = 2 + star->size;
}
#endif
arc->angle1 = 0;
arc->angle2 = 360 * 64;
if (MI_WIN_IS_USE3D(mi)) {
arcleft->angle1 = 0;
arcleft->angle2 = 360 * 64;
}
#if ((USEOLDXARCS == 1) || (ADAPT_ERASE == 1))
oarc->angle1 = 0;
oarc->angle2 = 360 * 64; /* ie. we draw whole disks:
* from 0 to 360 degrees */
if (MI_WIN_IS_USE3D(mi)) {
oarcleft->angle1 = 0;
oarcleft->angle2 = 360 * 64;
}
#endif
}
if (MI_NPIXELS(mi) > 2)
sp->colorp = NRAND(MI_NPIXELS(mi));
/* We set up the starfield color */
if (!MI_WIN_IS_USE3D(mi) && MI_NPIXELS(mi) > 2)
sp->color = MI_PIXEL(mi, sp->colorp);
else
sp->color = MI_WIN_WHITE_PIXEL(mi);
#if (ADAPT_ERASE == 1)
/* We initialize the adaptation code for screen erasing */
sp->hasbeenchecked = ADAPT_CHECKS * 2;
sp->rect_time = 0;
sp->xarc_time = 0;
#endif
}
ENTRYPOINT void
init_worm (ModeInfo * mi)
{
wormstruct *wp;
int size = MI_SIZE(mi);
int i, j;
if (worms == NULL) {
if ((worms = (wormstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (wormstruct))) == NULL)
return;
}
wp = &worms[MI_SCREEN(mi)];
if (MI_NPIXELS(mi) <= 2 || MI_WIN_IS_USE3D(mi))
wp->nc = 2;
else
wp->nc = MI_NPIXELS(mi);
if (wp->nc > NUMCOLORS)
wp->nc = NUMCOLORS;
free_worms(wp);
wp->nw = MI_BATCHCOUNT(mi);
if (wp->nw < -MINWORMS)
wp->nw = NRAND(-wp->nw - MINWORMS + 1) + MINWORMS;
else if (wp->nw < MINWORMS)
wp->nw = MINWORMS;
if (!wp->worm)
wp->worm = (wormstuff *) malloc(wp->nw * sizeof (wormstuff));
if (!wp->size)
wp->size = (int *) malloc(NUMCOLORS * sizeof (int));
wp->maxsize = (REDRAWSTEP + 1) * wp->nw; /* / wp->nc + 1; */
if (!wp->rects)
wp->rects =
(XRectangle *) malloc(wp->maxsize * NUMCOLORS * sizeof (XRectangle));
if (!init_table) {
init_table = 1;
for (i = 0; i < SEGMENTS; i++) {
sintab[i] = SINF(i * 2.0 * M_PI / SEGMENTS);
costab[i] = COSF(i * 2.0 * M_PI / SEGMENTS);
}
}
wp->xsize = MI_WIN_WIDTH(mi);
wp->ysize = MI_WIN_HEIGHT(mi);
wp->zsize = MAXZ - MINZ + 1;
if (MI_NPIXELS(mi) > 2)
wp->chromo = NRAND(MI_NPIXELS(mi));
if (size < -MINSIZE)
wp->circsize = NRAND(-size - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
wp->circsize = MINSIZE;
else
wp->circsize = size;
for (i = 0; i < wp->nc; i++) {
for (j = 0; j < wp->maxsize; j++) {
wp->rects[i * wp->maxsize + j].width = wp->circsize;
wp->rects[i * wp->maxsize + j].height = wp->circsize;
}
}
(void) memset((char *) wp->size, 0, wp->nc * sizeof (int));
wp->wormlength = (int) sqrt(wp->xsize + wp->ysize) *
MI_CYCLES(mi) / 8; /* Fudge this to something reasonable */
for (i = 0; i < wp->nw; i++) {
wp->worm[i].circ = (XPoint *) malloc(wp->wormlength * sizeof (XPoint));
wp->worm[i].diffcirc = (int *) malloc(wp->wormlength * sizeof (int));
for (j = 0; j < wp->wormlength; j++) {
wp->worm[i].circ[j].x = wp->xsize / 2;
wp->worm[i].circ[j].y = wp->ysize / 2;
if (MI_WIN_IS_USE3D(mi))
wp->worm[i].diffcirc[j] = 0;
}
wp->worm[i].dir = NRAND(SEGMENTS);
wp->worm[i].dir2 = NRAND(SEGMENTS);
wp->worm[i].tail = 0;
wp->worm[i].x = wp->xsize / 2;
wp->worm[i].y = wp->ysize / 2;
wp->worm[i].z = SCREENZ - MINZ;
wp->worm[i].redrawing = 0;
}
if (MI_WIN_IS_INSTALL(mi) && MI_WIN_IS_USE3D(mi)) {
XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_NONE_COLOR(mi));
XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
0, 0, wp->xsize, wp->ysize);
} else
XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
}
