* 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 (except when island placement fails for lack of room).
+ * islands with the same sizes.
*
- * Place and grow islands in spheres in turn. Place the first sector
- * randomly, pick an island size, then grow the island to that size.
+ * 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, randomly.
+ * 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
*
#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 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);
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");
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) {
if (!done)
qprint("Only managed to grow %d out of %d sectors.\n",
secs - 1, sc);
- ctot = nc;
return done;
}
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)) {
+ 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;
}
}
- find_coast(c);
- qprint(" %d(%d)", c - nc + 1, secs);
- ctot++;
+ 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;
+ }
+
+ 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);
+
+ for (c = nc; c < nc + ni; c++)
+ find_coast(c);
+
+ return 1;
}
/****************************************************************************
int i, mountain_search, k, c, total, ns, nm, highest, where, h, newk,
r, dk;
- for (c = 0; c < ctot; ++c) {
+ for (c = 0; c < nc + ni; ++c) {
total = 0;
ns = isecs[c];
nm = (pm * ns) / 100;
projects / empserver / blobdiff