crossfire
/
maps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
maps/Info/land.c

563 lines
15 KiB
C
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 3000
#define MAX(x,y) ((x)>(y)?(x):(y))
#define BASE_ALT -100
/* make this a global to avoid stack overflow */
int altitude[MAX_SIZE][MAX_SIZE];
/* This function writes out the crossfire maps. So shoot me for
* using compiled in constants - I'm not going to use this so much
* that I wanted to do anything too easy.
*/
#define MAP_FORMAT "world_%03d_%03d"
/* Maps are square */
#define MAP_SIZE 50
/* There will be a total of 2500 maps (eek) - 50 in
* each direction. startx and starty are where to start
* numbering from. I chose 100 for a few reasons - 1) it
* gives room to the left and above to add some things (another
* continent for that matter), and 2) since the format allows
* for up to 1000 in each direction, this seemed reasonable.
* Note - if you do the math, and have 1000 * 1000 maps, each
* with 50*50 spaces, you have a total of 2.5 billion spaces.
* So hopefully that should be large enough.
*/
int startx=100, starty=100;
typedef enum {
None=0,
DeepWater=1,
MediumWater=2,
ShallowWater=3,
Swamp=4,
DeepSwamp=5,
Grass=6,
Desert=7,
Brush=8,
EverGreens=9,
Jungle=10,
Tree1=11,
Tree2=12,
Woods1=13,
Woods2=14,
Woods3=15,
Hills=16,
HillsRocky=17,
Steppe=18,
Mountain=19,
HighMountain=20,
WasteLand=21, /*Now just higher mountain */
Beach = 22,
VeryHighMountain=23
} Terrain_Types;
char *Terrain_Names[][2] = {
/* these are the archetype names. They are in the same order
* as the Terrain_Types above. Note many terrain types are not
* included because handling them would be too difficult.
*/
{"None", "0, 0, 0 "},
{"deep_sea", "0 0 127 "},
{"sea", "0 0 192 "},
{"shallow_sea", "0 0 255 "}, /* wading depth */
{"swamp", "12 161 64 "},
{"deep_swamp", "155 175 164 "},
{"grass", "0 255 0 "},
{"desert", "222 218 135 "},
{"brush", "1 144 1 "},
{"evergreens", "0 128 0 "},
{"jungle_1", "0 176 0 "},
{"tree", "4 133 01 "},
{"evergreen", "20 209 0 "},
{"woods", "4 115 01 "},
{"woods_2", "1 182 02 "},
{"woods_3", "4 153 02 "},
{"hills", "166 160 70 "},
{"hills_rocky", "166 155 70 "},
{"steppe", "150 97 34 "},
{"mountain", "183 190 190 "},
{"mountain2", "191 196 185 "},
{"mountain4", "215 215 215 "},
/* Maybe need to put in order? */
{"beach", "232 228 165 "},
{"mountain5", "255 255 255 "},
};
void write_crossfire_maps(int mapy, int mapx)
{
int x, y,n,q, nx, ny,r1,r2,ax=0,ay=0, j, k;
char name[512];
FILE *fp;
Terrain_Types *terrain;
terrain = calloc(mapx * mapy * sizeof(Terrain_Types), sizeof(Terrain_Types));
/* First fill in the water and the highest of peaks */
for (x=0; x<mapx; x++) {
for (y=0; y<mapy; y++) {
if (altitude[y][x] < -5000) {
terrain[x + y * mapx] = DeepWater;
} else if (altitude[y][x] < -99) {
terrain[x + y * mapx] = MediumWater;
} else if (altitude[y][x] < 1) {
terrain[x + y * mapx] = ShallowWater;
} else if (altitude[y][x] >=25000) {
terrain[x + y * mapx] = VeryHighMountain;
}
}
}
/* Basically, take a random bit and populate the area with terrain.
* We do this so it won't be totally monolithic (have several forest types
* for example), yet patches will be the same thing, eg, a stretch of
* desert, which wouldn't work very well if we just chose randomly
* for each space.
*/
for (n=0; n<(mapx * mapy) / 100; n++) {
do {
x = random() % mapx;
y = random() % mapy;
} while ( terrain[x + y * mapx] == None);
nx = x + 40;
if (nx > mapx) nx=mapx;
ny = y + 40;
if (ny > mapy) ny = mapy;
r1 = random();
r2 = random();
for (x = nx-40; x<nx; x++) {
for (y=ny-40; y<ny; y++) {
if (terrain[x + y * mapx] != None) continue;
/* near the edges, don't always fill in so that hopefully something
* else will fill in and smooth these out some
*/
if ( (x < (nx -30) || y < (ny - 30) || x > (nx -10) || y > (ny - 10)) &&
random() % 2) continue;
if (altitude[y][x] < 10) {
terrain[x + y * mapx] = Swamp + (r1 % 2);
}
else if (altitude[y][x] < 75){
terrain[x + y * mapx] = Beach;
}
else if (altitude[y][x] < 1000) {
terrain[x + y * mapx] = Grass + (r1 % 3);
} else if (altitude[y][x] < 3000) {
terrain[x + y * mapx] = EverGreens + (r1 % 9);
} else if (altitude[y][x] < 5000) {
terrain[x + y * mapx] = Hills + (r2 % 3);
} else if (altitude[y][x] < 9000) {
terrain[x + y * mapx] = Mountain;
} else if (altitude[y][x] < 12000) {
terrain[x + y * mapx] = HighMountain;
} else if (altitude[y][x] < 25000) {
/* Not really precisely wasteland, but wastelands are impassable */
terrain[x + y * mapx] = WasteLand;
}
else fprintf(stderr,"altitude %d did not get filled in?\n", altitude[y][x]);
}
}
}
/* Now just fill in the spaces randomly. */
n=0;
r1 = random();
r2 = random();
for (x=0; x<mapx; x++) {
for (y=0; y<mapy; y++) {
if (terrain[x + y * mapx] != None) continue;
n++;
if (altitude[y][x] < 10) {
terrain[x + y * mapx] = Swamp + (r1 % 2);
}
else if (altitude[y][x] < 75){
terrain[x + y * mapx] = Beach;
}
else if (altitude[y][x] < 1000) {
terrain[x + y * mapx] = Grass + (r1 % 3);
} else if (altitude[y][x] < 3000) {
terrain[x + y * mapx] = EverGreens + (r2 % 9);
} else if (altitude[y][x] < 5000) {
terrain[x + y * mapx] = Hills + (r2 % 3);
} else if (altitude[y][x] < 9000) {
terrain[x + y * mapx] = Mountain;
} else if (altitude[y][x] < 12000) {
terrain[x + y * mapx] = HighMountain;
} else if (altitude[y][x] < 25000) {
terrain[x + y * mapx] = WasteLand;
}
}
}
fprintf(stderr,"Filled in %d spaces\n",n);
if ((mapx / MAP_SIZE) * MAP_SIZE != mapx ||
(mapy / MAP_SIZE) * MAP_SIZE != mapy) {
fprintf(stderr,"Warning - generated map does not evenly tile.\n");
}
for (nx= startx; nx<(startx + (mapx/ MAP_SIZE)); nx++) {
for (ny= starty; ny<(starty + (mapy/ MAP_SIZE)); ny++) {
ax = (nx - startx) * MAP_SIZE;
ay = (ny - starty) * MAP_SIZE;
sprintf(name,MAP_FORMAT,nx,ny);
if ((fp=fopen(name, "w"))==NULL) {
fprintf(stderr,"unable to open %s\n", name);
}
/* Write the header for the map */
fprintf(fp,"arch map\n");
fprintf(fp,"name %s\n", name);
fprintf(fp,"width %d\n", MAP_SIZE);
fprintf(fp,"height %d\n", MAP_SIZE);
/* Not used right now, but useful to include */
fprintf(fp,"outdoor 1\n");
/* don't do difficult, reset time, or enter coordinates */
/* Set up the tile paths */
if (ny != starty) {
fprintf(fp,"tile_path_1 ");
fprintf(fp,MAP_FORMAT,nx, ny-1);
fprintf(fp,"\n");
}
if ((nx+1) < startx + (mapx/ MAP_SIZE)) {
fprintf(fp,"tile_path_2 ");
fprintf(fp,MAP_FORMAT,nx+1, ny);
fprintf(fp,"\n");
}
if ((ny+1) < starty + (mapy/ MAP_SIZE)) {
fprintf(fp,"tile_path_3 ");
fprintf(fp,MAP_FORMAT,nx, ny+1);
fprintf(fp,"\n");
}
if (nx != startx) {
fprintf(fp,"tile_path_4 ");
fprintf(fp,MAP_FORMAT,nx-1, ny);
fprintf(fp,"\n");
}
fprintf(fp,"end\n");
for (x = 0; x<50; x++) {
for (y = 0; y < 50; y++) {
q = terrain[x + ax + (y + ay)* mapx];
fprintf(fp, "arch %s\n",Terrain_Names[q][0]);
fprintf(fp,"x %d\n", x);
fprintf(fp,"y %d\n", y);
q = altitude[y + ay ][x + ax];
if (q< -32000) q = -32000;
if (q > 32000) q = 32000;
fprintf(fp,"elevation %d\n", q);
fprintf(fp,"end\n");
}
}
fclose(fp);
}
}
fp = fopen("cmap", "w");
fprintf(fp, "P3 %d %d 255\n", mapy, mapx);
for (y=0; y < mapy; y++) {
for (x=0; x < mapx; x++) {
fprintf(fp, "%s", Terrain_Names[terrain[x + y * mapx]][1]);
}
fprintf(fp, "\n");
}
exit(0);
}
main(int argc, char *argv)
{
int x, y, max_x=500, max_y=500, seed, land=300000, npasses=40, newalt, wpasses=50, water=50000;
int n, i, j, k, l, z, w, r, a, write_maps=0;
FILE *fp, *lp;
int junk;
char c;
extern char *optarg;
seed = time(NULL);
while ((c = getopt(argc, argv,"x:y:X:Y:s:l:n:w:p:m"))!=-1) {
switch (c) {
case 'l':
land = atoi(optarg);
if (land < 11 ) {
fprintf(stderr,"-l must be at least 11\n");
exit(1);
}
break;
case 'w':
water = atoi(optarg);
if (water < 1 ) {
fprintf(stderr,"-w must be at least 1\n");
exit(1);
}
break;
case 'p':
wpasses = atoi(optarg);
if (wpasses < 1 ) {
fprintf(stderr,"-w must be at least 1\n");
exit(1);
}
break;
case 'n':
npasses = atoi(optarg);
if (npasses < 10 ) {
fprintf(stderr,"-n must be at least 10\n");
exit(1);
}
break;
case 'x':
max_x = atoi(optarg);
break;
case 'y':
max_y = atoi(optarg);
break;
case 'X':
startx = atoi(optarg);
case 'Y':
starty = atoi(optarg);
break;
case 's':
seed = atoi(optarg);
break;
case 'm':
write_maps=1;
break;
}
}
if (max_x > MAX_SIZE || max_y > MAX_SIZE) {
fprintf(stderr,"Max X and Y size is %d\n", MAX_SIZE);
exit(1);
}
fprintf(stderr,"Making %d X %d map, seed %d, land %d, passes = %d\n", max_x, max_y, seed, land, npasses);
fprintf(stderr,"wpasses =%d, water=%d\n", wpasses, water);
fprintf(stderr,"-x %d -y %d -X %d -Y %d -s %d -p %d -n %d -w %d -l %d\n",
max_x, max_y, startx, starty, seed, wpasses, npasses, water, land);
srandom(seed);
for (x=20; x < max_x-20; x++)
for (y=20; y < max_y-20; y++)
altitude[x][y] = BASE_ALT;
for (x=0; x<max_x; x++) {
for (y=0; y<20; y++) {
altitude[x][y] = (y -20 ) * 100;
altitude[x][max_y - y] = (y -20 ) * 100;
}
}
for (y=10; y<max_y-10; y++) {
for (x=0; x<20; x++) {
altitude[x][y] = (x - 20) * 100;
altitude[max_x - x][y] = (x - 20) * 100;
}
}
/* This basically produces areas of high variance (eg, islands, peaks, valleys, etc) */
for (l=0; l<npasses; l++) {
x = random()%max_x;
y = random()%max_y;
/* Weigh our selected starting position a little more towards the center
* so the continent is more in the center
*/
if (random() % 2) {
x += random()%max_x;
y += random()%max_y;
x /=2;
y /=2;
}
n = random()%500+800;
/* For some portion, try to find a pixel we have yet to modify */
if (l> (npasses * 15) / 20) {
int tries=0;
while (altitude[x][y] == BASE_ALT) {
x = random()%max_x;
y = random()%max_y;
if (random() % 2) {
x += random()%max_x;
y += random()%max_y;
x /=2;
y /=2;
}
tries++;
if (tries > 50) {
fprintf(stderr,"did not find free space within %d tries\n", tries);
break;
}
}
}
for (k=1; k< land ; k++) {
r = random()%4;
switch (r) {
case 0: if (x<max_x-1) x++; else x -= random() % (max_x/2); break;
case 1: if (y<max_y-1) y++; else y -= random() % (max_y/2); break;
case 2: if (x) x--; else x+= random() % (max_x/2); break;
case 3: if (y) y--; else y+= random() % (max_y/2); break;
}
altitude[x][y] += n;
if (random()%k < 100)
n -= 1;
}
}
/* Make lakes and ocean trenches.
* General note - it works better to have more passes, but each
* pass doing less working - this results in more consistent lakes
* and ocean trenching.
*/
for (l=0; l<wpasses; l++) {
/* for a small portion, we lower the area we make */
n = random()%1500-2000;
x = random()% max_x;
y = random()% max_y;
while (altitude[x][y] > BASE_ALT || altitude[x][y]<-7000) {
x = random()% max_x;
y = random()% max_y;
}
for (k=1; k< water ; k++) {
r = random()%4;
switch (r) {
case 0: if (x<max_x-1) x++; break;
case 1: if (y<max_y-1) y++; break;
case 2: if (x) x--; break;
case 3: if (y) y--; break;
}
altitude[x][y] += n;
if (random()%k < 100)
n += 1; /*less dramatic as things go on */
}
}
/* This block seems to average out the spaces somewhat to prevent
* cliffs and the like.
*/
#define NUM_PASSES 3
r = 10;
for (k=0; k<NUM_PASSES; k++) {
for (x=2; x<max_x-2; x++) {
for (y=2; y<max_y - 2; y++) {
newalt = (altitude[x][y] * r + altitude[x-1][y] +
altitude[x][y-1] + altitude[x-1][y-1] +
altitude[x+1][y] + altitude[x][y+1] +
altitude[x+1][y+1] + altitude[x+1][y-1] +
altitude[x-1][y+1]) / (r+8);
if (altitude[x][y] < 10 || altitude[x][y] > newalt) altitude[x][y] = newalt;
}
}
for (x=max_x-2; x>2; x--) {
for (y=max_y-2; y>2; y--) {
newalt = (altitude[x][y] * r + altitude[x-1][y] +
altitude[x][y-1] + altitude[x-1][y-1] +
altitude[x+1][y] + altitude[x][y+1] +
altitude[x+1][y+1] + altitude[x+1][y-1] +
altitude[x-1][y+1]) / (r+8);
if (altitude[x][y] < 10 || altitude[x][y] > newalt) altitude[x][y] = newalt;
}
}
}
/* Make this 100 so that we eliminate/reduce the lakiness of
* the map that is otherwise generated - otherwise, the map
* looks like an archipelago
*/
#define AVG_PT -10
/* water - does the same as above, but try to more equally balance the spaces*/
r = 1;
for (k=0; k<40; k++) {
for (x=2; x<max_x-2; x++) {
for (y=2; y<max_y -2; y++) {
if (altitude[x][y] < AVG_PT)
altitude[x][y] = (altitude[x][y] * r + altitude[x-1][y] +
altitude[x][y-1] + altitude[x-1][y-1] +
altitude[x+1][y] + altitude[x][y+1] +
altitude[x+1][y+1] + altitude[x+1][y-1] +
altitude[x-1][y+1]) / (r+8);
}
}
for (x=max_x-2; x>2; x--) {
for (y=max_y-2; y>2; y--) {
if (altitude[x][y] < AVG_PT)
altitude[x][y] = (altitude[x][y] * r + altitude[x-1][y] +
altitude[x][y-1] + altitude[x-1][y-1] +
altitude[x+1][y] + altitude[x][y+1] +
altitude[x+1][y+1] + altitude[x+1][y-1] +
altitude[x-1][y+1]) / (r+8);
}
}
}
if (write_maps)
write_crossfire_maps(max_x, max_y);
/* Now write the data out */
fp = fopen("lmap", "w");
lp = fopen("pmap", "w");
fprintf(fp, "P3 %d %d 255\n", max_y, max_x);
for (j=0; j < max_x; j++) {
for (k=0; k < max_y; k++) {
junk = altitude[j][k];
fprintf(lp, "%d ", altitude[j][k]);
if (junk < -5000)
fprintf(fp, "0 0 127 ");
/* Shallow water should really be just at the coastal
* area, so put a big gap between shallow and deep.
* this also evens out the occurrence of the different types
* to be more equal
*/
else if (junk < -99)
fprintf(fp, "0 0 192 ");
else if (junk < 1)
fprintf(fp, "0 0 255 ");
else if (junk < 1000)
fprintf(fp, "0 240 0 ");
else if (junk < 2000)
fprintf(fp, "0 220 0 ");
else if (junk < 3000)
fprintf(fp, "0 200 0 ");
else if (junk < 4000)
fprintf(fp, "0 180 0 ");
else if (junk < 5000)
fprintf(fp, "0 160 0 ");
else if (junk < 6000)
fprintf(fp, "255 130 71 ");
else if (junk < 8000)
fprintf(fp, "238 121 66 ");
else if (junk < 10000)
fprintf(fp, "205 104 57 ");
else if (junk < 12000)
fprintf(fp, "139 71 38 ");
else
fprintf(fp, "255 255 255 ");
}
fprintf(fp, "\n");
}
exit(0);
}
Reference in New Issue View Git Blame Copy Permalink