*
* 3. Place and grow additional islands
*
- * Place and grow islands one after the other. Place the first sector
- * randomly, pick an island size, then grow the island to that size.
+ * Each continent has a "sphere of influence": the set of sectors
+ * closer to it than to any other continent. Each island is entirely
+ * in one such sphere, and each sphere contains the same number of
+ * islands with the same sizes.
+ *
+ * First, split the specified number of island sectors per continent
+ * randomly into the island sizes. Sort by size so that larger
+ * islands are grown before smaller ones, to give the large ones the
+ * best chance to grow to their planned size.
+ *
+ * Then place one island's first sector into each sphere, using
+ * weighted random sampling with weights favoring sectors away from
+ * land and other spheres. Add one sector to each island in turn,
+ * until they have the intended size. Repeat until the specified
+ * number of islands has been grown.
+ *
+ * If placement fails due to lack of room, start over, just like for
+ * continents.
*
* Growing works as for continents, except the minimum distance for
- * additional islands applies, and growing simply stops when there is
- * no room.
+ * additional islands applies, and growing simply stops when any of
+ * the islands being grown lacks the room to grow further. The number
+ * of sectors not grown carries over to the next island size.
*
* 4. Compute elevation
*
* First, place the specified number of mountains randomly.
* Probability increases with distance to sea.
*
- * Last, elevate mountains and the capitals. Pick coastal mountain
- * elevation randomly from an interval of medium elevations reserved
- * for them. Pick non-coastal mountain elevation randomly from an
- * interval of high elevation reserved for them. Set capital
- * elevation to a fixed, medium value.
+ * Last, elevate mountains and the capitals. Set mountain elevations
+ * starting at a "high" elevation, then increasing linearly. Set
+ * capital elevation to a fixed value.
*
* In between, elevate the remaining land one by one, working from
- * mountains towards the sea, and from the elevation just below the
- * non-coastal mountains' interval linearly down to 1, avoiding the
- * coastal mountains' interval.
+ * mountains towards the sea, and from the elevation just below "high"
+ * elevation linearly down to 1.
*
- * This gives islands of the same size the same set of elevations,
- * except for mountains.
+ * This gives islands of the same size the same set of elevations.
*
* Elevate sea: pick a random depth from an interval that deepens with
* the distance to land.
/* lower URAN_MIN for more uranium */
#define URAN_MIN 56
-/* do not change these 4 defines */
+/* do not change these defines */
#define LANDMIN 1 /* plate altitude for normal land */
-#define HILLMIN 34 /* plate altitude for hills */
#define PLATMIN 36 /* plate altitude for plateau */
#define HIGHMIN 98 /* plate altitude for mountains */
#define new_x(newx) (((newx) + WORLD_X) % WORLD_X)
#define new_y(newy) (((newy) + WORLD_Y) % WORLD_Y)
-static int ctot; /* total number of continents and islands grown */
-static int *isecs; /* array of how large each island is */
+/*
+ * Island sizes
+ * isecs[i] is the size of the i-th island.
+ */
+static int *isecs;
static int *capx, *capy; /* location of the nc capitals */
-static int dirx[] = { -2, -1, 1, 2, 1, -1 }; /* gyujnb */
-static int diry[] = { 0, -1, -1, 0, 1, 1 };
static int **own; /* owner of the sector. -1 means water */
static unsigned *seen;
static unsigned cur_seen;
+/*
+ * Closest continent and "distance"
+ * closest[XYOFFSET(x, y)] is the closest continent's number.
+ * distance[] is complicated; see init_spheres_of_influence() and
+ * init_distance_to_coast().
+ */
+static natid *closest;
+static unsigned short *distance;
+
+/*
+ * Queue for breadth-first search
+ */
+static int *bfs_queue;
+static int bfs_queue_head, bfs_queue_tail;
+
static int **elev; /* elevation of the sectors */
static int **sectx, **secty; /* the sectors for each continent */
-static int **sectc; /* which sectors are on the coast? */
static int *weight; /* used for placing mountains */
static int *dsea, *dmoun; /* the dist to the ocean and mountain */
static int stable(int);
static void elevate_land(void);
static void elevate_sea(void);
-static void set_coastal_flags(void);
static void print_vars(void);
static void fl_move(int);
-static void grow_islands(void);
+static int grow_islands(void);
/* Debugging aids: */
void print_own_map(void);
void print_xzone_map(void);
+void print_closest_map(void);
+void print_distance_map(void);
void print_elev_map(void);
/****************************************************************************
qprint("unstable drift\n");
qprint("growing continents...\n");
done = grow_continents();
+ if (!done)
+ continue;
+ qprint("growing islands:");
+ done = grow_islands();
} while (!done && ++try < NUMTRIES);
if (!done) {
- fprintf(stderr, "%s: world not large enough to hold continents\n",
+ fprintf(stderr, "%s: world not large enough for this much land\n",
program_name);
exit(1);
}
- qprint("growing islands:");
- grow_islands();
- qprint("\nelevating land...\n");
+ qprint("elevating land...\n");
create_elevations();
qprint("writing to sectors file...\n");
program_name);
exit(1);
}
+ if (ni % nc) {
+ fprintf(stderr, "%s: number of islands must be a multiple of"
+ " the number of continents\n",
+ program_name);
+ exit(1);
+ }
if (argc > 3)
is = atoi(argv[3]);
adj_land = malloc(WORLD_SZ() * sizeof(*adj_land));
xzone = malloc(WORLD_SZ() * sizeof(*xzone));
seen = calloc(WORLD_SZ(), sizeof(*seen));
+ closest = malloc(WORLD_SZ() * sizeof(*closest));
+ distance = malloc(WORLD_SZ() * sizeof(*distance));
+ bfs_queue = malloc(WORLD_SZ() * sizeof(*bfs_queue));
elev = calloc(WORLD_X, sizeof(int *));
for (i = 0; i < WORLD_X; ++i) {
own[i] = calloc(WORLD_Y, sizeof(int));
}
sectx = calloc(nc + ni, sizeof(int *));
secty = calloc(nc + ni, sizeof(int *));
- sectc = calloc(nc + ni, sizeof(int *));
isecs = calloc(nc + ni, sizeof(int));
weight = calloc(MAX(sc, is * 2), sizeof(int));
dsea = calloc(MAX(sc, is * 2), sizeof(int));
for (i = 0; i < nc; ++i) {
sectx[i] = calloc(sc, sizeof(int));
secty[i] = calloc(sc, sizeof(int));
- sectc[i] = calloc(sc, sizeof(int));
}
for (i = nc; i < nc + ni; ++i) {
sectx[i] = calloc(is * 2, sizeof(int));
secty[i] = calloc(is * 2, sizeof(int));
- sectc[i] = calloc(is * 2, sizeof(int));
}
}
static void
fl_move(int j)
{
- int i, n, newx, newy;
-
- for (i = roll0(6), n = 0; n < 6; i = (i + 1) % 6, ++n) {
- newx = new_x(capx[j] + dirx[i]);
- newy = new_y(capy[j] + diry[i]);
+ int dir, i, newx, newy;
+
+ dir = DIR_L + roll0(6);
+ for (i = 0; i < 6; i++) {
+ if (dir > DIR_LAST)
+ dir -= 6;
+ newx = new_x(capx[j] + diroff[dir][0]);
+ newy = new_y(capy[j] + diroff[dir][1]);
+ dir++;
if (iso(j, newx, newy) >= iso(j, capx[j], capy[j])) {
capx[j] = newx;
capy[j] = newy;
GROW THE CONTINENTS
****************************************************************************/
-/* Look for a coastal sector of continent c
-*/
-
-static void
-find_coast(int c)
+static int
+is_coastal(int x, int y)
{
- int i, j;
-
- for (i = 0; i < isecs[c]; ++i) {
- sectc[c][i] = 0;
- for (j = 0; j < 6; ++j)
- if (own[new_x(sectx[c][i] + dirx[j])][new_y(secty[c][i] + diry[j])] == -1)
- sectc[c][i] = 1;
- }
+ return adj_land[XYOFFSET(x, y)]
+ != (1u << (DIR_LAST + 1)) - (1u << DIR_FIRST);
}
struct hexagon_iter {
xzone_around_island(c, id);
}
+/*
+ * Initialize breadth-first search.
+ */
+static void
+bfs_init(void)
+{
+ int i;
+
+ for (i = 0; i < WORLD_SZ(); i++) {
+ closest[i] = -1;
+ distance[i] = USHRT_MAX;
+ }
+
+ bfs_queue_head = bfs_queue_tail = 0;
+}
+
+/*
+ * Add sector @x,@y to the BFS queue.
+ * It's closest to @c, with distance @dist.
+ */
+static void
+bfs_enqueue(int c, int x, int y, int dist)
+{
+ int off = XYOFFSET(x, y);
+
+ assert(dist < distance[off]);
+ closest[off] = c;
+ distance[off] = dist;
+ bfs_queue[bfs_queue_tail] = off;
+ bfs_queue_tail++;
+ if (bfs_queue_tail >= WORLD_SZ())
+ bfs_queue_tail = 0;
+ assert(bfs_queue_tail != bfs_queue_head);
+}
+
+/*
+ * Search breadth-first until the queue is empty.
+ */
+static void
+bfs_run_queue(void)
+{
+ int off, dist, i, noff, nx, ny;
+ coord x, y;
+
+ while (bfs_queue_head != bfs_queue_tail) {
+ off = bfs_queue[bfs_queue_head];
+ bfs_queue_head++;
+ if (bfs_queue_head >= WORLD_SZ())
+ bfs_queue_head = 0;
+ dist = distance[off] + 1;
+ sctoff2xy(&x, &y, off);
+ for (i = DIR_FIRST; i <= DIR_LAST; i++) {
+ nx = new_x(x + diroff[i][0]);
+ ny = new_y(y + diroff[i][1]);
+ noff = XYOFFSET(nx, ny);
+ if (dist < distance[noff]) {
+ bfs_enqueue(closest[off], nx, ny, dist);
+ } else if (distance[noff] == dist) {
+ if (closest[off] != closest[noff])
+ closest[noff] = (natid)-1;
+ } else
+ assert(distance[noff] < dist);
+ }
+ }
+}
+
+/*
+ * Add island @c's coastal sectors to the BFS queue, with distance 0.
+ */
+static void
+bfs_enqueue_island(int c)
+{
+ int i;
+
+ for (i = 0; i < isecs[c]; i++) {
+ if (is_coastal(sectx[c][i], secty[c][i]))
+ bfs_enqueue(c, sectx[c][i], secty[c][i], 0);
+ }
+}
+
+/*
+ * Enqueue spheres of influence borders for breadth-first search.
+ */
+static void
+bfs_enqueue_border(void)
+{
+ int x, y, off, dir, nx, ny, noff;
+
+ for (y = 0; y < WORLD_Y; y++) {
+ for (x = y % 2; x < WORLD_X; x += 2) {
+ off = XYOFFSET(x, y);
+ if (distance[off] <= id + 1)
+ continue;
+ if (closest[off] == (natid)-1)
+ continue;
+ for (dir = DIR_FIRST; dir <= DIR_LAST; dir++) {
+ nx = new_x(x + diroff[dir][0]);
+ ny = new_y(y + diroff[dir][1]);
+ noff = XYOFFSET(nx, ny);
+ if (closest[noff] != closest[off]) {
+ bfs_enqueue(closest[off], x, y, id + 1);
+ break;
+ }
+ }
+ }
+ }
+}
+
+/*
+ * Compute spheres of influence
+ * A continent's sphere of influence is the set of sectors closer to
+ * it than to any other continent.
+ * Set closest[XYOFFSET(x, y)] to the closest continent's number,
+ * -1 if no single continent is closest.
+ * Set distance[XYOFFSET(x, y)] to the minimum of the distance to the
+ * closest coastal land sector and the distance to just outside the
+ * sphere of influence plus @id. For sea sectors within a continent's
+ * sphere of influence, distance[off] - id is the distance to the
+ * border of the area where additional islands can be placed.
+ */
+static void
+init_spheres_of_influence(void)
+{
+ int c;
+
+ bfs_init();
+ for (c = 0; c < nc; c++)
+ bfs_enqueue_island(c);
+ bfs_run_queue();
+ bfs_enqueue_border();
+ bfs_run_queue();
+}
+
+/*
+ * Precompute distance to coast
+ * Set distance[XYOFFSET(x, y)] to the distance to the closest coastal
+ * land sector.
+ * Set closest[XYOFFSET(x, y)] to the closest continent's number,
+ * -1 if no single continent is closest.
+ */
+static void
+init_distance_to_coast(void)
+{
+ int c;
+
+ bfs_init();
+ for (c = 0; c < nc + ni; c++)
+ bfs_enqueue_island(c);
+ bfs_run_queue();
+}
+
+/*
+ * Is @x,@y in the same sphere of influence as island @c?
+ * Always true when @c is a continent.
+ */
+static int
+is_in_sphere(int c, int x, int y)
+{
+ return c < nc || closest[XYOFFSET(x, y)] == c % nc;
+}
+
/*
* Can island @c grow at @x,@y?
*/
static int
can_grow_at(int c, int x, int y)
{
- return own[x][y] == -1 && xzone_ok(c, x, y);
+ return own[x][y] == -1 && xzone_ok(c, x, y) && is_in_sphere(c, x, y);
}
static void
adj_land_update(int x, int y)
{
+ int is_land = own[x][y] != -1;
int dir, nx, ny, noff;
- assert(own[x][y] != -1);
-
for (dir = DIR_FIRST; dir <= DIR_LAST; dir++) {
nx = new_x(x + diroff[dir][0]);
ny = new_y(y + diroff[dir][1]);
noff = XYOFFSET(nx, ny);
- adj_land[noff] |= 1u << DIR_BACK(dir);
+ if (is_land)
+ adj_land[noff] |= 1u << DIR_BACK(dir);
+ else
+ adj_land[noff] &= ~(1u << DIR_BACK(dir));
}
}
int done = 1;
int c, secs;
- ctot = 0;
xzone_init(0);
for (c = 0; c < nc; ++c) {
}
}
- for (c = 0; c < nc; ++c)
- find_coast(c);
-
if (!done)
qprint("Only managed to grow %d out of %d sectors.\n",
secs - 1, sc);
- ctot = nc;
return done;
}
* Return 1 on success, 0 on error.
*/
static int
-place_island(int c)
+place_island(int c, int isiz)
{
- int n, x, y, newx, newy;
+ int n, x, y, d, w, newx, newy;
n = 0;
for (y = 0; y < WORLD_Y; y++) {
for (x = y % 2; x < WORLD_X; x += 2) {
if (can_grow_at(c, x, y)) {
- n++;
- if (!roll0(n)) {
+ d = distance[XYOFFSET(x, y)];
+ assert(d > id);
+ w = (d - id) * (d - id);
+ n += MIN(w, (isiz + 2) / 3);
+ if (roll0(n) < w) {
newx = x;
newy = y;
}
return n;
}
-/* Grow all the islands
-*/
+static int
+int_cmp(const void *a, const void *b)
+{
+ return *(int *)b - *(int *)a;
+}
-static void
+static int *
+size_islands(void)
+{
+ int n = ni / nc;
+ int *isiz = malloc(n * sizeof(*isiz));
+ int r0, r1, i;
+
+ isiz[0] = n * is;
+ r1 = roll0(is);
+ for (i = 1; i < n; i++) {
+ r0 = r1;
+ r1 = roll0(is);
+ isiz[i] = is + r1 - r0;
+ isiz[0] -= isiz[i];
+ }
+
+ qsort(isiz, n, sizeof(*isiz), int_cmp);
+ return isiz;
+}
+
+/*
+ * Grow the additional islands.
+ * Return 1 on success, 0 on error.
+ */
+static int
grow_islands(void)
{
- int stunted_islands = 0;
- int c, secs, isiz;
+ int *island_size = size_islands();
+ int xzone_valid = 0;
+ int carry = 0;
+ int i, j, c, done, secs, isiz, x, y;
- xzone_init(nc);
+ init_spheres_of_influence();
- for (c = nc; c < nc + ni; ++c) {
- if (!place_island(c)) {
- qprint("\nNo room for island #%d", c - nc + 1);
- break;
+ for (i = 0; i < ni / nc; i++) {
+ c = nc + i * nc;
+
+ if (!xzone_valid)
+ xzone_init(c);
+
+ carry += island_size[i];
+ isiz = MIN(2 * is, carry);
+
+ for (j = 0; j < nc; j++) {
+ isecs[c + j] = 0;
+ if (!place_island(c + j, isiz)) {
+ qprint("\nNo room for island #%d\n", c - nc + j + 1);
+ free(island_size);
+ return 0;
+ }
}
- isiz = roll(is) + roll0(is);
- for (secs = 1; secs < isiz; secs++) {
- if (!grow_one_sector(c)) {
- stunted_islands++;
- break;
+ done = 1;
+ for (secs = 1; secs < isiz && done; secs++) {
+ for (j = 0; j < nc; j++) {
+ if (!grow_one_sector(c + j))
+ done = 0;
+ }
+ }
+
+ if (!done) {
+ secs--;
+ for (j = 0; j < nc; j++) {
+ if (isecs[c + j] != secs) {
+ isecs[c + j]--;
+ assert(isecs[c + j] == secs);
+ x = sectx[c + j][secs];
+ y = secty[c + j][secs];
+ own[x][y] = -1;
+ adj_land_update(x, y);
+ }
}
+ xzone_valid = 0;
}
- find_coast(c);
- qprint(" %d(%d)", c - nc + 1, secs);
- ctot++;
+ for (j = 0; j < nc; j++)
+ qprint(" %d(%d)", c - nc + j + 1, isecs[c + j]);
+
+ carry -= secs;
}
- if (stunted_islands)
- qprint("\n%d stunted island%s",
- stunted_islands, splur(stunted_islands));
+ free(island_size);
+ qprint("\n");
+
+ if (carry)
+ qprint("Only managed to grow %d out of %d island sectors.\n",
+ is * ni - carry * nc, is * ni);
+
+ return 1;
}
/****************************************************************************
static void
create_elevations(void)
{
- int i, j;
-
- for (i = 0; i < WORLD_X; i++) {
- for (j = 0; j < WORLD_Y; j++)
- elev[i][j] = -INFINITE_ELEVATION;
- }
+ init_distance_to_coast();
elevate_land();
elevate_sea();
}
return d;
}
-#define ELEV elev[sectx[c][i]][secty[c][i]]
-#define distance_to_sea() (sectc[c][i]?1:distance_to_what(sectx[c][i], secty[c][i], 0))
#define distance_to_mountain() distance_to_what(sectx[c][i], secty[c][i], 2)
/* Decide where the mountains go
static void
elevate_land(void)
{
- int i, mountain_search, k, c, total, ns, nm, highest, where, h, newk,
- r, dk;
+ int max_nm = (pm * MAX(sc, is * 2)) / 100;
+ int i, off, mountain_search, k, c, total, ns, nm, r, x, y;
+ int highest, where, h;
+ double elevation, delta;
- for (c = 0; c < ctot; ++c) {
+ for (c = 0; c < nc + ni; ++c) {
total = 0;
ns = isecs[c];
nm = (pm * ns) / 100;
/* Place the mountains */
for (i = 0; i < ns; ++i) {
- dsea[i] = distance_to_sea();
+ off = XYOFFSET(sectx[c][i], secty[c][i]);
+ dsea[i] = MIN(5, distance[off] + 1);
weight[i] = (total += (dsea[i] * dsea[i]));
}
k && mountain_search < MOUNTAIN_SEARCH_MAX;
++mountain_search) {
r = roll0(total);
- for (i = 0; i < ns; ++i)
- if (r < weight[i] && ELEV == -INFINITE_ELEVATION &&
+ for (i = 0; i < ns; ++i) {
+ x = sectx[c][i];
+ y = secty[c][i];
+ if (r < weight[i] && !elev[x][y] &&
(c >= nc ||
((!(capx[c] == sectx[c][i] &&
capy[c] == secty[c][i])) &&
(!(new_x(capx[c] + 2) == sectx[c][i] &&
capy[c] == secty[c][i]))))) {
- ELEV = INFINITE_ELEVATION;
+ elev[x][y] = INFINITE_ELEVATION;
break;
}
+ }
--k;
}
for (i = 0; i < ns; ++i)
dmoun[i] = distance_to_mountain();
- dk = (ns - nm - ((c < nc) ? 3 : 1) > 0) ?
- (100 * (HIGHMIN - LANDMIN)) / (ns - nm - ((c < nc) ? 3 : 1)) :
- 100 * INFINITE_ELEVATION;
- for (k = 100 * (HIGHMIN - 1);; k -= dk) {
+ delta = (double)(HIGHMIN - 1 - LANDMIN)
+ / (ns - nm - ((c < nc) ? 3 : 1));
+ for (elevation = HIGHMIN - 1;; elevation -= delta) {
highest = 0;
where = -1;
for (i = 0; i < ns; ++i) {
- if (ELEV == -INFINITE_ELEVATION &&
+ x = sectx[c][i];
+ y = secty[c][i];
+ if (!elev[x][y] &&
(c >= nc || ((!(capx[c] == sectx[c][i] &&
capy[c] == secty[c][i])) &&
(!(new_x(capx[c] + 2) == sectx[c][i] &&
}
if (where == -1)
break;
- newk = k / 100;
- if (newk >= HILLMIN && newk < PLATMIN)
- newk = PLATMIN;
- if (newk < LANDMIN)
- newk = LANDMIN;
- elev[sectx[c][where]][secty[c][where]] = newk;
+ if (elevation < LANDMIN)
+ elevation = LANDMIN;
+ elev[sectx[c][where]][secty[c][where]] = (int)(elevation + 0.5);
}
/* Elevate the mountains and capitals */
+ elevation = HIGHMIN;
+ delta = (127.0 - HIGHMIN) / max_nm;
for (i = 0; i < ns; ++i) {
- if (ELEV == INFINITE_ELEVATION) {
+ x = sectx[c][i];
+ y = secty[c][i];
+ if (elev[x][y] == INFINITE_ELEVATION) {
+ elevation += delta;
+ elev[x][y] = (int)(elevation + 0.5);
+ /*
+ * Temporary "useless" die rolls to minimize
+ * tests/fairland/ churn:
+ */
if (dsea[i] == 1)
- ELEV = HILLMIN + roll0(PLATMIN - HILLMIN);
- else
- ELEV = HIGHMIN + roll0((256 - HIGHMIN) / 2) +
- roll0((256 - HIGHMIN) / 2);
+ roll0(2);
+ else {
+ roll0((256 - HIGHMIN) / 2);
+ roll0((256 - HIGHMIN) / 2);
+ }
} else if (c < nc &&
(((capx[c] == sectx[c][i] && capy[c] == secty[c][i])) ||
((new_x(capx[c] + 2) == sectx[c][i] &&
capy[c] == secty[c][i]))))
- ELEV = PLATMIN;
+ elev[x][y] = PLATMIN;
}
}
}
-#define distance_to_land() distance_to_what(x, y, 1)
-
static void
elevate_sea(void)
{
- int x, y;
+ int x, y, off;
for (y = 0; y < WORLD_Y; ++y) {
for (x = y % 2; x < WORLD_X; x += 2) {
- if (elev[x][y] == -INFINITE_ELEVATION)
- elev[x][y] = -roll(distance_to_land() * 20 + 27);
+ off = XYOFFSET(x, y);
+ if (own[x][y] == -1)
+ elev[x][y] = -roll(MIN(5, distance[off]) * 20 + 27);
}
}
}
{
if (elevation < LANDMIN)
return SCT_WATER;
- if (elevation < HILLMIN)
- return SCT_RURAL;
- if (elevation < PLATMIN)
- return SCT_MOUNT;
if (elevation < HIGHMIN)
return SCT_RURAL;
return SCT_MOUNT;
sct->sct_type = elev_to_sct_type(elev[x][y]);
sct->sct_newtype = sct->sct_type;
sct->sct_dterr = own[sct->sct_x][y] + 1;
+ sct->sct_coastal = is_coastal(sct->sct_x, sct->sct_y);
add_resources(sct);
}
}
- set_coastal_flags();
}
/****************************************************************************
}
}
+/*
+ * Print a map to help visualize closest[].
+ * This is for debugging.
+ */
+void
+print_closest_map(void)
+{
+ int sx, sy, x, y, off;
+
+ for (sy = -WORLD_Y / 2; sy < WORLD_Y / 2; sy++) {
+ y = YNORM(sy);
+ printf("%4d ", sy);
+ for (sx = -WORLD_X / 2; sx < WORLD_X / 2; sx++) {
+ x = XNORM(sx);
+ off = XYOFFSET(x, y);
+ if ((x + y) & 1)
+ putchar(' ');
+ else if (closest[off] == (natid)-1)
+ putchar('.');
+ else if (!distance[off]) {
+ assert(closest[off] == own[x][y]);
+ putchar('-');
+ } else {
+ putchar(numletter[closest[off] % 62]);
+ }
+ }
+ printf("\n");
+ }
+}
+
+void
+print_distance_map(void)
+{
+ int sx, sy, x, y, off;
+
+ for (sy = -WORLD_Y / 2; sy < WORLD_Y / 2; sy++) {
+ y = YNORM(sy);
+ printf("%4d ", sy);
+ for (sx = -WORLD_X / 2; sx < WORLD_X / 2; sx++) {
+ x = XNORM(sx);
+ off = XYOFFSET(x, y);
+ if ((x + y) & 1)
+ putchar(' ');
+ else if (closest[off] == (natid)-1)
+ putchar('.');
+ else if (!distance[off]) {
+ assert(closest[off] == own[x][y]);
+ putchar('-');
+ } else {
+ putchar(numletter[distance[off] % 62]);
+ }
+ }
+ printf("\n");
+ }
+}
+
/***************************************************************************
WRITE A SCRIPT FOR PLACING CAPITALS
va_end(ap);
}
}
-
-static void
-set_coastal_flags(void)
-{
- int i, j;
- struct sctstr *sp;
-
- for (i = 0; i < nc + ni; ++i) {
- for (j = 0; j < isecs[i]; j++) {
- sp = getsectp(sectx[i][j], secty[i][j]);
- sp->sct_coastal = sectc[i][j];
- }
- }
-}