land.c

Go to the documentation of this file.

#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);
}