* 5. Set resources
*
* Sector resources are simple functions of elevation. You can alter
- * macros OIL_MAX, IRON_MIN, GOLD_MIN, FERT_MAX, and URAN_MIN to
- * customize them.
+ * iron_conf[], gold_conf[], fert_conf[], oil_conf[], and uran_conf[]
+ * to customize them.
*/
#include <config.h>
#include "version.h"
#include "xy.h"
-/* The following five numbers refer to elevation under which (in the case of
- fertility or oil) or over which (in the case of iron, gold, and uranium)
- sectors with that elevation will contain that resource. Elevation ranges
- from 0 to 100 */
-
-/* raise FERT_MAX for more fertility */
-#define FERT_MAX 56
-
-/* raise OIL_MAX for more oil */
-#define OIL_MAX 33
-
-/* lower IRON_MIN for more iron */
-#define IRON_MIN 22
-
-/* lower GOLD_MIN for more gold */
-#define GOLD_MIN 36
-
-/* lower URAN_MIN for more uranium */
-#define URAN_MIN 56
-
/* do not change these defines */
#define LANDMIN 1 /* plate altitude for normal land */
#define PLATMIN 36 /* plate altitude for plateau */
#define HIGHMIN 98 /* plate altitude for mountains */
+/*
+ * Resource configuration
+
+ * Resources are determined by elevation. The map from elevation to
+ * resource is defined as a linear interpolation of resource data
+ * points (elev, res) defined in the tables below. Elevations range
+ * from -127 to 127, and resource values from 0 to 100.
+ */
+
+struct resource_point {
+ int elev, res;
+};
+
+struct resource_point iron_conf[] = {
+ { -127, 0 },
+ { 21, 0 },
+ { 85, 100 },
+ { HIGHMIN - 1, 100 },
+ { HIGHMIN , 0 },
+ { 127, 0 } };
+
+struct resource_point gold_conf[] = {
+ { -127, 0 },
+ { 35, 0 },
+ { HIGHMIN - 1, 80 },
+ { HIGHMIN, 80 },
+ { 127, 85 } };
+
+struct resource_point fert_conf[] = {
+ { -127, 100 },
+ { -59, 100 },
+ { LANDMIN - 1, 41 },
+ { LANDMIN, 100 },
+ { 10, 100 },
+ { 56, 0 },
+ { 127, 0 } };
+
+struct resource_point oil_conf[] = {
+ { -127, 100 },
+ { -49, 100 },
+ { LANDMIN - 1, 2 },
+ { LANDMIN, 100 },
+ { 6, 100 },
+ { 34, 0 },
+ { 127, 0 } };
+
+struct resource_point uran_conf[] = {
+ { -127, 0 },
+ { 55, 0 },
+ { 90, 100 },
+ { 97, 100 },
+ { 98, 0 },
+ { 127, 0 } };
+
static void qprint(const char * const fmt, ...)
ATTRIBUTE((format (printf, 1, 2)));
static int *capx, *capy; /* location of the nc capitals */
-static int **own; /* owner of the sector. -1 means water */
+/*
+ * Island at x, y
+ * own[XYOFFSET(x, y)] is x,y's island number, -1 if water.
+ */
+static short *own;
/*
* Adjacent land sectors
capx = calloc(nc, sizeof(int));
capy = calloc(nc, sizeof(int));
- own = calloc(WORLD_X, sizeof(int *));
+ own = malloc(WORLD_SZ() * sizeof(*own));
adj_land = malloc(WORLD_SZ() * sizeof(*adj_land));
elev = calloc(WORLD_SZ(), sizeof(*elev));
xzone = malloc(WORLD_SZ() * sizeof(*xzone));
closest = malloc(WORLD_SZ() * sizeof(*closest));
distance = malloc(WORLD_SZ() * sizeof(*distance));
bfs_queue = malloc(WORLD_SZ() * sizeof(*bfs_queue));
- 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 *));
isecs = calloc(nc + ni, sizeof(int));
static void
init(void)
{
- int i, j;
+ int i;
- for (i = 0; i < WORLD_X; ++i) {
- for (j = 0; j < WORLD_Y; ++j) {
- own[i][j] = -1;
- }
- }
+ for (i = 0; i < WORLD_SZ(); i++)
+ own[i] = -1;
memset(adj_land, 0, WORLD_SZ() * sizeof(*adj_land));
}
static int
can_grow_at(int c, int x, int y)
{
- return own[x][y] == -1 && xzone_ok(c, x, y) && is_in_sphere(c, x, y);
+ return own[XYOFFSET(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 is_land = own[XYOFFSET(x, y)] != -1;
int dir, nx, ny, noff;
for (dir = DIR_FIRST; dir <= DIR_LAST; dir++) {
static void
add_sector(int c, int x, int y)
{
- assert(own[x][y] == -1);
+ int off = XYOFFSET(x, y);
+
+ assert(own[off] == -1);
xzone_around_sector(c, x, y, c < nc ? di : DISTINCT_ISLANDS ? id : 0);
sectx[c][isecs[c]] = x;
secty[c][isecs[c]] = y;
isecs[c]++;
- own[x][y] = c;
+ own[off] = c;
adj_land_update(x, y);
}
assert(isecs[c + j] == secs);
x = sectx[c + j][secs];
y = secty[c + j][secs];
- own[x][y] = -1;
+ own[XYOFFSET(x, y)] = -1;
adj_land_update(x, y);
}
}
while (n > 0) {
off0 = roll0(WORLD_SZ());
sctoff2xy(&x0, &y0, off0);
- if (own[x0][y0] == -1) {
+ if (own[off0] == -1) {
r = roll(MIN(3, distance[off0]));
sign = -1;
} else {
ADD THE RESOURCES
****************************************************************************/
+/*
+ * Map elevation @elev to a resource value according to @conf.
+ * This is a linear interpolation on the data points in @conf.
+ */
static int
-set_fert(int e)
-{
- int fert = 0;
- if (e < LANDMIN)
- fert = LANDMIN - e + 40;
- else if (e < FERT_MAX)
- fert = (120 * (FERT_MAX - e)) / (FERT_MAX - LANDMIN);
- if (fert > 100)
- fert = 100;
- return fert;
-}
-
-static int
-set_oil(int e)
-{
- int oil = 0;
- if (e < LANDMIN)
- oil = (LANDMIN - e) * 2;
- else if (e <= OIL_MAX)
- oil = (120 * (OIL_MAX - e + 1)) / (OIL_MAX - LANDMIN + 1);
- if (oil > 100)
- oil = 100;
- return oil;
-}
-
-static int
-set_iron(int e)
-{
- int iron = 0;
- if (e >= IRON_MIN && e < HIGHMIN)
- iron = (120 * (e - IRON_MIN + 1)) / (HIGHMIN - IRON_MIN);
- if (iron > 100)
- iron = 100;
- return iron;
-}
-
-static int
-set_gold(int e)
-{
- int gold = 0;
- if (e >= GOLD_MIN) {
- if (e < HIGHMIN)
- gold = (80 * (e - GOLD_MIN + 1)) / (HIGHMIN - GOLD_MIN);
- else
- gold = 80 + 5 * (e - HIGHMIN) / (127 - HIGHMIN);
- }
- if (gold > 100)
- gold = 100;
- return gold;
-}
-
-static int
-set_uran(int e)
+elev_to_resource(int elev, struct resource_point conf[])
{
- int uran = 0;
- if (e >= URAN_MIN && e < HIGHMIN)
- uran = (120 * (e - URAN_MIN + 1)) / (HIGHMIN - URAN_MIN);
- if (uran > 100)
- uran = 100;
- return uran;
+ int i, elev1, elev2, delev, res1, res2, dres;
+
+ for (i = 1; elev > conf[i].elev; i++) ;
+ assert(conf[i - 1].elev <= elev);
+
+ elev1 = conf[i - 1].elev;
+ elev2 = conf[i].elev;
+ delev = elev2 - elev1;
+ res1 = conf[i - 1].res;
+ res2 = conf[i].res;
+ dres = res2 - res1;
+ return (int)(res1 + (double)((elev - elev1) * dres) / delev);
}
static void
add_resources(struct sctstr *sct)
{
- sct->sct_fertil = set_fert(sct->sct_elev);
- sct->sct_oil = set_oil(sct->sct_elev);
- sct->sct_min = set_iron(sct->sct_elev);
- sct->sct_gmin = set_gold(sct->sct_elev);
- sct->sct_uran = set_uran(sct->sct_elev);
+ sct->sct_min = elev_to_resource(sct->sct_elev, iron_conf);
+ sct->sct_gmin = elev_to_resource(sct->sct_elev, gold_conf);
+ sct->sct_fertil = elev_to_resource(sct->sct_elev, fert_conf);
+ sct->sct_oil = elev_to_resource(sct->sct_elev, oil_conf);
+ sct->sct_uran = elev_to_resource(sct->sct_elev, uran_conf);
}
/****************************************************************************
sct->sct_elev = elev[sct->sct_uid];
sct->sct_type = elev_to_sct_type(sct->sct_elev);
sct->sct_newtype = sct->sct_type;
- sct->sct_dterr = own[sct->sct_x][y] + 1;
+ sct->sct_dterr = own[sct->sct_uid] + 1;
sct->sct_coastal = is_coastal(sct->sct_x, sct->sct_y);
add_resources(sct);
}
for (sx = -WORLD_X / 2 + y % 2; sx < WORLD_X / 2; sx += 2) {
x = XNORM(sx);
off = XYOFFSET(x, y);
- c = own[x][y];
+ c = own[off];
type = elev_to_sct_type(elev[off]);
if (type == SCT_WATER)
printf(". ");
}
/*
- * Print a map to help visualize own[][].
+ * Print a map to help visualize own[].
* This is for debugging.
*/
void
print_own_map(void)
{
- int sx, sy, x, y;
+ 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 (own[x][y] == -1)
+ else if (own[off] == -1)
putchar('.');
else
- putchar(numletter[own[x][y] % 62]);
+ putchar(numletter[own[off] % 62]);
}
putchar('\n');
}
off = XYOFFSET(x, y);
if ((x + y) & 1)
putchar(' ');
- else if (own[x][y] >= 0)
+ else if (own[off] >= 0)
putchar('-');
else if (xzone[off] >= 0)
putchar(numletter[xzone[off] % 62]);
else {
- assert(own[x][y] == -1);
+ assert(own[off] == -1);
putchar(xzone[off] == -1 ? '.' : '!');
}
}
else if (closest[off] == (natid)-1)
putchar('.');
else if (!distance[off]) {
- assert(closest[off] == own[x][y]);
+ assert(closest[off] == own[off]);
putchar('-');
} else {
putchar(numletter[closest[off] % 62]);
else if (closest[off] == (natid)-1)
putchar('.');
else if (!distance[off]) {
- assert(closest[off] == own[x][y]);
+ assert(closest[off] == own[off]);
putchar('-');
} else {
putchar(numletter[distance[off] % 62]);
projects / empserver / blobdiff