[Freeciv-Dev] (PR#9627) PATCH: correct some parameters in map generator and clean-up

["Marcelo Burda" <mburda@xxxxxxxxx>]

<URL: http://rt.freeciv.org/Ticket/Display.html?id=9627 >

Hi i split the last part of this patch. 
No more splits todo

LAST CHANGES
no more changes in default value
make_relief use slope (i am not so happy with this, i wait to see when
temperature will depend on height befor do more changes to make_relief.

this patch no more depend in MASS_SIZE() patch (9798)

only in 9797 and 9799

Marcelo

diff -ruN -Xfreeciv/diff_ignore freeciv_/server/mapgen.c 
freeciv__/server/mapgen.c
--- freeciv_/server/mapgen.c    2004-08-28 08:56:44.423222264 +0200
+++ freeciv__/server/mapgen.c   2004-08-28 09:35:31.526448800 +0200
@@ -63,7 +63,7 @@
 static void mapgenerator4(void);
 static void mapgenerator5(void);
 static void smooth_map(void);
-static void adjust_map(void);
+static void adjust_hmap(void);
 static void adjust_terrain_param(void);
 
 #define RIVERS_MAXTRIES 32767
@@ -76,8 +76,13 @@
 static int *river_map;
 
 static int *height_map;
-static int maxval=0;
-static int forests=0;
+static const int maxval=1000;
+static int reliefval=0, seaval=0;
+static int forests_to_be_placed =0;
+static int deserts_to_be_placed=0;
+static int grass_to_be_placed=0;
+static int plains_to_be_placed=0;
+static int swamps_to_be_placed=0;
 
 struct isledata {
   int goodies;
@@ -98,13 +103,38 @@
 /* An estimate of the linear (1-dimensional) size of the map. */
 #define SQSIZE MAX(1, sqrt(map.xsize * map.ysize / 1000))
 
+/* define the 5 region of a Earth like map
+   =========================================================
+    0-COLD_LV                cold region: 
+    COLD_LV-TREOPICAL_LV     temperate wet region: 
+    TROPICAL_LV-MAX_TEMP     tropical wet region:
+
+   and a dry region, this last one can ovelap others 
+   DRY_MIN_LEVEL- DRY_MAX_LEVEL
+ */
+#define COLD_LEVEL (10 * MAX_TEMP / 100)
+#define TROPICAL_LEVEL (70 * MAX_TEMP / 100)
+#define DRY_MIN_LEVEL (65 * MAX_TEMP / 100)
+#define DRY_MAX_LEVEL (80 * MAX_TEMP / 100)
+
 /* used to create the poles and for separating them.  In a
  * mercator projection map we don't want the poles to be too big. */
 #define ICE_BASE_LEVEL                                         \
   ((!topo_has_flag(TF_WRAPX) || !topo_has_flag(TF_WRAPY))      \
    /* 5% for little maps; 2% for big ones */                   \
    ? MAX_TEMP * (3 + 2 * SQSIZE) / (100 * SQSIZE)              \
-   : 5 * MAX_TEMP / 100  /* 5% for all maps */)
+   : COLD_LEVEL / 2  /* for all maps */)
+
+/********************************************************************
+ * used to initialize a array with some value
+ ********************************************************************/
+#define INITIALIZE_ARRAY(_a, _size, _val)                            \
+  { \
+    int _ini_index = 0; \
+    for(; _ini_index < (_size);_ini_index++) { \
+      (_a)[_ini_index] = (_val); \
+     } \
+  } 
 
 /****************************************************************************
   Returns the temperature of this map position.  This is a value in the
@@ -288,41 +318,73 @@
 }
 
 /**************************************************************************
-  make_mountains() will convert all squares that are higher than thill to
+  we don't want huge areas of grass/plains, 
+  so we put in a hill here and there, where it gets too 'clean' 
+
+  Return TRUE if the terrain at the given map position is "clean".  This
+  means that all the terrain for 2 squares around it is not mountain or hill.
+****************************************************************************/
+static bool terrain_is_to_flat(int map_x, int map_y,int thill, int my_high)
+{
+  int biger_me = 0;
+  square_iterate(map_x, map_y, 2, x1, y1) {
+    if (hmap(x1, y1) > thill) {
+      return FALSE;
+    }
+    if (hmap(x1, y1) > my_high){
+      if(map_distance(map_x, map_y, x1, y1) == 1) {
+       return FALSE;
+      }
+      if(++biger_me > 2) {
+       return FALSE;
+      };
+    }
+  } square_iterate_end;
+
+  if ((thill - seaval) * (biger_me)  > (my_high - seaval) * 4 ) {
+      return FALSE;
+  }
+  return TRUE;
+}
+
+/**************************************************************************
+  we don't want huge areas of hill/mountains, 
+  so we put in a plains here and there, where it gets too 'height' 
+
+  Return TRUE if the terrain at the given map position is to height.
+****************************************************************************/
+static bool terrain_is_to_height(int map_x, int map_y,int thill, int my_high)
+{
+  square_iterate(map_x, map_y, 1, x1, y1) {
+    if (hmap(x1, y1) +(maxval - reliefval) / 5 < thill) {
+      return FALSE;
+    }
+  } square_iterate_end;
+  return TRUE;
+}
+
+/**************************************************************************
+  make_relief() will convert all squares that are higher than thill to
   mountains and hills. Notice that thill will be adjusted according to
   the map.mountains value, so increase map.mountains and you'll get more 
   hills and mountains (and vice versa).
 **************************************************************************/
-static void make_mountains(int thill)
+static void make_relief()
 {
-  int mount;
-  int j;
-
-  for (j = 0; j < 10; j++) {
-    mount = 0;
-    whole_map_iterate(x, y) {
-      if (hmap(x, y) > thill) {
-       mount++;
-      }
-    } whole_map_iterate_end;
-    if (mount < (map_num_tiles() * map.mountains) / 1000) {
-      thill *= 95;
-    } else {
-      thill *= 105;
-    }
-    thill /= 100;
-  }
-  
+  reliefval = ((maxval - seaval)* (100 - map.mountains)) / 100 + seaval;
   whole_map_iterate(x, y) {
-    if (hmap(x, y) > thill && !is_ocean(map_get_terrain(x,y))) { 
+    if (not_placed(x,y) 
+       && ((reliefval < hmap(x, y) && (myrand(10) > 5 
+                  || !terrain_is_to_height(x, y, reliefval, hmap(x, y)))) 
+           || terrain_is_to_flat(x, y, reliefval, hmap(x, y)))) { 
       /* Randomly place hills and mountains on "high" tiles.  But don't
        * put hills near the poles (they're too green). */
-      if (myrand(100) > 75 
-         || map_temperature(x, y) <= MAX_TEMP / 10) {
+      if (myrand(100) > 70 
+         || map_temperature(x, y) <= COLD_LEVEL) {
        map_set_terrain(x, y, T_MOUNTAINS);
-      } else if (myrand(100) > 25) {
+      } else {
        map_set_terrain(x, y, T_HILLS);
-      }
+      }  
     }
   } whole_map_iterate_end;
 }
@@ -360,6 +422,24 @@
     }
   } whole_map_iterate_end;
 }
+/*************************************************************************
+ if separatepoles is set, return false if this tile has to kip ocean
+************************************************************************/
+static bool ok_for_separate_poles(int x, int y) 
+{
+  if (!map.separatepoles) {
+    return TRUE;
+  }
+  adjc_iterate(x, y, x1, y1) {
+    if(!is_ocean(map_get_terrain(x1, y1))
+       && map_get_continent(x1, y1 ) != 0) {
+      return FALSE;
+    }
+  } adjc_iterate_end;
+  return TRUE;
+}
+
+
 
 /****************************************************************************
   Place untextured land at the poles.  This is used by generators 1 and 5.
@@ -370,30 +450,17 @@
   struct tile *ptile;
   int T;
 
+  assign_continent_numbers();
   whole_map_iterate(map_x, map_y) {
     T = map_temperature(map_x, map_y); /* temperature parameter */
     ptile = map_get_tile(map_x, map_y);
-    if (T < 1.5 * ICE_BASE_LEVEL) {
+    if (T < 1.5 * ICE_BASE_LEVEL && ok_for_separate_poles(map_x, map_y)) {
       ptile->terrain = T_NOT_PLACED;
-    } else if ((T <= 2 * ICE_BASE_LEVEL) && myrand(10) > 4 ) { 
+      map_set_continent(map_x, map_y, 0);
+    } else if ((T <= 2 * ICE_BASE_LEVEL) 
+              && myrand(10) > 4 && ok_for_separate_poles(map_x, map_y)) { 
       ptile->terrain = T_NOT_PLACED;
-    }
-  } whole_map_iterate_end;
-}
-
-/****************************************************************************
-  Create tundra in cold zones.  Used by generators 1 and 5.  This must be
-  called after make_arctic since it will fill all remaining untextured
-  areas (we don't want any grassland left on the poles).
-****************************************************************************/
-static void make_tundra(void)
-{
-  whole_map_iterate(x, y) {
-    int T = map_temperature(x, y);
-
-    if (not_placed(x,y) 
-       && (2 * ICE_BASE_LEVEL > T || myrand(MAX_TEMP/5) > T)) {
-      map_set_terrain(x, y, T_TUNDRA);
+      map_set_continent(map_x, map_y, 0);
     }
   } whole_map_iterate_end;
 }
@@ -406,8 +473,8 @@
   whole_map_iterate(x, y) {
     int T = map_temperature(x, y);
 
-    if (not_placed(x,y) 
-       && myrand(15 * MAX_TEMP / 100) > T -  ICE_BASE_LEVEL 
+    if (not_placed(x, y)
+       && myrand(1.5 * COLD_LEVEL) > T -  ICE_BASE_LEVEL 
        && T <= 3 * ICE_BASE_LEVEL) {
       map_set_terrain(x, y, T_ARCTIC);
     }
@@ -428,14 +495,16 @@
 {
   const int DeltaT = MAX_TEMP / (3 * SQSIZE);
 
+  if(deserts_to_be_placed <= 0) { return; }
+
   if (abs(hmap(x, y) - height) < diff 
-      && not_placed(x,y)) {
+      && not_placed(x, y) && count_ocean_near_tile(x,y) <= 2) {
     map_set_terrain(x, y, T_DESERT);
+    deserts_to_be_placed--;
     cardinal_adjc_iterate(x, y, x1, y1) {
       make_desert(x1, y1, height,
                  diff - 1 - abs(map_temperature(x1, y1) - base_T) / DeltaT,
                  base_T);
-     
     } cardinal_adjc_iterate_end;
   }
 }
@@ -448,125 +517,174 @@
 **************************************************************************/
 static void make_forest(int map_x, int map_y, int height, int diff)
 {
-  int nat_x, nat_y, T;
+  int T;
 
-  map_to_native_pos(&nat_x, &nat_y, map_x, map_y);
-  T = map_temperature(map_x, map_y);
+  if(forests_to_be_placed <= 0) { return; }
   if (not_placed(map_x, map_y)) {
-    if (T > 8 * MAX_TEMP / 10 
-       && myrand(1000) > 500 - 300 * (T * 1000 / MAX_TEMP - 800)) {
+    if ((T = map_temperature(map_x, map_y)) > TROPICAL_LEVEL 
+       && myrand(100) >  50) {
       map_set_terrain(map_x, map_y, T_JUNGLE);
     } else {
       map_set_terrain(map_x, map_y, T_FOREST);
     }
+    forests_to_be_placed--;
     if (abs(hmap(map_x, map_y) - height) < diff) {
       cardinal_adjc_iterate(map_x, map_y, x1, y1) {
-       if (myrand(10) > 5) {
+       if (myrand(10) > 5 || (T > TROPICAL_LEVEL && myrand(10) >  5)) {
          make_forest(x1, y1, height, diff - 5);
        }
       } cardinal_adjc_iterate_end;
     }
-    forests++;
   }
 }
 
 /**************************************************************************
-  makeforest calls make_forest with random unplaced locations until there
-  has been made enough forests. (the map.forestsize value controls this) 
+  a recursive function that adds swamps to the current location and try
+  to spread out to the neighbours.
 **************************************************************************/
-static void make_forests(void)
+static void make_swamp(int map_x, int map_y, int height, int diff)
 {
-  int x, y;
-  int forestsize = (map_num_tiles() * map.forestsize) / 1000;
-
-  forests = 0;
-
-  do {
-    /* Place one forest clump anywhere. */
-    if (rand_map_pos_temperature(&x, &y,
-                                MAX_TEMP / 10, MAX_TEMP,
-                                T_NOT_PLACED)) {
-      make_forest(x, y, hmap(x, y), 25);
-    } else { 
-      /* If rand_map_pos_temperature returns FALSE we may as well stop
-       * looking. */
-      break;
-    }
-
-    /* Now add another tropical forest clump (70-100% temperature). */
-    if (rand_map_pos_temperature(&x, &y,
-                                7 *MAX_TEMP / 10, MAX_TEMP,
-                                T_NOT_PLACED)) {
-      make_forest(x, y, hmap(x, y), 25);
-    }
-
-    /* And add a cold forest clump (10%-30% temperature). */
-    if (rand_map_pos_temperature(&x, &y,
-                                1 * MAX_TEMP / 10, 3 * MAX_TEMP / 10,
-                                T_NOT_PLACED)) {
-      make_forest(x, y, hmap(x, y), 25);
+  if(swamps_to_be_placed <= 0) { return; }
+  if (not_placed(map_x, map_y) 
+      && ( 2 * (hmap(map_x, map_y) - seaval) < myrand(reliefval - seaval)
+       || (map_temperature(map_x, map_y) > DRY_MAX_LEVEL
+           && map_temperature(map_x, map_y) < DRY_MIN_LEVEL
+           && myrand(40) >  30))) {
+      map_set_terrain(map_x, map_y, T_SWAMP);
+      swamps_to_be_placed--;
+      if (abs(hmap(map_x, map_y) - height) < diff) {
+         cardinal_adjc_iterate(map_x, map_y, x1, y1) {
+         make_forest(x1, y1, height, diff - 5);
+      } cardinal_adjc_iterate_end;
     }
-  } while (forests < forestsize);
+  }
 }
-
 /**************************************************************************
-  swamps, is placed on low lying locations, that will typically be close to
-  the shoreline. They're put at random (where there is grassland)
-  and with 50% chance each of it's neighbour squares will be converted to
-  swamp aswell
+  a simple function that adds plains or tundra to the current location.
 **************************************************************************/
-static void make_swamps(void)
+static void make_plain(int x, int y)
 {
-  int x, y, swamps;
-  int forever = 0;
+  int T = map_temperature(x, y);
 
-  for (swamps = 0; swamps < map.swampsize; ) {
-    forever++;
-    if (forever > 1000) {
-      return;
-    }
-    rand_map_pos(&x, &y);
-    if (not_placed(x, y)
-       && hmap(x, y) < (maxval * 60) / 100) {
-      map_set_terrain(x, y, T_SWAMP);
-      cardinal_adjc_iterate(x, y, x1, y1) {
-       if (myrand(10) > 5 && !is_ocean(map_get_terrain(x1, y1)) 
-           && map_get_terrain(x1, y1) != T_SWAMP ) { 
-         map_set_terrain(x1, y1, T_SWAMP);
-         swamps++;
-       }
-      } cardinal_adjc_iterate_end;
-      swamps++;
-    }
+  if(2 * ICE_BASE_LEVEL > T || myrand(2 * COLD_LEVEL) > T) {
+    map_set_terrain(x, y, T_TUNDRA); /* in cold place we get tundra instead */
+  } else {
+    map_set_terrain(x, y, T_PLAINS);
   }
+  plains_to_be_placed--;
 }
 
-/*************************************************************************
-  Make deserts until we have enough of them.
+/**************************************************************************
+  make_terrains calls make_forest, make_dessert  with random free locations 
+  until there  has been made enough.
+ Comment: funtions as make_swamp, etc. has to have a non 0 probability
+ to place one terrains in called position. Else make_terrains can get
+ in a infinite loop!
 **************************************************************************/
-static void make_deserts(void)
+static void make_terrains(void)
 {
-  int x, y, i = map.deserts, j = 0;
+  int x, y;
+  int total = 0;
+  whole_map_iterate(x, y) {
+    if(not_placed(x,y)) {
+      total++;
+    }
+  } whole_map_iterate_end;
 
-  /* "i" is the number of desert clumps made; "j" is the number of tries. */
-  /* TODO: j is no longer needed */
-  while (i > 0 && j < 100 * map.deserts) {
-    j++;
+  forests_to_be_placed = total * map.forestsize
+       / ( map.forestsize + map.deserts + map.grasssize +  map.swampsize );
+  deserts_to_be_placed = total * map.deserts
+       / ( map.forestsize + map.deserts + map.grasssize +  map.swampsize);
+  swamps_to_be_placed = total * map.swampsize
+       / ( map.forestsize + map.deserts + map.grasssize +  map.swampsize);
+
+  /* tundra and plains is counted in map.grasssize */
+  grass_to_be_placed = total * map.grasssize / 2
+       / ( map.forestsize + map.deserts + map.grasssize +  map.swampsize);
+  plains_to_be_placed = total /* and tundra */
+      - forests_to_be_placed - deserts_to_be_placed - grass_to_be_placed;
 
-    /* Choose a random coordinate between 20 and 30 degrees north/south
-     * (deserts tend to be between 15 and 35; make_desert will expand
-     * them). */
-    if (rand_map_pos_temperature(&x, &y,
-                                65 * MAX_TEMP / 100, 80 * MAX_TEMP / 100,
-                                T_NOT_PLACED)){
-      make_desert(x, y, hmap(x, y), 50, map_temperature(x, y));
-      i--;
-    } else {
-      /* If rand_map_pos_temperature returns FALSE we may as well stop
-       * looking. */
-      break;
+  /* the plasing loop */
+  do {
+    if(forests_to_be_placed > 0) {
+      /* Place one forest clump between Very Cold level and MAX_TEMP. */
+      if (rand_map_pos_temperature(&x, &y,
+                                  (COLD_LEVEL + ICE_BASE_LEVEL) / 2, MAX_TEMP,
+                                  T_NOT_PLACED)) {
+       make_forest(x, y, hmap(x, y), 25);
+      } else { 
+        /* If rand_map_pos_temperature returns FALSE we may as well stop
+         * looking for forest. */
+       plains_to_be_placed += forests_to_be_placed;
+       forests_to_be_placed = 0;
+      }
     }
-  }
+
+    if(swamps_to_be_placed > 0) {
+      /* Place one swamp clump between COLD_LEVEL and MAX_TEMP.. */
+      if (rand_map_pos_temperature(&x, &y,
+                                  COLD_LEVEL, MAX_TEMP,
+                                  T_NOT_PLACED)) {
+       make_swamp(x, y, hmap(x, y), 25);
+      } else { 
+        /* If rand_map_pos_temperature returns FALSE we may as well stop
+         * looking for swamp. */
+       plains_to_be_placed += swamps_to_be_placed; /* reactivate plains */
+       swamps_to_be_placed = 0;
+      }
+    }
+
+    if(deserts_to_be_placed > 0) {
+      /* Choose a random coordinate between TROPICAL_LEVEL and WET_LEVEL;
+        make_desert will expand them). */
+      if (rand_map_pos_temperature(&x, &y,
+                                  DRY_MIN_LEVEL, DRY_MAX_LEVEL,
+                                  T_NOT_PLACED)){
+         make_desert(x, y, hmap(x, y), 40, map_temperature(x, y));
+      } else {
+       /* If rand_map_pos_temperature returns FALSE we may as well stop
+        * looking for dessert. (convert to plains) */
+       plains_to_be_placed += deserts_to_be_placed;
+       deserts_to_be_placed = 0;
+      }
+    }
+
+    /* Make the grass */
+    if(grass_to_be_placed > 0) {
+      if (rand_map_pos_temperature(&x, &y,
+                                  COLD_LEVEL, MAX_TEMP,
+                                  T_NOT_PLACED)){
+       map_set_terrain(x, y, T_GRASSLAND);
+       grass_to_be_placed--;
+      } else {
+         plains_to_be_placed += grass_to_be_placed;
+         grass_to_be_placed = 0;
+      }
+    }
+
+    /* there is very important: this place all terrains when there
+       is not posibe for other types kip the 0, MAX_TEMP range. */
+    /* make the plains and tundras */
+    if(plains_to_be_placed > 0) {
+      if (rand_map_pos_temperature(&x, &y,
+                                  0, MAX_TEMP,
+                                  T_NOT_PLACED)){
+       make_plain(x,y);
+      } else {
+       /* If rand_map_pos_temperature returns FALSE we may as well stop
+        * looking for plains. */
+       plains_to_be_placed = 0;
+      }
+    }
+
+  } while (forests_to_be_placed > 0 || deserts_to_be_placed > 0 
+          || grass_to_be_placed > 0 || plains_to_be_placed > 0 
+          || swamps_to_be_placed > 0 );
+
+  /* final test */
+  whole_map_iterate(x, y) {
+    assert(!not_placed(x,y));
+  } whole_map_iterate_end;
 }
 
 /*********************************************************************
@@ -819,7 +937,7 @@
     if (adjacent_river_tiles4(x, y) != 0
        || adjacent_ocean_tiles4(x, y) != 0
         || (map_get_terrain(x, y) == T_ARCTIC 
-           && map_temperature(x, y) < 8 * MAX_TEMP / 100)) { 
+           && map_temperature(x, y) < 0.8 * COLD_LEVEL)) { 
 
       freelog(LOG_DEBUG,
              "The river ended at (%d, %d).\n", x, y);
@@ -1032,61 +1150,6 @@
   river_map = NULL;
 }
 
-/**************************************************************************
-  make_plains converts 50% of the remaining terrains to plains and 50%
-  grassland,
-**************************************************************************/
-static void make_plains(void)
-{
-  whole_map_iterate(x, y) {
-    if (not_placed(x, y)) {
-      if(myrand(100) > 50) {
-         map_set_terrain(x, y, T_GRASSLAND);
-      } else {
-         map_set_terrain(x, y, T_PLAINS);
-      }
-    }
-  } whole_map_iterate_end;
-}
-/****************************************************************************
-  Return TRUE if the terrain at the given map position is "clean".  This
-  means that all the terrain for 2 squares around it is either grassland or
-  plains.
-****************************************************************************/
-static bool terrain_is_clean(int map_x, int map_y)
-{
-  square_iterate(map_x, map_y, 2, x1, y1) {
-    if (map_get_terrain(x1, y1) != T_GRASSLAND
-       && map_get_terrain(x1, y1) != T_PLAINS) {
-      return FALSE;
-    }
-  } square_iterate_end;
-
-  return TRUE;
-}
-
-/**************************************************************************
-  we don't want huge areas of grass/plains, 
- so we put in a hill here and there, where it gets too 'clean' 
-**************************************************************************/
-static void make_fair(void)
-{
-  whole_map_iterate(map_x, map_y) {
-    if (terrain_is_clean(map_x, map_y)) {
-      if (!map_has_special(map_x, map_y, S_RIVER)) {
-       map_set_terrain(map_x, map_y, T_HILLS);
-      }
-      cardinal_adjc_iterate(map_x, map_y, x1, y1) {
-       if (myrand(100) > 66
-           && !is_ocean(map_get_terrain(x1, y1))
-           && !map_has_special(x1, y1, S_RIVER)) {
-         map_set_terrain(x1, y1, T_HILLS);
-       }
-      } cardinal_adjc_iterate_end;
-    }
-  } whole_map_iterate_end;
-}
-
 /****************************************************************************
   Lower the land near the polar region to avoid too much land there.
 
@@ -1135,44 +1198,21 @@
 **************************************************************************/
 static void make_land(void)
 {
-  int tres;
-  int count=0;
-  int total = (map_num_tiles() * map.landpercent) / 100;
-  int forever=0;
-
-  adjust_map();
+  adjust_hmap();
   normalize_hmap_poles();
-  tres = (maxval * map.landpercent) / 100;
-
-  do {
-    forever++;
-    if (forever>50) break; /* loop elimination */
-    count=0;
-    whole_map_iterate(x, y) {
-      if (hmap(x, y) < tres)
-       map_set_terrain(x, y, T_OCEAN);
-      else {
-       map_set_terrain(x, y, T_NOT_PLACED);
-       count++;
-      }
-    } whole_map_iterate_end;
-    if (count>total)
-      tres*=11;
-    else
-      tres*=9;
-    tres/=10;
-  } while (abs(total-count)> maxval/40);
-
+  seaval = (maxval *(100 - map.landpercent)) / 100;
+  whole_map_iterate(x, y) {
+    if (hmap(x, y) < seaval)
+      map_set_terrain(x, y, T_OCEAN);
+    else {
+      map_set_terrain(x, y, T_NOT_PLACED);
+    }
+  } whole_map_iterate_end;
   renormalize_hmap_poles();
   make_polar_land(); /* make extra land at poles*/
-  make_mountains(maxval*8/10);
-  make_arctic();
-  make_tundra();
-  make_forests();
-  make_swamps();
-  make_deserts();
-  make_plains();
-  make_fair();
+  make_relief(); /* base relief on map */
+  make_arctic(); 
+  make_terrains();/* place forest/dessert/swamp/grass/tundra and plains */
   make_rivers();
 
   assign_continent_numbers();
@@ -1627,9 +1667,9 @@
 static void adjust_terrain_param(void)
 {
   int total;
-  int polar = 5; /* FIXME: convert to a server option */
+  int polar = ICE_BASE_LEVEL * 100 / MAX_TEMP;
 
-  total = map.mountains + map.deserts + map.forestsize + map.swampsize 
+  total = map.mountains + map.deserts + map.forestsize + map.swampsize
     + map.grasssize;
 
   if (total != 100 - polar) {
@@ -1643,25 +1683,44 @@
 }
 
 /**************************************************************************
-  Adjust the map so that its minimum height is 0.  This raises or lowers
-  every position by a fixed amount and sets the "maxval" global variable
-  to hold the maximum height.
+  Adjust the hmap to be a linearize distribution of heights
+  form 0 to maxval (maxval is a global const )
+  
+  ( hmap[x,y] < 0.13 * maxval) handle the 13% lowerest part of the map
+  slope can globaly be estiamted as maxval*sqrt(num_of_isles)/linear_size
 **************************************************************************/
-static void adjust_map(void)
+static void adjust_hmap(void)
 {
-  int minval = maxval = hnat(0, 0);
+  int i, min = hnat(0, 0), max = min;
+  int count=0, f[maxval];
+  
+  INITIALIZE_ARRAY(f,maxval,0);
 
   /* Determine minimum and maximum heights. */
   whole_map_iterate(x, y) {
-    maxval = MAX(maxval, hmap(x, y));
-    minval = MIN(minval, hmap(x, y));
+    max = MAX(max, hmap(x, y));
+    min = MIN(min, hmap(x, y));
   } whole_map_iterate_end;
 
-  /* Translate heights so the minimum height is 0. */
-  maxval -= minval;
+  /* Translate heights so the minimum height is 0 and  maximum is maxval.
+     and count the number of accurnecies in all values */
+  max -= min;
   whole_map_iterate(x, y) {
-    hmap(x, y) -= minval;
+    hmap(x, y) = (hmap(x, y) - min) * maxval;
+    hmap(x, y) /= max;
+    f[hmap(x, y)]++;
   } whole_map_iterate_end;
+
+  /* create the linearize function as a incremental occurrencies count */
+  for(i =  -1; i++ < maxval;) {
+      count += f[i];
+      f[i] = (count * maxval) / (map.xsize * map.ysize) ;
+     }
+
+  /* apply the linearize function */
+  whole_map_iterate(x, y) {
+    hmap(x, y) = f[hmap(x, y)];
+  } whole_map_iterate_end; 
 }
 
 /**************************************************************************
@@ -2317,6 +2376,22 @@
 #define DMSIS 10
 
 /**************************************************************************
+  make_plains converts 50% of the remaining grassland to plains, this should
+  maybe be lowered to 30% or done in batches, like the swamps?
+**************************************************************************/
+static void make_plains(void)
+{
+  whole_map_iterate(x, y) {
+    if (not_placed(x, y)) {
+      if(myrand(100) > 50) {
+         map_set_terrain(x, y, T_GRASSLAND);
+      } else {
+         map_set_terrain(x, y, T_PLAINS);
+      }
+    }
+  } whole_map_iterate_end;
+}
+/**************************************************************************
   island base map generators
 **************************************************************************/
 static void mapgenerator2(void)
diff -ruN -Xfreeciv/diff_ignore freeciv_/server/maphand.c 
freeciv__/server/maphand.c
--- freeciv_/server/maphand.c   2004-08-27 21:49:06.000000000 +0200
+++ freeciv__/server/maphand.c  2004-08-27 21:37:31.000000000 +0200
@@ -41,6 +41,10 @@
 #include "maphand.h"
 
 /**************************************************************************
+ * used to store the size of continent
+ **************************************************************************/
+int mass_size[2 * MAP_NCONT];
+/**************************************************************************
   Number this tile and nearby tiles (recursively) with the specified
   continent number, using a flood-fill algorithm.
 
@@ -58,6 +62,7 @@
   }
 
   map_set_continent(x, y, nr);
+  MASS_SIZE(nr)++;
 
   adjc_iterate(x, y, x1, y1) {
     assign_continent_flood(x1, y1, is_land, nr);
@@ -73,7 +78,12 @@
 **************************************************************************/
 void assign_continent_numbers(void)
 {
+  int i;
+
   /* Initialize */
+  for(i = 0; i < 2 * MAP_NCONT; i++) {
+    MASS_SIZE(i) = 0;
+  }
   map.num_continents = 0;
   map.num_oceans = 0;
 
diff -ruN -Xfreeciv/diff_ignore freeciv_/server/maphand.h 
freeciv__/server/maphand.h
--- freeciv_/server/maphand.h   2004-08-27 21:49:06.000000000 +0200
+++ freeciv__/server/maphand.h  2004-08-27 21:37:31.000000000 +0200
@@ -52,6 +52,9 @@
 /* The maximum number of continents and oceans. */
 #define MAP_NCONT 300
 
+/* signus safe way for nr continent <0 or >0 */
+extern int mass_size[2 * MAP_NCONT];
+#define MASS_SIZE(nr) (mass_size[FC_WRAP((nr), 2 * MAP_NCONT)]) 
 void assign_continent_numbers(void);
 
 void global_warming(int effect);
diff -ruN -Xfreeciv/diff_ignore freeciv_/server/stdinhand.c 
freeciv__/server/stdinhand.c
--- freeciv_/server/stdinhand.c 2004-08-27 21:49:05.000000000 +0200
+++ freeciv__/server/stdinhand.c        2004-08-27 20:09:20.000000000 +0200
@@ -370,7 +370,7 @@
 
   GEN_INT("grass", map.grasssize,
          SSET_MAP_GEN, SSET_ECOLOGY, SSET_SITUATIONAL, SSET_TO_CLIENT,
-         N_("Amount of grass squares"), "", NULL,
+         N_("Amount of grass and plains squares"), "", NULL,
          MAP_MIN_GRASS, MAP_MAX_GRASS, MAP_DEFAULT_GRASS)
 
   GEN_INT("forests", map.forestsize,