static void fill_random(COMPLEX *a, int n)
{
int i;
/* generate random inputs */
for (i = 0; i < n; ++i) {
RE(a[i]) = double_rand();
IM(a[i]) = double_rand();
}
}
int main(int argc, char *argv[])
{ int nsites,d,i;
if (!argv[1] || !argv[2]) exit(3);
sscanf(argv[1], "%d", &nsites);
sscanf(argv[2], "%d", &d);
init_rand(0);
while(nsites>0){
for (i=0;i<d;i++) printf("%6.0f ", floor(1e5*double_rand()));
printf("\n");
nsites--;
}
}
static double verify_linear(fftd_func *dft,
int N,
COMPLEX *inA,
COMPLEX *inB,
COMPLEX *inC,
COMPLEX *outA,
COMPLEX *outB,
COMPLEX *outC,
COMPLEX *tmp,
int rounds)
{
int i; double maxerr = 0.0; double e;
/* test 1: check linearity */
for (i = 0; i < rounds; ++i) {
COMPLEX alpha, beta;
RE(alpha) = double_rand();
IM(alpha) = double_rand();
RE(beta) = double_rand();
IM(beta) = double_rand();
fill_random(inA, N);
fill_random(inB, N);
dft((double *)outA, (double *)inA);
dft((double *)outB, (double *)inB);
ascale(outA, alpha, N);
ascale(outB, beta, N);
aadd(tmp, outA, outB, N);
ascale(inA, alpha, N);
ascale(inB, beta, N);
aadd(inC, inA, inB, N);
dft((double *)outC, (double *)inC);
e = acmp(outC, tmp, N);
if(e > maxerr) maxerr = e;
}
return maxerr;
}
static void make_shuffle(void){
long i,t,j;
static long mat_size = 0;
if (mat_size<=num_sites) {
mat_size = num_sites+1;
shufmat = (long*)malloc(mat_size*sizeof(long));
}
for (i=0;i<=num_sites;i++) shufmat[i] = i;
for (i=0;i<num_sites;i++){
t = shufmat[i];
shufmat[i] = shufmat[j = i + (num_sites-i)*(long)double_rand()];
shufmat[j] = t;
}
}
int main(int argc, char *argv[])
{
FILE *stardata;
FILE *planetdata;
FILE *sectordata;
FILE *outputtxt = NULL;
char str[200];
int c;
int i;
int star;
/*
* int x;
*/
/*
* double att;
*/
double xspeed[NUMSTARS];
double yspeed[NUMSTARS];
/*
* Empty stars
*/
int nempty;
/*
* How many rows and columns are needed
*/
int rowcolumns;
/*
* Non-empty stars not placed
*/
int starsleft;
/*
* How many planetless systems is in each square
*/
int emptyrounds;
/*
* Size of square
*/
double displacement;
/*
* How many wormholes
*/
int whcnt;
int wormholes = -1;
int wormidx;
struct w_holes w_holes[NUMSTARS + 1];
int x;
int y;
int z;
int squaresleft;
int total;
int flag = 0;
struct power power[MAXPLAYERS];
struct block block[MAXPLAYERS];
/*
* Initialize
*/
/*
* srandom(getpid());
*/
Bzero(Sdata);
/*
* Read the arguments for values
*/
for (i = 1; i < argc; ++i) {
if (argv[i][0] != '-') {
printf("\n");
printf("Usage: makeuniv [-a] [-b] [-d] [-e E] [-l MIN] [-m MAX] ");
printf("[-s N] [-v] [-w C] [-x]\n");
printf(" -a Autoload star names.\n");
printf(" -b Autoload planet names.\n");
printf(" -d Use smashup (asteroid impact routines.\n");
printf(" -e E Make E%% of stars have no planets.\n");
printf(" -l MIN Other systems will have at least MIN planets.\n");
printf(" -m MAX Other systems will have at most MAX planets.\n");
printf(" -p Create postscript map file of the univese.\n");
printf(" -s N The univers will have N stars.\n");
printf(" -v Do no print info and map of planets generated.\n");
printf(" -w C The universe will have C wormholes.\n");
printf(" -x Do not print info on stars generated.\n");
printf("\n");
return 0;
} else {
switch (argv[i][1]) {
case 'a':
autoname_star = 1;
break;
case 'b':
autoname_plan = 1;
break;
case 'd':
use_smashup = 1;
break;
case 'e':
++i;
planetlesschance = atoi(argv[i]);
break;
case 'l':
++i;
minplanets = atoi(argv[i]);
break;
case 'm':
++i;
maxplanets = atoi(argv[i]);
break;
case 'p':
printpostscript = 1;
break;
case 's':
++i;
nstars = atoi(argv[i]);
break;
case 'v':
printplaninfo = 0;
break;
case 'x':
printstarinfo = 0;
break;
case 'w':
++i;
wormholes = atoi(argv[i]);
break;
default:
printf("\n");
printf("Unknown option \"%s\".\n", argv[i]);
printf("\n");
printf("Usage: makeuniv [-a] [-b] [-e E] [-l MIN] [-m MAX] ");
printf("[-s N] [-v] [-w C] [-x]\n");
printf(" -a Autoload star names.\n");
printf(" -b Autoload planetnames.\n");
printf(" -d Use smashup (asteroid impact) routines.\n");
printf(" -e E Make E%% of stars have no planets.\n");
printf(" -l MIN Other systems will have at least MIN planets.\n");
printf(" -m MAX Other systems will have at most MAX planets.\n");
printf(" -p Create postscript map file of the universe.\n");
printf(" -s N The universe will have N stars.\n");
printf(" -v Do not print info and map of planets generated.\n");
printf(" -w C The universe will have C wormholes.\n");
printf(" -x Do not print info on stars generated.\n");
printf("\n");
return 0;
}
}
}
/*
* Get values for all the switches that still don't have good values.
*/
if (autoname_star == -1) {
printf("\nDo you wish to use the file \"%s\" for star names? [y/n]> ",
STARLIST);
c = getchr();
if (c != '\n') {
getchr();
}
autoname_star = (c == 'y');
}
if (autoname_plan == -1) {
printf("\nDo you wish to use the file \"%s\" for planet names? [y/n]> ",
PLANETLIST);
c = getchr();
if (c != '\n') {
getchr();
}
autoname_plan = (c == 'y');
}
if (use_smashup == -1) {
printf("\nUse the smashup (asteroid impact) routines? [y/n]> ");
c = getchr();
if (c != '\n') {
getchr();
}
use_smashup = (c == 'y');
}
while ((nstars < 1) || (nstars >= NUMSTARS)) {
printf("Number of stars [1-%d]:", NUMSTARS - 1);
scanf("%d", &nstars);
}
while ((planetlesschance < 0) || (planetlesschance > 100)) {
printf("Percentage of empty systems [0-100]:");
scanf("%d", &planetlesschance);
}
while ((minplanets <= 0) || (minplanets > absmaxplan)) {
printf("Minimum number of planets per system [1-%d]:", absmaxplan);
scanf("%d", &maxplanets);
}
while ((wormholes < 0) || (wormholes > nstars) || ((wormholes % 2) == 1)) {
printf("Number of wormholes (muse be even number) [0-%d]:", nstars);
scanf("%d", &wormholes);
}
Makeplanet_init();
Makestar_init();
Sdata.numstars = nstars;
sprintf(str, "/bin/mkdir -p %s", DATADIR);
system(str);
planetdata = fopen(PLANETDATAFL, "w+");
if (planetdata == NULL) {
printf("Unable to open planet data file \"%s\"\n", PLANETDATAFL);
return -1;
}
sectordata = fopen(SECTORDATAFL, "w+");
if (sectordata == NULL) {
printf("Unable to open sector data file \"%s\"\n", SECTORDATAFL);
return -1;
}
if (printstarinfo || printplaninfo) {
outputtxt = fopen(OUTPUTFILE, "w+");
if (outputtxt == NULL) {
printf("Unable to open \"%s\" for output.\n", OUTPUTFILE);
return -1;
}
}
if (!wormholes) {
whcnt = 0;
} else {
whcnt (int)(nstars / wormholes) - 1;
}
wormidx = 0;
for (star = 0; star < nstars; ++star) {
Stars[star] = Makestar(planetdata, sectordata, outputtxt);
xspeed[star] = 0;
yspeed[star] = 0;
Stars[star]->wh_has_wormhole = 0;
Stars[star]->wh_dest_starnum = -1;
Stars[star]->wh_stability = 0;
/*
* See if time to put a wormhole in
*/
if (!whcnt) {
/*
* Make a wormhole here. This adds a wormhole planet to this star.
*/
if (Stars[star]->numplanets == MAXPLANETS) {
/*
* Skip until a star as < MAXPLANETS
*/
whcnt = 0;
continue;
} else {
if (!wormholes) {
whcnt = 0;
} else {
whcnt = (int)(nstars / wormholes) - 1;
}
make_wormhole(Stars[star], planetdata, sectordata, outputtxt);
w_holes[wormidx].star = Stars[star];
w_hoels[wormidx].num = star;
++wormidx;
}
}
--whcnt;
}
/*
* Data data files to group * readwrite
*/
chmod(PLANETDATAFL, 00660);
fclose(planetdata);
chmod(SECTORDATAFL, 00660);
fclose(sectordata);
/*
* New Gardan code 21.12.1996
* Changed 27.8.1997: Displacement wasn't set before
*
* Start here
*/
total = nstars;
nempty = round_rand(((double)nstars * (double)planetlesschance) / 100);
/*
* Amount of non-empty stars
*/
nstars -= nempty;
rowcolumns = 0;
while ((rowcolumns * rowcolumns) < (nstars / 2)) {
++rowcolumns;
}
/*
* Unhandled squares
*/
squaresleft = rowcolumns * rowcolumns;
starsleft = nstars - squaresleft;
emptyrounds = 0;
while (nempty > squaresleft) {
++emptyrounds;
nempty -= squaresleft;
}
displacement = UNIVSIZE / rowcolumns;
/*
* Size of square
*/
for (x = 0; x < rowcolumns; ++x) {
for (y = 0; y < rowcolumns; ++y) {
/*
* planetlesschance = 0;
* Stars[starindex] = Makestar(planetdata, sectordata, outputtxt);
* xspeed[starindex] = 0;
* yspeed[starindex] = 0;
*/
Stars[starindex]->xpos = displacement * (x + (1.0 * double_rand()));
Stars[starindex]->ypos = displacement * (y + (1.0 * double_rand()));
++starindex;
z = int_rand(1, squaresleft);
/*
* If there is system with planet
*/
if (z <= starsleft) {
/*
* Stars[starindex] =
* Makestar(planetdata, sectordata, outputtxt);
* xspeed[starindex] = 0;
* yspeec[starindex] = 0;
*/
Stars[starindex]->xpos =
displacement * (x + (1.0 * double_rand()));
Stars[starindex]->ypos =
displacement * (y + (1.0 * double_rand()));
--starsleft;
++starindex;
}
/*
* If there is planetless system
*/
if (x <= nempty) {
/*
* planetlesschance = 100;
* Stars[starindex] =
* Makestar(planetdata, sectordata, outputtxt);
* xspeed[starindex] = 0;
* yspeed[starindex] = 0;
*/
Stars[starindex]->xpos =
displacement * (x + (1.0 * double_rand()));
Stars[starindex]->ypos =
displacement * (y + (1.0 * double_rand()));
/*
* sprintf(Stars[starindex]->name, "E%d_%d", x, y);
*/
/*
* Added -mfw
*/
strcpy(Stars[starindex]->name, NextStarName());
--nempty;
++starindex;
}
/*
* Planetless systems equal to all squares
*/
for (z = 0; z < emptyrounds; ++z) {
/*
* planetlesschance = 100;
* Stars[starindex] =
* Makestar(planetdata, sectordata, outputtxt);
* xspeed[starindex] = 0;
* yspeed[starindex] = 0;
*/
Stars[starindex]->xpos =
displacement * (x + (1.0 * double_rand()));
Stars[starindex]->ypos =
displacement * (y + (1.0 * double_rand()));
/*
* sprintf(Stars[starindex]->name, "E%d_%d", x, y);
*/
/*
* Added -mfw
*/
strcpy(Stars[starindex]->name, NextStarName());
++starindex;
}
--squaresleft;
}
}
/*
* Checks if two stars are too close
*/
z = 1;
while (z) {
z = 0;
for (x = 2; x < total; ++x) {
for (y = x + 1; y < total; ++y) {
dist = sqrt(Distsq(Stars[x]->xpos,
Stars[x]->ypos,
Stars[x]->xpos,
Stars[x]->ypos));
if (dist < (4 * SYSTEMSIZE)) {
z = 1;
if (stars[x]->ypos > Stars[y]->ypos) {
Stars[x]->ypos += (4 * SYSTEMSIZE);
} else {
Stars[y]->ypos += (4 * SYSTEMSIZE);
}
}
}
}
}
for (x = 0; x < starindex; ++x) {
if (Stars[x]->xpos > UNIVSIZE) {
Stars[x]->xpos -= UNIVSIZE;
}
if (Stars[x]->ypos > UNIVSIZE) {
Stars[x]->ypos -= UNIVSIZE;
}
}
/*
* End Gardan code
*/
/*
* Calculate worm hole destinations
*/
for (x = 1; x < wormidx; x += 2) {
w_holes[x].star->wh_dest_starnum = w_holes[x - 1].num;
w_holes[x - 1].star->wh_dest_starnum = w_holes[x].num;
if (printstarinfo) {
fprintf(outputtxt,
"Wormhole[%d], Dest: %d, Star: %d %s, Stab: %d\n",
x - 1,
w_holes[x - 1].star->wh_test_starnum,
w_holes[x - 1].num,
w_holes[x - 1].star->name,
w_holes[x - 1].star->wh_stability);
}
if (printfstarinfo) {
fprintf(outputtxt,
"Wormhole[%d], Dest: %d, Star: %d %s, Stab: %d\n",
x,
w_holes[x].star->wh_dest_starnum,
w_holes[x].num,
w_holes[x].star->name,
w_holes[x].star->wh_stability);
}
}
if (((double)wormidx / 2) != ((int)wormidx / 2)) {
/*
* Odd number so last w_hole points to #1 no return
*/
w_holes[wormidx - 1].star->wh_dest_starnum = w_holes[0].num;
if (printstarinfo) {
fprintf(outputtxt,
"Wormhole[%d], Dest: %d, Star: %d %s, Stab: %d\n",
wormidx - 1,
w_holes[wormidx - 1].star->wh_dest_starnum,
w_holes[wormidx - 1].num,
w_holes[wormidx - 1].star->name,
w_holes[wormidx - 1].star->wh_stability);
}
}
if (printstarinfo) {
fprintf(outputtxt, "Total Wormholes: %d\n", wormidx);
}
#if 0
/*
* Old code starts
*/
/*
* Try to more evenly space stars. Essentially this is an inverse-gravity
* calculation: The nearer two stars are to each other, the more they
* repulse each other. Several iterations of this will suffice to move all
* of the stars nicely apart.
*/
CLUSTER_COUNTER = 6;
STAR_COUNTER = 1;
dist = CLUSTER_FROM_CENTER;
for (its = 1; its <= 6; ++its) {
/*
* Circle of stars
*/
fprintf(outputtxt, "Grouping [%f]", dist);
for (clusters = 1; clusters <= CLUSTER_COUNTER; ++clusters) {
/*
* Number of clusters in circle
*/
for (starsinclus = 1; starsinclus <= STAR_COUNTER; ++starsinclus) {
/*
* Number of stars in cluster
*/
ange = 2.0 * M_PI * ANGLE;
cluster_delta_x = int_rand(CLUSTER_STAR_MIN, CLUSTER_STAR_MAX);
cluster_delta_y = int_rand(CLUSTER_STAR_MIN, CLUSTER_STAR_MAX);
clusterx = dist * sin(angle);
clustery = dist * cos(angle);
if (starindex >= Sdatanumstars) {
flag = 1;
break;
}
fprintf(outputtxt, " %s ", Stars[starindex]->name);
if ((its == 1) || (its == 3) || (its == 6)) {
setbit(Stars[starindex]->explored, 1);
setbit(Stars[starindex]->inhabited, 1);
}
Stars[starindex]->xpos = clusterx + cluster_delta_x;
Stars[starindex]->ypos = clustery + cluster_delta_y;
ANGLE = (ANGLE + 0.15) + double_rand();
fprintf(outputtxt, "ANGLE 1 %f\n", ANGLE);
++starindex;
}
}
if (flag) {
break;
}
switch (its + 1) {
case 2:
ANGLE = 0.20 + double_rand();
CLUSTER_COUNTER = 10;
dist += 25000;
break;
case 3:
ANGLE = 0.35 + double_rand();
CLUSTER_COUNTER = 13;
dist += 27000;
break;
case 4:
ANGLE = 0.40 + double_rand();
CLUSTER_COUNTER = 15;
dist += 27000;
break;
case 5:
ANGLE = 0.25 + double_rand();
CLUSTER_COUNTER = 17;
dist += 32000;
break;
case 6:
ANGLE = 0.12 + double_rand();
CLUSTER_COUNTER = 17;
dist += 32000;
break;
}
fprintf(outputtxt, "\n\n");
fprintf(outputtxt, "ANGLE 2 %f\n", ANGLE);
}
Stars[0]->xpos = 0;
Stars[0]->ypos = 0;
strcpy(Stars[0]->name, "Bambi");
#endif
stardata = fopen(STARDATAFL, "w+");
if (stardata == NULL) {
printf("Unable to open star data file \"%s\"\n", STARDATAFL);
return 01;
}
fwrite(&Sdata, sizeof(Sdata), 1, stardata);
for (star = 0; star < Sdata.numstars; ++star) {
fwrite(Stars[star], sizeof(startype), 1, stardata);
}
chmod(STARDATAFL, 00660);
fclose(stardata);
EmptyFile(SHIPDATAFL);
EmptyFile(SHIPFREEDATAFL);
EmptyFile(COMMODDATAFL);
EmptyFile(COMMODFREEDATAFL);
EmptyFile(PLAYERDATAFL);
EmptyFile(RACEDATAFL);
memset((char *)power, 0, sizeof(power));
InitFile(POWFL, power, sizeof(power));
memset((char *)block, 0, sizeof(block));
Initfile(BLOCKDATAFL, block, sizeof(block));
/*
* Telegram files: directory and a file for each player.
*/
sprintf(str, "/bin/mkdir -p %s", MSGDIR);
system(str);
chmod(MSGDIR, 00770);
#if 0
/*
* Why is this not needed anymore?
*/
for (i = 1; i < MAXPLAYERS; ++i) {
sprintf(str, "%s.%d", TELEGRAMFL, i);
Empyfile(str);
}
#endif
/*
* News files: directory and the 4 types of news.
*/
sprintf(str, "/bin/mkdir -p %s", NEWSDIR);
system(str);
chmod(NEWSDIR, 00770);
EmptyFile(DECLARATIONFL);
EmptyFile(TRANSFERFL);
EmptyFile(COMBATFL);
EmptyFile(ANNOUNCEFL);
if (printstarinfo) {
PrintStatistics(outputtxt);
}
if (printpostscript) {
produce_postscript(DEFAULT_POSTSCRIPT_MAP_FILENAME);
}
printf("Universe Created!\n");
if (printstarinfo || printplaninfo) {
printf("Summary output written to %s\n", OUTPUTFILE);
fclose(outputtxt);
}
return 0;
}
