[Freeciv-Dev] Re: (PR#3489) Patch to add new generator

["jjc@xxxxxxxxxxxxxxxxxx" <jjc@xxxxxxxxxxxxxxxxxx>]

On Sat, Mar 29, 2003 at 12:25:07PM -0800, Mike Kaufman wrote:
> On Thu, Mar 27, 2003 at 03:32:37PM -0800, jjc@xxxxxxxxxxxxxxxxxx wrote:
> > I humbly submit what I hope is the last version of my patch to add a new 
> > generator 6. This patch fixes some problems with generating too many 
> > mountains
> > in the player's peninsula.  It also removes one of  the isthmus loop 
> > so it is a little shorter.  
> > 
> > It is generated in relation to cvs.  I think it is ready for committing 
> > into 
> > cvs.  
> 
> josh-
> 
> could you please put up a couple of screenshots somewhere (or if you can't
> upload them to the ftp server) and send us a savegame with a map using this
Savegames and screenshots are up at:
http://www.honors.montana.edu/~jjc/gen_6_upload/

> generator? Also please review doc/CodingStyle. your code isn't compliant.
New patch.
Changes:
Now the isthmus road defaults to the center, instead of left side.
Added enum to eliminate use of T_GRASSLAND to mean new land created.
Ran indent -kr -i2 -l77 on the file to get it to conform to the 
coding style.
Added header comments to all new functions that I introduced.



-- 
Josh Cogliati
jjc@xxxxxxxxxxxxxxxxxx
This message created in Linux, the choice of a GNU generation.


Index: common/map.h
===================================================================
RCS file: /home/freeciv/CVS/freeciv/common/map.h,v
retrieving revision 1.141
diff -U9 -r1.141 map.h
--- common/map.h        2003/03/11 17:59:26     1.141
+++ common/map.h        2003/03/31 15:24:25
@@ -629,19 +629,19 @@
 #define MAP_MIN_RIVERS           0
 #define MAP_MAX_RIVERS           100
 
 #define MAP_DEFAULT_FORESTS      20
 #define MAP_MIN_FORESTS          0
 #define MAP_MAX_FORESTS          100
 
 #define MAP_DEFAULT_GENERATOR    1
 #define MAP_MIN_GENERATOR        1
-#define MAP_MAX_GENERATOR        5
+#define MAP_MAX_GENERATOR        6
 
 #define MAP_DEFAULT_TINYISLES    FALSE
 #define MAP_MIN_TINYISLES        FALSE
 #define MAP_MAX_TINYISLES        TRUE
 
 #define MAP_DEFAULT_SEPARATE_POLES   TRUE
 #define MAP_MIN_SEPARATE_POLES       FALSE
 #define MAP_MAX_SEPARATE_POLES       TRUE
 
Index: server/mapgen.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/server/mapgen.c,v
retrieving revision 1.110
diff -U9 -r1.110 mapgen.c
--- server/mapgen.c     2003/02/20 09:45:22     1.110
+++ server/mapgen.c     2003/03/31 15:24:49
@@ -36,18 +36,19 @@
 #define rmap(x, y) (river_map[map_pos_to_index(x, y)])
 
 static void make_huts(int number);
 static void add_specials(int prob);
 static void mapgenerator1(void);
 static void mapgenerator2(void);
 static void mapgenerator3(void);
 static void mapgenerator4(void);
 static void mapgenerator5(void);
+static void mapgenerator6(void);
 static void smooth_map(void);
 static void adjust_map(int minval);
 
 #define RIVERS_MAXTRIES 32767
 enum river_map_type {RS_BLOCKED = 0, RS_RIVER = 1};
 
 /* Array needed to mark tiles as blocked to prevent a river from
    falling into itself, and for storing rivers temporarly.
    A value of 1 means blocked.
@@ -1151,18 +1152,20 @@
 
   mysrand(map.seed);
   
   /* don't generate tiles with mapgen==0 as we've loaded them from file */
   /* also, don't delete (the handcrafted!) tiny islands in a scenario */
   if (map.generator != 0) {
     map_allocate();
     /* if one mapgenerator fails, it will choose another mapgenerator */
     /* with a lower number to try again */
+    if (map.generator == 6 )
+      mapgenerator6();
     if (map.generator == 5 )
       mapgenerator5();
     if (map.generator == 4 )
       mapgenerator4();
     if (map.generator == 3 )
       mapgenerator3();
     if( map.generator == 2 )
       mapgenerator2();
     if( map.generator == 1 )
@@ -2133,10 +2136,283 @@
     if (hmap(x, y) < minval)
       minval = hmap(x, y);
   } whole_map_iterate_end;
   maxval -= minval;
   adjust_map(minval);
   
   make_land();
   free(height_map);
   height_map = NULL;
+}
+
+/****************************************************************************
+ returns true if the terrain at point x,y is land. 
+****************************************************************************/
+static int land_terrain(int x, int y)
+{
+  return !is_ocean(map_get_terrain(x, y));
+}
+
+/****************************************************************************
+ returns a score based on the amount of land surrounding the point x,y. 
+ No land is 0.  All eight neighbors is 12
+ ***************************************************************************/
+static int border_score(int x, int y)
+{
+  int adj_score = 2;
+  int diag_score = 1;
+  int score = 0;
+  score += land_terrain(x - 1, y) ? adj_score : 0;
+  score += land_terrain(x + 1, y) ? adj_score : 0;
+  score += land_terrain(x, y - 1) ? adj_score : 0;
+  score += land_terrain(x, y + 1) ? adj_score : 0;
+  score += land_terrain(x - 1, y - 1) ? diag_score : 0;
+  score += land_terrain(x + 1, y - 1) ? diag_score : 0;
+  score += land_terrain(x - 1, y + 1) ? diag_score : 0;
+  score += land_terrain(x + 1, y + 1) ? diag_score : 0;
+  return score;
+}
+
+enum terrain_status { TS_OCEAN, TS_LAND, TS_NEW_LAND };
+
+/*************************************************************************
+  Returns TS_NEW_LAND if the point is not already land and 
+  the random number is less than the border score.
+  More likely to return TS_NEW_LAND on a location that has
+  more land around it.  Will never return TS_NEW_LAND on a
+  location that has no land in any of the eight neighbors.
+ *************************************************************************/
+static int random_new_land(int x, int y)
+{
+  int score;
+  int random;
+  if (land_terrain(x, y)) {
+    return TS_LAND;
+  }
+  score = border_score(x, y);
+  random = myrand(4 * 2 + 4 * 1);
+  return random + 1 > score ? TS_OCEAN : TS_NEW_LAND;
+
+}
+
+/*************************************************************************
+ Creates a peninsula and put the player's starting position
+ on it. The direction is either +1 or -1 depending on which 
+ direction the peninsula should go from the y position.
+ The remaining_count is the number of tiles to  fill with 
+ land.
+ *************************************************************************/
+static void create_peninsula(int x, int y, int player_number,
+                            int width, int height, int direction,
+                            int remaining_count)
+{
+  int cx, cy;
+
+  cx = x + width / 2;
+  for (cy = y; cy != y + (height + 1) * direction; cy += direction) {
+    map_set_terrain(cx, cy, T_GRASSLAND);
+    map_set_continent(cx, cy, 1);
+  }
+  remaining_count -= height;   /* account for the already added strip */
+  cy = y;
+  for (cx = x + width / 2 - 2; cx <= x + width / 2 + 2; cx++) {
+    map_set_terrain(cx, cy, T_GRASSLAND);
+    map_set_continent(cx, cy, 1);
+  }
+  remaining_count -= 4;                /* account for extra 4 (not 5 because 
that would 
+                                  double count the one already done by height 
strip. */
+
+  while (remaining_count > 0) {
+    for (cx = x; cx < x + width; cx++) {
+      for (cy = y; cy != y + (height + 1) * direction; cy += direction) {
+       int new_terrain = random_new_land(cx, cy);
+       if (new_terrain == TS_NEW_LAND) {
+         remaining_count--;
+         map_set_terrain(cx, cy, T_GRASSLAND);
+         map_set_continent(cx, cy, 1);
+         hmap(cx, cy) = myrand(7000) - 2000;
+       }
+       if (remaining_count <= 0) {
+         goto done_with_peninsula;
+       }
+      }
+    }
+  }
+
+done_with_peninsula:
+
+  map.start_positions[player_number].x = x + width / 2;
+  map.start_positions[player_number].y = y;
+}
+
+/*************************************************************************
+  This generator creates a map with one penisula for each 
+   player and an isthmus between.  It creates a central
+   ocean and puts the peninsulas around the edges.  It is 
+   intented for quicker games. Should look something like this:
+   *****************************
+   ****  *****  *****  *****    
+    **    ***    ***    ***     
+    **                          
+    **                           
+    **       ***    ***             
+   ****     *****  *****           
+   *****************************
+
+ *************************************************************************/
+static void mapgenerator6(void)
+{
+  int peninsulas = game.nplayers;
+  int peninsulas_on_one_side = (peninsulas + 1) / 2;
+  int isthmus_width = 10;
+  int peninsula_separation = 5;
+  int peninsula_width = (map.xsize - isthmus_width - peninsula_separation)
+      / (peninsulas_on_one_side) - peninsula_separation;
+  /* if landpercent <= 50, then make shorter peninsulas */
+  int peninsula_height = (map.landpercent <= 50)
+      ? map.ysize / 3 : (map.ysize * 2) / 5;
+  int continent_percent = (map.landpercent <= 50)
+      ? (map.landpercent * 3) / 2 : (map.landpercent * 5) / 4;
+  int i, x, y;
+  int polar_height = 3;
+  int remaining_count = MIN(isthmus_width * (map.ysize - polar_height * 2),
+                           ((isthmus_width +
+                             peninsula_separation) * (map.ysize -
+                                                      polar_height * 2)
+                            * continent_percent) / 100);
+
+  height_map = fc_malloc(sizeof(int) * map.xsize * map.ysize);
+
+  /* initialize everything to ocean */
+  for (y = 0; y < map.ysize; y++)
+    for (x = 0; x < map.xsize; x++) {
+      map_set_terrain(x, y, T_OCEAN);
+      map_set_continent(x, y, 0);
+      hmap(x, y) = 0;
+    }
+
+  /* create polar regions */
+  for (x = 0; x < map.xsize; x++) {
+    for (y = 0; y < polar_height; y++) {
+      int rand_num = myrand(9);
+      map_set_terrain(x, y, rand_num > 7 ? T_ARCTIC :
+                     (rand_num < 2 ? T_MOUNTAINS : T_TUNDRA));
+      map_set_continent(x, y, 1);
+      rand_num = myrand(9);
+      map_set_terrain(x, map.ysize - 1 - y, rand_num > 7 ? T_ARCTIC :
+                     (rand_num < 2 ? T_MOUNTAINS : T_TUNDRA));
+      map_set_continent(x, map.ysize - 1 - y, 1);
+    }
+  }
+
+  /* build polar regions road */
+  for (x = 0; x < map.xsize; x++) {
+    y = polar_height - 1;
+    if (map_build_road_time(x, y - 1) < map_build_road_time(x, y)) {
+      map_set_special(x, y - 1, S_ROAD);
+    } else {
+      map_set_special(x, y, S_ROAD);
+    }
+    y = map.ysize - polar_height;
+    if (map_build_road_time(x, y + 1) < map_build_road_time(x, y)) {
+      map_set_special(x, y + 1, S_ROAD);
+    } else {
+      map_set_special(x, y, S_ROAD);
+    }
+  }
+
+  map.num_continents = 1;
+
+  /* create isthmus centeral strip */
+  x = isthmus_width / 2;
+  for (y = polar_height; y < map.ysize - polar_height; y++) {
+    map_set_terrain(x, y, T_GRASSLAND);
+    map_set_continent(x, y, 1);
+    hmap(x, y) = 100 * x * (isthmus_width - x) + (myrand(400) - 200);
+  }
+
+  remaining_count -= (map.ysize - 2 * polar_height) * 1;
+
+  /* add additional isthmus area randomly */
+  while (remaining_count > 0) {
+    int low = polar_height;
+    int high = map.ysize - polar_height - 1;
+    int direction;
+    for (direction = -1; direction < 2; direction += 2) {
+      int start = (direction == 1) ? low : high;
+      int end = (direction == 1) ? high : low;
+      for (y = start; y != end + direction; y += direction) {
+       for (x = 0; x < isthmus_width; x++) {
+         int new_terrain = random_new_land(x, y);
+         if (new_terrain == TS_NEW_LAND) {
+           remaining_count--;
+           map_set_terrain(x, y, T_GRASSLAND);
+           map_set_continent(x, y, 1);
+           hmap(x, y) = 100 * x * (isthmus_width - x) + (myrand(400) - 200);
+         }
+         if (remaining_count <= 0) {
+           goto done_with_isthmus;
+         }
+       }
+      }
+    }
+  }
+done_with_isthmus:
+
+  /* setup peninsulas */
+  for (i = 0; i < game.nplayers; i++) {
+    /* direction is the direction to increment from the x and y location */
+    int direction = (i < peninsulas_on_one_side) ? -1 : 1;
+    int index = (direction == -1) ? i : i - peninsulas_on_one_side;
+    int width = (continent_percent < 95)
+       ? peninsula_width : peninsula_width + peninsula_separation - 1; /*Give 
more room */
+    int height = peninsula_height - polar_height;
+    int peninsula_remaining_count = MIN(width * height,
+                                       ((width + peninsula_separation)
+                                        * height *
+                                        continent_percent) / 100);
+    /* x_adder centers the peninsulas if there are an odd number */
+    int x_adder = (direction == 1 && game.nplayers % 2 == 1) ?
+       (peninsula_width + peninsula_separation) / 2 : 0;
+    x = index * (peninsula_width + peninsula_separation)
+       + isthmus_width + peninsula_separation + x_adder;
+    y = (direction == -1)
+       ? peninsula_height : map.ysize - 1 - peninsula_height;
+    create_peninsula(x, y, i, width, height, direction,
+                    peninsula_remaining_count);
+  }
+
+  map.num_start_positions = game.nplayers;
+
+  /* setup terrain */
+  smooth_map();
+  make_mountains(1600);
+  make_swamps();
+  make_forests();
+  make_deserts();
+  make_plains();
+  make_fair();
+  make_rivers();
+
+  /* create isthmus road */
+  {
+    int last_x, middle_x = isthmus_width / 2;
+    last_x = middle_x;
+    for (y = polar_height - 1; y < map.ysize - polar_height + 1; y++) {
+      int best_x = middle_x;
+      int min_build = map_build_road_time(middle_x, y);
+      for (x = MAX(last_x - 1, middle_x - 1);
+          x != MIN(last_x + 1, middle_x + 1) + 1; x++) {
+       if (land_terrain(x, y) && map_build_road_time(x, y) < min_build) {
+         best_x = x;
+         min_build = map_build_road_time(x, y);
+       }
+      }
+      map_set_special(best_x, y, S_ROAD);
+      last_x = best_x;
+    }
+  }
+
+
+  free(height_map);
+
 }
Index: server/stdinhand.c
===================================================================
RCS file: /home/freeciv/CVS/freeciv/server/stdinhand.c,v
retrieving revision 1.273
diff -U9 -r1.273 stdinhand.c
--- server/stdinhand.c  2003/03/24 22:20:58     1.273
+++ server/stdinhand.c  2003/03/31 15:25:12
@@ -236,19 +236,21 @@
        "3 = equally sized large islands with one player each, and "
        "a number of other\n"
        "    islands of similar size;\n"
        "4 = equally sized large islands with two players on every "
        "island (or one\n"
        "    with three players for an odd number of players), and "
        "additional\n"
        "    smaller islands.\n"
        "5 = one or more large earthlike continents with some scatter.\n"
-       "Note: values 2,3 and 4 generate \"fairer\" (but more boring) "
+       "6 = equally sized peninsulas with one player each surrounding  \n"
+       "    an inland sea.\n"
+       "Note: values 2,3,4 and 6 generate \"fairer\" (but more boring) "
        "maps.\n"
        "(Zero indicates a scenario map.)"), NULL,
          MAP_MIN_GENERATOR, MAP_MAX_GENERATOR, MAP_DEFAULT_GENERATOR)
 
   GEN_BOOL("tinyisles", map.tinyisles, SSET_MAP_GEN, SSET_TO_CLIENT,
           N_("Presence or absence of 1x1 islands"),
           N_("0 = no 1x1 islands; 1 = some 1x1 islands"), NULL,
           MAP_DEFAULT_TINYISLES)